[Mono.Android] Java.Interop Unification! (#9640)

Context: #9636
Context: dotnet/java-interop@d5dfa0a
Context: https://github.com/xamarin/monodroid/commit/e318861ed8eb20a71852378ddd558409d6b1c234
Context: 130905e
Context: de04316
Changes: dotnet/java-interop@4f06201...d5dfa0a
* dotnet/java-interop@d5dfa0aa: [Java.Interop] `Java.Lang.Object, Mono.Android` Unification Changes (dotnet/java-interop#1293)
* dotnet/java-interop@c86ae26c: [ci] Fail build if any git tracked files were modified. (dotnet/java-interop#1288)
In the beginning there was Mono for Android, which had a set of
`Mono.Android.dll` assemblies (one per supported API level), each of
which contained "duplicated" binding logic: each API level had its
own `Java.Lang.Object`, `Android.Runtime.JNIEnv`, etc.
dotnet/java-interop started, in part, as a way to "split out" the
core integration logic, so that it *wouldn't* need to be duplicated
across every assembly. As part of this, it introduced its own core
abstractions, notably `Java.Interop.IJavaPeerable` and
`Java.Interop.JavaObject`.
When dotnet/java-interop was first introduced into Xamarin.Android,
with xamarin/monodroid@e318861e, the integration was incomplete.
Integration continued with 130905e, allowing unit tests within
`Java.Interop-Tests.dll` to run within Xamarin.Android and
construction of instances of e.g. `JavaInt32Array`, but one large
piece of integration remained:
Move GC bridge code *out* of `Java.Lang.Object`, and instead rely on
`Java.Interop.JavaObject`, turning this:
namespace Java.Lang {
public partial class Object : System.Object, IJavaPeerable /* … */ {
}
}
into this:
namespace Java.Lang {
public partial class Object : Java.Interop.JavaObject, IJavaPeerable /* … */ {
}
}
*Why*? In part because @jonpryor has wanted to do this for literal
years at this point, but also in part because of #9636
and related efforts to use Native AOT, which involves avoiding /
bypassing `DllImportAttribute` invocations (for now, everything
touched by Native AOT becomes a single `.so` binary, which we don't
know the name of). Avoiding P/Invoke means *embracing* and extending
existing Java.Interop constructs (e.g. de04316).
In addition to altering the base types of `Java.Lang.Object` and
`Java.Lang.Throwable`:
* Remove `handle` and related fields from `Java.Lang.Object` and
`Java.Lang.Throwable`.
* Update `PreserveLists/Mono.Android.xml` et al. so that the
removed fields are not preserved.
* Rename `JNIenvInit.AndroidValueManager` to
`JNIEnvInit.ValueManager`, and change its type to
`JniRuntime.JniValueManager`. This is to help "force" usage of
`JnIRuntime.JniValueManager` in more places, as we can't
currently use `AndroidValueManager` in Native AOT (P/Invokes!).
* Cleanup: Remove `JNIEnv.Exit()` and related code. These were
used by the Android Designer, which is no longer supported.
* Update (`internal`) interface `IJavaObjectEx` to remove
constructs present on `IJavaPeerable.`
* Update the `Java.Lang.Object(IntPtr, JniHandleOwnership)` and
`Java.Lang.Throwable(IntPtr, JniHandleOwnership)` constructors to
follow dotnet/java-interop convention, and patch over the
differences that exist between the two paradigms.
* Update `ExceptionTest.CompareStackTraces()` to use
`System.Diagnostics.StackTrace(ex, fNeedFileInfo:true)`
so that when the `debug.mono.debug` system property is set, the
`ExceptionTest.InnerExceptionIsSet()` unit test doesn't fail.
Also, increase assertion message utility.
* Update `AndroidObjectReferenceManager` so that
dotnet/java-interop -initiated JNI object reference log messages
are appropriately captured.
* Update `JNIEnv.IsGCUserPeer()` to also consider types which
implement `net.dot.jni.GCUserPeerable` to be "GC User Peers".

Author: jonpryor

external/Java.Interop

@@ -9,7 +9,6 @@
  <typefullname="Android.Runtime.InputStreamAdapter"preserve="methods" />
  <typefullname="Android.Runtime.InputStreamInvoker"preserve="methods" />
  <typefullname="Android.Runtime.JNIEnv">
- <methodname="Exit" />
  <methodname="PropagateUncaughtException" />
  </type>
  <typefullname="Android.Runtime.JNIEnvInit">
@@ -36,15 +35,7 @@
 -->
  <typefullname="Java.Interop.TypeManager*JavaTypeManager" />
  <typefullname="Java.Lang.Object">
- <fieldname="handle" />
- <fieldname="handle_type" />
- <fieldname="refs_added" />
  <methodname="SetHandleOnDeserialized" />
  </type>
- <typefullname="Java.Lang.Throwable">
- <fieldname="handle" />
- <fieldname="handle_type" />
- <fieldname="refs_added" />
- </type>
 	</assembly>
 </linker>

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

@@ -56,29 +56,36 @@ public override string GetCurrentManagedThreadStackTrace (int skipFrames, bool f
 {
 if(!reference.IsValid)
 returnnull;
-varpeeked=JNIEnvInit.AndroidValueManager?.PeekPeer(reference);
+varpeeked=JNIEnvInit.ValueManager?.PeekPeer(reference);
 varpeekedExc=peekedasException;
 if(peekedExc==null){
 varthrowable=Java.Lang.Object.GetObject<Java.Lang.Throwable>(reference.Handle,JniHandleOwnership.DoNotTransfer);
 JniObjectReference.Dispose(refreference,options);
 returnthrowable;
 }
 JniObjectReference.Dispose(refreference,options);
-varunwrapped=JNIEnvInit.AndroidValueManager?.UnboxException(peeked!);
+varunwrapped=UnboxException(peeked!);
 if(unwrapped!=null){
 returnunwrapped;
 }
 returnpeekedExc;
 }
 
+Exception?UnboxException(IJavaPeerablevalue)
+{
+if(JNIEnvInit.ValueManagerisAndroidValueManagervm){
+returnvm.UnboxException(value);
+}
+returnnull;
+}
+
 publicoverridevoidRaisePendingException(ExceptionpendingException)
 {
-varje=pendingExceptionasJavaProxyThrowable;
+varje=pendingExceptionasJavaException;
 if(je==null){
 je=JavaProxyThrowable.Create(pendingException);
 }
-varr=newJniObjectReference(je.Handle);
-JniEnvironment.Exceptions.Throw(r);
+JniEnvironment.Exceptions.Throw(je.PeerReference);
 }
 }
 
@@ -158,6 +165,14 @@ public override IntPtr ReleaseLocalReference (ref JniObjectReference value, ref
 returnr;
 }
 
+publicoverrideboolLogGlobalReferenceMessages=>Logger.LogGlobalRef;
+publicoverrideboolLogLocalReferenceMessages=>Logger.LogLocalRef;
+
+publicoverridevoidWriteLocalReferenceLine(stringformat,paramsobject?[]args)
+{
+RuntimeNativeMethods._monodroid_gref_log("[LREF] "+string.Format(CultureInfo.InvariantCulture,format,args));
+}
+
 publicoverridevoidWriteGlobalReferenceLine(stringformat,paramsobject?[]args)
 {
 RuntimeNativeMethods._monodroid_gref_log(string.Format(CultureInfo.InvariantCulture,format,args));
@@ -470,6 +485,7 @@ static bool CallRegisterMethodByIndex (JniNativeMethodRegistrationArguments argu
 }
 }
 
+[Obsolete("Use RegisterNativeMembers(JniType, Type, ReadOnlySpan<char>) instead.")]
 publicoverridevoidRegisterNativeMembers(
 JniTypenativeClass,
 [DynamicallyAccessedMembers(MethodsAndPrivateNested)]

src/Mono.Android/Android.Runtime/AndroidRuntime.cs

@@ -52,7 +52,8 @@ internal static bool IsGCUserPeer (IntPtr value)
 if(value==IntPtr.Zero)
 returnfalse;
 
-returnIsInstanceOf(value,JNIEnvInit.grefIGCUserPeer_class);
+returnIsInstanceOf(value,JNIEnvInit.grefIGCUserPeer_class)||
+IsInstanceOf(value,JNIEnvInit.grefGCUserPeerable_class);
 }
 
 internalstaticboolShouldWrapJavaException(Java.Lang.Throwable?t,[CallerMemberName]string?caller=null)
@@ -76,49 +77,6 @@ internal static bool ShouldWrapJavaException (Java.Lang.Throwable? t, [CallerMem
 returnwrap;
 }
 
-[DllImport("libc")]
-staticexternintgettid();
-
-internalstaticvoidExit()
-{
-/* Manually dispose surfaced objects and close the current JniEnvironment to
- * avoid ObjectDisposedException thrown on finalizer threads after shutdown
- */
-foreach(varsurfacedObjectinJava.Interop.Runtime.GetSurfacedObjects()){
-try{
-varobj=surfacedObject.TargetasIDisposable;
-if(obj!=null)
-obj.Dispose();
-continue;
-}catch(Exceptione){
-RuntimeNativeMethods.monodroid_log(LogLevel.Warn,LogCategories.Default,$"Couldn't dispose object: {e}");
-}
-/* If calling Dispose failed, the assumption is that user-code in
- * the Dispose(bool) overload is to blame for it. In that case we
- * fallback to manual deletion of the surfaced object.
- */
-varjobj=surfacedObject.TargetasJava.Lang.Object;
-if(jobj!=null)
-ManualJavaObjectDispose(jobj);
-}
-JniEnvironment.Runtime.Dispose();
-}
-
-/* FIXME: This reproduces the minimal steps in Java.Lang.Object.Dispose
- * that needs to be executed so that we don't leak any GREF and prevent
- * code execution into an appdomain that we are disposing via a finalizer.
- * Ideally it should be done via another more generic mechanism, likely
- * from the Java.Interop.Runtime API.
- */
-staticvoidManualJavaObjectDispose(Java.Lang.Objectobj)
-{
-varpeer=obj.PeerReference;
-varhandle=peer.Handle;
-varkeyHandle=((IJavaObjectEx)obj).KeyHandle;
-Java.Lang.Object.Dispose(obj,refhandle,keyHandle,(JObjectRefType)peer.Type);
-GC.SuppressFinalize(obj);
-}
-
 internalstaticvoidPropagateUncaughtException(IntPtrenv,IntPtrjavaThreadPtr,IntPtrjavaExceptionPtr)
 {
 if(!JNIEnvInit.PropagateExceptions)

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

@@ -32,17 +32,19 @@ internal struct JnienvInitializeArgs {
 publicintjniAddNativeMethodRegistrationAttributePresent;
 publicbooljniRemappingInUse;
 publicboolmarshalMethodsEnabled;
+publicIntPtrgrefGCUserPeerable;
 }
 #pragma warning restore 0649
 
-internalstaticAndroidValueManager?AndroidValueManager;
+internalstaticJniRuntime.JniValueManager?ValueManager;
 internalstaticboolIsRunningOnDesktop;
 internalstaticbooljniRemappingInUse;
 internalstaticboolMarshalMethodsEnabled;
 internalstaticboolPropagateExceptions;
 internalstaticBoundExceptionTypeBoundExceptionType;
 internalstaticintgref_gc_threshold;
 internalstaticIntPtrgrefIGCUserPeer_class;
+internalstaticIntPtrgrefGCUserPeerable_class;
 internalstaticIntPtrjava_class_loader;
 internalstaticJniMethodInfo?mid_Class_forName;
 
@@ -94,11 +96,12 @@ internal static unsafe void Initialize (JnienvInitializeArgs* args)
 
 BoundExceptionType=(BoundExceptionType)args->ioExceptionType;
 androidRuntime=newAndroidRuntime(args->env,args->javaVm,args->grefLoader,args->Loader_loadClass,args->jniAddNativeMethodRegistrationAttributePresent!=0);
-AndroidValueManager=(AndroidValueManager)androidRuntime.ValueManager;
+ValueManager=androidRuntime.ValueManager;
 
 IsRunningOnDesktop=args->isRunningOnDesktop==1;
 
 grefIGCUserPeer_class=args->grefIGCUserPeer;
+grefGCUserPeerable_class=args->grefGCUserPeerable;
 
 PropagateExceptions=args->brokenExceptionTransitions==0;
 

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

@@ -3,9 +3,6 @@
 namespaceJava.Interop{
 
 interfaceIJavaObjectEx{
-IntPtrKeyHandle{get;set;}
-boolIsProxy{get;set;}
-boolNeedsActivation{get;set;}
 IntPtrToLocalJniHandle();
 }
 }

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

@@ -11,7 +11,7 @@ public static class Runtime {
 [Obsolete("Please use Java.Interop.JniEnvironment.Runtime.ValueManager.GetSurfacedPeers()")]
 publicstaticList<WeakReference>GetSurfacedObjects()
 {
-varpeers=JNIEnvInit.AndroidValueManager!.GetSurfacedPeers();
+varpeers=JNIEnvInit.ValueManager!.GetSurfacedPeers();
 varr=newList<WeakReference>(peers.Count);
 foreach(varpinpeers){
 if(p.SurfacedPeer.TryGetTarget(outvartarget))

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

@@ -133,9 +133,10 @@ static Type[] GetParameterTypes (string? signature)
 staticvoidn_Activate(IntPtrjnienv,IntPtrjclass,IntPtrtypename_ptr,IntPtrsignature_ptr,IntPtrjobject,IntPtrparameters_ptr)
 {
 varo=Java.Lang.Object.PeekObject(jobject);
-varex=oasIJavaObjectEx;
+varex=oasIJavaPeerable;
 if(ex!=null){
-if(!ex.NeedsActivation&&!ex.IsProxy)
+varstate=ex.JniManagedPeerState;
+if(!state.HasFlag(JniManagedPeerStates.Activatable)&&!state.HasFlag(JniManagedPeerStates.Replaceable))
 return;
 }
 if(!ActivationEnabled){
@@ -171,10 +172,8 @@ internal static void Activate (IntPtr jobject, ConstructorInfo cinfo, object? []
 {
 try{
 varnewobj=RuntimeHelpers.GetUninitializedObject(cinfo.DeclaringType!);
-if(newobjisJava.Lang.Objecto){
-o.handle=jobject;
-}elseif(newobjisJava.Lang.Throwablethrowable){
-throwable.handle=jobject;
+if(newobjisIJavaPeerablepeer){
+peer.SetPeerReference(newJniObjectReference(jobject));
 }else{
 thrownewInvalidOperationException($"Unsupported type: '{newobj}'");
 }
@@ -232,7 +231,7 @@ static Exception CreateJavaLocationException ()
 returnnull;
 }
 
-internalstaticIJavaPeerableCreateInstance(IntPtrhandle,JniHandleOwnershiptransfer)
+internalstaticIJavaPeerable?CreateInstance(IntPtrhandle,JniHandleOwnershiptransfer)
 {
 returnCreateInstance(handle,transfer,null);
 }
@@ -320,7 +319,7 @@ internal static IJavaPeerable CreateInstance (IntPtr handle, JniHandleOwnership
 try{
 result=(IJavaPeerable)CreateProxy(type,handle,transfer);
 if(Runtime.IsGCUserPeer(result.PeerReference.Handle)){
-result.SetJniManagedPeerState(JniManagedPeerStates.Replaceable);
+result.SetJniManagedPeerState(JniManagedPeerStates.Replaceable|JniManagedPeerStates.Activatable);
 }
 }catch(MissingMethodExceptione){
 varkey_handle=JNIEnv.IdentityHash(handle);
@@ -353,7 +352,6 @@ internal static object CreateProxy (
 JniObjectReferenceOptionso=JniObjectReferenceOptions.Copy;
 varpeer=(IJavaPeerable)c.Invoke(newobject[]{r,o});
 JNIEnv.DeleteRef(handle,transfer);
-peer.SetJniManagedPeerState(peer.JniManagedPeerState|JniManagedPeerStates.Replaceable);
 returnpeer;
 }
 thrownewMissingMethodException(