Add JavaBridgedValueManager

Context: dotnet/runtime#115506
Context: dotnet/android#10125

We have an *API*, but not (yet) usable *implementation*.

"Import" the `ManagedValueManager` from dotnet/android#10125, renaming
to `JavaBridgedValueManager`, and add the proposed bridge API
from dotnet/runtime#115506 to verify that it all compiles.

It compiles!

Next step: does it *work*?

If I squint right, the proposed API looks very very similar to the
existing MonoVM GC bridge API.  Can I implement the proposed API
in terms of MonoVM, and then have C# code perform the bridge code
instead of native code, when using MonoVM?

Let's find out!

Author: jonpryor

src/Java.Runtime.Environment/Java.Interop/JavaBridgedValueManager.cs

@@ -0,0 +1,318 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.InteropServices.Java;
+using System.Threading;
+
+using Java.Interop;
+
+namespace System.Runtime.InteropServices.Java {
+	// https://github.com/dotnet/runtime/issues/115506
+
+	public struct ComponentCrossReference {
+		public nint SourceGroupIndex;
+		public nint DestinationGroupIndex;
+	}
+
+	public unsafe struct StronglyConnectedComponent {
+		public nint Count;
+		public System.IntPtr* Context;
+	}
+
+	public unsafe struct MarkCrossReferences {
+		public nint ComponentsLen;
+		public StronglyConnectedComponent* Components;
+		public nint CrossReferencesLen;
+		public ComponentCrossReference* CrossReferences;
+	}
+
+	static class JavaMarshal {
+		public static unsafe void Initialize(delegate* unmanaged<MarkCrossReferences*, void> markCrossReferences) =>
+			throw null!;
+
+		public static GCHandle CreateReferenceTrackingHandle(object obj, IntPtr context) =>
+			throw null!;
+
+		public static IntPtr GetContext(GCHandle obj) =>
+			throw null!;
+
+		public static unsafe void ReleaseMarkCrossReferenceResources(MarkCrossReferences* crossReferences) =>
+			throw null!;
+	}
+}
+
+namespace Java.Interop {
+
+	class JavaBridgedValueManager : JniRuntime.JniValueManager
+	{
+		Dictionary<int, List<GCHandle>>?   RegisteredInstances = new ();
+
+		internal unsafe JavaBridgedValueManager ()
+		{
+			JavaMarshal.Initialize (&MarkCrossReferences);
+		}
+
+		public override void WaitForGCBridgeProcessing ()
+		{
+		}
+
+		public override void CollectPeers ()
+		{
+			if (RegisteredInstances == null)
+				throw new ObjectDisposedException (nameof (ManagedValueManager));
+
+			var peers = new List<GCHandle> ();
+
+			lock (RegisteredInstances) {
+				foreach (var ps in RegisteredInstances.Values) {
+					foreach (var p in ps) {
+						peers.Add (p);
+					}
+				}
+				RegisteredInstances.Clear ();
+			}
+			List<Exception>? exceptions = null;
+			foreach (var peer in peers) {
+				try {
+					if (peer.Target is IDisposable disposable)
+						disposable.Dispose ();
+				}
+				catch (Exception e) {
+					exceptions = exceptions ?? new List<Exception> ();
+					exceptions.Add (e);
+				}
+			}
+			if (exceptions != null)
+				throw new AggregateException ("Exceptions while collecting peers.", exceptions);
+		}
+
+		public override void AddPeer (IJavaPeerable value)
+		{
+			if (RegisteredInstances == null)
+				throw new ObjectDisposedException (nameof (ManagedValueManager));
+
+			var r = value.PeerReference;
+			if (!r.IsValid)
+				throw new ObjectDisposedException (value.GetType ().FullName);
+
+			if (r.Type != JniObjectReferenceType.Global) {
+				value.SetPeerReference (r.NewGlobalRef ());
+				JniObjectReference.Dispose (ref r, JniObjectReferenceOptions.CopyAndDispose);
+			}
+			int key = value.JniIdentityHashCode;
+			lock (RegisteredInstances) {
+				List<GCHandle>? peers;
+				if (!RegisteredInstances.TryGetValue (key, out peers)) {
+					peers = new List<GCHandle> () {
+						CreateReferenceTrackingHandle (value)
+					};
+					RegisteredInstances.Add (key, peers);
+					return;
+				}
+
+				for (int i = peers.Count - 1; i >= 0; i--) {
+					var p   = peers [i];
+					if (p.Target is not IJavaPeerable peer)
+						continue;
+					if (!JniEnvironment.Types.IsSameObject (peer.PeerReference, value.PeerReference))
+						continue;
+					if (Replaceable (p)) {
+						peers [i] = CreateReferenceTrackingHandle (value);
+					} else {
+						WarnNotReplacing (key, value, peer);
+					}
+					return;
+				}
+				peers.Add (CreateReferenceTrackingHandle (value));
+			}
+		}
+
+		static bool Replaceable (GCHandle handle)
+		{
+			if (handle.Target is not IJavaPeerable peer)
+				return true;
+			return peer.JniManagedPeerState.HasFlag (JniManagedPeerStates.Replaceable);
+		}
+
+		void WarnNotReplacing (int key, IJavaPeerable ignoreValue, IJavaPeerable keepValue)
+		{
+			Runtime.ObjectReferenceManager.WriteGlobalReferenceLine (
+					"Warning: Not registering PeerReference={0} IdentityHashCode=0x{1} Instance={2} Instance.Type={3} Java.Type={4}; " +
+					"keeping previously registered PeerReference={5} Instance={6} Instance.Type={7} Java.Type={8}.",
+					ignoreValue.PeerReference.ToString (),
+					key.ToString ("x", CultureInfo.InvariantCulture),
+					RuntimeHelpers.GetHashCode (ignoreValue).ToString ("x", CultureInfo.InvariantCulture),
+					ignoreValue.GetType ().FullName,
+					JniEnvironment.Types.GetJniTypeNameFromInstance (ignoreValue.PeerReference),
+					keepValue.PeerReference.ToString (),
+					RuntimeHelpers.GetHashCode (keepValue).ToString ("x", CultureInfo.InvariantCulture),
+					keepValue.GetType ().FullName,
+					JniEnvironment.Types.GetJniTypeNameFromInstance (keepValue.PeerReference));
+		}
+
+		public override IJavaPeerable? PeekPeer (JniObjectReference reference)
+		{
+			if (RegisteredInstances == null)
+				throw new ObjectDisposedException (nameof (ManagedValueManager));
+
+			if (!reference.IsValid)
+				return null;
+
+			int key = GetJniIdentityHashCode (reference);
+
+			lock (RegisteredInstances) {
+				List<GCHandle>? peers;
+				if (!RegisteredInstances.TryGetValue (key, out peers))
+					return null;
+
+				for (int i = peers.Count - 1; i >= 0; i--) {
+					var p = peers [i];
+					if (p.Target is IJavaPeerable peer && JniEnvironment.Types.IsSameObject (reference, peer.PeerReference))
+						return peer;
+				}
+				if (peers.Count == 0)
+					RegisteredInstances.Remove (key);
+			}
+			return null;
+		}
+
+		public override void RemovePeer (IJavaPeerable value)
+		{
+			if (RegisteredInstances == null)
+				throw new ObjectDisposedException (nameof (ManagedValueManager));
+
+			if (value == null)
+				throw new ArgumentNullException (nameof (value));
+
+			int key = value.JniIdentityHashCode;
+			lock (RegisteredInstances) {
+				List<GCHandle>? peers;
+				if (!RegisteredInstances.TryGetValue (key, out peers))
+					return;
+
+				for (int i = peers.Count - 1; i >= 0; i--) {
+					var p   = peers [i];
+					if (object.ReferenceEquals (value, p.Target)) {
+						peers.RemoveAt (i);
+						FreeHandle (p);
+					}
+				}
+				if (peers.Count == 0)
+					RegisteredInstances.Remove (key);
+			}
+		}
+
+		public override void FinalizePeer (IJavaPeerable value)
+		{
+			var h = value.PeerReference;
+			var o = Runtime.ObjectReferenceManager;
+			// MUST NOT use SafeHandle.ReferenceType: local refs are tied to a JniEnvironment
+			// and the JniEnvironment's corresponding thread; it's a thread-local value.
+			// Accessing SafeHandle.ReferenceType won't kill anything (so far...), but
+			// instead it always returns JniReferenceType.Invalid.
+			if (!h.IsValid || h.Type == JniObjectReferenceType.Local) {
+				if (o.LogGlobalReferenceMessages) {
+					o.WriteGlobalReferenceLine ("Finalizing PeerReference={0} IdentityHashCode=0x{1} Instance=0x{2} Instance.Type={3}",
+							h.ToString (),
+							value.JniIdentityHashCode.ToString ("x", CultureInfo.InvariantCulture),
+							RuntimeHelpers.GetHashCode (value).ToString ("x", CultureInfo.InvariantCulture),
+							value.GetType ().ToString ());
+				}
+				RemovePeer (value);
+				value.SetPeerReference (new JniObjectReference ());
+				value.Finalized ();
+				return;
+			}
+
+			RemovePeer (value);
+			if (o.LogGlobalReferenceMessages) {
+				o.WriteGlobalReferenceLine ("Finalizing PeerReference={0} IdentityHashCode=0x{1} Instance=0x{2} Instance.Type={3}",
+						h.ToString (),
+						value.JniIdentityHashCode.ToString ("x", CultureInfo.InvariantCulture),
+						RuntimeHelpers.GetHashCode (value).ToString ("x", CultureInfo.InvariantCulture),
+						value.GetType ().ToString ());
+			}
+			value.SetPeerReference (new JniObjectReference ());
+			JniObjectReference.Dispose (ref h);
+			value.Finalized ();
+		}
+
+		public override void ActivatePeer (IJavaPeerable? self, JniObjectReference reference, ConstructorInfo cinfo, object?[]? argumentValues)
+		{
+			try {
+				ActivateViaReflection (reference, cinfo, argumentValues);
+			} catch (Exception e) {
+				var m = string.Format (
+						CultureInfo.InvariantCulture,
+						"Could not activate {{ PeerReference={0} IdentityHashCode=0x{1} Java.Type={2} }} for managed type '{3}'.",
+						reference,
+						GetJniIdentityHashCode (reference).ToString ("x", CultureInfo.InvariantCulture),
+						JniEnvironment.Types.GetJniTypeNameFromInstance (reference),
+						cinfo.DeclaringType?.FullName);
+				Debug.WriteLine (m);
+
+				throw new NotSupportedException (m, e);
+			}
+		}
+
+		void ActivateViaReflection (JniObjectReference reference, ConstructorInfo cinfo, object?[]? argumentValues)
+		{
+			var declType  = GetDeclaringType (cinfo);
+
+	#pragma warning disable IL2072
+			var self      = (IJavaPeerable) System.Runtime.CompilerServices.RuntimeHelpers.GetUninitializedObject (declType);
+	#pragma warning restore IL2072
+			self.SetPeerReference (reference);
+
+			cinfo.Invoke (self, argumentValues);
+
+			[UnconditionalSuppressMessage ("Trimming", "IL2073", Justification = "🤷‍♂️")]
+			[return: DynamicallyAccessedMembers (Constructors)]
+			Type GetDeclaringType (ConstructorInfo cinfo) =>
+				cinfo.DeclaringType ?? throw new NotSupportedException ("Do not know the type to create!");
+		}
+
+		public override List<JniSurfacedPeerInfo> GetSurfacedPeers ()
+		{
+			if (RegisteredInstances == null)
+				throw new ObjectDisposedException (nameof (ManagedValueManager));
+
+			lock (RegisteredInstances) {
+				var peers = new List<JniSurfacedPeerInfo> (RegisteredInstances.Count);
+				foreach (var e in RegisteredInstances) {
+					foreach (var p in e.Value) {
+						if (p.Target is not IJavaPeerable peer)
+							continue;
+						peers.Add (new JniSurfacedPeerInfo (e.Key, new WeakReference<IJavaPeerable> (peer)));
+					}
+				}
+				return peers;
+			}
+		}
+
+		static GCHandle CreateReferenceTrackingHandle (IJavaPeerable value) =>
+			JavaMarshal.CreateReferenceTrackingHandle (value, value.JniObjectReferenceControlBlock);
+
+		static unsafe void FreeHandle (GCHandle handle)
+		{
+			IntPtr context = JavaMarshal.GetContext (handle);
+			NativeMemory.Free ((void*) context);
+		}
+
+		[UnmanagedCallersOnly]
+		internal static unsafe void MarkCrossReferences (MarkCrossReferences* crossReferences)
+		{
+			// Java.Lang.JavaSystem.Gc ();
+
+			JavaMarshal.ReleaseMarkCrossReferenceResources (crossReferences);
+		}
+	}
+}