Implement remaining [Export] marshaling gaps

- Support arrays in export marshal wrappers using JNIEnv.GetArray<T>/NewArray<T>/CopyArray<T>
  including copy-back cleanup for array parameters
- Support enum signatures and marshaling as JNI int while calling managed enum methods
- Map Java.Lang.ICharSequence to Ljava/lang/CharSequence; in export signature generation
- Resolve JNI object descriptors from [Register] metadata for managed object types
  (e.g. View[] -> [Landroid/view/View; instead of Object[])
- Improve ManagedTypeToAssemblyQualifiedName to resolve non-BCL types and array element types
- Generate proxies for export-only ACW types (no activation ctor / no [Register] methods)

Add fixture coverage and tests for export-only proxies plus array/enum/charsequence signatures
and registration. All 312 tests pass.

Author: simonrozsival

src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/ModelBuilder.cs

@@ -117,8 +117,8 @@ static void EmitPeers (TypeMapAssemblyData model, string jniName,
 			var peer = peersForName [i];
 			string entryJniName = i == 0 ? jniName : $"{jniName}[{i}]";
 
-			bool hasProxy = peer.ActivationCtor != null || peer.InvokerTypeName != null;
 			bool isAcw = !peer.DoNotGenerateAcw && !peer.IsInterface && peer.MarshalMethods.Count > 0;
+			bool hasProxy = peer.ActivationCtor != null || peer.InvokerTypeName != null || isAcw;
 
 			JavaPeerProxyData? proxy = null;
 			if (hasProxy) {

src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/TypeMapAssemblyEmitter.cs

@@ -306,7 +306,7 @@ void ScanAssembly (AssemblyIndex index, Dictionary<string, JavaPeerInfo> results
 		return (methods, exportFields);
 	}
 
-	static void AddMarshalMethod (List<MarshalMethodInfo> methods, RegisterInfo registerInfo, MethodDefinition methodDef, AssemblyIndex index)
+	void AddMarshalMethod (List<MarshalMethodInfo> methods, RegisterInfo registerInfo, MethodDefinition methodDef, AssemblyIndex index)
 	{
 		// Skip methods that are just the JNI name (type-level [Register])
 		if (registerInfo.Signature == null && registerInfo.Connector == null) {
@@ -326,10 +326,10 @@ static void AddMarshalMethod (List<MarshalMethodInfo> methods, RegisterInfo regi
 		if (registerInfo.Connector == null || isConstructor) {
 			var sig = methodDef.DecodeSignature (SignatureTypeProvider.Instance, genericContext: default);
 			for (int i = 0; i < parameters.Count && i < sig.ParameterTypes.Length; i++) {
-				parameters [i].ManagedType = ManagedTypeToAssemblyQualifiedName (sig.ParameterTypes [i]);
+				parameters [i].ManagedType = ManagedTypeToAssemblyQualifiedName (sig.ParameterTypes [i], index);
 			}
 			if (sig.ReturnType != "System.Void") {
-				managedReturnType = ManagedTypeToAssemblyQualifiedName (sig.ReturnType);
+				managedReturnType = ManagedTypeToAssemblyQualifiedName (sig.ReturnType, index);
 			}
 		}
 		methods.Add (new MarshalMethodInfo {
@@ -406,7 +406,7 @@ List<string> ResolveImplementedInterfaceJavaNames (TypeDefinition typeDef, Assem
 		return null;
 	}
 
-	static RegisterInfo ParseExportAttribute (CustomAttribute ca, MethodDefinition methodDef, AssemblyIndex index)
+	RegisterInfo ParseExportAttribute (CustomAttribute ca, MethodDefinition methodDef, AssemblyIndex index)
 	{
 		var value = ca.DecodeValue (index.customAttributeTypeProvider);
 
@@ -436,7 +436,7 @@ static RegisterInfo ParseExportAttribute (CustomAttribute ca, MethodDefinition m
 
 		// Build JNI signature from method signature
 		var sig = methodDef.DecodeSignature (SignatureTypeProvider.Instance, genericContext: default);
-		var jniSig = BuildJniSignatureFromManaged (sig);
+		var jniSig = BuildJniSignatureFromManaged (sig, index);
 
 		return new RegisterInfo (exportName, jniSig, null, false,
 			thrownNames: thrownNames, superArgumentsString: superArguments);
@@ -446,11 +446,11 @@ static RegisterInfo ParseExportAttribute (CustomAttribute ca, MethodDefinition m
 	/// Creates a RegisterInfo for an [ExportField] method.
 	/// The method is registered like [Export] (Connector = null) so it gets a full marshal body.
 	/// </summary>
-	static RegisterInfo ParseExportFieldAsRegisterInfo (MethodDefinition methodDef, AssemblyIndex index)
+	RegisterInfo ParseExportFieldAsRegisterInfo (MethodDefinition methodDef, AssemblyIndex index)
 	{
 		var methodName = index.Reader.GetString (methodDef.Name);
 		var sig = methodDef.DecodeSignature (SignatureTypeProvider.Instance, genericContext: default);
-		var jniSig = BuildJniSignatureFromManaged (sig);
+		var jniSig = BuildJniSignatureFromManaged (sig, index);
 		return new RegisterInfo (methodName, jniSig, null, false);
 	}
 
@@ -494,19 +494,19 @@ static RegisterInfo ParseExportFieldAsRegisterInfo (MethodDefinition methodDef,
 		return null;
 	}
 
-	static string BuildJniSignatureFromManaged (MethodSignature<string> sig)
+	string BuildJniSignatureFromManaged (MethodSignature<string> sig, AssemblyIndex index)
 	{
 		var sb = new System.Text.StringBuilder ();
 		sb.Append ('(');
 		foreach (var param in sig.ParameterTypes) {
-			sb.Append (ManagedTypeToJniDescriptor (param));
+			sb.Append (ManagedTypeToJniDescriptor (param, index));
 		}
 		sb.Append (')');
-		sb.Append (ManagedTypeToJniDescriptor (sig.ReturnType));
+		sb.Append (ManagedTypeToJniDescriptor (sig.ReturnType, index));
 		return sb.ToString ();
 	}
 
-	static string ManagedTypeToJniDescriptor (string managedType)
+	string ManagedTypeToJniDescriptor (string managedType, AssemblyIndex index)
 	{
 		switch (managedType) {
 		case "System.Void": return "V";
@@ -523,9 +523,17 @@ static string ManagedTypeToJniDescriptor (string managedType)
 		case "System.Single": return "F";
 		case "System.Double": return "D";
 		case "System.String": return "Ljava/lang/String;";
+		case "Java.Lang.ICharSequence": return "Ljava/lang/CharSequence;";
 		default:
 			if (managedType.EndsWith ("[]")) {
-				return "[" + ManagedTypeToJniDescriptor (managedType.Substring (0, managedType.Length - 2));
+				return "[" + ManagedTypeToJniDescriptor (managedType.Substring (0, managedType.Length - 2), index);
+			}
+			if (IsEnumManagedType (managedType, index)) {
+				return "I";
+			}
+			var jniName = ResolveManagedTypeJniName (managedType, index);
+			if (!string.IsNullOrEmpty (jniName)) {
+				return "L" + jniName + ";";
 			}
 			return "Ljava/lang/Object;";
 		}
@@ -535,8 +543,12 @@ static string ManagedTypeToJniDescriptor (string managedType)
 	/// Maps a managed type name (from SignatureTypeProvider) to an assembly-qualified name
 	/// like "System.Int32, System.Private.CoreLib" used in TypeManager.Activate calls.
 	/// </summary>
-	static string ManagedTypeToAssemblyQualifiedName (string managedType)
+	string ManagedTypeToAssemblyQualifiedName (string managedType, AssemblyIndex index)
 	{
+		if (managedType.IndexOf (", ", StringComparison.Ordinal) >= 0) {
+			return managedType;
+		}
+
 		// BCL types all live in System.Private.CoreLib
 		switch (managedType) {
 		case "System.Void":
@@ -558,11 +570,131 @@ static string ManagedTypeToAssemblyQualifiedName (string managedType)
 		case "System.UIntPtr":
 			return managedType + ", System.Private.CoreLib";
 		default:
-			// For non-BCL types, we don't know the assembly at this point.
-			// This is a best-effort mapping; full assembly resolution for
-			// arbitrary types is a follow-up.
-			return managedType;
+			// Best-effort assembly resolution across loaded assemblies.
+			var assemblyName = ResolveManagedTypeAssemblyName (managedType, index);
+			return assemblyName != null ? managedType + ", " + assemblyName : managedType;
+		}
+	}
+
+	string? ResolveManagedTypeAssemblyName (string managedType, AssemblyIndex index)
+	{
+		string typeName = StripManagedTypeDecorations (managedType);
+		if (typeName.Length == 0 || typeName [0] == '!') {
+			return null; // generic method/type parameter
+		}
+
+		if (IsBclTypeName (typeName)) {
+			return "System.Private.CoreLib";
+		}
+
+		if (TryResolveManagedTypeDefinition (typeName, index, out _, out var resolvedIndex)) {
+			return resolvedIndex.AssemblyName;
+		}
+
+		return index.AssemblyName;
+	}
+
+	bool IsEnumManagedType (string managedType, AssemblyIndex index)
+	{
+		string typeName = StripManagedTypeDecorations (managedType);
+		if (typeName.Length == 0 || typeName [0] == '!') {
+			return false;
+		}
+
+		if (!TryResolveManagedTypeDefinition (typeName, index, out var handle, out var resolvedIndex)) {
+			return false;
+		}
+
+		var typeDef = resolvedIndex.Reader.GetTypeDefinition (handle);
+		if (typeDef.BaseType.Kind == HandleKind.TypeReference) {
+			var (baseTypeName, _) = ResolveTypeReference ((TypeReferenceHandle) typeDef.BaseType, resolvedIndex);
+			return baseTypeName == "System.Enum";
+		}
+		if (typeDef.BaseType.Kind == HandleKind.TypeDefinition) {
+			var baseTypeDef = resolvedIndex.Reader.GetTypeDefinition ((TypeDefinitionHandle) typeDef.BaseType);
+			return AssemblyIndex.GetFullName (baseTypeDef, resolvedIndex.Reader) == "System.Enum";
+		}
+		return false;
+	}
+
+	string? ResolveManagedTypeJniName (string managedType, AssemblyIndex index)
+	{
+		string typeName = StripManagedTypeDecorations (managedType);
+		if (typeName.Length == 0 || typeName [0] == '!') {
+			return null;
+		}
+
+		if (!TryResolveManagedTypeDefinition (typeName, index, out var handle, out var resolvedIndex)) {
+			return null;
+		}
+
+		if (resolvedIndex.RegisterInfoByType.TryGetValue (handle, out var regInfo) &&
+			!string.IsNullOrEmpty (regInfo.JniName)) {
+			return regInfo.JniName;
+		}
+
+		return null;
+	}
+
+	bool TryResolveManagedTypeDefinition (string managedTypeName, AssemblyIndex index, out TypeDefinitionHandle handle, out AssemblyIndex resolvedIndex)
+	{
+		if (TryResolveType (managedTypeName, index.AssemblyName, out handle, out resolvedIndex)) {
+			return true;
+		}
+
+		foreach (var candidate in assemblyCache.Values) {
+			if (candidate.TypesByFullName.TryGetValue (managedTypeName, out handle)) {
+				resolvedIndex = candidate;
+				return true;
+			}
+		}
+
+		handle = default;
+		resolvedIndex = null!;
+		return false;
+	}
+
+	static bool IsBclTypeName (string managedTypeName)
+	{
+		switch (managedTypeName) {
+		case "System.Void":
+		case "System.Boolean":
+		case "System.Byte":
+		case "System.SByte":
+		case "System.Char":
+		case "System.Int16":
+		case "System.UInt16":
+		case "System.Int32":
+		case "System.UInt32":
+		case "System.Int64":
+		case "System.UInt64":
+		case "System.Single":
+		case "System.Double":
+		case "System.String":
+		case "System.Object":
+		case "System.IntPtr":
+		case "System.UIntPtr":
+			return true;
+		default:
+			return false;
+		}
+	}
+
+	static string StripManagedTypeDecorations (string managedType)
+	{
+		string result = managedType;
+		while (result.EndsWith ("[]", StringComparison.Ordinal) ||
+			   result.EndsWith ("&", StringComparison.Ordinal) ||
+			   result.EndsWith ("*", StringComparison.Ordinal)) {
+			result = result.Substring (0, result.Length - (result.EndsWith ("[]", StringComparison.Ordinal) ? 2 : 1));
+		}
+
+		int genericStart = result.IndexOf ('<');
+		if (genericStart >= 0) {
+			result = result.Substring (0, genericStart);
 		}
+
+		return result;
 	}
 
 	ActivationCtorInfo? ResolveActivationCtor (string typeName, TypeDefinition typeDef, AssemblyIndex index)

src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs

@@ -383,6 +383,29 @@ public void Generate_ExportMethod_HasWrapperMethods ()
 			}
 		}
 
+		[Fact]
+		public void Generate_ExportMarshalComplex_UsesArrayMarshalHelpers ()
+		{
+			var peers = ScanFixtures ();
+			var peer = peers.First (p => p.JavaName == "my/app/ExportMarshalComplex");
+			var path = GenerateAssembly (new [] { peer }, "ExportMarshalComplexHelpers");
+			try {
+				var (pe, reader) = OpenAssembly (path);
+				using (pe) {
+					var memberNames = Enumerable.Range (1, reader.GetTableRowCount (TableIndex.MemberRef))
+						.Select (i => reader.GetMemberReference (MetadataTokens.MemberReferenceHandle (i)))
+						.Select (m => reader.GetString (m.Name))
+						.ToList ();
+					Assert.Contains ("GetArray", memberNames);
+					Assert.Contains ("NewArray", memberNames);
+					Assert.Contains ("CopyArray", memberNames);
+					Assert.Contains ("GetCharSequence", memberNames);
+				}
+			} finally {
+				CleanUp (path);
+			}
+		}
+
 		[Fact]
 		public void Generate_ExportConstructor_HasWrapperMethods ()
 		{
@@ -410,6 +433,34 @@ public void Generate_ExportConstructor_HasWrapperMethods ()
 			}
 		}
 
+		[Fact]
+		public void Generate_ExportOnlyType_HasProxyAndRegistration ()
+		{
+			var peers = ScanFixtures ();
+			var peer = peers.First (p => p.ManagedTypeName == "MyApp.UnregisteredExporter");
+			var path = GenerateAssembly (new [] { peer }, "ExportOnlyType");
+			try {
+				var (pe, reader) = OpenAssembly (path);
+				using (pe) {
+					var proxy = reader.TypeDefinitions
+						.Select (h => reader.GetTypeDefinition (h))
+						.First (t => reader.GetString (t.Name) == "MyApp_UnregisteredExporter_Proxy");
+
+					var methods = proxy.GetMethods ()
+						.Select (h => reader.GetMethodDefinition (h))
+						.Select (m => reader.GetString (m.Name))
+						.ToList ();
+					Assert.Contains ("n_doExportedWork_uco_0", methods);
+					Assert.Contains ("RegisterNatives", methods);
+
+					var entries = ReadRegisterNativesEntries (pe, reader, proxy);
+					Assert.Contains (entries, e => e.jniMethodName == "n_DoExportedWork" && e.jniSignature == "()V");
+				}
+			} finally {
+				CleanUp (path);
+			}
+		}
+
 		[Fact]
 		public void Generate_ExportMethod_HasMethodBody ()
 		{
@@ -619,6 +670,31 @@ public void Generate_StaticExportAndExportField_RegisteredInRegisterNatives ()
 			}
 		}
 
+		[Fact]
+		public void Generate_ExportMarshalComplex_RegisteredInRegisterNatives ()
+		{
+			var peers = ScanFixtures ();
+			var peer = peers.First (p => p.JavaName == "my/app/ExportMarshalComplex");
+			var path = GenerateAssembly (new [] { peer }, "ExportMarshalComplexRegistration");
+			try {
+				var (pe, reader) = OpenAssembly (path);
+				using (pe) {
+					var proxy = reader.TypeDefinitions
+						.Select (h => reader.GetTypeDefinition (h))
+						.First (t => reader.GetString (t.Name) == "MyApp_ExportMarshalComplex_Proxy");
+
+					var entries = ReadRegisterNativesEntries (pe, reader, proxy);
+					Assert.Contains (entries, e => e.jniMethodName == "n_MutateInts" && e.jniSignature == "([I)V");
+					Assert.Contains (entries, e => e.jniMethodName == "n_RoundTripEnum" && e.jniSignature == "(I)I");
+					Assert.Contains (entries, e => e.jniMethodName == "n_EchoCharSequence" && e.jniSignature == "(Ljava/lang/CharSequence;)Ljava/lang/CharSequence;");
+					Assert.Contains (entries, e => e.jniMethodName == "n_EchoViews" && e.jniSignature == "([Landroid/view/View;)[Landroid/view/View;");
+					Assert.Contains (entries, e => e.jniMethodName == "n_EchoStrings" && e.jniSignature == "([Ljava/lang/String;)[Ljava/lang/String;");
+				}
+			} finally {
+				CleanUp (path);
+			}
+		}
+
 		[Fact]
 		public void Generate_ExportRegistration_HasCorrectJniSignatures ()
 		{
@@ -1071,4 +1147,4 @@ static void CleanUp (string path)
 			try { Directory.Delete (dir, true); } catch { }
 		}
 	}
-}
+}