[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,6 +93,11 @@ static bool GetBuiltInTypeSignature (Type type, ref JniTypeSignature signature)
 				signature = GetCachedTypeSignature (ref __BooleanNullableTypeSignature, "java/lang/Boolean");
 				return true;
 			}
+			if (type == typeof (Byte?)) {
+				signature = GetCachedTypeSignature (ref __SByteNullableTypeSignature, "java/lang/Byte");
+				return true;
+			}
+
 			if (type == typeof (SByte?)) {
 				signature = GetCachedTypeSignature (ref __SByteNullableTypeSignature, "java/lang/Byte");
 				return true;
@@ -162,6 +167,7 @@ static KeyValuePair<Type, JniValueMarshaler>[] InitJniBuiltinMarshalers ()
 				return new []{
 					new KeyValuePair<Type, JniValueMarshaler>(typeof (string), JniStringValueMarshaler.Instance),
 					new KeyValuePair<Type, JniValueMarshaler>(typeof (JavaProxyObject), ProxyValueMarshaler.Instance),
+					new KeyValuePair<Type, JniValueMarshaler>(typeof (Byte?), JniNullableByteValueMarshaler.Instance),
 					new KeyValuePair<Type, JniValueMarshaler>(typeof (Boolean),   JniBooleanValueMarshaler.Instance),
 					new KeyValuePair<Type, JniValueMarshaler>(typeof (Boolean?),  JniNullableBooleanValueMarshaler.Instance),
 					new KeyValuePair<Type, JniValueMarshaler>(typeof (SByte),   JniSByteValueMarshaler.Instance),
@@ -465,6 +471,37 @@ public override void DestroyGenericArgumentState (SByte? value, ref JniValueMars
 		}
 	}
 
+	sealed class JniNullableByteValueMarshaler : JniValueMarshaler<Byte?> {
+
+		internal    static  readonly    JniNullableByteValueMarshaler   Instance    = new JniNullableByteValueMarshaler ();
+
+		public override Byte? CreateGenericValue (
+				ref JniObjectReference reference,
+				JniObjectReferenceOptions options,
+				Type? targetType)
+		{
+			if (!reference.IsValid)
+				return null;
+
+			return unchecked ((Byte) JniByte.GetValueFromJni (ref reference, options, targetType: null));
+		}
+
+		public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState ([MaybeNull] Byte? value, ParameterAttributes synchronize)
+		{
+		    if (!value.HasValue)
+		        return new JniValueMarshalerState ();
+			var r = JniByte.CreateLocalRef (unchecked ((SByte) value.Value));
+			return new JniValueMarshalerState (r);
+		}
+
+		public override void DestroyGenericArgumentState (Byte? value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+		{
+			var r   = state.ReferenceValue;
+			JniObjectReference.Dispose (ref r);
+			state   = new JniValueMarshalerState ();
+		}
+	}
+
 	static class JniCharacter {
 		internal    const   string  JniTypeName = "java/lang/Character";
 

external/Java.Interop/src/Java.Interop/Java.Interop/JniBuiltinMarshalers.tt

@@ -84,6 +84,11 @@ namespace Java.Interop {
 			if (!type.IsValueType)
 				return false;
 
+			if (type == typeof (Byte?)) {
+				signature = GetCachedTypeSignature (ref __SByteNullableTypeSignature, "java/lang/Byte");
+				return true;
+			}
+
 <#
 	foreach (var type in types) {
 #>
@@ -127,6 +132,7 @@ namespace Java.Interop {
 				return new []{
 					new KeyValuePair<Type, JniValueMarshaler>(typeof (string), JniStringValueMarshaler.Instance),
 					new KeyValuePair<Type, JniValueMarshaler>(typeof (JavaProxyObject), ProxyValueMarshaler.Instance),
+					new KeyValuePair<Type, JniValueMarshaler>(typeof (Byte?), JniNullableByteValueMarshaler.Instance),
 <#
 	foreach (var type in types) {
 #>
@@ -284,6 +290,41 @@ namespace Java.Interop {
 		}
 	}
 <#
+		if (type.UnsignedType == "Byte") {
+#>
+
+	sealed class JniNullableByteValueMarshaler : JniValueMarshaler<Byte?> {
+
+		internal    static  readonly    JniNullableByteValueMarshaler   Instance    = new JniNullableByteValueMarshaler ();
+
+		public override Byte? CreateGenericValue (
+				ref JniObjectReference reference,
+				JniObjectReferenceOptions options,
+				Type? targetType)
+		{
+			if (!reference.IsValid)
+				return null;
+
+			return unchecked ((Byte) JniByte.GetValueFromJni (ref reference, options, targetType: null));
+		}
+
+		public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState ([MaybeNull] Byte? value, ParameterAttributes synchronize)
+		{
+		    if (!value.HasValue)
+		        return new JniValueMarshalerState ();
+			var r = JniByte.CreateLocalRef (unchecked ((SByte) value.Value));
+			return new JniValueMarshalerState (r);
+		}
+
+		public override void DestroyGenericArgumentState (Byte? value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+		{
+			var r   = state.ReferenceValue;
+			JniObjectReference.Dispose (ref r);
+			state   = new JniValueMarshalerState ();
+		}
+	}
+<#
+		}
 	}
 #>
 }

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

@@ -93,6 +93,22 @@ public void ObjectArrayType ()
 		}
 	}
 
+	[TestFixture]
+	public class JavaObjectArray_NullableByte_ContractTest : JavaObjectArrayContractTest<byte?> {
+		protected override byte? CreateValueA () {return 128;}
+		protected override byte? CreateValueB () {return 255;}
+
+		[Test]
+		public void NullableByteValues ()
+		{
+			var values = new byte? [] { 1, null, 127, 128, 200, 255 };
+			using (var array = new JavaObjectArray<byte?> (values)) {
+				Assert.AreEqual ("[Ljava/lang/Byte;", array.GetJniTypeName ());
+				CollectionAssert.AreEqual (values, array.ToArray ());
+			}
+		}
+	}
+
 	[TestFixture]
 	public class JavaObjectArray_Int32Array_ContractTest : JavaObjectArrayContractTest<int[]> {
 		protected override int[]  CreateValueA () {return new[]{1};}

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;"));

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

@@ -282,6 +282,8 @@ protected static string GetTypeName (Type type)
 			switch (type.Name) {
 			case "Boolean":
 				return "bool";
+			case "Byte":
+				return "byte";
 			case "Char":
 				return "char";
 			case "Double":
@@ -422,6 +424,12 @@ public class JniValueMarshaler_NullableSByte_ContractTests : JniValueMarshalerCo
 		protected   override    sbyte?  Value           {get {return (sbyte) 2;}}
 	}
 
+	[TestFixture]
+	[Category("LLVMIgnore")] //FIXME: https://github.com/dotnet/runtime/issues/89190
+	public class JniValueMarshaler_NullableByte_ContractTests : JniValueMarshalerContractTests<byte?> {
+		protected   override    byte?   Value           {get {return (byte) 200;}}
+	}
+
 	[TestFixture]
 	[Category("LLVMIgnore")] //FIXME: https://github.com/dotnet/runtime/issues/89190
 	public class JniValueMarshaler_NullableChar_ContractTests : JniValueMarshalerContractTests<char?> {

tests/Mono.Android-Tests/Mono.Android-Tests/Android.Runtime/JnienvArrayMarshaling.cs

@@ -243,13 +243,8 @@ public void GetArray_NullableByte ()
 		}
 
 		[Test]
-		[Category ("NativeAOTTrimmable")]
 		public void GetArray_NullableByteArrayArray ()
 		{
-			if (!Microsoft.Android.Runtime.RuntimeFeature.TrimmableTypeMap) {
-				Assert.Ignore ("Test only relevant for the trimmable typemap path.");
-			}
-
 			var values = new [] {
 				new byte? [] { 1, null, 200 },
 				new byte? [] { 255, 128 },
@@ -265,6 +260,32 @@ public void GetArray_NullableByteArrayArray ()
 			}
 		}
 
+		[Test]
+		public void GetArray_NullableByteArrayArrayArray ()
+		{
+			var values = new [] {
+				new [] {
+					new byte? [] { 1, null, 200 },
+					new byte? [] { 255, 128 },
+				},
+				new [] {
+					new byte? [] { null, 42 },
+				},
+			};
+			using (var array = new Java.Lang.Object (JNIEnv.NewArray (values), JniHandleOwnership.TransferLocalRef)) {
+				Assert.AreEqual ("[[[Ljava/lang/Byte;", JNIEnv.GetClassNameFromInstance (array.Handle));
+
+				var copy = JNIEnv.GetArray<byte?[][]> (array.Handle);
+				Assert.AreEqual (values.Length, copy.Length);
+				for (int i = 0; i < values.Length; i++) {
+					Assert.AreEqual (values [i].Length, copy [i].Length);
+					for (int j = 0; j < values [i].Length; j++) {
+						AssertArrays ($"GetArray<byte?[][]>[{i}][{j}]", copy [i][j], values [i][j]);
+					}
+				}
+			}
+		}
+
 		[Test]
 		public void GetArray_JavaLangStringArrayToJavaLangObjectArray ()
 		{

tests/Mono.Android-Tests/Mono.Android-Tests/Java.Interop/TrimmableTypeMapTypeManagerTests.cs

@@ -34,14 +34,15 @@ public void GetStaticMethodFallbackTypes_ReturnsDesugarFallbacks (string jniSimp
 			Assert.AreEqual (expectedFallback, fallbacks [1]);
 		}
 
-		[Test]
+		[TestCase (typeof (byte?[][]), "[[Ljava/lang/Byte;")]
+		[TestCase (typeof (byte?[][][]), "[[[Ljava/lang/Byte;")]
 		[Category ("NativeAOTTrimmable")]
-		public void GetTypeSignature_NullableByteArrayArray_ReturnsJavaLangByte ()
+		public void GetTypeSignature_NullableByteJaggedArray_ReturnsJavaLangByte (Type type, string expected)
 		{
 			using var manager = new TestableTrimmableTypeMapTypeManager ();
-			var signature = manager.GetTypeSignature (typeof (byte?[][]));
+			var signature = manager.GetTypeSignature (type);
 
-			Assert.AreEqual ("[[Ljava/lang/Byte;", signature.Name);
+			Assert.AreEqual (expected, signature.Name);
 		}
 
 		// Verifies the generic-type-definition fallback in GetProxyForManagedType: