[Mono.Android] Fix UnhandledExceptionRaiser not firing in .NET 10 (#10966)

Context: dotnet/java-interop#1275
Fixes: https://devdiv.visualstudio.com/DevDiv/_workitems/edit/2842209

dotnet/java-interop#1275 eliminated
`JNINativeWrapper.CreateDelegate()` from generated binding marshal
methods. The old code path routed exceptions through
`AndroidEnvironment.UnhandledException()`, which fires the
`UnhandledExceptionRaiser` event. The new code path calls
`JniRuntime.OnUserUnhandledException()`, which only calls
`SetPendingException()` and never invokes
`AndroidEnvironment.UnhandledException()`.

Fix by overriding `OnUserUnhandledException()` in `AndroidRuntime` to
call `AndroidEnvironment.TryRaiseUnhandledException()` before
delegating to the base implementation. If a subscriber sets `Handled =
true`, the exception is swallowed and not transitioned to JNI.

Refactor `AndroidEnvironment.UnhandledException()` to extract the
event- raising logic into `TryRaiseUnhandledException()` so it can be
called from both the old and new code paths.

~~ Tests ~~

Add a test that verifies both `UnhandledExceptionRaiser` and
`AppDomain.UnhandledException` fire when an unhandled exception is
thrown from a button click handler.

The test:

1. Registers both `UnhandledExceptionRaiser` (with `e.Handled = true`)
   and `AppDomain.UnhandledException` handlers
2. Throws from the button click delegate
3. Asserts `UnhandledExceptionRaiser` fires via logcat

Author: jonathanpeppers

src/Mono.Android/Android.Runtime/AndroidEnvironment.cs

@@ -111,17 +111,25 @@ public static void RaiseThrowable (Java.Lang.Throwable throwable)
 
 		internal static void UnhandledException (Exception e)
 		{
-			var raisers         = UnhandledExceptionRaiser;
+			if (TryRaiseUnhandledException (e))
+				return;
+
+			RaiseThrowable (Java.Lang.Throwable.FromException (e));
+		}
+
+		// Returns true if the exception was handled by a subscriber.
+		internal static bool TryRaiseUnhandledException (Exception e)
+		{
+			var raisers          = UnhandledExceptionRaiser;
 			if (raisers != null) {
 				var info    = new RaiseThrowableEventArgs (e);
 				foreach (EventHandler<RaiseThrowableEventArgs> handler in raisers.GetInvocationList ()) {
 					handler (null, info);
 					if (info.Handled)
-						return;
+						return true;
 				}
 			}
-
-			RaiseThrowable (Java.Lang.Throwable.FromException (e));
+			return false;
 		}
 
 		// This is invoked by

src/Mono.Android/Android.Runtime/AndroidRuntime.cs

@@ -73,6 +73,19 @@ public override string GetCurrentManagedThreadStackTrace (int skipFrames, bool f
 			return peekedExc;
 		}
 
+		public override void OnUserUnhandledException (ref JniTransition transition, Exception e)
+		{
+			// Raise the UnhandledExceptionRaiser event via TryRaiseUnhandledException().
+			// If a subscriber sets Handled = true, the exception is considered handled
+			// and we return without transitioning to JNI.
+			// See: https://github.com/dotnet/android/issues/10654
+			if (AndroidEnvironment.TryRaiseUnhandledException (e)) {
+				return;
+			}
+
+			base.OnUserUnhandledException (ref transition, e);
+		}
+
 		public override void RaisePendingException (Exception pendingException)
 		{
 			var je  = pendingException as JavaException;

tests/MSBuildDeviceIntegration/Tests/InstallAndRunTests.cs

@@ -530,6 +530,40 @@ void Reset ()
 			}
 		}
 
+		[Test]
+		public void UnhandledExceptionFromButtonClick ([Values (AndroidRuntime.MonoVM, AndroidRuntime.CoreCLR)] AndroidRuntime runtime)
+		{
+			proj = new XamarinAndroidApplicationProject ();
+			proj.SetRuntime (runtime);
+			proj.SetAndroidSupportedAbis (DeviceAbi);
+
+			proj.MainActivity = proj.DefaultMainActivity.Replace ("//${AFTER_ONCREATE}", """
+				Android.Runtime.AndroidEnvironment.UnhandledExceptionRaiser += (sender, e) => {
+					Android.Util.Log.Error ("UnhandledTest", $"UnhandledExceptionRaiser: {e.Exception}");
+					e.Handled = true;
+				};
+
+				button!.Click += (sender, e) => {
+					throw new Exception ("Unhandled exception test");
+				};
+			""");
+
+			builder = CreateApkBuilder ();
+			Assert.IsTrue (builder.Install (proj), "Install should have succeeded.");
+			AdbStartActivity ($"{proj.PackageName}/{proj.JavaPackageName}.MainActivity");
+			Assert.IsTrue (WaitForActivityToStart (proj.PackageName, "MainActivity",
+				Path.Combine (Root, builder.ProjectDirectory, "startup-logcat.log")), "Activity should have started.");
+			ClearAdbLogcat ();
+			ClearBlockingDialogs ();
+			ClickButton (proj.PackageName, "myButton", "MY BUTTON");
+
+			string expectedRaiser = "UnhandledExceptionRaiser: System.Exception: Unhandled exception test";
+			Assert.IsTrue (
+				MonitorAdbLogcat (CreateLineChecker (expectedRaiser),
+					logcatFilePath: Path.Combine (Root, builder.ProjectDirectory, "unhandled-logcat.log"), timeout: 60),
+				$"Output did not contain {expectedRaiser}!");
+		}
+
 		[Test]
 		[Category ("UsesDevice")]
 		[TestCase ("テスト")]