[TrimmableTypeMap] Implement runtime TypeManager, ValueManager, and JavaConvert (#10967)

Fixes: #10791

## Summary

Adds the runtime-side support for the trimmable typemap: type resolution, peer creation, native method registration, and AOT-safe collection marshaling. All behind `RuntimeFeature.TrimmableTypeMap` (defaults to `false`).

### New runtime types
- **`JavaPeerProxy` / `JavaPeerProxy<T>`** — AOT-safe proxy attribute base. Generated proxy types extend this and provide `CreateInstance()` for peer creation and `GetContainerFactory()` for collection marshaling.
- **`IAndroidCallableWrapper`** — `RegisterNatives(JniType)` interface for ACW proxy types to register JNI native methods.
- **`JavaPeerContainerFactory`** — AOT-safe factories for arrays, lists, collections, and dictionaries without `MakeGenericType()`.
- **`TrimmableTypeMap`** — Central class owning the `TypeMapping` dictionary. Encapsulates all proxy attribute access: peer creation, invoker resolution, container factories, and native method registration bootstrap.
- **`TrimmableTypeMapTypeManager`** — `JniTypeManager` subclass delegating type lookups to `TrimmableTypeMap`. `RegisterNativeMembers` throws `UnreachableException` (JCW static blocks handle registration).

### Type resolution
- `GetProxyForManagedType(Type)` resolves managed type → JNI name via `IJniNameProviderAttribute` (shared interface for `[Register]` and `[JniTypeSignature]`) → TypeMap dictionary → proxy. Results cached in `ConcurrentDictionary`.
- `TryGetJniNameForType` shared between `TrimmableTypeMap` and `TrimmableTypeMapTypeManager`.
- `ActivateInstance` uses JNI `GetObjectClass` → `GetJniTypeNameFromClass` → TypeMap lookup for constructor activation (proxy types have self-applied attribute, not the target type).

### TypeMap dictionary initialization
- The runtime's `GetOrCreateExternalTypeMapping<Java.Lang.Object>()` handles assembly resolution automatically via the `System.Runtime.InteropServices.TypeMappingEntryAssembly` runtimeconfig property (set in `Trimmable.targets`). No manual `Assembly.Load` pre-loading is needed — the runtime walks `TypeMapAssemblyTargetAttribute` attributes from the entry assembly recursively.

### Native interop refactoring
- **`RegisterJniNatives` passed via init args** — `Initialize` sets `args->registerJniNativesFn` (null when `TrimmableTypeMap=true`). Eliminates the `create_delegate` call for `RegisterJniNatives`, letting the trimmer remove it cleanly in the trimmable path.
- **C++ `registerNatives` stub** — `Host::Java_mono_android_Runtime_registerNatives` no-op for the trimmable path (managed code handles registration via `Initialize`).
- **Null guard** on `jnienv_register_jni_natives` call site.
- `Initialize` is now the **single** `create_delegate` entry point from native code.

### RegisterNatives bootstrap
- `mono.android.Runtime.registerNatives(Class)` Java native method added
- `TrimmableTypeMap.Initialize()` registers the JNI callback during init (behind explicit `if (RuntimeFeature.TrimmableTypeMap)` guard for trimmer compatibility)
- When Java loads a JCW class, `OnRegisterNatives` resolves the proxy and calls `IAndroidCallableWrapper.RegisterNatives()` to bind UCO function pointers

### AOT-safe JavaConvert
- `JavaConvert.GetJniHandleConverter()` uses `JavaPeerContainerFactory` for `IList`, `ICollection`, `IDictionary`
- `JNIEnv.ArrayCreateInstance()` uses factory path

### Peer creation
- `JavaMarshalValueManager` (renamed from `ManagedValueManager`) overrides `CreatePeer` for the trimmable path — calls `proxy.CreateInstance()` directly, bypassing `GetUninitializedObject`
- `GetSimpleReferences` walks base type chain for managed-only subclasses without `[Register]`

### Wiring
- `RuntimeFeature.TrimmableTypeMap` feature switch with ILLink substitutions
- `JNIEnvInit` (CoreCLR) and `JavaInteropRuntime` + `JreRuntime` (NativeAOT) create the new managers when the feature is on
- `JavaMarshalValueManager` (renamed from `ManagedValueManager`) gets proxy-based peer creation in `TryConstructPeer`

### Dependencies
- dotnet/java-interop#1391 (RegisterNatives with raw function pointers — follow-up optimization)
- Manifest generator: #10991
- Build pipeline: #10980

### Test coverage
- 255/255 generator tests pass
- End-to-end HelloWorld app runs on device with Activity, layout XML, FindViewById\<Button\>, Click events
- Runtime tests require device integration (tracked by #10793)

### Trimmer size regression prevention
- Add ILLink substitutions for `IsMonoRuntime` and `IsCoreClrRuntime` — enables trimmer to eliminate runtime-specific branches
- `JavaMarshalValueManager`: remove `TrimmableTypeMap?` field, use `TrimmableTypeMap.Instance` singleton
- `TrimmableTypeMap`: private ctor, `Initialize()` static method, `Instance` throws if not initialized
- `TrimmableTypeMapTypeManager`: no constructor parameter, uses singleton
- No `TrimmableTypeMap` type references outside feature guards — clean trimming for MonoVM/NativeAOT

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Co-authored-by: Jonathan Peppers <jonathan.peppers@microsoft.com>

Author: 3 people

src/Microsoft.Android.Runtime.NativeAOT/Android.Runtime.NativeAOT/JavaInteropRuntime.cs

@@ -61,11 +61,13 @@ static void init (IntPtr jnienv, IntPtr klass, IntPtr classLoader, IntPtr langua
 			var settings    = new DiagnosticSettings ();
 			settings.AddDebugDotnetLog ();
 
+			var typeManager = CreateTypeManager ();
+
 			var options = new NativeAotRuntimeOptions {
 				EnvironmentPointer          = jnienv,
 				ClassLoader                 = new JniObjectReference (classLoader, JniObjectReferenceType.Global),
-				TypeManager                 = new ManagedTypeManager (),
-				ValueManager                = ManagedValueManager.GetOrCreateInstance (),
+				TypeManager                 = typeManager,
+				ValueManager                = new JavaMarshalValueManager (),
 				UseMarshalMemberBuilder     = false,
 				JniGlobalReferenceLogWriter = settings.GrefLog,
 				JniLocalReferenceLogWriter  = settings.LrefLog,
@@ -86,4 +88,13 @@ static void init (IntPtr jnienv, IntPtr klass, IntPtr classLoader, IntPtr langua
 		}
 		transition.Dispose ();
 	}
+
+	static JniRuntime.JniTypeManager CreateTypeManager ()
+	{
+		if (RuntimeFeature.TrimmableTypeMap) {
+			return new TrimmableTypeMapTypeManager ();
+		}
+
+		return new ManagedTypeManager ();
+	}
 }

src/Microsoft.Android.Runtime.NativeAOT/Java.Interop/JreRuntime.cs

@@ -58,10 +58,10 @@ static NativeAotRuntimeOptions CreateJreVM (NativeAotRuntimeOptions builder)
 				throw new InvalidOperationException ($"Member `{nameof (NativeAotRuntimeOptions)}.{nameof (NativeAotRuntimeOptions.JvmLibraryPath)}` must be set.");
 
 #if NET
-			builder.TypeManager     ??= new ManagedTypeManager ();
+			builder.TypeManager     ??= CreateDefaultTypeManager ();
 #endif  // NET
 
-			builder.ValueManager            ??= ManagedValueManager.GetOrCreateInstance();
+			builder.ValueManager            ??= JavaMarshalValueManager.Instance;
 			builder.ObjectReferenceManager  ??= new Android.Runtime.AndroidObjectReferenceManager ();
 
 			if (builder.InvocationPointer != IntPtr.Zero || builder.EnvironmentPointer != IntPtr.Zero)
@@ -75,6 +75,15 @@ internal protected JreRuntime (NativeAotRuntimeOptions builder)
 		{
 		}
 
+		static JniRuntime.JniTypeManager CreateDefaultTypeManager ()
+		{
+			if (RuntimeFeature.TrimmableTypeMap) {
+				return new TrimmableTypeMapTypeManager ();
+			}
+
+			return new ManagedTypeManager ();
+		}
+
 		public override string? GetCurrentManagedThreadName ()
 		{
 			return Thread.CurrentThread.Name;

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

@@ -24,12 +24,18 @@ public static partial class JNIEnv {
 
 		public static IntPtr Handle => JniEnvironment.EnvironmentPointer;
 
-		static Array ArrayCreateInstance (Type elementType, int length) =>
-			// FIXME: https://github.com/xamarin/xamarin-android/issues/8724
-			// IL3050 disabled in source: if someone uses NativeAOT, they will get the warning.
-			#pragma warning disable IL3050
-			Array.CreateInstance (elementType, length);
+		static Array ArrayCreateInstance (Type elementType, int length)
+		{
+			if (RuntimeFeature.TrimmableTypeMap) {
+				var factory = TrimmableTypeMap.Instance?.GetContainerFactory (elementType);
+				if (factory is not null)
+					return factory.CreateArray (length, 1);
+			}
+
+			#pragma warning disable IL3050 // Array.CreateInstance is not AOT-safe, but this is the legacy fallback path
+			return Array.CreateInstance (elementType, length);
 			#pragma warning restore IL3050
+		}
 
 		static Type MakeArrayType (Type type) =>
 			// FIXME: https://github.com/xamarin/xamarin-android/issues/8724

src/Mono.Android/Android.Runtime/JNIEnvInit.cs

@@ -36,6 +36,7 @@ internal struct JnienvInitializeArgs {
 			public IntPtr          grefGCUserPeerable;
 			public bool            managedMarshalMethodsLookupEnabled;
 			public IntPtr          propagateUncaughtExceptionFn;
+			public IntPtr          registerJniNativesFn;
 		}
 #pragma warning restore 0649
 
@@ -81,7 +82,10 @@ static Type TypeGetType (string typeName) =>
 			JniType.GetCachedJniType (ref jniType, className);
 
 			ReadOnlySpan<char> methods = new ReadOnlySpan<char> ((void*) methods_ptr, methods_len);
-			androidRuntime!.TypeManager.RegisterNativeMembers (jniType, type, methods);
+			if (androidRuntime is null) {
+				throw new InvalidOperationException ("androidRuntime has not been initialized");
+			}
+			androidRuntime.TypeManager.RegisterNativeMembers (jniType, type, methods);
 		}
 
 		// This must be called by NativeAOT before InitializeJniRuntime, as early as possible
@@ -130,16 +134,20 @@ internal static unsafe void Initialize (JnienvInitializeArgs* args)
 
 			BoundExceptionType = (BoundExceptionType)args->ioExceptionType;
 			JniRuntime.JniTypeManager typeManager;
-			JniRuntime.JniValueManager valueManager;
-			if (RuntimeFeature.ManagedTypeMap) {
+			JniRuntime.JniValueManager? valueManager = null;
+			if (RuntimeFeature.TrimmableTypeMap) {
+				typeManager     = new TrimmableTypeMapTypeManager ();
+				valueManager    = new JavaMarshalValueManager ();
+			} else if (RuntimeFeature.ManagedTypeMap) {
 				typeManager     = new ManagedTypeManager ();
 			} else {
 				typeManager     = new AndroidTypeManager (args->jniAddNativeMethodRegistrationAttributePresent != 0);
 			}
 			if (RuntimeFeature.IsMonoRuntime) {
 				valueManager = new AndroidValueManager ();
 			} else if (RuntimeFeature.IsCoreClrRuntime) {
-				valueManager = ManagedValueManager.GetOrCreateInstance ();
+				// Note: this will be removed once trimmable typemap is the only supported option for CoreCLR runtime
+				valueManager ??= new JavaMarshalValueManager ();
 			} else {
 				throw new NotSupportedException ("Internal error: unknown runtime not supported");
 			}
@@ -152,6 +160,10 @@ internal static unsafe void Initialize (JnienvInitializeArgs* args)
 					args->jniAddNativeMethodRegistrationAttributePresent != 0
 			);
 
+			if (RuntimeFeature.TrimmableTypeMap) {
+				TrimmableTypeMap.Initialize ();
+			}
+
 			grefIGCUserPeer_class = args->grefIGCUserPeer;
 			grefGCUserPeerable_class = args->grefGCUserPeerable;
 
@@ -165,6 +177,10 @@ internal static unsafe void Initialize (JnienvInitializeArgs* args)
 			}
 
 			args->propagateUncaughtExceptionFn = (IntPtr)(delegate* unmanaged<IntPtr, IntPtr, IntPtr, void>)&PropagateUncaughtException;
+
+			if (!RuntimeFeature.TrimmableTypeMap) {
+				args->registerJniNativesFn = (IntPtr)(delegate* unmanaged<IntPtr, int, IntPtr, IntPtr, int, void>)&RegisterJniNatives;
+			}
 			RunStartupHooksIfNeeded ();
 			SetSynchronizationContext ();
 		}

src/Mono.Android/ILLink/ILLink.Substitutions.xml

@@ -4,9 +4,5 @@
       <method signature="System.Boolean get_NegotiateAuthenticationIsEnabled()" body="stub" feature="Xamarin.Android.Net.UseNegotiateAuthentication" featurevalue="false" value="false" />
       <method signature="System.Boolean get_NegotiateAuthenticationIsEnabled()" body="stub" feature="Xamarin.Android.Net.UseNegotiateAuthentication" featurevalue="true" value="true" />
     </type>
-    <type fullname="Microsoft.Android.Runtime.RuntimeFeature">
-      <method signature="System.Boolean get_ManagedTypeMap()" body="stub" feature="Microsoft.Android.Runtime.RuntimeFeature.ManagedTypeMap" featurevalue="false" value="false" />
-      <method signature="System.Boolean get_ManagedTypeMap()" body="stub" feature="Microsoft.Android.Runtime.RuntimeFeature.ManagedTypeMap" featurevalue="true" value="true" />
-    </type>
   </assembly>
 </linker>

src/Mono.Android/Java.Interop/IAndroidCallableWrapper.cs

@@ -0,0 +1,21 @@
+#nullable enable
+
+using System;
+
+namespace Java.Interop
+{
+	/// <summary>
+	/// Interface for proxy types that represent Android Callable Wrappers (ACW).
+	/// ACW types are .NET types that have a corresponding generated Java class
+	/// which calls back into .NET via JNI native methods.
+	/// </summary>
+	public interface IAndroidCallableWrapper
+	{
+		/// <summary>
+		/// Registers JNI native methods for this ACW type.
+		/// Called when the Java class is first loaded and needs its native methods bound.
+		/// </summary>
+		/// <param name="nativeClass">The JNI type for the Java class.</param>
+		void RegisterNatives (JniType nativeClass);
+	}
+}

src/Mono.Android/Java.Interop/JavaConvert.cs

@@ -6,6 +6,7 @@
 using System.Reflection;
 
 using Android.Runtime;
+using Microsoft.Android.Runtime;
 
 namespace Java.Interop {
 
@@ -79,6 +80,13 @@ params Type [] typeArguments
 				return converter;
 			if (target.IsArray)
 				return (h, t) => JNIEnv.GetArray (h, t, target.GetElementType ());
+
+			if (RuntimeFeature.TrimmableTypeMap) {
+				var factoryConverter = TryGetFactoryBasedConverter (target);
+				if (factoryConverter != null)
+					return factoryConverter;
+			}
+
 			if (target.IsGenericType && target.GetGenericTypeDefinition() == typeof (IDictionary<,>)) {
 				Type t = MakeGenericType (typeof (JavaDictionary<,>), target.GetGenericArguments ());
 				return GetJniHandleConverterForType (t);
@@ -101,6 +109,52 @@ params Type [] typeArguments
 			return null;
 		}
 
+		/// <summary>
+		/// AOT-safe converter using <see cref="JavaPeerContainerFactory"/> from the generated proxy.
+		/// Avoids <c>MakeGenericType()</c> by using the pre-typed factory from the proxy attribute.
+		/// </summary>
+		static Func<IntPtr, JniHandleOwnership, object?>? TryGetFactoryBasedConverter (Type target)
+		{
+			if (!target.IsGenericType)
+				return null;
+
+			var genericDef = target.GetGenericTypeDefinition ();
+			var typeArgs = target.GetGenericArguments ();
+
+			if (genericDef == typeof (IList<>) && typeArgs.Length == 1) {
+				var factory = TryGetContainerFactory (typeArgs [0]);
+				if (factory != null)
+					return (h, t) => factory.CreateList (h, t);
+			}
+
+			if (genericDef == typeof (ICollection<>) && typeArgs.Length == 1) {
+				var factory = TryGetContainerFactory (typeArgs [0]);
+				if (factory != null)
+					return (h, t) => factory.CreateCollection (h, t);
+			}
+
+			if (genericDef == typeof (IDictionary<,>) && typeArgs.Length == 2) {
+				var keyFactory = TryGetContainerFactory (typeArgs [0]);
+				var valueFactory = TryGetContainerFactory (typeArgs [1]);
+				if (keyFactory != null && valueFactory != null)
+					return (h, t) => valueFactory.CreateDictionary (keyFactory, h, t);
+			}
+
+			return null;
+		}
+
+		static JavaPeerContainerFactory? TryGetContainerFactory (Type elementType)
+		{
+			if (!typeof (IJavaPeerable).IsAssignableFrom (elementType))
+				return null;
+
+			if (RuntimeFeature.TrimmableTypeMap) {
+				return TrimmableTypeMap.Instance?.GetContainerFactory (elementType);
+			}
+
+			return null;
+		}
+
 		static Func<IntPtr, JniHandleOwnership, object> GetJniHandleConverterForType ([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)] Type t)
 		{
 			MethodInfo m = t.GetMethod ("FromJniHandle", BindingFlags.Static | BindingFlags.Public)!;

src/Mono.Android/Java.Interop/JavaPeerContainerFactory.cs

@@ -0,0 +1,114 @@
+#nullable enable
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+using Android.Runtime;
+
+namespace Java.Interop
+{
+	/// <summary>
+	/// AOT-safe factory for creating typed containers (arrays, lists, collections, dictionaries)
+	/// without using <c>MakeGenericType()</c> or <c>Array.CreateInstance()</c>.
+	/// </summary>
+	public abstract class JavaPeerContainerFactory
+	{
+		/// <summary>
+		/// Creates a typed jagged array. Rank 1 = T[], rank 2 = T[][], etc.
+		/// </summary>
+		internal abstract Array CreateArray (int length, int rank);
+
+		/// <summary>
+		/// Creates a typed <c>JavaList&lt;T&gt;</c> from a JNI handle.
+		/// </summary>
+		internal abstract IList CreateList (IntPtr handle, JniHandleOwnership transfer);
+
+		/// <summary>
+		/// Creates a typed <c>JavaCollection&lt;T&gt;</c> from a JNI handle.
+		/// </summary>
+		internal abstract ICollection CreateCollection (IntPtr handle, JniHandleOwnership transfer);
+
+		/// <summary>
+		/// Creates a typed <c>JavaDictionary&lt;TKey, TValue&gt;</c> using the visitor pattern.
+		/// This factory provides the value type; <paramref name="keyFactory"/> provides the key type.
+		/// </summary>
+		internal virtual IDictionary? CreateDictionary (JavaPeerContainerFactory keyFactory, IntPtr handle, JniHandleOwnership transfer)
+			=> null;
+
+		/// <summary>
+		/// Visitor callback invoked by the value factory's <see cref="CreateDictionary"/>.
+		/// Override in <see cref="JavaPeerContainerFactory{T}"/> to provide both type parameters.
+		/// </summary>
+		internal virtual IDictionary? CreateDictionaryWithValueFactory<TValue> (
+			JavaPeerContainerFactory<TValue> valueFactory, IntPtr handle, JniHandleOwnership transfer)
+			where TValue : class, IJavaPeerable
+			=> null;
+
+		/// <summary>
+		/// Creates a <see cref="JavaPeerContainerFactory{T}"/> singleton for the specified type.
+		/// </summary>
+		public static JavaPeerContainerFactory Create<
+			[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
+			T
+		> () where T : class, IJavaPeerable
+			=> JavaPeerContainerFactory<T>.Instance;
+	}
+
+	/// <summary>
+	/// Typed container factory. All creation uses direct <c>new</c> expressions — fully AOT-safe.
+	/// </summary>
+	/// <typeparam name="T">The Java peer element type.</typeparam>
+	public sealed class JavaPeerContainerFactory<
+	 	// TODO (https://github.com/dotnet/android/issues/10794): Remove this DAM annotation — it preserves too much reflection metadata on all types in the typemap.
+		[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
+		T
+	> : JavaPeerContainerFactory
+		where T : class, IJavaPeerable
+	{
+		internal static readonly JavaPeerContainerFactory<T> Instance = new ();
+
+		JavaPeerContainerFactory () { }
+
+		// TODO (https://github.com/dotnet/android/issues/10794): This might cause unnecessary code bloat for NativeAOT. Revisit
+		// how we use this API and instead use a differnet approach that uses AOT-safe `Array.CreateInstanceFromArrayType`
+		// with statically provided array types based on a statically known array type.
+		internal override Array CreateArray (int length, int rank) => rank switch {
+			1 => new T [length],
+			2 => new T [length][],
+			3 => new T [length][][],
+			_ when rank >= 0 => CreateHigherRankArray (length, rank),
+			_ => throw new ArgumentOutOfRangeException (nameof (rank), rank, "Rank must be non-negative."),
+		};
+
+		static Array CreateHigherRankArray (int length, int rank)
+		{
+			if (!RuntimeFeature.IsDynamicCodeSupported) {
+				throw new NotSupportedException ($"Cannot create array of rank {rank} because dynamic code is not supported.");
+			}
+
+			var arrayType = typeof (T);
+			for (int i = 0; i < rank; i++) {
+				arrayType = arrayType.MakeArrayType ();
+			}
+
+			return Array.CreateInstanceFromArrayType (arrayType, length);
+		}
+
+		internal override IList CreateList (IntPtr handle, JniHandleOwnership transfer)
+			=> new Android.Runtime.JavaList<T> (handle, transfer);
+
+		internal override ICollection CreateCollection (IntPtr handle, JniHandleOwnership transfer)
+			=> new Android.Runtime.JavaCollection<T> (handle, transfer);
+
+		internal override IDictionary? CreateDictionary (JavaPeerContainerFactory keyFactory, IntPtr handle, JniHandleOwnership transfer)
+			=> keyFactory.CreateDictionaryWithValueFactory (this, handle, transfer);
+
+		#pragma warning disable IL2091 // DynamicallyAccessedMembers on base method type parameter cannot be repeated on override in C#
+		internal override IDictionary? CreateDictionaryWithValueFactory<TValue> (
+			JavaPeerContainerFactory<TValue> valueFactory, IntPtr handle, JniHandleOwnership transfer)
+			=> new Android.Runtime.JavaDictionary<T, TValue> (handle, transfer);
+		#pragma warning restore IL2091
+	}
+}