protected override bool UsesVirtualDispatch(IJavaPeerable value, Type declaringType)
{
var peerType = GetThresholdType (value);
if (peerType != null) {
return peerType == value.GetType ();
}
return base.UsesVirtualDispatch (value, declaringType);
}
static Type GetThresholdType(IJavaPeerable value)
{
var o = value as Java.Lang.Object;
if (o != null) {
return o.GetThresholdType ();
}
var t = value as Java.Lang.Throwable;
if (t != null) {
return t.GetThresholdType ();
}
return null;
}
static IntPtr GetThresholdClass(IJavaPeerable value)
{
var o = value as Java.Lang.Object;
if (o != null) {
return o.GetThresholdClass ();
}
var t = value as Java.Lang.Throwable;
if (t != null) {
return t.GetThresholdClass ();
}
return IntPtr.Zero;
}
protected override JniPeerMembers GetPeerMembers(IJavaPeerable value)
{
var peerType = GetThresholdType (value);
if (peerType == null || value.JniPeerMembers.ManagedPeerType == peerType) {
return base.GetPeerMembers (value);
};
var jniClass = Java.Interop.TypeManager.GetClassName (GetThresholdClass (value));
lock (LegacyPeerMembers) {
JniPeerMembers members;
if (!LegacyPeerMembers.TryGetValue (jniClass, out members)) {
members = new XAPeerMembers (jniClass, peerType);
LegacyPeerMembers.Add (jniClass, members);
}
return members;
}
}
public override void RemovePeer(IJavaPeerable value)
{
}
public override void AddPeer(IJavaPeerable value)
{
}
static IntPtr GetThresholdClass(IJavaPeerable value)
{
return(IntPtr.Zero);
}
protected virtual bool UsesVirtualDispatch(IJavaPeerable value, Type declaringType)
{
return(value.GetType() == declaringType ||
declaringType == null ||
value.GetType() == value.JniPeerMembers.ManagedPeerType);
}
public abstract void AddPeer(IJavaPeerable value);
public override void Remove(IJavaPeerable reference)
{
}
public override void AddPeer(IJavaPeerable value)
{
if (RegisteredInstances == null)
{
throw new ObjectDisposedException(nameof(MonoRuntimeValueManager));
}
var r = value.PeerReference;
if (!r.IsValid)
{
throw new ObjectDisposedException(value.GetType().FullName);
}
var o = PeekPeer(value.PeerReference);
if (o != null)
{
return;
}
if (r.Type != JniObjectReferenceType.Global)
{
value.SetPeerReference(r.NewGlobalRef());
JniObjectReference.Dispose(ref r, JniObjectReferenceOptions.CopyAndDispose);
}
int key = value.JniIdentityHashCode;
lock (RegisteredInstances) {
List <WeakReference <IJavaPeerable> > peers;
if (!RegisteredInstances.TryGetValue(key, out peers))
{
peers = new List <WeakReference <IJavaPeerable> > ()
{
new WeakReference <IJavaPeerable>(value, trackResurrection: true),
};
RegisteredInstances.Add(key, peers);
return;
}
for (int i = peers.Count - 1; i >= 0; i--)
{
var wp = peers [i];
IJavaPeerable p;
if (!wp.TryGetTarget(out p))
{
// Peer was collected
peers.RemoveAt(i);
continue;
}
if (!JniEnvironment.Types.IsSameObject(p.PeerReference, value.PeerReference))
{
continue;
}
if (Replaceable(p))
{
peers [i] = new WeakReference <IJavaPeerable>(value, trackResurrection: true);
}
else
{
WarnNotReplacing(key, value, p);
}
return;
}
peers.Add(new WeakReference <IJavaPeerable> (value, trackResurrection: true));
}
}
public override void FinalizePeer(IJavaPeerable value)
{
throw new NotImplementedException();
}
public override void RemovePeer(IJavaPeerable peer)
{
}
public override void FinalizePeer(IJavaPeerable peer)
{
}
public override void AddPeer(IJavaPeerable peer)
{
}
public abstract void Finalize(IJavaPeerable value);
protected virtual JniPeerMembers GetPeerMembers(IJavaPeerable value)
{
return(value.JniPeerMembers);
}
public override void FinalizePeer(IJavaPeerable value)
{
}
public override void Add(IJavaPeerable reference)
{
}
public static WeakReference <IJavaPeerable> CreateWeakReference(IJavaPeerable value)
{
return(new WeakReference <IJavaPeerable> (value, trackResurrection: true));
}
public override void Finalize(IJavaPeerable reference)
{
}
public IdentityHashTargets(IJavaPeerable value)
{
first = CreateWeakReference(value);
}
public abstract void RemovePeer(IJavaPeerable value);
protected virtual JniPeerMembers GetPeerMembers(IJavaPeerable value)
{
return(isInterface ? this : value.JniPeerMembers);
}
protected override bool UsesVirtualDispatch(IJavaPeerable value, Type declaringType)
{
return(false);
}
bool ShouldReplaceMapping(WeakReference <IJavaPeerable> current, JniObjectReference reference, out IJavaPeerable target)
{
target = null;
if (current == null)
{
return(true);
}
// Target has been GC'd; see also FIXME, above, in finalizer
if (!current.TryGetTarget(out target) || target == null)
{
return(true);
}
// It's possible that the instance was GC'd, but the finalizer
// hasn't executed yet, so the `instances` entry is stale.
if (!target.PeerReference.IsValid)
{
return(true);
}
if (!JniEnvironment.Types.IsSameObject(target.PeerReference, reference))
{
return(false);
}
// JNIEnv.NewObject/JNIEnv.CreateInstance() compatibility.
// When two MCW's are created for one Java instance [0],
// we want the 2nd MCW to replace the 1st, as the 2nd is
// the one the dev created; the 1st is an implicit intermediary.
//
// [0]: If Java ctor invokes overridden virtual method, we'll
// transition into managed code w/o a registered instance, and
// thus will create an "intermediary" via
// (IntPtr, JniHandleOwnership) .ctor.
if ((target.JniManagedPeerState & JniManagedPeerStates.Replaceable) == JniManagedPeerStates.Replaceable)
{
return(true);
}
return(false);
}
static Type GetThresholdType(IJavaPeerable value)
{
return(null);
}
public static string?GetJniTypeName(this IJavaPeerable self)
{
JniPeerMembers.AssertSelf(self);
return(JniEnvironment.Types.GetJniTypeNameFromInstance(self.PeerReference));
}
