Fix Application subclass usage.

Context: https://discord.com/channels/732297728826277939/732297837953679412/1334614545871929345
PR #9716 was crashing with a stack overflow:
I NativeAotFromAndroid: at Java.Interop.JniEnvironment.InstanceMethods.CallVoidMethod(JniObjectReference, JniMethodInfo, JniArgumentValue*) + 0xa8
I NativeAotFromAndroid: at Java.Interop.JniPeerMembers.JniInstanceMethods.InvokeVirtualVoidMethod(String, IJavaPeerable, JniArgumentValue*) + 0x184
I NativeAotFromAndroid: at Android.App.Application.n_OnCreate(IntPtr jnienv, IntPtr native__this) + 0xa8
I NativeAotFromAndroid: at libNativeAOT!<BaseAddress>+0x4f3e44
The cause was the topmost frame: `CallVoidMethod()`, which performs a
*virtual* method invocation. The stack overflow was that
Java `MainApplication.onCreate()` called C# `Application.n_OnCreate()`,
which called `InvokeVirtualVoidMethod()`, which did a *virtual*
invocation back on `MainApplication.onCreate()`, …
`InvokeVirtualVoidMethod()` should have been calling
`CallNonvirtualVoidMethod()`; why wasn't it?
Further investigation showed:
Created PeerReference=0x2d06/G IdentityHashCode=0x8edcb07 Instance=0x957d2a Instance.Type=Android.App.Application, Java.Type=my/MainApplication
which at a glance seems correct, but isn't: the `Instance.Type` for
a `Java.Type` of `my/MainApplication` should be `MainApplication`,
*not* `Android.App.Application`!
Because the runtime type of this value was `Application`,
it was warranted and expected that `InvokeVirtualVoidMethod()`
would do a virtual invocation!
So, why did the avove `Created PeerReference …` line show the wrong
type? Because `NativeAotTypeManager.CreatePeer()` needs to check
for bindings of the the runtime type of the Java handle *before*
using the `targetType` parameter, because the targetType parameter
will *never* be for that of a custom subclass.
Copy *lots* of code from dotnet/java-interop -- showing that this
needs some major cleanup & refactoring -- so that we properly check
the runtime type of `reference` + base classes when trying to determine
the type of the proxy to create.
This fixes the stack overflow.

Author: jonpryor

samples/NativeAOT/MainApplication.cs

@@ -11,6 +11,7 @@ public class MainApplication : Application
 publicMainApplication(IntPtrhandle,JniHandleOwnershiptransfer)
 :base(handle,transfer)
 {
+Log.Debug("NativeAOT",$"Application..ctor({handle.ToString("x2")}, {transfer})");
 }
 
 publicoverridevoidOnCreate()

samples/NativeAOT/NativeAotValueManager.cs

@@ -17,6 +17,8 @@ namespace NativeAOT;
 
 internalclassNativeAotValueManager:JniRuntime.JniValueManager
 {
+constDynamicallyAccessedMemberTypesConstructors=DynamicallyAccessedMemberTypes.PublicConstructors|DynamicallyAccessedMemberTypes.NonPublicConstructors;
+
 readonlyNativeAotTypeManagerTypeManager;
 Dictionary<int,List<IJavaPeerable>>?RegisteredInstances=newDictionary<int,List<IJavaPeerable>>();
 
@@ -253,105 +255,180 @@ public override List<JniSurfacedPeerInfo> GetSurfacedPeers ()
 
 publicoverrideIJavaPeerable?CreatePeer(
 refJniObjectReferencereference,
-JniObjectReferenceOptionsoptions,
-[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors|DynamicallyAccessedMemberTypes.NonPublicConstructors)]
+JniObjectReferenceOptionstransfer,
+[DynamicallyAccessedMembers(Constructors)]
 Type?targetType)
 {
-if(!reference.IsValid)
+if(!reference.IsValid){
 returnnull;
+}
 
-varpeer=CreateInstance(reference.Handle,JniHandleOwnership.DoNotTransfer,targetType);
-JniObjectReference.Dispose(refreference,options);
-returnpeer;
-}
+targetType=targetType??typeof(global::Java.Interop.JavaObject);
+targetType=GetPeerType(targetType);
 
-internalIJavaPeerable?CreateInstance(
-IntPtrhandle,
-JniHandleOwnershiptransfer,
-[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors|DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-Type?targetType)
-{
-if(targetType.IsInterface||targetType.IsAbstract){
-varinvokerType=JavaObjectExtensions.GetInvokerType(targetType);
-if(invokerType==null)
-thrownewNotSupportedException("Unable to find Invoker for type '"+targetType.FullName+"'. Was it linked away?",
-CreateJavaLocationException());
-targetType=invokerType;
-}
+if(!typeof(IJavaPeerable).IsAssignableFrom(targetType))
+thrownewArgumentException($"targetType `{targetType.AssemblyQualifiedName}` must implement IJavaPeerable!",nameof(targetType));
 
-vartypeSig=TypeManager.GetTypeSignature(targetType);
-if(!typeSig.IsValid||typeSig.SimpleReference==null){
+vartargetSig=Runtime.TypeManager.GetTypeSignature(targetType);
+if(!targetSig.IsValid||targetSig.SimpleReference==null){
 thrownewArgumentException($"Could not determine Java type corresponding to `{targetType.AssemblyQualifiedName}`.",nameof(targetType));
 }
 
-JniObjectReferencetypeClass=default;
-JniObjectReferencehandleClass=default;
+varrefClass=JniEnvironment.Types.GetObjectClass(reference);
+JniObjectReferencetargetClass;
 try{
-try{
-typeClass=JniEnvironment.Types.FindClass(typeSig.SimpleReference);
-}catch(Exceptione){
-thrownewArgumentException($"Could not find Java class `{typeSig.SimpleReference}`.",
-nameof(targetType),
-e);
-}
+targetClass=JniEnvironment.Types.FindClass(targetSig.SimpleReference);
+}catch(Exceptione){
+JniObjectReference.Dispose(refrefClass);
+thrownewArgumentException($"Could not find Java class `{targetSig.SimpleReference}`.",
+nameof(targetType),
+e);
+}
+
+if(!JniEnvironment.Types.IsAssignableFrom(refClass,targetClass)){
+JniObjectReference.Dispose(refrefClass);
+JniObjectReference.Dispose(reftargetClass);
+returnnull;
+}
+
+JniObjectReference.Dispose(reftargetClass);
+
+varproxy=CreatePeerProxy(refrefClass,targetType,refreference,transfer);
+
+if(proxy==null){
+thrownewNotSupportedException(string.Format("Could not find an appropriate constructable wrapper type for Java type '{0}', targetType='{1}'.",
+JniEnvironment.Types.GetJniTypeNameFromInstance(reference),targetType));
+}
+
+proxy.SetJniManagedPeerState(proxy.JniManagedPeerState|JniManagedPeerStates.Replaceable);
+returnproxy;
+}
+
+[return:DynamicallyAccessedMembers(Constructors)]
+staticTypeGetPeerType([DynamicallyAccessedMembers(Constructors)]Typetype)
+{
+if(type==typeof(object))
+returntypeof(global::Java.Interop.JavaObject);
+if(type==typeof(IJavaPeerable))
+returntypeof(global::Java.Interop.JavaObject);
+if(type==typeof(Exception))
+returntypeof(global::Java.Interop.JavaException);
+returntype;
+}
+
+staticreadonlyTypeByRefJniObjectReference=typeof(JniObjectReference).MakeByRefType();
+
+IJavaPeerable?CreatePeerProxy(
+refJniObjectReferenceklass,
+[DynamicallyAccessedMembers(Constructors)]
+TypefallbackType,
+refJniObjectReferencereference,
+JniObjectReferenceOptionsoptions)
+{
+varjniTypeName=JniEnvironment.Types.GetJniTypeNameFromClass(klass);
 
-handleClass=JniEnvironment.Types.GetObjectClass(newJniObjectReference(handle));
-if(!JniEnvironment.Types.IsAssignableFrom(handleClass,typeClass)){
+Type?type=null;
+while(jniTypeName!=null){
+JniTypeSignaturesig;
+if(!JniTypeSignature.TryParse(jniTypeName,outsig))
 returnnull;
+
+type=Runtime.TypeManager.GetType(sig);
+
+if(type!=null){
+varpeer=TryCreatePeerProxy(type,refreference,options);
+if(peer!=null){
+returnpeer;
+}
 }
-}finally{
-JniObjectReference.Dispose(refhandleClass);
-JniObjectReference.Dispose(reftypeClass);
+
+varsuper=JniEnvironment.Types.GetSuperclass(klass);
+jniTypeName=super.IsValid
+?JniEnvironment.Types.GetJniTypeNameFromClass(super)
+:null;
+
+JniObjectReference.Dispose(refklass,JniObjectReferenceOptions.CopyAndDispose);
+klass=super;
 }
+JniObjectReference.Dispose(refklass,JniObjectReferenceOptions.CopyAndDispose);
 
-IJavaPeerable?result=null;
+returnTryCreatePeerProxy(fallbackType,refreference,options);
+}
 
-try{
-result=(IJavaPeerable)CreateProxy(targetType,handle,transfer);
-//if (JNIEnv.IsGCUserPeer (result.PeerReference.Handle)) {
-result.SetJniManagedPeerState(JniManagedPeerStates.Replaceable|JniManagedPeerStates.Activatable);
-//}
-}catch(MissingMethodExceptione){
-varkey_handle=JNIEnv.IdentityHash(handle);
-JNIEnv.DeleteRef(handle,transfer);
-thrownewNotSupportedException(FormattableString.Invariant(
-$"Unable to activate instance of type {targetType} from native handle 0x{handle:x} (key_handle 0x{key_handle:x})."),e);
+staticConstructorInfo?GetActivationConstructor(
+[DynamicallyAccessedMembers(Constructors)]
+Typetype)
+{
+if(type.IsAbstract||type.IsInterface){
+type=GetInvokerType(type)??type;
 }
-returnresult;
+foreach(varcintype.GetConstructors(BindingFlags.Public|BindingFlags.NonPublic|BindingFlags.Instance)){
+varp=c.GetParameters();
+if(p.Length==2&&p[0].ParameterType==ByRefJniObjectReference&&p[1].ParameterType==typeof(JniObjectReferenceOptions))
+returnc;
+if(p.Length==2&&p[0].ParameterType==typeof(IntPtr)&&p[1].ParameterType==typeof(JniHandleOwnership))
+returnc;
+}
+returnnull;
 }
 
+[return:DynamicallyAccessedMembers(Constructors)]
+staticType?GetInvokerType(Typetype)
+{
+// https://github.com/xamarin/xamarin-android/blob/5472eec991cc075e4b0c09cd98a2331fb93aa0f3/src/Microsoft.Android.Sdk.ILLink/MarkJavaObjects.cs#L176-L186
+conststringmakeGenericTypeMessage="Generic 'Invoker' types are preserved by the MarkJavaObjects trimmer step.";
+
+[UnconditionalSuppressMessage("Trimming","IL2055",Justification=makeGenericTypeMessage)]
+[return:DynamicallyAccessedMembers(Constructors)]
+staticTypeMakeGenericType(
+[DynamicallyAccessedMembers(Constructors)]
+Typetype,
+Type[]arguments)=>
+// FIXME: https://github.com/dotnet/java-interop/issues/1192
+ #pragma warning disable IL3050
+type.MakeGenericType(arguments);
+ #pragma warning restore IL3050
+
+varsignature=type.GetCustomAttribute<JniTypeSignatureAttribute>();
+if(signature==null||signature.InvokerType==null){
+returnnull;
+}
+
+Type[]arguments=type.GetGenericArguments();
+if(arguments.Length==0)
+returnsignature.InvokerType;
+
+returnMakeGenericType(signature.InvokerType,arguments);
+}
+
+constBindingFlagsActivationConstructorBindingFlags=BindingFlags.Public|BindingFlags.NonPublic|BindingFlags.Instance;
+
+
 staticreadonlyType[]XAConstructorSignature=newType[]{typeof(IntPtr),typeof(JniHandleOwnership)};
 staticreadonlyType[]JIConstructorSignature=newType[]{typeof(JniObjectReference).MakeByRefType(),typeof(JniObjectReferenceOptions)};
 
-internalstaticobjectCreateProxy(
-[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors|DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-Typetype,
-IntPtrhandle,
-JniHandleOwnershiptransfer)
+protectedvirtualIJavaPeerable?TryCreatePeerProxy(Typetype,refJniObjectReferencereference,JniObjectReferenceOptionsoptions)
 {
-// Skip Activator.CreateInstance() as that requires public constructors,
-// and we want to hide some constructors for sanity reasons.
-BindingFlagsflags=BindingFlags.Public|BindingFlags.NonPublic|BindingFlags.Instance;
-varc=type.GetConstructor(flags,null,XAConstructorSignature,null);
+varc=type.GetConstructor(ActivationConstructorBindingFlags,null,XAConstructorSignature,null);
 if(c!=null){
-returnc.Invoke(newobject[]{handle,transfer});
+varargs=newobject[]{
+reference.Handle,
+JniHandleOwnership.DoNotTransfer,
+};
+varp=(IJavaPeerable)c.Invoke(args);
+JniObjectReference.Dispose(refreference,options);
+returnp;
 }
-c=type.GetConstructor(flags,null,JIConstructorSignature,null);
+c=type.GetConstructor(ActivationConstructorBindingFlags,null,JIConstructorSignature,null);
 if(c!=null){
-JniObjectReferencer=newJniObjectReference(handle);
-JniObjectReferenceOptionso=JniObjectReferenceOptions.Copy;
-varpeer=(IJavaPeerable)c.Invoke(newobject[]{r,o});
-JNIEnv.DeleteRef(handle,transfer);
-returnpeer;
+varargs=newobject[]{
+reference,
+options,
+};
+varp=(IJavaPeerable)c.Invoke(args);
+reference=(JniObjectReference)args[0];
+returnp;
 }
-thrownewMissingMethodException(
-"No constructor found for "+type.FullName+"::.ctor(System.IntPtr, Android.Runtime.JniHandleOwnership)",
-CreateJavaLocationException());
-}
-
-staticExceptionCreateJavaLocationException()
-{
-using(varloc=newJava.Lang.Error("Java callstack:"))
-returnnewJavaLocationException(loc.ToString());
+returnnull;
 }
 }