diff --git a/Documentation/docs-mobile/TOC.yml b/Documentation/docs-mobile/TOC.yml
index bdb778ad713..5c0e8c892f7 100644
--- a/Documentation/docs-mobile/TOC.yml
+++ b/Documentation/docs-mobile/TOC.yml
@@ -274,6 +274,8 @@
href: messages/xa1037.md
- name: XA1038
href: messages/xa1038.md
+ - name: XA1050
+ href: messages/xa1050.md
- name: "XA2xxx: Linker"
items:
- name: "XA2xxx: Linker"
diff --git a/Documentation/docs-mobile/building-apps/build-properties.md b/Documentation/docs-mobile/building-apps/build-properties.md
index c261eccd0b9..964d0d7a4db 100644
--- a/Documentation/docs-mobile/building-apps/build-properties.md
+++ b/Documentation/docs-mobile/building-apps/build-properties.md
@@ -1119,6 +1119,22 @@ r8 dex-compiler and shrinker. The default value is a path into the
.NET for Android workload installation. For further information see our
documentation on [D8 and R8][d8-r8].
+## AndroidR8ObfuscationMode
+
+An enum-style property that specifies how `r8` obfuscates Java names when
+[`$(AndroidLinkTool)`](#androidlinktool) is `r8`. Supported values are:
+
+- `private-members` preserves Java class and interface names and public or
+ protected member names. Private and package-private members can be
+ obfuscated, and R8 optimization is enabled.
+- `disabled` disables obfuscation, preserves all Java names, and uses the
+ non-optimizing Android R8 defaults.
+
+This property does not disable R8 code shrinking.
+
+This property was introduced in a .NET 10 servicing release and defaults to
+`disabled` in .NET 10.
+
## AndroidResgenExtraArgs
Specifies
diff --git a/Documentation/docs-mobile/messages/index.md b/Documentation/docs-mobile/messages/index.md
index 4ed408a0899..48a3517dbc9 100644
--- a/Documentation/docs-mobile/messages/index.md
+++ b/Documentation/docs-mobile/messages/index.md
@@ -150,6 +150,7 @@ Either change the value in the AndroidManifest.xml to match the $(SupportedOSPla
+ [XA1039](xa1039.md): The Android Support libraries are not supported in .NET 9 and later, please migrate to AndroidX. See https://aka.ms/xamarin/androidx for more details.
+ [XA1040](xa1040.md): The CoreCLR runtime on Android is an experimental feature and not yet suitable for production use. File issues at: https://github.com/dotnet/android/issues
+ [XA1041](xa1041.md): The MSBuild property 'MonoAndroidAssetPrefix' has an invalid value of 'c:\Foo\Assets'. The value is expected to be a directory path representing the relative location of your Assets or Resources
++ [XA1050](xa1050.md): The 'AndroidR8ObfuscationMode' MSBuild property has an invalid value.
## XA2xxx: Linker
diff --git a/Documentation/docs-mobile/messages/xa1050.md b/Documentation/docs-mobile/messages/xa1050.md
new file mode 100644
index 00000000000..1f984daa7ba
--- /dev/null
+++ b/Documentation/docs-mobile/messages/xa1050.md
@@ -0,0 +1,34 @@
+---
+title: .NET for Android error XA1050
+description: XA1050 error code
+ms.date: 09/10/2026
+f1_keywords:
+ - "XA1050"
+---
+
+# .NET for Android error XA1050
+
+## Example messages
+
+```dotnetcli
+error XA1050: The 'AndroidR8ObfuscationMode' MSBuild property has an invalid value of 'private-member'. Valid values are 'disabled' and 'private-members'.
+```
+
+## Issue
+
+The [`$(AndroidR8ObfuscationMode)`](../building-apps/build-properties.md#androidr8obfuscationmode)
+MSBuild property contains an unsupported value. This property is validated when
+R8 runs.
+
+## Solution
+
+Set `$(AndroidR8ObfuscationMode)` to one of the supported values:
+
+```xml
+
+ private-members
+
+```
+
+Use `disabled` to preserve all Java names and use the legacy non-optimizing
+Android R8 configuration.
diff --git a/build-tools/installers/create-installers.targets b/build-tools/installers/create-installers.targets
index 6eea7e7fe9c..bdf7ac5f34f 100644
--- a/build-tools/installers/create-installers.targets
+++ b/build-tools/installers/create-installers.targets
@@ -136,6 +136,7 @@
<_MSBuildFiles Include="$(MicrosoftAndroidSdkOutDir)java_runtime_clr.dex" ExcludeFromLegacy="true" />
<_MSBuildFiles Include="$(MicrosoftAndroidSdkOutDir)java_runtime_fastdev_clr.dex" ExcludeFromLegacy="true" />
<_MSBuildFiles Include="$(MicrosoftAndroidSdkOutDir)manifestmerger.jar" />
+ <_MSBuildFiles Include="$(MicrosoftAndroidSdkOutDir)proguard-android-optimize.txt" />
<_MSBuildFiles Include="$(MicrosoftAndroidSdkOutDir)proguard-android.txt" />
<_MSBuildFiles Include="$(MicrosoftAndroidSdkOutDir)protobuf-net.dll" />
<_MSBuildFiles Include="$(MicrosoftAndroidSdkOutDir)System.CodeDom.dll" />
diff --git a/src/Xamarin.Android.Build.Tasks/Properties/Resources.Designer.cs b/src/Xamarin.Android.Build.Tasks/Properties/Resources.Designer.cs
index c301a8d6dd6..6a9e06b74e1 100644
--- a/src/Xamarin.Android.Build.Tasks/Properties/Resources.Designer.cs
+++ b/src/Xamarin.Android.Build.Tasks/Properties/Resources.Designer.cs
@@ -902,6 +902,15 @@ public static string XA1041 {
}
}
+ ///
+ /// Looks up a localized string similar to The 'AndroidR8ObfuscationMode' MSBuild property has an invalid value of '{0}'. Valid values are 'disabled' and 'private-members'..
+ ///
+ public static string XA1050 {
+ get {
+ return ResourceManager.GetString("XA1050", resourceCulture);
+ }
+ }
+
///
/// Looks up a localized string similar to Use of AppDomain.CreateDomain() detected in assembly: {0}. .NET 6 and higher will only support a single AppDomain, so this API will no longer be available in .NET for Android once .NET 6 is released..
///
diff --git a/src/Xamarin.Android.Build.Tasks/Properties/Resources.resx b/src/Xamarin.Android.Build.Tasks/Properties/Resources.resx
index 756007eea2a..b669a9ae8e1 100644
--- a/src/Xamarin.Android.Build.Tasks/Properties/Resources.resx
+++ b/src/Xamarin.Android.Build.Tasks/Properties/Resources.resx
@@ -1008,6 +1008,11 @@ To use a custom JDK path for a command line build, set the 'JavaSdkDirectory' MS
{0} - The MSBuild property that has the incorrect value.
{1} - The current value of the property
+
+
+ The 'AndroidR8ObfuscationMode' MSBuild property has an invalid value of '{0}'. Valid values are 'disabled' and 'private-members'.
+ The following are literal names and should not be translated: AndroidR8ObfuscationMode, MSBuild, disabled, private-members.
+{0} - The invalid value of the AndroidR8ObfuscationMode MSBuild property.
Java dependency '{0}' is not satisfied.
diff --git a/src/Xamarin.Android.Build.Tasks/Resources/proguard_xamarin.cfg b/src/Xamarin.Android.Build.Tasks/Resources/proguard_xamarin.cfg
index 9b16fefd6cf..f5e0e1e128a 100644
--- a/src/Xamarin.Android.Build.Tasks/Resources/proguard_xamarin.cfg
+++ b/src/Xamarin.Android.Build.Tasks/Resources/proguard_xamarin.cfg
@@ -1,7 +1,5 @@
# This is Xamarin-specific (and enhanced) configuration.
--dontobfuscate
-
-keep class android.support.multidex.MultiDexApplication { (); }
-keep class net.dot.jni.** { *; (); }
-keep class mono.MonoRuntimeProvider* { *; (...); }
@@ -22,6 +20,8 @@
-keepclassmembers class md52ce486a14f4bcd95899665e9d932190b.** { *; (...); }
# .NET runtime
+# Loaded by name from managed code.
+-keep class net.dot.android.ApplicationRegistration { *; }
-keep class net.dot.android.crypto.** { *; (...); }
# Android's template misses fluent setters...
diff --git a/src/Xamarin.Android.Build.Tasks/Tasks/R8.cs b/src/Xamarin.Android.Build.Tasks/Tasks/R8.cs
index b11d504734f..88cbe90c547 100644
--- a/src/Xamarin.Android.Build.Tasks/Tasks/R8.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tasks/R8.cs
@@ -36,6 +36,7 @@ public class R8 : D8
public string? ProguardMappingFileOutput { get; set; }
public string? BuildMetadataFileOutput { get; set; }
public string []? ProguardConfigurationFiles { get; set; }
+ public string ObfuscationMode { get; set; } = "disabled";
protected override string MainClass => "com.android.tools.r8.R8";
@@ -116,6 +117,9 @@ protected override string CreateResponseFile ()
}
if (!ProguardCommonXamarinConfiguration.IsNullOrWhiteSpace ()) {
using (var xamcfg = File.CreateText (ProguardCommonXamarinConfiguration)) {
+ WriteObfuscationRules (xamcfg, ObfuscationMode);
+ xamcfg.WriteLine ();
+ xamcfg.Flush ();
GetType ().Assembly.GetManifestResourceStream ("proguard_xamarin.cfg").CopyTo (xamcfg.BaseStream);
if (IgnoreWarnings) {
xamcfg.WriteLine ("-ignorewarnings");
@@ -165,6 +169,27 @@ protected override string CreateResponseFile ()
return responseFile;
}
+ internal static void WriteObfuscationRules (TextWriter writer, string obfuscationMode)
+ {
+ if (string.Equals (obfuscationMode, "disabled", StringComparison.OrdinalIgnoreCase)) {
+ writer.WriteLine ("-dontobfuscate");
+ return;
+ }
+ if (!string.Equals (obfuscationMode, "private-members", StringComparison.OrdinalIgnoreCase)) {
+ throw new ArgumentException ($"Unsupported R8 obfuscation mode '{obfuscationMode}'.", nameof (obfuscationMode));
+ }
+
+ writer.WriteLine ("-keep,allowshrinking,allowoptimization class **");
+ writer.WriteLine ("-keepclassmembers,allowshrinking,allowoptimization class ** {");
+ writer.WriteLine (" public protected *;");
+ writer.WriteLine ("}");
+ // Managed interface proxy selection observes Class.getInterfaces(), which R8 cannot infer.
+ writer.WriteLine ("-keep,allowoptimization interface ** {");
+ writer.WriteLine (" public protected *;");
+ writer.WriteLine ("}");
+ writer.WriteLine ("-keep,allowshrinking class * implements **");
+ }
+
// Note: We do not want to call the base.LogEventsFromTextOutput as it will incorrectly identify
// Warnings and Info messages as errors.
protected override void LogEventsFromTextOutput (string singleLine, MessageImportance messageImportance)
diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/PackagingTest.cs b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/PackagingTest.cs
index 617ef224248..307629c9d25 100644
--- a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/PackagingTest.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/PackagingTest.cs
@@ -4,6 +4,7 @@
using Xamarin.ProjectTools;
using System.Linq;
using System.Text;
+using System.Text.Json;
using System.Collections.Generic;
using System.Xml.Linq;
using Xamarin.Tools.Zip;
@@ -17,12 +18,18 @@ namespace Xamarin.Android.Build.Tests
public class PackagingTest : BaseTest
{
[Test]
- public void CheckR8MetadataFilesExist ()
+ [TestCase (null, false)]
+ [TestCase ("disabled", false)]
+ [TestCase ("private-members", true)]
+ public void CheckR8MetadataFilesExist (string obfuscationMode, bool optimizationsEnabled)
{
var proj = new XamarinAndroidApplicationProject {
IsRelease = true,
};
proj.SetProperty (proj.ReleaseProperties, KnownProperties.AndroidLinkTool, "r8");
+ if (obfuscationMode != null) {
+ proj.SetProperty (proj.ReleaseProperties, KnownProperties.AndroidR8ObfuscationMode, obfuscationMode);
+ }
// Projects must set $(AndroidCreateProguardMappingFile) to true to opt in
proj.SetProperty (proj.ReleaseProperties, "AndroidCreateProguardMappingFile", true);
proj.SetProperty ("AndroidPackageFormat", "aab");
@@ -35,7 +42,14 @@ public void CheckR8MetadataFilesExist ()
FileAssert.Exists (aab, $"'{aab}' should have been generated.");
using (var zip = ZipHelper.OpenZip (aab)) {
Assert.IsTrue (zip.Any (e => e.FullName == "BUNDLE-METADATA/com.android.tools.build.obfuscation/proguard.map"), $"AAB file `{aab}` should contain the ProGuard mapping.");
- Assert.IsTrue (zip.Any (e => e.FullName == "BUNDLE-METADATA/com.android.tools/r8.json"), $"AAB file `{aab}` should contain the R8 build metadata.");
+ var metadata = zip.SingleOrDefault (e => e.FullName == "BUNDLE-METADATA/com.android.tools/r8.json");
+ Assert.IsNotNull (metadata, $"AAB file `{aab}` should contain the R8 build metadata.");
+ using var stream = new MemoryStream ();
+ metadata.Extract (stream);
+ stream.Position = 0;
+ using var document = JsonDocument.Parse (stream);
+ var options = document.RootElement.GetProperty ("options");
+ Assert.AreEqual (optimizationsEnabled, options.GetProperty ("isOptimizationsEnabled").GetBoolean ());
}
Assert.IsTrue (b.Build (proj), "second build should have succeeded.");
@@ -45,6 +59,43 @@ public void CheckR8MetadataFilesExist ()
}
}
+ [Test]
+ public void InvalidR8ObfuscationModeFailsBuild ()
+ {
+ var proj = new XamarinAndroidApplicationProject {
+ IsRelease = true,
+ };
+ proj.SetProperty (proj.ReleaseProperties, KnownProperties.AndroidLinkTool, "r8");
+ proj.SetProperty (proj.ReleaseProperties, KnownProperties.AndroidR8ObfuscationMode, "private-member");
+
+ using var builder = CreateApkBuilder ();
+ builder.ThrowOnBuildFailure = false;
+ Assert.IsFalse (builder.Build (proj), "Build should reject an invalid AndroidR8ObfuscationMode.");
+ StringAssertEx.Contains ("error XA1050", builder.LastBuildOutput);
+ StringAssertEx.Contains ("'private-member'", builder.LastBuildOutput);
+ }
+
+ [TestCase ("", true)]
+ [TestCase ("r8", false)]
+ public void InvalidR8ObfuscationModeIsValidatedOnlyForR8 (string linkTool, bool expectedResult)
+ {
+ var proj = new XamarinAndroidApplicationProject {
+ IsRelease = true,
+ };
+ proj.SetProperty (proj.ReleaseProperties, KnownProperties.AndroidLinkTool, linkTool);
+ proj.SetProperty (proj.ReleaseProperties, KnownProperties.AndroidR8ObfuscationMode, "private-member");
+
+ using var builder = CreateApkBuilder ();
+ builder.Target = "_ValidateAndroidR8ObfuscationMode";
+ builder.ThrowOnBuildFailure = false;
+ builder.AutomaticNuGetRestore = false;
+ Assert.AreEqual (expectedResult, builder.Build (proj), "Validation result should depend on whether R8 is enabled.");
+ if (!expectedResult) {
+ StringAssertEx.Contains ("error XA1050", builder.LastBuildOutput);
+ StringAssertEx.Contains ("'private-member'", builder.LastBuildOutput);
+ }
+ }
+
[Test]
public void CheckR8InfoMessagesToNotBreakTheBuild ()
{
diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/Tasks/R8Tests.cs b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/Tasks/R8Tests.cs
new file mode 100644
index 00000000000..6e9ff979952
--- /dev/null
+++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/Tasks/R8Tests.cs
@@ -0,0 +1,48 @@
+using System;
+using System.IO;
+using NUnit.Framework;
+using Xamarin.Android.Tasks;
+
+namespace Xamarin.Android.Build.Tests
+{
+ [TestFixture]
+ public class R8Tests
+ {
+ [Test]
+ public void WritePrivateMemberObfuscationRules ()
+ {
+ using var writer = new StringWriter ();
+ R8.WriteObfuscationRules (writer, "private-members");
+
+ var expected = """
+ -keep,allowshrinking,allowoptimization class **
+ -keepclassmembers,allowshrinking,allowoptimization class ** {
+ public protected *;
+ }
+ -keep,allowoptimization interface ** {
+ public protected *;
+ }
+ -keep,allowshrinking class * implements **
+
+ """;
+ Assert.AreEqual (expected.ReplaceLineEndings (Environment.NewLine), writer.ToString ());
+ }
+
+ [Test]
+ public void WriteDisabledObfuscationRules ()
+ {
+ using var writer = new StringWriter ();
+ R8.WriteObfuscationRules (writer, "disabled");
+
+ Assert.AreEqual ("-dontobfuscate" + Environment.NewLine, writer.ToString ());
+ }
+
+ [Test]
+ public void WriteInvalidObfuscationModeThrows ()
+ {
+ using var writer = new StringWriter ();
+
+ Assert.Throws (() => R8.WriteObfuscationRules (writer, "private-member"));
+ }
+ }
+}
diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.ProjectTools/Android/KnownProperties.cs b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.ProjectTools/Android/KnownProperties.cs
index d6f5a732054..2175b2b6f05 100644
--- a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.ProjectTools/Android/KnownProperties.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.ProjectTools/Android/KnownProperties.cs
@@ -25,6 +25,7 @@ public static class KnownProperties
public const string AndroidEnableDesugar = "AndroidEnableDesugar";
public const string AndroidManifestMerger = "AndroidManifestMerger";
public const string AndroidLinkTool = "AndroidLinkTool";
+ public const string AndroidR8ObfuscationMode = "AndroidR8ObfuscationMode";
public const string UseJackAndJill = "UseJackAndJill";
public const string AotAssemblies = "AotAssemblies";
public const string AndroidEnableProfiledAot = "AndroidEnableProfiledAot";
diff --git a/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Common.targets b/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Common.targets
index eafdb06f3aa..81294786733 100644
--- a/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Common.targets
+++ b/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Common.targets
@@ -252,6 +252,7 @@ Copyright (C) 2011-2012 Xamarin. All rights reserved.
False
True
True
+ disabled
True
@@ -968,6 +969,7 @@ because xbuild doesn't support framework reference assemblies.
<_PropertyCacheItems Include="AndroidEnableProfiledAot=$(AndroidEnableProfiledAot)" />
<_PropertyCacheItems Include="AndroidDexTool=$(AndroidDexTool)" />
<_PropertyCacheItems Include="AndroidLinkTool=$(AndroidLinkTool)" />
+ <_PropertyCacheItems Include="AndroidR8ObfuscationMode=$(AndroidR8ObfuscationMode)" />
<_PropertyCacheItems Include="AndroidLinkResources=$(AndroidLinkResources)" />
<_PropertyCacheItems Include="AndroidPackageFormat=$(AndroidPackageFormat)" />
<_PropertyCacheItems Include="EmbedAssembliesIntoApk=$(EmbedAssembliesIntoApk)" />
@@ -2115,7 +2117,8 @@ because xbuild doesn't support framework reference assemblies.
<_ProguardConfiguration Include="$(ProguardConfigFiles)" />
- <_ProguardConfiguration Include="$(MSBuildThisFileDirectory)proguard-android.txt" />
+ <_ProguardConfiguration Include="$(MSBuildThisFileDirectory)proguard-android.txt" Condition=" '$(AndroidR8ObfuscationMode)' == 'disabled' " />
+ <_ProguardConfiguration Include="$(MSBuildThisFileDirectory)proguard-android-optimize.txt" Condition=" '$(AndroidR8ObfuscationMode)' == 'private-members' " />
<_ProguardConfiguration Include="$(IntermediateOutputPath)proguard\proguard_xamarin.cfg" Condition=" '$(AndroidLinkTool)' != '' " />
<_ProguardConfiguration Include="$(_ProguardProjectConfiguration)" Condition=" '$(AndroidLinkTool)' != '' " />
<_ProguardConfiguration Include="$(IntermediateOutputPath)proguard\proguard_project_primary.cfg" Condition=" '$(AndroidLinkTool)' != '' " />
@@ -3080,6 +3083,15 @@ because xbuild doesn't support framework reference assemblies.
+
+
+
+
diff --git a/src/Xamarin.Android.Build.Tasks/Xamarin.Android.D8.targets b/src/Xamarin.Android.Build.Tasks/Xamarin.Android.D8.targets
index 5f197b76ffa..7897212fe5e 100644
--- a/src/Xamarin.Android.Build.Tasks/Xamarin.Android.D8.targets
+++ b/src/Xamarin.Android.Build.Tasks/Xamarin.Android.D8.targets
@@ -75,6 +75,7 @@ Copyright (C) 2018 Xamarin. All rights reserved.
ProguardMappingFileOutput="$(AndroidProguardMappingFile)"
BuildMetadataFileOutput="$(_AndroidR8BuildMetadataFile)"
ProguardConfigurationFiles="@(_ProguardConfiguration)"
+ ObfuscationMode="$(AndroidR8ObfuscationMode)"
EnableShrinking="$(_R8EnableShrinking)"
EnableMultiDex="$(AndroidEnableMultiDex)"
MultiDexMainDexListFile="$(_AndroidMainDexListFile)"
diff --git a/src/proguard-android/proguard-android.targets b/src/proguard-android/proguard-android.targets
index c2664819ae0..40a28ec9c68 100644
--- a/src/proguard-android/proguard-android.targets
+++ b/src/proguard-android/proguard-android.targets
@@ -1,29 +1,35 @@
<_Destination>$(MicrosoftAndroidSdkOutDir)proguard-android.txt
+ <_OptimizeDestination>$(MicrosoftAndroidSdkOutDir)proguard-android-optimize.txt
+ Outputs="$(_Destination);$(_OptimizeDestination)">
- <_ProguardRules Include="$(MSBuildThisFileDirectory)build\intermediates\default_proguard_files\global\proguard-android.txt-*" />
+ <_ProguardRules Include="$(MSBuildThisFileDirectory)build\intermediates\default_proguard_files\global\proguard-android.txt-*">
+ $(_Destination)
+
+ <_ProguardRules Include="$(MSBuildThisFileDirectory)build\intermediates\default_proguard_files\global\proguard-android-optimize.txt-*">
+ $(_OptimizeDestination)
+
-
+
-
+
"""
+ package example;
+
+ public class ObfuscationProbe {
+ public static int publicEntry (int value) {
+ return protectedEntry (value) + packagePrivateEntry (value) + privateEntry (value);
+ }
+
+ protected static int protectedEntry (int value) {
+ return value + 1;
+ }
+
+ static int packagePrivateEntry (int value) {
+ return value + 2;
+ }
+
+ private static int privateEntry (int value) {
+ return value + 3;
+ }
+ }
+ """,
+ Metadata = {
+ { "Bind", "False" },
+ },
+ },
+ new BuildItem (AndroidBuildActions.ProguardConfiguration, "proguard.cfg") {
+ TextContent = () => """
+ -keep,allowobfuscation class example.ObfuscationProbe {
+ ;
+ ;
+ }
+ """,
+ },
+ },
+ };
+ proj.SetRuntime (runtime);
+ proj.SetRuntimeIdentifiers (new [] { DeviceAbi });
+ proj.SetProperty ("AndroidLinkTool", "r8");
+ proj.SetProperty ("AndroidR8ObfuscationMode", "private-members");
+ proj.SetProperty ("AndroidCreateProguardMappingFile", "true");
+ proj.SetDefaultTargetDevice ();
+ proj.MainActivity = proj.DefaultMainActivity.Replace (
+ "//${AFTER_ONCREATE}",
+ """
+ using var probeClass = Java.Lang.Class.ForName (
+ "example.ObfuscationProbe",
+ initialize: true,
+ Android.App.Application.Context.ClassLoader);
+ IntPtr publicEntry = Android.Runtime.JNIEnv.GetStaticMethodID (probeClass.Handle, "publicEntry", "(I)I");
+ int result = Android.Runtime.JNIEnv.CallStaticIntMethod (probeClass.Handle, publicEntry, new Android.Runtime.JValue (5));
+ Console.WriteLine ($"# R8_SELECTIVE_OBFUSCATION_RESULT {result}");
+ if (result != 21) {
+ throw new InvalidOperationException ($"Unexpected R8 obfuscation probe result: {result}");
+ }
+ """);
+
+ using var builder = CreateApkBuilder ();
+ bool installed = false;
+ try {
+ installed = builder.Install (proj);
+ Assert.IsTrue (installed, "Project should have installed.");
+
+ var projectDirectory = Path.Combine (Root, builder.ProjectDirectory);
+ var mappingFiles = Directory.GetFiles (
+ Path.Combine (projectDirectory, proj.OutputPath),
+ "mapping.txt",
+ SearchOption.AllDirectories);
+ Assert.AreEqual (1, mappingFiles.Length, "The R8 build should produce one mapping file.");
+ string mapping = File.ReadAllText (mappingFiles [0]);
+
+ StringAssert.Contains ($"{JavaMappingClassName} -> {JavaMappingClassName}:", mapping,
+ "Java class names should remain unchanged.");
+ string mappedPackagePrivateMethod = GetRenamedMethod (mapping, "packagePrivateEntry");
+ string mappedPrivateMethod = GetRenamedMethod (mapping, "privateEntry");
+
+ var dexFiles = Directory.GetFiles (
+ Path.Combine (projectDirectory, proj.IntermediateOutputPath),
+ "classes*.dex",
+ SearchOption.AllDirectories);
+ Assert.IsNotEmpty (dexFiles, "R8 should produce at least one DEX file.");
+ AssertDexContainsMethod (dexFiles, "publicEntry");
+ AssertDexContainsMethod (dexFiles, "protectedEntry");
+ AssertDexContainsMethod (dexFiles, mappedPackagePrivateMethod);
+ AssertDexContainsMethod (dexFiles, mappedPrivateMethod);
+ AssertDexDoesNotContainMethod (dexFiles, "packagePrivateEntry");
+ AssertDexDoesNotContainMethod (dexFiles, "privateEntry");
+
+ ClearAdbLogcat ();
+ RunProjectAndAssert (proj, builder, doNotCleanupOnUpdate: true);
+ Assert.IsTrue (WaitForActivityToStart (proj.PackageName, "MainActivity",
+ Path.Combine (projectDirectory, "logcat.log"), 30), "Activity should have started.");
+ Assert.IsTrue (MonitorAdbLogcat (line => line.Contains (SuccessMarker),
+ Path.Combine (projectDirectory, "startup-logcat.log"), 45), $"Output did not contain {SuccessMarker}.");
+ } finally {
+ if (installed) {
+ try {
+ builder.ThrowOnBuildFailure = false;
+ if (!builder.Uninstall (proj)) {
+ TestContext.Error.WriteLine ($"Failed to uninstall '{proj.PackageName}' during test cleanup.");
+ }
+ } catch (Exception ex) {
+ TestContext.Error.WriteLine ($"Failed to uninstall '{proj.PackageName}' during test cleanup: {ex}");
+ }
+ }
+ }
+ }
+
+ static string GetRenamedMethod (string mapping, string methodName)
+ {
+ var match = Regex.Match (
+ mapping,
+ $@"(?m)^\s*(?:\d+:\d+:)?int {Regex.Escape (methodName)}\(int\)(?::\d+:\d+)?\s+->\s+(?\S+)\s*$");
+ Assert.IsTrue (match.Success, $"R8 mapping should contain {methodName}(int).");
+ string mappedMethodName = match.Groups ["name"].Value;
+ Assert.AreNotEqual (methodName, mappedMethodName, $"{methodName}(int) should be renamed.");
+ return mappedMethodName;
+ }
+
+ void AssertDexContainsMethod (string [] dexFiles, string methodName)
+ {
+ Assert.IsTrue (dexFiles.Any (dex => DexUtils.ContainsClassWithMethod (
+ $"L{JavaClassName};", methodName, "(I)I", dex, AndroidSdkPath)),
+ $"DEX should contain {JavaClassName}.{methodName}(int).");
+ }
+
+ void AssertDexDoesNotContainMethod (string [] dexFiles, string methodName)
+ {
+ Assert.IsFalse (dexFiles.Any (dex => DexUtils.ContainsClassWithMethod (
+ $"L{JavaClassName};", methodName, "(I)I", dex, AndroidSdkPath)),
+ $"DEX should not contain {JavaClassName}.{methodName}(int).");
+ }
+ }
+}