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)); }