[TrimmableTypeMap] Implement reflection-free TrimmableTypeMapValueManager and TrimmableTypeMapTypeManager

Documentation/docs-mobile/messages/index.md

@@ -221,8 +221,7 @@ Either change the value in the AndroidManifest.xml to match the $(SupportedOSPla
 + [XA4250](xa4250.md): Manifest-referenced type '{type}' was not found in any scanned assembly. It may be a framework type.
 + [XA4252](xa4252.md): Insecure HTTP Maven repository URL '{url}' is not allowed. Use an HTTPS URL, or set AllowInsecureHttp="true" metadata on the item to override this check.
 + [XA4253](xa4253.md): Generated Java callable wrapper code changed: '{path}'
-+ [XA4254](xa4254.md): Trimmable type map Java source input directory '{input}' and output directory '{output}' must be different.
-+ [XA4255](xa4255.md): Generated trimmable type map Java source '{path}' was not found.
++ [XA4256](xa4256.md): Skipping Java peer type '{type}' from assembly '{assembly}' because referenced type '{referencedType}' from assembly '{referencedAssembly}' could not be resolved in '{path}'. This type will not be included in the trimmable type map.
 + XA4300: Native library '{library}' will not be bundled because it has an unsupported ABI.
 + [XA4301](xa4301.md): Apk already contains the item `xxx`.
 + [XA4302](xa4302.md): Unhandled exception merging \`AndroidManifest.xml\`: {ex}

Documentation/docs-mobile/messages/xa4256.md

@@ -0,0 +1,27 @@
+---
+title: .NET for Android warning XA4256
+description: XA4256 warning code
+ms.date: 06/25/2026
+f1_keywords:
+  - "XA4256"
+---
+
+# .NET for Android warning XA4256
+
+## Example message
+
+```
+warning XA4256: Skipping Java peer type 'Google.Android.Material.Shadow.ShadowDrawableWrapper' from assembly 'Xamarin.Google.Android.Material' because referenced type 'AndroidX.AppCompat.Graphics.Drawable.DrawableWrapper' from assembly 'Xamarin.AndroidX.AppCompat.AppCompatResources' could not be resolved in '/home/user/.nuget/packages/xamarin.androidx.appcompat.appcompatresources/1.6.0/lib/net6.0-android31.0/Xamarin.AndroidX.AppCompat.AppCompatResources.dll'. This type will not be included in the trimmable type map.
+```
+
+## Issue
+
+The trimmable type map found a Java peer type whose managed base type or implemented interface references a type that is not present in the resolved assembly set.
+
+This can happen when NuGet packages in the Android binding graph were built against different versions of another binding package. The type may be unused by the app, but NativeAOT compiles a closed world and must resolve rooted managed types eagerly.
+
+## Solution
+
+If your app uses the skipped type, update the affected NuGet packages so the referenced type exists, or update to versions of the binding packages that are compatible with each other.
+
+If your app does not use the skipped type, no action is required. The type is omitted from the trimmable type map so NativeAOT does not fail while resolving unused stale metadata.

samples/HelloWorld/HelloWorld/HelloWorld.DotNet.csproj

@@ -3,6 +3,7 @@
     <TargetFramework>$(DotNetAndroidTargetFramework)</TargetFramework>
     <OutputType>Exe</OutputType>
     <RootNamespace>HelloWorld</RootNamespace>
+    <PublishAot>true</PublishAot>
   </PropertyGroup>
   <ItemGroup>
     <ProjectReference Include="..\HelloLibrary\HelloLibrary.DotNet.csproj" />

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

@@ -61,7 +61,7 @@ static NativeAotRuntimeOptions CreateJreVM (NativeAotRuntimeOptions builder)
 			builder.TypeManager     ??= CreateDefaultTypeManager ();
 #endif  // NET
 
-			builder.ValueManager            ??= new JavaMarshalValueManager ();
+			builder.ValueManager            ??= Android.Runtime.JNIEnvInit.CreateValueManager ();
 			builder.ObjectReferenceManager  ??= new Android.Runtime.AndroidObjectReferenceManager ();
 
 			if (builder.InvocationPointer != IntPtr.Zero || builder.EnvironmentPointer != IntPtr.Zero)
@@ -81,7 +81,7 @@ static JniRuntime.JniTypeManager CreateDefaultTypeManager ()
 				return new TrimmableTypeMapTypeManager ();
 			}
 
-			return new ManagedTypeManager ();
+			throw new NotImplementedException ();
 		}
 
 		public override string? GetCurrentManagedThreadName ()

src/Microsoft.Android.Sdk.ILLink/PreserveLists/Mono.Android.xml

@@ -27,6 +27,7 @@
 		<type fullname="Android.Runtime.RaiseThrowableEventArgs" />
 		<type fullname="Android.Runtime.RegisterAttribute" />
 		<type fullname="Android.Runtime.TypeManager" />
+		<type fullname="Microsoft.Android.Runtime.ManagedTypeMapping" preserve="all" />
 		<!--
 		<type fullname="Android.Runtime.XmlResourceParserReader" />
 		<type fullname="Android.Runtime.XmlPullParserReader" />

src/Microsoft.Android.Sdk.TrimmableTypeMap/AssemblyInput.cs

@@ -0,0 +1,5 @@
+using System.Reflection.PortableExecutable;
+
+namespace Microsoft.Android.Sdk.TrimmableTypeMap;
+
+public readonly record struct AssemblyInput (string Name, string Path, PEReader Reader);

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

@@ -17,6 +17,14 @@ static class AndroidEnumConverter
 		_ => null,
 	};
 
+	public static string? RotationAnimationToString (int value) => value switch {
+		0 => "rotate",
+		1 => "crossfade",
+		2 => "jumpcut",
+		3 => "seamless",
+		_ => null,
+	};
+
 	public static string? ScreenOrientationToString (int value, int targetSdkVersion = 0) => value switch {
 		-1 => "unspecified",
 		0 => "landscape",
@@ -126,8 +134,8 @@ static class AndroidEnumConverter
 
 	public static string? ActivityPersistableModeToString (int value) => value switch {
 		0 => "persistRootOnly",
-		1 => "persistAcrossReboots",
-		2 => "persistNever",
+		1 => "persistNever",
+		2 => "persistAcrossReboots",
 		_ => null,
 	};
 }

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

@@ -14,7 +14,7 @@ static class ComponentElementBuilder
 	static readonly XNamespace AndroidNs = ManifestConstants.AndroidNs;
 	static readonly XName AttName = ManifestConstants.AttName;
 
-	internal static XElement? CreateComponentElement (JavaPeerInfo peer, string jniName, int targetSdkVersion = 0)
+	internal static XElement? CreateComponentElement (JavaPeerInfo peer, string jniName, int targetSdkVersion = 0, IReadOnlyDictionary<string, string>? managedToManifestNames = null)
 	{
 		var component = peer.ComponentAttribute;
 		if (component is null) {
@@ -34,11 +34,24 @@ static class ComponentElementBuilder
 		// Map known properties to android: attributes
 		PropertyMapper.MapComponentProperties (element, component, targetSdkVersion);
 
+		// android:parentActivityName comes from a [Activity (ParentActivity = typeof (...))] and is
+		// captured as the managed type name. Resolve it to the parent's Java/manifest name, matching
+		// the legacy ManifestDocument behavior (JavaNativeTypeManager.ToJniName).
+		ResolveParentActivityName (element, managedToManifestNames);
+
 		// Add intent filters
 		foreach (var intentFilter in component.IntentFilters) {
 			element.Add (CreateIntentFilterElement (intentFilter));
 		}
 
+		// Add <layout> element from a [Layout] attribute, if present
+		if (component.LayoutProperties is not null) {
+			var layout = CreateLayoutElement (component.LayoutProperties);
+			if (layout is not null) {
+				element.Add (layout);
+			}
+		}
+
 		// Handle MainLauncher for activities
 		if (component.Kind == ComponentKind.Activity && component.Properties.TryGetValue ("MainLauncher", out var ml) && ml is bool b && b) {
 			AddLauncherIntentFilter (element);
@@ -49,9 +62,54 @@ static class ComponentElementBuilder
 			element.Add (CreateMetaDataElement (meta));
 		}
 
+		// The legacy ManifestDocumentElement.ToElement sorts attributes alphabetically
+		// (specified.OrderBy (e => e)). Match that ordering so the generated manifest is
+		// byte-compatible with the legacy path when AndroidManifestMerger='legacy' (the
+		// manifestmerger.jar path re-sorts attributes itself, so this is also safe there).
+		SortAttributesAlphabetically (element);
+
 		return element;
 	}
 
+	// Reorders an element's attributes alphabetically by local name (case-insensitive),
+	// matching the legacy manifest generator's attribute ordering.
+	static void SortAttributesAlphabetically (XElement element)
+	{
+		var sorted = element.Attributes ()
+			.OrderBy (a => a.Name.LocalName, StringComparer.OrdinalIgnoreCase)
+			.ToList ();
+		if (sorted.Count < 2) {
+			return;
+		}
+		foreach (var attr in element.Attributes ().ToList ()) {
+			attr.Remove ();
+		}
+		foreach (var attr in sorted) {
+			element.Add (attr);
+		}
+	}
+
+	static void ResolveParentActivityName (XElement element, IReadOnlyDictionary<string, string>? managedToManifestNames)
+	{
+		if (managedToManifestNames is null) {
+			return;
+		}
+
+		var attr = element.Attribute (AndroidNs + "parentActivityName");
+		if (attr is null) {
+			return;
+		}
+
+		// The value may be assembly-qualified ("Foo.Bar, Asm [Version=...]"); use the type name part.
+		var value = attr.Value;
+		int comma = value.IndexOf (',');
+		var typeName = (comma < 0 ? value : value.Substring (0, comma)).Trim ();
+
+		if (managedToManifestNames.TryGetValue (typeName, out var manifestName)) {
+			attr.Value = manifestName;
+		}
+	}
+
 	internal static void AddLauncherIntentFilter (XElement activity)
 	{
 		// Check if there's already a launcher intent filter
@@ -154,6 +212,30 @@ internal static XElement CreateMetaDataElement (MetaDataInfo meta)
 		return element;
 	}
 
+	// Maps [Layout] attribute properties to the <layout> element's android: attributes.
+	static readonly (string Property, string Attribute) [] LayoutMappings = [
+		("DefaultHeight", "defaultHeight"),
+		("DefaultWidth", "defaultWidth"),
+		("Gravity", "gravity"),
+		("MinHeight", "minHeight"),
+		("MinWidth", "minWidth"),
+	];
+
+	internal static XElement? CreateLayoutElement (IReadOnlyDictionary<string, object?> layoutProperties)
+	{
+		var element = new XElement ("layout");
+		bool hasAttribute = false;
+
+		foreach (var (property, attribute) in LayoutMappings) {
+			if (layoutProperties.TryGetValue (property, out var value) && value is string s && !string.IsNullOrEmpty (s)) {
+				element.SetAttributeValue (AndroidNs + attribute, s);
+				hasAttribute = true;
+			}
+		}
+
+		return hasAttribute ? element : null;
+	}
+
 	internal static void UpdateApplicationElement (XElement app, JavaPeerInfo peer, int targetSdkVersion = 0)
 	{
 		string jniName = JniSignatureHelper.JniNameToJavaName (peer.JavaName);

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

@@ -0,0 +1,96 @@
+using System;
+using System.Buffers;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace Microsoft.Android.Sdk.TrimmableTypeMap;
+
+sealed class DeterministicHashBuilder : IDisposable
+{
+	readonly HashAlgorithm hash = SHA256.Create ();
+	readonly byte [] intBuffer = new byte [4];
+	readonly byte [] byteBuffer = new byte [1];
+	bool finished;
+
+	public void AddString (string value)
+	{
+		var bytes = Encoding.UTF8.GetBytes (value);
+		AddInt32 (bytes.Length);
+		AddBytes (bytes);
+	}
+
+	public void AddVersion (Version version)
+	{
+		AddInt32 (version.Major);
+		AddInt32 (version.Minor);
+		AddInt32 (version.Build);
+		AddInt32 (version.Revision);
+	}
+
+	public void AddInt32 (int value)
+	{
+		intBuffer [0] = (byte) value;
+		intBuffer [1] = (byte) (value >> 8);
+		intBuffer [2] = (byte) (value >> 16);
+		intBuffer [3] = (byte) (value >> 24);
+		AddBytes (intBuffer);
+	}
+
+	public void AddByte (byte value)
+	{
+		byteBuffer [0] = value;
+		AddBytes (byteBuffer);
+	}
+
+	public void AddBytes (byte [] bytes)
+	{
+		EnsureNotFinished ();
+		if (bytes.Length != 0) {
+			hash.TransformBlock (bytes, 0, bytes.Length, null, 0);
+		}
+	}
+
+	public void AddBytes (ReadOnlySpan<byte> bytes)
+	{
+		EnsureNotFinished ();
+		if (bytes.IsEmpty) {
+			return;
+		}
+
+		var buffer = ArrayPool<byte>.Shared.Rent (Math.Min (bytes.Length, 4096));
+		try {
+			while (!bytes.IsEmpty) {
+				var count = Math.Min (bytes.Length, buffer.Length);
+				bytes.Slice (0, count).CopyTo (buffer);
+				hash.TransformBlock (buffer, 0, count, null, 0);
+				bytes = bytes.Slice (count);
+			}
+		} finally {
+			ArrayPool<byte>.Shared.Return (buffer);
+		}
+	}
+
+	public byte [] ToHash ()
+	{
+		if (!finished) {
+			hash.TransformFinalBlock ([], 0, 0);
+			finished = true;
+		}
+		if (hash.Hash is not null) {
+			return hash.Hash;
+		}
+		throw new InvalidOperationException ("SHA256 did not produce a hash.");
+	}
+
+	void EnsureNotFinished ()
+	{
+		if (finished) {
+			throw new InvalidOperationException ("Cannot add data after finalizing the hash.");
+		}
+	}
+
+	public void Dispose ()
+	{
+		hash.Dispose ();
+	}
+}