[Java.Interop] Use Class.forName() as fallback to load Java classes (#1326)

Fixes: #23

Context: dotnet/android@aba2726
Context: b4d44e4
Context: https://github.com/xamarin/monodroid/commit/ed984a3a0bfbe71f6499a7855c647b5bc2b28466
Context: dotnet/android#7616

Commit b4d44e4 noted:

> Android is..."special", in that not all threads get the same
> ClassLoader behavior. Specifically, *managed* threads --
> System.Threading.Thread instances -- get a different ClassLoader than
> the main/UI thread on Android. (Untested, but the ClassLoader *may*
> behave sanely if you use a java.lang.Thread instance instead. But who
> wants to use java.lang.Thread instances...?)

dotnet/android#7616 provided additional context: `JNIEnv::FindClass()`
behavior *is* tied to the thread that calls it, and one of the knock-on
effects is that `Java.Lang.JavaSystem.LoadLibrary("MyLib")` doesn't
work properly when invoked from a new `System.Threading.Thread` thread.
(This is still the case, by the way.)

Which brings us to xamarin/mondroid@ed984a3a, which updated then
Xamarin.Android to use
[`Class.forName(String name, boolean initialize, ClassLoader loader)`][0]
instead of [`ClassLoader.loadClass(String)`][1], because the "real"
JDK cannot use `ClassLoader.loadClass(String)` to load array types:

	Class c1 = Class.forName("[Ljava.lang.String;");    // works
	Class c2 = ClassLoader.getSystemClassLoader()
	    .loadClass("[Ljava.lang.String;");              // throws java.lang.ClassNotFoundException

	Class c3 = Class.forName("[I");                     // works; array of int
	Class c4 = ClassLoader.getSystemClassLoader()
	    .loadClass("[I");                               // throws java.lang.ClassNotFoundException

Using `ClassLoader.loadClass(String)` to load array types works on
Android, presumably as an undocumented implementation detail, but as
xamarin/monodroid@ed984a3a was trying to get things working within
the (now dead) Android Designer -- which ran using a Desktop JDK --
Android-specific extensions were not available.

Update `JniEnvironment.Types` to use `Class.forName(String)` instead
of `ClassLoader.loadClass(String)` to load Java classes, as a fallback
for when `JNIEnv::FindClass()` fails to find the class. 

`[Obsolete]` the `JniRuntime.CreationOptions.ClassLoader_LoadClass_id`
property as it is no longer used.

[0]: https://developer.android.com/reference/java/lang/Class#forName(java.lang.String,%20boolean,%20java.lang.ClassLoader)
[1]: https://developer.android.com/reference/java/lang/ClassLoader#loadClass(java.lang.String)

Author: jonpryor

src/Java.Interop/Java.Interop/JniEnvironment.Types.cs

@@ -24,11 +24,15 @@ static partial class Types {
 			};
 
 			static  readonly    JniMethodInfo           Class_getName;
+			static  readonly    JniMethodInfo           Class_forName;
+			static  readonly    JniObjectReference      Class_reference;
 
 			static Types ()
 			{
 				using (var t = new JniType ("java/lang/Class")) {
+					Class_reference = t.PeerReference.NewGlobalRef ();
 					Class_getName   = t.GetInstanceMethod ("getName", "()Ljava/lang/String;");
+					Class_forName   = t.GetStaticMethod ("forName", "(Ljava/lang/String;ZLjava/lang/ClassLoader;)Ljava/lang/Class;");
 				}
 			}
 
@@ -57,12 +61,14 @@ static unsafe JniObjectReference TryFindClass (string classname, bool throwOnErr
 				LogCreateLocalRef (findClassThrown);
 				var pendingException    = info.Runtime.GetExceptionForThrowable (ref findClassThrown, JniObjectReferenceOptions.CopyAndDispose);
 
-				if (info.Runtime.ClassLoader_LoadClass != null) {
+				if (Class_forName.IsValid) {
 					var java    = info.ToJavaName (classname);
-					var __args  = stackalloc JniArgumentValue [1];
+					var __args  = stackalloc JniArgumentValue [3];
 					__args [0]  = new JniArgumentValue (java);
+					__args [1]  = new JniArgumentValue (true);  // initialize the class
+					__args [2]  = new JniArgumentValue (info.Runtime.ClassLoader);
 
-					c = RawCallObjectMethodA (info.EnvironmentPointer, out thrown, info.Runtime.ClassLoader.Handle, info.Runtime.ClassLoader_LoadClass.ID, (IntPtr) __args);
+					c = RawCallStaticObjectMethodA (info.EnvironmentPointer, out thrown, Class_reference.Handle, Class_forName.ID, (IntPtr) __args);
 					JniObjectReference.Dispose (ref java);
 					if (thrown == IntPtr.Zero) {
 						(pendingException as IJavaPeerable)?.Dispose ();
@@ -169,12 +175,12 @@ static void RawExceptionClear (IntPtr env)
 #endif  // FEATURE_JNIENVIRONMENT_JI_FUNCTION_POINTERS
 			}
 
-			static IntPtr RawCallObjectMethodA (IntPtr env, out IntPtr thrown, IntPtr instance, IntPtr jmethodID, IntPtr args)
+			static IntPtr RawCallStaticObjectMethodA (IntPtr env, out IntPtr thrown, IntPtr clazz, IntPtr jmethodID, IntPtr args)
 			{
 #if FEATURE_JNIENVIRONMENT_JI_PINVOKES
-				return NativeMethods.java_interop_jnienv_call_object_method_a (env, out thrown, instance, jmethodID, args);
+				return NativeMethods.java_interop_jnienv_call_static_object_method_a (env, out thrown, clazz, instance, jmethodID, args);
 #elif FEATURE_JNIENVIRONMENT_JI_FUNCTION_POINTERS
-				var r   = JniNativeMethods.CallObjectMethodA (env, instance, jmethodID, args);
+				var r   = JniNativeMethods.CallStaticObjectMethodA (env, clazz, jmethodID, args);
 				thrown  = JniNativeMethods.ExceptionOccurred (env);
 				return r;
 #else   // FEATURE_JNIENVIRONMENT_JI_FUNCTION_POINTERS

src/Java.Interop/Java.Interop/JniRuntime.cs

@@ -59,6 +59,7 @@ public partial class CreationOptions {
 			public  IntPtr                      EnvironmentPointer          {get; set;}
 
 			public  JniObjectReference          ClassLoader                 {get; set;}
+			[Obsolete ("No longer supported; Class.forName() is now used instead")]
 			public  IntPtr                      ClassLoader_LoadClass_id    {get; set;}
 
 			public  JniObjectReferenceManager?  ObjectReferenceManager      {get; set;}
@@ -152,7 +153,6 @@ public static void SetCurrent (JniRuntime newCurrent)
 		bool                                            DestroyRuntimeOnDispose;
 
 		internal    JniObjectReference                  ClassLoader;
-		internal    JniMethodInfo?                      ClassLoader_LoadClass;
 
 		public  IntPtr                                  InvocationPointer   {get; private set;}
 
@@ -206,25 +206,14 @@ protected JniRuntime (CreationOptions options)
 			JniEnvironment.SetEnvironmentInfo (env);
 
 			ClassLoader = options.ClassLoader;
-			if (options.ClassLoader_LoadClass_id != IntPtr.Zero) {
-				ClassLoader_LoadClass   = new JniMethodInfo (options.ClassLoader_LoadClass_id, isStatic: false);
-			}
-
 			if (ClassLoader.IsValid) {
 				ClassLoader = ClassLoader.NewGlobalRef ();
-			}
-
-			if (!ClassLoader.IsValid || ClassLoader_LoadClass == null) {
+			} else {
 				using (var t = new JniType ("java/lang/ClassLoader")) {
-					if (!ClassLoader.IsValid) {
-						var m       = t.GetStaticMethod ("getSystemClassLoader", "()Ljava/lang/ClassLoader;");
-						var loader  = JniEnvironment.StaticMethods.CallStaticObjectMethod (t.PeerReference, m);
-						ClassLoader = loader.NewGlobalRef ();
-						JniObjectReference.Dispose (ref loader);
-					}
-					if (ClassLoader_LoadClass == null) {
-						ClassLoader_LoadClass   = t.GetInstanceMethod ("loadClass", "(Ljava/lang/String;)Ljava/lang/Class;");
-					}
+					var m       = t.GetStaticMethod ("getSystemClassLoader", "()Ljava/lang/ClassLoader;");
+					var loader  = JniEnvironment.StaticMethods.CallStaticObjectMethod (t.PeerReference, m);
+					ClassLoader = loader.NewGlobalRef ();
+					JniObjectReference.Dispose (ref loader);
 				}
 			}