Bump to dotnet/java-interop/main@d3d3a1bf

[jonpryor]

Fixes: #9862

Changes: dotnet/java-interop@8221b7d...d3d3a1b

• dotnet/java-interop@d3d3a1bf: [Java.Interop] JNIEnv::NewObject and Replaceable instances ([Java.Interop] JNIEnv::NewObject and Replaceable instances java-interop#1323)

Issue #9862 is an observed "race condition" around
Android.App.Application subclass creation. Two instances of
AndroidApp were created, one from the "normal" app startup:

at crc647fae2f69c19dcd0d.AndroidApp.n_onCreate(Native Method)
at crc647fae2f69c19dcd0d.AndroidApp.onCreate(AndroidApp.java:25)
at android.app.Instrumentation.callApplicationOnCreate(Instrumentation.java:1316)

and another from an androidx.work.WorkerFactory:

at mono.android.TypeManager.n_activate(Native Method)
at mono.android.TypeManager.Activate(TypeManager.java:7)
at crc647fae2f69c19dcd0d.SyncWorker.<init>(SyncWorker.java:23)
at java.lang.reflect.Constructor.newInstance0(Native Method)
at java.lang.reflect.Constructor.newInstance(Constructor.java:343)
at androidx.work.WorkerFactory.createWorkerWithDefaultFallback(WorkerFactory.java:95)

However, what was odd about this "race condition" was that the
second instance created would reliably win!

Further investigation suggested that this was less of a
"race condition" and more a bug in AndroidValueManager, wherein when
"Replaceable" instances were created, an existing instance would
always be replaced, even if the new instance was also Replaceable!
This feels bananas; yes, Replaceable should be replaceable, but the
expectation was that it would be replaced by non-Replaceable
instances, not just any instance that came along later.

dotnet/java-interop@d3d3a1bf updates
JniRuntimeJniValueManagerContract to add a new
CreatePeer_ReplaceableDoesNotReplace() test to codify the desired
semantic that Replaceable instances do not replace Replaceable
instances.

Update AndroidValueManager so that the new
CreatePeer_ReplaceableDoesNotReplace() test passes. It turns out
that the existing code within TypeManager.CreateInstance():

var result = CreateProxy (type, handle, transfer);
if (Runtime.IsGCUserPeer (result.PeerReference.Handle)) {
  result.SetJniManagedPeerState (JniManagedPeerStates.Replaceable | JniManagedPeerStates.Activatable);
}
return result;

sets .Replaceable too late, as during execution of the activation
constructor the instance thinks it isn't replaceable, and thus
creation of a new instance via the activation constructor will
replace an already existing replaceable instance; it's not until
after the constructor finished executing that we set .Replaceable.

Address this by updating CreatePeer() to split up instance creation:

1. Create an un-constructed instance using
   RuntimeHelpers.GetUninitializedObject(Type).

2. Set .Replaceable on the instance from (1)

3. Then invoke the activation constructor.

This allows AddPeer() to reliably determine that an instance is
.Replaceable, and thus not replace a .Replaceable instance with
another .Replaceable instance.

dotnet/java-interop@d3d3a1bf does similar things with
JniRuntime.JniValueManager. Update ManagedValueManager to
override the new TryConstructPeer() method, as TryCreatePeer()
has been removed.

[jonpryor]

So I expected JniRuntimeJniValueManagerContract.CreatePeer_ReplaceableDoesNotReplace() to fail, but it failed for the wrong reason:

Expected peer1.JniManagedPeerState to have .Replaceable, but was None.

Further investigation was because we weren't hitting this line:

android/src/Mono.Android/Java.Interop/TypeManager.cs

Line 363 in 542cf52

result.SetJniManagedPeerState (JniManagedPeerStates.Replaceable | JniManagedPeerStates.Activatable);

because Runtime.IsGCUserPeer() returned false, because AnotherJavaInterfaceImpl.java does not implement GCUserPeerable.

Okay, fair.

What I no longer remember -- and thus need to dig around for -- is why we're "protect" setting .Replacable with IsGCUserPeer(). Offhand, this feels like something we could always do?

[jonpryor]

The story so far…?

dotnet/java-interop@d3d3a1bf added several unit tests, one of which is CreatePeer_ReplaceableDoesNotReplace(), which was the unit test for #9862.

CI for this PR is observing crashes in tests/Mono.Android-Tests, which don't entirely make sense.

For testing, PR #10047 is a "similar" bump that also bumps to dotnet/java-interop@d3d3a1bf and fixes ManagedValueManager so that it builds, but does not contain fixes for CreatePeer_ReplaceableDoesNotReplace(). It shows two meaningful results:

1. CreatePeer_ReplaceableDoesNotReplace() fails, which is expected, and
2. It does not crash.

This suggests that the crash isn't caused by dotnet/java-interop@d3d3a1bf (yay), and may be "random" based on history.

Next step: copy over the remaining changes in this PR into #10047. Maybe it'll pass the tests?