[Java.Interop] Map nullable byte jagged arrays to java.lang.Byte

build-tools/automation/yaml-templates/stage-package-tests.yaml

@@ -178,6 +178,15 @@ stages:
         artifactSource: bin/Test$(XA.Build.Configuration)/$(DotNetTargetFramework)-android/Mono.Android.NET_Tests-Signed.aab
         artifactFolder: $(DotNetTargetFramework)-NativeAOT
 
+    - template: /build-tools/automation/yaml-templates/apk-instrumentation.yaml
+      parameters:
+        configuration: $(XA.Build.Configuration)
+        testName: Mono.Android.NET_Tests-NativeAOTTrimmable
+        project: tests/Mono.Android-Tests/Mono.Android-Tests/Mono.Android.NET-Tests.csproj
+        extraBuildArgs: -p:TestsFlavor=NativeAOTTrimmable -p:PublishAot=true -p:_AndroidTypeMapImplementation=trimmable
+        artifactSource: bin/Test$(XA.Build.Configuration)/$(DotNetTargetFramework)-android/Mono.Android.NET_Tests-Signed.aab
+        artifactFolder: $(DotNetTargetFramework)-NativeAOTTrimmable
+
     - template: /build-tools/automation/yaml-templates/apk-instrumentation.yaml
       parameters:
         configuration: $(XA.Build.Configuration)

external/Java.Interop/src/Java.Interop/Java.Interop/JniBuiltinMarshalers.cs

@@ -93,7 +93,7 @@ static bool GetBuiltInTypeSignature (Type type, ref JniTypeSignature signature)
 				signature = GetCachedTypeSignature (ref __BooleanNullableTypeSignature, "java/lang/Boolean");
 				return true;
 			}
-			if (type == typeof (SByte?)) {
+			if (type == typeof (Byte?) || type == typeof (SByte?)) {
 				signature = GetCachedTypeSignature (ref __SByteNullableTypeSignature, "java/lang/Byte");
 				return true;
 			}

external/Java.Interop/tests/Java.Interop-Tests/Java.Interop/JniTypeManagerTests.cs

@@ -32,7 +32,11 @@ public void GetTypeSignature_Type ()
 			AssertGetJniTypeInfoForType (typeof (bool),     "Z",    true,   0);
 			AssertGetJniTypeInfoForType (typeof (void),     "V",    true,   0);
 
-			AssertGetJniTypeInfoForType (typeof (float?),      "java/lang/Float",   true,   0);
+			AssertGetJniTypeInfoForType (typeof (float?),      "java/lang/Float",      true,   0);
+			AssertGetJniTypeInfoForType (typeof (byte?),       "java/lang/Byte",       true,   0);
+			AssertGetJniTypeInfoForType (typeof (byte?[]),     "[Ljava/lang/Byte;",    true,   1);
+			AssertGetJniTypeInfoForType (typeof (byte?[][]),   "[[Ljava/lang/Byte;",   true,   2);
+			AssertGetJniTypeInfoForType (typeof (byte?[][][]), "[[[Ljava/lang/Byte;",  true,   3);
 
 			AssertGetJniTypeInfoForType (typeof (JavaObject),  "java/lang/Object",  false,  0);
 
@@ -136,6 +140,7 @@ static void AssertGetJniTypeInfoForType (Type type, string jniType, bool isKeywo
 			Assert.AreEqual (typeof (float),    GetType ("F"));
 			Assert.AreEqual (typeof (double),   GetType ("D"));
 			Assert.AreEqual (typeof (string),   GetType ("java/lang/String"));
+			Assert.AreEqual (typeof (sbyte?),   GetType ("java/lang/Byte"));
 			Assert.AreEqual (typeof (float?),   GetType ("java/lang/Float"));
 			Assert.AreEqual (null,              GetType ("com/example/does/not/exist"));
 			Assert.AreEqual (null,              GetType ("Lcom/example/does/not/exist;"));

src/Mono.Android/Android.Runtime/JNIEnv.cs

@@ -32,19 +32,7 @@ static Array ArrayCreateInstance (Type elementType, int length)
 			}
 
 			if (RuntimeFeature.TrimmableTypeMap) {
-				if (RuntimeFeature.IsNativeAotRuntime) {
-					// NativeAOT: resolve via per-rank typemap + generated array proxy.
-					if (TrimmableTypeMap.Instance.TryGetArrayProxy (elementType, additionalRank: 1, out var arrayProxy)) {
-						return arrayProxy.CreateManagedArray (length);
-					}
-				}
-
-				int arrayRank = GetArrayRank (elementType, out var leafElementType);
-				throw new NotSupportedException (
-					$"No TrimmableTypeMap array proxy entry for element type '{elementType}' " +
-					$"(leaf element type '{leafElementType}', rank {arrayRank}). " +
-					$"Array lookups use the leaf element type within the per-rank __ArrayMapRank{arrayRank} typemap group; " +
-					$"ensure the mapping is emitted for that rank (for example by increasing _AndroidTrimmableTypeMapMaxArrayRank) or report an issue.");
+				return SafeArrayFactory.CreateInstance (elementType, rank: 1, length);
 			}
 
 			if (RuntimeFeature.ManagedTypeMap) {
@@ -61,21 +49,6 @@ Array ArrayCreateInstanceWithSuppression (Type elementType, int length)
 			throw new NotSupportedException ($"It is not possible to create an array with element type '{elementType}'.");
 		}
 
-		static int GetArrayRank (Type elementType, out Type leafElementType)
-		{
-			int rank = 1;
-			while (elementType.IsSZArray) {
-				rank++;
-				var nestedElementType = elementType.GetElementType ();
-				if (nestedElementType is null) {
-					break;
-				}
-				elementType = nestedElementType;
-			}
-			leafElementType = elementType;
-			return rank;
-		}
-
 		internal static IntPtr IdentityHash (IntPtr v)
 		{
 			return JniEnvironment.References.GetIdentityHashCode (new JniObjectReference (v));
@@ -613,11 +586,30 @@ static void AssertCompatibleArrayTypes (IntPtr sourceArray, Type destElementType
 
 		static IntPtr FindArrayClassByElementType (Type elementType)
 		{
+			var boxedPrimitiveJniClassName = GetBoxedPrimitiveJniClassName (elementType);
+			if (boxedPrimitiveJniClassName != null) {
+				return FindClass ("[L" + boxedPrimitiveJniClassName + ";");
+			}
+
 			int rank = JavaNativeTypeManager.GetArrayInfo (elementType, out elementType) + 1;
 			var typeSignature = JniRuntime.CurrentRuntime.TypeManager.GetTypeSignature (elementType).AddArrayRank (rank);
 			return FindClass (typeSignature.Name);
 		}
 
+		static string? GetBoxedPrimitiveJniClassName (Type type)
+		{
+			if (type == typeof (bool?))   return "java/lang/Boolean";
+			if (type == typeof (byte?))   return "java/lang/Byte";
+			if (type == typeof (sbyte?))  return "java/lang/Byte";
+			if (type == typeof (char?))   return "java/lang/Character";
+			if (type == typeof (short?))  return "java/lang/Short";
+			if (type == typeof (int?))    return "java/lang/Integer";
+			if (type == typeof (long?))   return "java/lang/Long";
+			if (type == typeof (float?))  return "java/lang/Float";
+			if (type == typeof (double?)) return "java/lang/Double";
+			return null;
+		}
+
 		public static void CopyArray (IntPtr src, bool[] dest)
 		{
 			if (dest == null)
@@ -692,6 +684,15 @@ public static void CopyArray (IntPtr src, string[] dest)
 					_GetDoubleArrayRegion (source, index, 1, r);
 					return r [0];
 				} },
+				{ typeof (bool?),   (type, source, index) => GetNullableArrayElement (source, index, typeof (bool?)) },
+				{ typeof (byte?),   (type, source, index) => GetNullableArrayElement (source, index, typeof (byte?)) },
+				{ typeof (sbyte?),  (type, source, index) => GetNullableArrayElement (source, index, typeof (sbyte?)) },
+				{ typeof (char?),   (type, source, index) => GetNullableArrayElement (source, index, typeof (char?)) },
+				{ typeof (short?),  (type, source, index) => GetNullableArrayElement (source, index, typeof (short?)) },
+				{ typeof (int?),    (type, source, index) => GetNullableArrayElement (source, index, typeof (int?)) },
+				{ typeof (long?),   (type, source, index) => GetNullableArrayElement (source, index, typeof (long?)) },
+				{ typeof (float?),  (type, source, index) => GetNullableArrayElement (source, index, typeof (float?)) },
+				{ typeof (double?), (type, source, index) => GetNullableArrayElement (source, index, typeof (double?)) },
 				{ typeof (string), (type, source, index) => {
 					IntPtr elem = GetObjectArrayElement (source, index);
 					if (type == typeof (Java.Lang.String))
@@ -717,6 +718,12 @@ public static void CopyArray (IntPtr src, string[] dest)
 			};
 		}
 
+		static object? GetNullableArrayElement (IntPtr source, int index, [DynamicallyAccessedMembers (Constructors)] Type targetType)
+		{
+			IntPtr elem = GetObjectArrayElement (source, index);
+			return JavaConvert.FromJniHandle (elem, JniHandleOwnership.TransferLocalRef, targetType);
+		}
+
 		static TValue GetConverter<TValue>(Dictionary<Type, TValue> dict, Type? elementType, IntPtr array)
 		{
 			TValue? converter;
@@ -921,6 +928,15 @@ static Dictionary<Type, Action<Array, IntPtr>> CreateCopyManagedToNativeArray ()
 				{ typeof (long),        (source, dest) => CopyArray ((long[]) source, dest) },
 				{ typeof (float),       (source, dest) => CopyArray ((float[]) source, dest) },
 				{ typeof (double),      (source, dest) => CopyArray ((double[]) source, dest) },
+				{ typeof (bool?),       (source, dest) => CopyManagedObjectArray (source, dest) },
+				{ typeof (byte?),       (source, dest) => CopyManagedObjectArray (source, dest) },
+				{ typeof (sbyte?),      (source, dest) => CopyManagedObjectArray (source, dest) },
+				{ typeof (char?),       (source, dest) => CopyManagedObjectArray (source, dest) },
+				{ typeof (short?),      (source, dest) => CopyManagedObjectArray (source, dest) },
+				{ typeof (int?),        (source, dest) => CopyManagedObjectArray (source, dest) },
+				{ typeof (long?),       (source, dest) => CopyManagedObjectArray (source, dest) },
+				{ typeof (float?),      (source, dest) => CopyManagedObjectArray (source, dest) },
+				{ typeof (double?),     (source, dest) => CopyManagedObjectArray (source, dest) },
 				{ typeof (string),      (source, dest) => {
 					var s = source as string[];
 					if (s != null) {
@@ -950,6 +966,23 @@ static Dictionary<Type, Action<Array, IntPtr>> CreateCopyManagedToNativeArray ()
 			};
 		}
 
+		static void CopyManagedObjectArray (Array source, IntPtr dest)
+		{
+			// Inlined equivalent of JavaConvert.WithLocalJniHandle to avoid allocating a capturing
+			// closure per element (this runs once per array element for both NewObjectArray and the
+			// nullable-primitive CopyManagedToNativeArray entries).
+			for (int i = 0; i < source.Length; i++) {
+				object? value = source.GetValue (i);
+				IntPtr lref = JavaConvert.ToLocalJniHandle (value);
+				try {
+					SetObjectArrayElement (dest, i, lref);
+				} finally {
+					DeleteLocalRef (lref);
+					GC.KeepAlive (value);
+				}
+			}
+		}
+
 		public static void CopyArray (Array source, Type elementType, IntPtr dest)
 		{
 			if (source == null)
@@ -1053,6 +1086,15 @@ public static void CopyArray<T> (T[] src, IntPtr dest)
 					CopyArray (source, r);
 					return r;
 				} },
+				{ typeof (bool?),   (type, source, len) => CreateManagedArrayFromObjectArray (type, source, len) },
+				{ typeof (byte?),   (type, source, len) => CreateManagedArrayFromObjectArray (type, source, len) },
+				{ typeof (sbyte?),  (type, source, len) => CreateManagedArrayFromObjectArray (type, source, len) },
+				{ typeof (char?),   (type, source, len) => CreateManagedArrayFromObjectArray (type, source, len) },
+				{ typeof (short?),  (type, source, len) => CreateManagedArrayFromObjectArray (type, source, len) },
+				{ typeof (int?),    (type, source, len) => CreateManagedArrayFromObjectArray (type, source, len) },
+				{ typeof (long?),   (type, source, len) => CreateManagedArrayFromObjectArray (type, source, len) },
+				{ typeof (float?),  (type, source, len) => CreateManagedArrayFromObjectArray (type, source, len) },
+				{ typeof (double?), (type, source, len) => CreateManagedArrayFromObjectArray (type, source, len) },
 				{ typeof (string), (type, source, len) => {
 					if (type != null && typeof (Java.Lang.Object).IsAssignableFrom (type)) {
 						var r = new Java.Lang.String [len];
@@ -1077,6 +1119,16 @@ public static void CopyArray<T> (T[] src, IntPtr dest)
 			};
 		}
 
+		static Array CreateManagedArrayFromObjectArray (Type? elementType, IntPtr source, int len)
+		{
+			if (elementType == null)
+				throw new ArgumentNullException (nameof (elementType));
+
+			var r = ArrayCreateInstance (elementType, len);
+			CopyArray (source, r, elementType);
+			return r;
+		}
+
 		static Array? _GetArray (IntPtr array_ptr, Type? element_type)
 		{
 			if (array_ptr == IntPtr.Zero)
@@ -1329,12 +1381,49 @@ static Dictionary<Type, Func<Array, IntPtr>> CreateCreateManagedToNativeArray ()
 				{ typeof (long),          (source) => NewArray ((long[]) source) },
 				{ typeof (float),         (source) => NewArray ((float[]) source) },
 				{ typeof (double),        (source) => NewArray ((double[]) source) },
+				{ typeof (bool?),         (source) => NewObjectArray (source, typeof (bool?)) },
+				{ typeof (byte?),         (source) => NewObjectArray (source, typeof (byte?)) },
+				{ typeof (sbyte?),        (source) => NewObjectArray (source, typeof (sbyte?)) },
+				{ typeof (char?),         (source) => NewObjectArray (source, typeof (char?)) },
+				{ typeof (short?),        (source) => NewObjectArray (source, typeof (short?)) },
+				{ typeof (int?),          (source) => NewObjectArray (source, typeof (int?)) },
+				{ typeof (long?),         (source) => NewObjectArray (source, typeof (long?)) },
+				{ typeof (float?),        (source) => NewObjectArray (source, typeof (float?)) },
+				{ typeof (double?),       (source) => NewObjectArray (source, typeof (double?)) },
 				{ typeof (string),        (source) => NewArray ((string[]) source) },
 				{ typeof (IJavaObject),   (source) => NewArray ((IJavaObject[]) source) },
 				{ typeof (Array),         (source) => NewArray (source) },
 			};
 		}
 
+		static IntPtr NewObjectArray (Array value, Type elementType)
+		{
+			IntPtr grefArrayElementClass = FindObjectArrayElementClass (elementType);
+			try {
+				IntPtr array = IntPtr.Zero;
+				try {
+					array = NewObjectArray (value.Length, grefArrayElementClass, IntPtr.Zero);
+					CopyManagedObjectArray (value, array);
+					return array;
+				} catch {
+					DeleteLocalRef (array);
+					throw;
+				}
+			} finally {
+				DeleteGlobalRef (grefArrayElementClass);
+			}
+		}
+
+		static IntPtr FindObjectArrayElementClass (Type elementType)
+		{
+			var boxedPrimitiveJniClassName = GetBoxedPrimitiveJniClassName (elementType);
+			if (boxedPrimitiveJniClassName != null) {
+				return FindClass (boxedPrimitiveJniClassName);
+			}
+
+			return FindClass (elementType);
+		}
+
 		public static IntPtr NewArray (Array value, Type? elementType = null)
 		{
 			if (value == null)
@@ -1444,6 +1533,15 @@ static IntPtr NewArray (Array value, Type elementType, IntPtr elementClass)
 					var _value = new[]{(double) value!};
 					_SetDoubleArrayRegion (dest, index, _value.Length, _value);
 				} },
+				{ typeof (bool?),   (dest, index, value) => SetObjectArrayElementFromManagedValue (dest, index, value) },
+				{ typeof (byte?),   (dest, index, value) => SetObjectArrayElementFromManagedValue (dest, index, value) },
+				{ typeof (sbyte?),  (dest, index, value) => SetObjectArrayElementFromManagedValue (dest, index, value) },
+				{ typeof (char?),   (dest, index, value) => SetObjectArrayElementFromManagedValue (dest, index, value) },
+				{ typeof (short?),  (dest, index, value) => SetObjectArrayElementFromManagedValue (dest, index, value) },
+				{ typeof (int?),    (dest, index, value) => SetObjectArrayElementFromManagedValue (dest, index, value) },
+				{ typeof (long?),   (dest, index, value) => SetObjectArrayElementFromManagedValue (dest, index, value) },
+				{ typeof (float?),  (dest, index, value) => SetObjectArrayElementFromManagedValue (dest, index, value) },
+				{ typeof (double?), (dest, index, value) => SetObjectArrayElementFromManagedValue (dest, index, value) },
 				{ typeof (string), (dest, index, value) => {
 					IntPtr s = NewString (value!.ToString ());
 					try {
@@ -1463,6 +1561,19 @@ static IntPtr NewArray (Array value, Type elementType, IntPtr elementClass)
 			};
 		}
 
+		static void SetObjectArrayElementFromManagedValue (IntPtr dest, int index, object? value)
+		{
+			// Inlined equivalent of JavaConvert.WithLocalJniHandle to avoid allocating a capturing
+			// closure on every element set (this runs once per element on the SetArrayItem path).
+			IntPtr lref = JavaConvert.ToLocalJniHandle (value);
+			try {
+				SetObjectArrayElement (dest, index, lref);
+			} finally {
+				DeleteLocalRef (lref);
+				GC.KeepAlive (value);
+			}
+		}
+
 		static unsafe void _SetBooleanArrayRegion (IntPtr array, int start, int length, bool[] buffer)
 		{
 			fixed (bool* p = buffer)