[Java.Interop] Type & Member Remapping Support

[jonpryor]

Context: #867

There are two scenarios for which a "generalized" type & member
remapping solution would be useful:

1. Desugaring
2. Microsoft Intune MAM

Note: this new support is only present when targeting .NET 6+,
and will not (currently) be present in Classic Xamarin.Android.

~~ Desugaring ~~

Context: dotnet/android#4574 (comment)
Context: dotnet/android#6142 (comment)

The Android Runtime is responsible for running the Dalvik
bytecode within e.g. classes.dex. The Android runtime and Dalvik
bytecode formats have apparently changed over time in order to
support newer Java language features, such as support for static
interface methods:

package org.webrtc;

public /* partial */ interface EGLBase {
    public static EGLBase create() { /* … */}
}

Support for static interface methods was added in Java 8 and in
Android v8.0 (API-26). If you want to use static interface methods
on an Android device running API-25 or earlier, you must desugar
the Java Bytecode. The result of desugaring the above
org.webrtc.EGLBase type is that the static methods are moved to a
new type, with a $-CC suffix, "as if" the Java code were instead:

package org.webrtc;

public /* partial */ interface EGLBase {
    // …
}

public final /* partial */ class EGLBase$-CC {
    public static EGLBase create { /* … */ }
}

While this works for pure Java code, this does not work with
Xamarin.Android, because our bindings currently expect (require) that
the types & members our binding process detects don't "move":

// C# Binding for EGLBase
namespace Org.Webrtc {
    public partial interface IEGLBase {
        private static readonly JniPeerMembers _members = new JniPeerMembers ("org/webrtc/EGLBase", typeof (IEGLBase));
        public static IEGLBase Create()
        {
            const string __id = "create.()Lorg/webrtc/EglBase;"
            var __rm = _members.StaticMethods.InvokeObjectMethod (__id, null);
            return Java.Lang.Object.GetObject<IEGLBase>(__rm.Handle, JniHandleOwnership.TransferLocalRef);
        }
    }
}

The new JniPeerMembers(…) invocation will use JNIEnv::FindClass()
to lookup the org/webrtc/EGLBase type, and IEGLBase.Create() will
use JNIEnv::GetStaticMethodID() and JNIEnv::CallStaticObjectMethod()
to lookup and invoke the EGLBase.create() method.

However, when desugaring is used, there is no EGLBase.create()
method. Consequently, in a "desugared" environment,
Java.Lang.NoSuchMethodError will be thrown when IEGLBase.Create()
is invoked, as EGLBase.create() doesn't exist; it "should" instead
be looking for EGLBase$-CC.create()!

Introduce partial support for this scenario by adding the new method:

namespace Java.Interop {
    public partial class JniRuntime {
        public partial class JniTypeManager {
            public IReadOnlyList<string>? GetStaticMethodFallbackTypes (string jniSimpleReference) =>
                GetStaticMethodFallbackTypesCore (jniSimpleReference);
            protected virtual IReadOnlyList<string>? GetStaticMethodFallbackTypesCore (string jniSimpleReference) => null;
        }
    }
}

JniPeerMembers.JniStaticMethods.GetMethodInfo() will attempt to
lookup the static method, "as normal". If the method cannot be
found, then JniRuntime.JniTypeManager.GetStaticMethodFallbackTypes()
will be called, and we'll attempt to resolve the static method on each
type returned by GetStaticMethodFallbackTypes().
If GetStaticMethodFallbackTypes() returns null or no fallback type
provides the method, then a NoSuchMethodError will be thrown.

TODO: Update xamarin-android to override
GetStaticMethodFallbackTypes(), to return
$"{jniSimpleReference}$-CC".

~~ Microsoft Intune MAM ~~

Context: https://www.nuget.org/packages/Microsoft.Intune.MAM.Remapper.Tasks/
Context: https://docs.microsoft.com/en-us/mem/intune/developer/app-sdk-xamarin#remapper

The Microsoft Intune App SDK Xamarin Bindings is in a
similar-yet-different position: it involves Java & Dalvik Bytecode
manipulation for various security purposes, and in order to make that
work reasonably from Xamarin.Android, they also rewrite
Xamarin.Android IL so that it's consistent with the manipulated
Dalvik bytecode.

See readme.md and content/MonoAndroid10/remapping-config.json
within the Microsoft.Intune.MAM.Remapper.Tasks NuGet package
for some additional details/tidbits such as:

This task operates on assemblies to replace the base type classes
which Microsoft Intune requires to implement its SDK (for example,
Intune requires using a MAMActivity in place of Activity and
methods such as OnMAMCreate instead of OnCreate).

"ClassRewrites": [
  {
    "Class": {
      "From": "android.app.Activity",
      "To": "com.microsoft.intune.mam.client.app.MAMActivity"
    },
    "Methods": [
      {
        "MakeStatic": false,
        "OriginalName": "onCreate",
        "NewName": "onMAMCreate",
        "OriginalParams": [
          "android.os.Bundle"
        ]
      }
    ]
  },
  {	
    "Class": {
      "From": "android.content.pm.PackageManager",
      "To": "com.microsoft.intune.mam.client.content.pm.MAMPackageManagement"
    },
    "Methods": [
      {
        "MakeStatic": true,
        "OriginalName": "checkPermission",
      }
    ]
  }
]
"GlobalMethodCalls": [
  {
    "Class": {
      "From": "android.app.PendingIntent",
      "To": "com.microsoft.intune.mam.client.app.MAMPendingIntent"
    },
    "Methods": [
      {
        "MakeStatic": false,
        "OriginalName": "getActivities"
      },
    ]
  }
]

While what the InTune team has works, it suffers from a number of
"workflow" problems, e.g. incremental builds are problematic (they
might try to rewrite assemblies which were already rewritten), IL
rewriting is always "fun", and if we change IL binding patterns,
they'll need to support previous "binding styles" and newer styles.

Introduce partial support for this scenario by adding the following
members to Java.Interop.JniRuntime.JniTypeManager:

namespace Java.Interop {
    public partial class JniRuntime {

        public struct ReplacementMethodInfo {
            public  string? SourceJniType                   {get; set;}
            public  string? SourceJniMethodName             {get; set;}
            public  string? SourceJniMethodSignature        {get; set;}
            public  string? TargetJniType                   {get; set;}
            public  string? TargetJniMethodName             {get; set;}
            public  string? TargetJniMethodSignature        {get; set;}
            public  int?    TargetJniMethodParameterCount   {get; set;}
            public  bool    TargetJniMethodIsStatic         {get; set;}
        }

        public partial class JniTypeManager {

            public string? GetReplacementType (string jniSimpleReference) =>
                GetReplacementTypeCore (jniSimpleReference);
            protected virtual string? GetReplacementTypeCore (string jniSimpleReference) => null;

            public ReplacementMethodInfo? GetReplacementMethodInfo (string jniSimpleReference, string jniMethodName, string jniMethodSignature) =>
                GetReplacementMethodInfoCore (jniSimpleReference, jniMethodName,jniMethodSignature);
            protected virtual ReplacementMethodInfo? GetReplacementMethodInfoCore (string jniSimpleReference, string jniMethodName, string jniMethodSignature) => null;
        }
    }
}

These new methods are used by JniPeerMembers.

Consider "normal" usage of JniPeerMembers, within a binding:

partial class Activity {
    static readonly JniPeerMembers _members = new XAPeerMembers (jniPeerTypeName:"android/app/Activity", managedPeerType:typeof (Activity));
}

JniRuntime.JniTypeManager.GetReplacementType() allows "replacing"
the jniPeerTypeName value with a "replacement" JNI type name.
The "replacement" type will be used for all field and method lookups.
This allows supporting the ClassRewrites[0].Class.From /
ClassRewrites[0].Class.To semantics.

JniRuntime.JniTypeManager.GetReplacementMethodInfo() is the key
integration for all other "replacement" semantics. Given the
source type, source method name, and source JNI signature, it is
responsible for providing an overriding target type, target method
name, and target JNI signature.

For ClassRewrites[0].Methods[0], this allows "renaming"
Activity.onCreate() to MAMActivity.onMAMCreate():

var r = JniEnvironment.Runtime.TypeManager.GetReplacementMethodInfo (
    // Note: must match GetReplacementType() *output*, and since
    // `Activity` is mapped to `MAMActivity`…
    "com/microsoft/intune/mam/client/app/MAMActivity",
    "onCreate",
    "(Landroid/os/Bundle;)V"
);
// is equivalent to:
var r = new JniRuntime.ReplacementMethodInfo {
    SourceJniType                   = "com/microsoft/intune/mam/client/app/MAMActivity",
                                                                // from input parameter
    SourceJniMethodName             = "onCreate",               // from input parameter
    SourceJniMethodSignature        = "(Landroid/os/Bundle;)V", // from input parameter

    TargetJniType                   = "com/microsoft/intune/mam/client/app/MAMActivity",
    TargetJniMethodName             = "onMAMCreate",
    TargetJniMethodSignature        = null,                     // "use original value"
    TargetJniMethodParameterCount   = null,                     // unchanged
    TargetJniMethodIsStatic         = false,
}

ClassRewrites[1].Methods[0] is "weird", in that it has
MakeStatic: true. The semantics for when MakeStatic: true exists
is that the "original" method is an instance method, and the target
method is a static method, and the this instance now becomes
a parameter to the method. This is likewise supported via
JniRuntime.JniTypeManager.GetReplacementMethodInfo(), and is
identified by:

1. ReplacementMethodInfo.TargetJniMethodParameterCount being a
   non-null value, and

2. ReplacementMethodInfo.TargetJniMethodIsStatic is true.

Thus, ClassRewrites[1].Methods[0] is akin to:

var r = JniEnvironment.Runtime.TypeManager.GetReplacementMethodInfo (
    "android/content/pm/PackageManager",
    "checkPermission",
    "(Ljava/lang/String;Ljava/lang/String;)I"
);
// is equivalent to:
var r = new JniRuntime.ReplacementMethodInfo {
    SourceJniType                   = "android/content/pm/PackageManager",          // from input parameter
    SourceJniMethodName             = "checkPermission",                            // from input parameter
    SourceJniMethodSignature        = "(Ljava/lang/String;Ljava/lang/String;)I",    // from input parameter

    TargetJniType                   = "com/microsoft/intune/mam/client/content/pm/MAMPackageManagement",
    TargetJniMethodName             = "CheckPermission",
    TargetJniMethodSignature        = "(Landroid/content/pm/PackageManager;Ljava/lang/String;Ljava/lang/String;)I",
                                      // Note: `PackageManager` is inserted as new first parameter
    TargetJniMethodParameterCount   = 3,
    TargetJniMethodIsStatic         = true,
}

(Note that the subclass is responsible for providing this data.)

ReplacementMethodInfo.TargetJniMethodParameterCount must be the
number of parameters that the target method accepts. This is needed
so that JniPeerMembers.JniInstanceMethods.TryInvoke*StaticRedirect()
can appropriately reallocate the JniArgumentValue* array, so that
the this parameter can be added to the beginning of the parameters.

~~ Overhead? ~~

All these extra invocations into JniRuntime.JniTypeManager imply
additional overhead to invoke a Java method. However, this is all
done during the first time a method is looked up, after which the
JniMethodInfo instance is cached for a given
(type, method, signature) tuple.

To demonstrate overheads, samples/Hello has been updated to accept
a new -t value; when provided, it invokes the
java.lang.Object.hashCode() method 1 million times and calculates
the average invocation overhead:

% dotnet run --project samples/Hello -- -t
Object.hashCode: 1000000 invocations. Total=00:00:00.5196758; Average=0.0005196758ms

If we replace the .NET 6 samples/Hello/bin/Debug/Java.Interop.dll
assembly with e.g. bin/Debug/Java.Interop.dll, we can compare to
performance without these new changes, as the changes are only in
the .NET 6 build:

% \cp bin/Debug/Java.Interop{.dll,.pdb} samples/Hello/bin/Debug
% dotnet samples/Hello/bin/Debug/Hello.dll -t
Object.hashCode: 1000000 invocations. Total=00:00:00.5386676; Average=0.0005386676ms

There is a fair bit of variation in dotnet Hello.dll -t output,
but they're all roughly similar. There doesn't appear to be
significant overhead for this particular test.

~~ Other Changes ~~

Cleaned up the JniPeerMembers constructors. The Debug.Assert()
calls were duplicative and redundant.

Replace the Debug.Assert() with Debug.WriteLine().
Mono.Android.NET-Tests.apk was running into an "unfixable" scenario:

WARNING: ManagedPeerType <=> JniTypeName Mismatch!
javaVM.GetJniTypeInfoForType(typeof(Android.Runtime.JavaList)).JniTypeName="java/util/ArrayList" != "java/util/List"

This was because of Android.Runtime.JavaList using a
JniPeerMembers for List while registering ArrayList, causing
typemaps to associate JavaList with ArrayList:

[Register ("java/util/ArrayList", DoNotGenerateAcw=true)]
partial class JavaList {
    internal static readonly JniPeerMembers list_members =
        new XAPeerMembers ("java/util/List", typeof (JavaList), isInterface: true);
}

@jonpryor doesn't want to try fixing this right now; turning the
assertion into a diagnostic message feels preferable.

[jonathanpeppers]

Is there an example of what MAMActivity would look like? There is a code snippet above, but I don't understand how they would make their library fixup other activity subclasses like MAUI:

https://github.com/dotnet/maui/blob/3c05a08555e5fe6a4fedc8807c4442c3d782d8ab/src/Templates/src/templates/maui-mobile/Platforms/Android/MainActivity.cs#L8

https://github.com/dotnet/maui/blob/3c05a08555e5fe6a4fedc8807c4442c3d782d8ab/src/Core/src/Platform/Android/MauiAppCompatActivity.cs#L8

[jonpryor]

@jonathanpeppers asked:

Is there an example of what MAMActivity would look like?

With some digging, I found the .class file!

1. Microsoft.Intune.MAM.Xamarin.Android NuGet

2. Extract lib/MonoAndroid/Microsoft.Intune.Android.dll

   unzip microsoft.intune.mam.xamarin.android.3.0.4635.1.nupkg lib/MonoAndroid/Microsoft.Intune.Android.dll
   

3. Extract resources from Microsoft.Intune.Android.dll

   monodis --mresources lib/MonoAndroid/Microsoft.Intune.Android.dll
   

4. Extract classes.jar from __AndroidLibraryProjects__:

   unzip __AndroidLibraryProjects__.zip library_project_imports/bin/classes.jar
   

classes.jar contains MAMActivity:

% javap -cp library_project_imports/bin/classes.jar com/microsoft/intune/mam/client/app/MAMActivity
Compiled from "MAMActivity.java"
public abstract class com.microsoft.intune.mam.client.app.MAMActivity extends android.app.Activity implements com.microsoft.intune.mam.client.app.Hooked
Activity {
  com.microsoft.intune.mam.client.app.ActivityBehavior mBehavior;
  public com.microsoft.intune.mam.client.app.MAMActivity();
  protected void attachBaseContext(android.content.Context);
…
  protected final void onCreate(android.os.Bundle);
  public void onMAMCreate(android.os.Bundle);
…
  protected final void onDestroy();
  public void onMAMDestroy();
  public final void onDestroyReal();
…
  protected final void onActivityResult(int, int, android.content.Intent);
  public void onMAMActivityResult(int, int, android.content.Intent);
…
}

The Microsoft.Intune.MAM.Remapper.Tasks NuGet package contains the remapping information, in content/MonoAndroid10/remapping-config.json. You can use tools/remap-mam-json-to-xml in dotnet/android#6591 to "dump" it to something more meaningful in the context of this PR:

dotnet run --project tools/remap-mam-json-to-xml \
  ~/.nuget/packages/microsoft.intune.mam.remapper.tasks/0.1.4635.1/content/MonoAndroid10/remapping-config.json \
  > renames.xml

  <replace-type from="android/app/Activity" to="com/microsoft/intune/mam/client/app/MAMActivity" />
…
  <replace-method source-type="com/microsoft/intune/mam/client/app/MAMActivity" source-method-name="onActivityResult" source-method-signature="(IILandroid/content/Intent;)" target-type="com/microsoft/intune/mam/client/app/MAMActivity" target-method-name="onMAMActivityResult" target-method-instance-to-static="false" />
  <replace-method source-type="com/microsoft/intune/mam/client/app/MAMActivity" source-method-name="onCreate" source-method-signature="(Landroid/os/Bundle;)" target-type="com/microsoft/intune/mam/client/app/MAMActivity" target-method-name="onMAMCreate" target-method-instance-to-static="false" />
  <replace-method source-type="com/microsoft/intune/mam/client/app/MAMActivity" source-method-name="onDestroy" target-type="com/microsoft/intune/mam/client/app/MAMActivity" target-method-name="onMAMDestroy" target-method-instance-to-static="false" />
  <replace-method source-type="com/microsoft/intune/mam/client/app/MAMActivity" source-method-name="onNewIntent" source-method-signature="(Landroid/content/Intent;)" target-type="com/microsoft/intune/mam/client/app/MAMActivity" target-method-name="onMAMNewIntent" target-method-instance-to-static="false" />
  <replace-method source-type="com/microsoft/intune/mam/client/app/MAMActivity" source-method-name="onPause" target-type="com/microsoft/intune/mam/client/app/MAMActivity" target-method-name="onMAMPause" target-method-instance-to-static="false" />
  <replace-method source-type="com/microsoft/intune/mam/client/app/MAMActivity" source-method-name="onPostCreate" source-method-signature="(Landroid/os/Bundle;)" target-type="com/microsoft/intune/mam/client/app/MAMActivity" target-method-name="onMAMPostCreate" target-method-instance-to-static="false" />
  <replace-method source-type="com/microsoft/intune/mam/client/app/MAMActivity" source-method-name="onPostResume" target-type="com/microsoft/intune/mam/client/app/MAMActivity" target-method-name="onMAMPostResume" target-method-instance-to-static="false" />
  <replace-method source-type="com/microsoft/intune/mam/client/app/MAMActivity" source-method-name="onPrepareOptionsMenu" source-method-signature="(Landroid/view/Menu;)" target-type="com/microsoft/intune/mam/client/app/MAMActivity" target-method-name="onMAMPrepareOptionsMenu" target-method-instance-to-static="false" />
  <replace-method source-type="com/microsoft/intune/mam/client/app/MAMActivity" source-method-name="onProvideAssistContent" source-method-signature="(Landroid/app/assist/AssistContent;)" target-type="com/microsoft/intune/mam/client/app/MAMActivity" target-method-name="onMAMProvideAssistContent" target-method-instance-to-static="false" />
  <replace-method source-type="com/microsoft/intune/mam/client/app/MAMActivity" source-method-name="onProvideReferrer" target-type="com/microsoft/intune/mam/client/app/MAMActivity" target-method-name="onMAMProvideReferrer" target-method-instance-to-static="false" />
  <replace-method source-type="com/microsoft/intune/mam/client/app/MAMActivity" source-method-name="onResume" target-type="com/microsoft/intune/mam/client/app/MAMActivity" target-method-name="onMAMResume" target-method-instance-to-static="false" />
  <replace-method source-type="com/microsoft/intune/mam/client/app/MAMActivity" source-method-name="onSaveInstanceState" source-method-signature="(Landroid/os/Bundle;)" target-type="com/microsoft/intune/mam/client/app/MAMActivity" target-method-name="onMAMSaveInstanceState" target-method-instance-to-static="false" />
  <replace-method source-type="com/microsoft/intune/mam/client/app/MAMActivity" source-method-name="onSearchRequested" source-method-signature="(Landroid/view/SearchEvent;)" target-type="com/microsoft/intune/mam/client/app/MAMActivity" target-method-name="onMAMSearchRequested" target-method-instance-to-static="false" />
  <replace-method source-type="com/microsoft/intune/mam/client/app/MAMActivity" source-method-name="onStateNotSaved" target-type="com/microsoft/intune/mam/client/app/MAMActivity" target-method-name="onMAMStateNotSaved" target-method-instance-to-static="false" />

[jonpryor]

@jonathanpeppers asked:

I don't understand how they would make their library fixup other activity subclasses like MAUI:

I'm not sure I see how that matters? MauiAppCompatActivity inherits AndroidX.AppCompat.App.AppCompatActivity, which is remapped:

  <replace-type from="android/support/v7/app/AppCompatActivity" to="com/microsoft/intune/mam/client/support/v7/app/MAMAppCompatActivity" />

When AppCompatActivity.OnCreate() is invoked via C#, we'll consult the member remapping "table":

  <replace-method source-type="com/microsoft/intune/mam/client/support/v7/app/MAMAppCompatActivity" source-method-name="onActivityResult" source-method-signature="(IILandroid/content/Intent;)" target-type="com/microsoft/intune/mam/client/support/v7/app/MAMAppCompatActivity" target-method-name="onMAMActivityResult" target-method-instance-to-static="false" />
  <replace-method source-type="com/microsoft/intune/mam/client/support/v7/app/MAMAppCompatActivity" source-method-name="onCreate" source-method-signature="(Landroid/os/Bundle;)" target-type="com/microsoft/intune/mam/client/support/v7/app/MAMAppCompatActivity" target-method-name="onMAMCreate" target-method-instance-to-static="false" />
  <replace-method source-type="com/microsoft/intune/mam/client/support/v7/app/MAMAppCompatActivity" source-method-name="onDestroy" target-type="com/microsoft/intune/mam/client/support/v7/app/MAMAppCompatActivity" target-method-name="onMAMDestroy" target-method-instance-to-static="false" />
  <replace-method source-type="com/microsoft/intune/mam/client/support/v7/app/MAMAppCompatActivity" source-method-name="onNewIntent" source-method-signature="(Landroid/content/Intent;)" target-type="com/microsoft/intune/mam/client/support/v7/app/MAMAppCompatActivity" target-method-name="onMAMNewIntent" target-method-instance-to-static="false" />
  <replace-method source-type="com/microsoft/intune/mam/client/support/v7/app/MAMAppCompatActivity" source-method-name="onPause" target-type="com/microsoft/intune/mam/client/support/v7/app/MAMAppCompatActivity" target-method-name="onMAMPause" target-method-instance-to-static="false" />
  <replace-method source-type="com/microsoft/intune/mam/client/support/v7/app/MAMAppCompatActivity" source-method-name="onPostCreate" source-method-signature="(Landroid/os/Bundle;)" target-type="com/microsoft/intune/mam/client/support/v7/app/MAMAppCompatActivity" target-method-name="onMAMPostCreate" target-method-instance-to-static="false" />
  <replace-method source-type="com/microsoft/intune/mam/client/support/v7/app/MAMAppCompatActivity" source-method-name="onPostResume" target-type="com/microsoft/intune/mam/client/support/v7/app/MAMAppCompatActivity" target-method-name="onMAMPostResume" target-method-instance-to-static="false" />
  <replace-method source-type="com/microsoft/intune/mam/client/support/v7/app/MAMAppCompatActivity" source-method-name="onPrepareOptionsMenu" source-method-signature="(Landroid/view/Menu;)" target-type="com/microsoft/intune/mam/client/support/v7/app/MAMAppCompatActivity" target-method-name="onMAMPrepareOptionsMenu" target-method-instance-to-static="false" />
  <replace-method source-type="com/microsoft/intune/mam/client/support/v7/app/MAMAppCompatActivity" source-method-name="onProvideAssistContent" source-method-signature="(Landroid/app/assist/AssistContent;)" target-type="com/microsoft/intune/mam/client/support/v7/app/MAMAppCompatActivity" target-method-name="onMAMProvideAssistContent" target-method-instance-to-static="false" />
  <replace-method source-type="com/microsoft/intune/mam/client/support/v7/app/MAMAppCompatActivity" source-method-name="onProvideReferrer" target-type="com/microsoft/intune/mam/client/support/v7/app/MAMAppCompatActivity" target-method-name="onMAMProvideReferrer" target-method-instance-to-static="false" />
  <replace-method source-type="com/microsoft/intune/mam/client/support/v7/app/MAMAppCompatActivity" source-method-name="onResume" target-type="com/microsoft/intune/mam/client/support/v7/app/MAMAppCompatActivity" target-method-name="onMAMResume" target-method-instance-to-static="false" />
  <replace-method source-type="com/microsoft/intune/mam/client/support/v7/app/MAMAppCompatActivity" source-method-name="onSaveInstanceState" source-method-signature="(Landroid/os/Bundle;)" target-type="com/microsoft/intune/mam/client/support/v7/app/MAMAppCompatActivity" target-method-name="onMAMSaveInstanceState" target-method-instance-to-static="false" />
  <replace-method source-type="com/microsoft/intune/mam/client/support/v7/app/MAMAppCompatActivity" source-method-name="onSearchRequested" source-method-signature="(Landroid/view/SearchEvent;)" target-type="com/microsoft/intune/mam/client/support/v7/app/MAMAppCompatActivity" target-method-name="onMAMSearchRequested" target-method-instance-to-static="false" />
  <replace-method source-type="com/microsoft/intune/mam/client/support/v7/app/MAMAppCompatActivity" source-method-name="onStateNotSaved" target-type="com/microsoft/intune/mam/client/support/v7/app/MAMAppCompatActivity" target-method-name="onMAMStateNotSaved" target-method-instance-to-static="false" />

and remap onCreate() to onMAMCreate().

[jonathanpeppers]

So this XML above is going to happen at runtime instead of build time.

I'm not seeing an example of what the new MAM library would actually do.

What does this look like:

<replace-method source-type="com/microsoft/intune/mam/client/support/v7/app/MAMAppCompatActivity" source-method-name="onCreate" source-method-signature="(Landroid/os/Bundle;)" target-type="com/microsoft/intune/mam/client/support/v7/app/MAMAppCompatActivity" target-method-name="onMAMCreate" target-method-instance-to-static="false" />

When you do it in C# instead?

Also, where do they run this code? Is there a place they can do it on startup? If most apps have an Activity as an entry point, that sounds tricky...

[jonpryor]

@jonathanpeppers said:

So this XML above is going to happen at runtime instead of build time.

I need to write up the PR description for dotnet/android#6591, don't I. :-)

What do you mean by "this XML above is going to happen"? I'll just need to guess which verb you meant…

Please turn your attention to this PR description:

JniRuntime.JniTypeManager.GetReplacementType() allows "replacing"
the jniPeerTypeName value with a "replacement" JNI type name.
…
JniRuntime.JniTypeManager.GetReplacementMethodInfo() is the key
integration for all other "replacement" semantics. Given the
source type, source method name, and source JNI signature, it is
responsible for providing an overriding target type, target method
name, and target JNI signature.

For ClassRewrites[0].Methods[0], this allows "renaming"
Activity.onCreate() to MAMActivity.onMAMCreate():

	var r = JniEnvironment.Runtime.TypeManager.GetReplacementMethodInfo (
	    "android/app/Activity",
	    "onCreate",
	    "(Landroid/os/Bundle;)V"
	);
	// is equivalent to:
	var r = new JniRuntime.ReplacementMethodInfo {
	    SourceJniType                   = "android/app/Activity",   // from input parameter
	    SourceJniMethodName             = "onCreate",               // from input parameter
	    SourceJniMethodSignature        = "(Landroid/os/Bundle;)V", // from input parameter

	    TargetJniType                   = "com/microsoft/intune/mam/client/app/MAMActivity",
	    TargetJniMethodName             = "onMAMCreate",
	    SourceJniMethodSignature        = null,                     // "use original value"
	    TargetJniMethodParameterCount   = null,                     // unchanged
	    TargetJniMethodIsStatic         = false,
	}

TypeManager.GetReplacementMethodInfo() thus allows JniPeerMembers to remap Activity.onCreate(Bundle) to MAMActivity.onMAMCreate(Bundle).

Not mentioned here is how TypeManager gets that remapping information. That is the purview of dotnet/android#6591, which takes the content/MonoAndroid10/remapping-config.json file in the Microsoft.Intune.MAM.Remapper.Tasks NuGet package and converts it into a "form" usable by AndroidTypeManager.

The specifics of that form "doesn't matter" here, just that it exists. That form also needs to change, for performance reasons; we don't really want to parse XML during on-device app startup! That's just what I could very easily prototype.

Which brings us to the above XML: it's a "translation" of the original JSON data into something that can be used to implement TypeManager.GetReplacementMethodInfo(). If you "squint" just right, this element:

<replace-method
    source-type="com/microsoft/intune/mam/client/app/MAMActivity"
    source-method-name="onActivityResult"
    source-method-signature="(IILandroid/content/Intent;)"
    target-type="com/microsoft/intune/mam/client/app/MAMActivity"
    target-method-name="onMAMActivityResult"
    target-method-instance-to-static="false"
/>

can be read as saying "given this TypeManager.GetReplacementMethodInfo() call":

var r = JniEnvironment.Runtime.TypeManager.GetReplacementMethodInfo (
    "com/microsoft/intune/mam/client/app/MAMActivity",
    "onActivityResult",
    "(IILandroid/content/Intent;)"
);

"then the data returned will be":

var r = new JniRuntime.ReplacementMethodInfo {
    SourceJniType                   = "com/microsoft/intune/mam/client/app/MAMActivity",   // from input parameter
    SourceJniMethodName             = "onActivityResult",               // from input parameter
    SourceJniMethodSignature        = "(IILandroid/content/Intent;)", // from input parameter
    TargetJniType                   = "com/microsoft/intune/mam/client/app/MAMActivity",
    TargetJniMethodName             = "onMAMActivityResult",
    SourceJniMethodSignature        = null,                     // "use original value"
    TargetJniMethodParameterCount   = null,                     // unchanged
    TargetJniMethodIsStatic         = false,
}

API-wise, XML isn't required. It's used as an implementation detail, which will need to die in a fire before .NET 7 GA. (Hence the use of tab-delimited data as the latest commit on dotnet/android#6591, in the hopes that TSV will allow us to do "typemap-style" string tables within libxamarin-app.so.)

Additionally, and this wasn't very clear, while the ability to remap types & members will exist in all apps, the underlying data will only exist if the (undocumented!) @(_AndroidMamMappingFile) item group is used. Meaning 99.999% of the time, no remapping information will be present, and these should all be no-ops (with virtual dispatch overhead 😔, but it should only be on first member lookup, so I think that'll be "fine"?).

Also, where do they run this code?

What does "this code" refer to? XML parsing? That's currently at app startup, if the XML blob exists in the app, and I want to turn that into constant data within libxamarin-app.so by .NET 7 GA.

If most apps have an Activity as an entry point, that sounds tricky...

Indeed, and that trickiness is also partially up to the InTune team. This isn't a "complete" "user story"; it's part of one. The other part is on the InTune team providing the appropriate JSON data, the appropriate .jar file, their Java bytecode rewriter…

[jonathanpeppers]

I don't think I have anything else to add on this PR, but I can comment further when the xamarin-android changes are final. There might be some general build-performance things I want to read through and understand there.

[dellis1972]

In the PR description I think these lines are using the wrong parameter

SourceJniMethodSignature        = null,                     // "use original value"

Shouldn't this be TargetJniMethodSignature ?

I ask because if you look at the following example code

var r = new JniRuntime.ReplacementMethodInfo {
    SourceJniType                   = "com/microsoft/intune/mam/client/app/MAMActivity",   // from input parameter
    SourceJniMethodName             = "onActivityResult",               // from input parameter
    SourceJniMethodSignature        = "(IILandroid/content/Intent;)", // from input parameter
    TargetJniType                   = "com/microsoft/intune/mam/client/app/MAMActivity",
    TargetJniMethodName             = "onMAMActivityResult",
    SourceJniMethodSignature        = null,                     // "use original value"
    TargetJniMethodParameterCount   = null,                     // unchanged
    TargetJniMethodIsStatic         = false,
}

SourceJniMethodSignature is being set twice but TargetJniMethodSignature is never set.

[jonpryor]

Need to update commit message about removal of Debug.Assert(), and replacement w/ Console.WriteLine().

The reason was this:

ManagedPeerType <=> JniTypeName Mismatch! javaVM.GetJniTypeInfoForType(typeof(Android.Runtime.JavaList)).JniTypeName="java/util/ArrayList" != "java/util/List"

That's not easily fixable within xamarin-android right now, and with .NET 6 making Debug.Assert() an "abort the process" affair, changing this to a "runtime warning + continue execution" seems like the better idea.