[One .NET] fix debugging (#4864)

If you tried to debug an app with:

	dotnet build HelloAndroid/HelloAndroid.csproj -t:Install,_Run -p:AndroidAttachDebugger=true

The presence of `$(AndroidAttachDebugger)` causes a crash on startup:

	E mono    : Unhandled Exception:
	E mono    : System.ArgumentNullException: Value cannot be null. (Parameter 'meth')
	E mono    :    at System.Reflection.Emit.ILGenerator.Emit(OpCode opcode, MethodInfo meth)
	E mono    :    at Android.Runtime.JNINativeWrapper.CreateDelegate(Delegate dlg)
	E mono    :    at Android.App.Activity.GetOnCreate_Landroid_os_Bundle_Handler()
	E mono    :    at Android.Runtime.AndroidTypeManager.RegisterNativeMembers(JniType nativeClass, Type type, String methods)
	E mono    :    at Android.Runtime.JNIEnv.RegisterJniNatives(IntPtr typeName_ptr, Int32 typeName_len, IntPtr jniClass, IntPtr methods_ptr, Int32 methods_len)
	E mono-rt : [ERROR] FATAL UNHANDLED EXCEPTION: System.ArgumentNullException: Value cannot be null. (Parameter 'meth')
	E mono-rt :    at System.Reflection.Emit.ILGenerator.Emit(OpCode opcode, MethodInfo meth)
	E mono-rt :    at Android.Runtime.JNINativeWrapper.CreateDelegate(Delegate dlg)
	E mono-rt :    at Android.App.Activity.GetOnCreate_Landroid_os_Bundle_Handler()
	E mono-rt :    at Android.Runtime.AndroidTypeManager.RegisterNativeMembers(JniType nativeClass, Type type, String methods)
	E mono-rt :    at Android.Runtime.JNIEnv.RegisterJniNatives(IntPtr typeName_ptr, Int32 typeName_len, IntPtr jniClass, IntPtr methods_ptr, Int32 methods_len)

The cause of the crash is because we pass
`JNINativeWrapper.mono_unhandled_exception_method` to
[`ILGenerator.Emit(OpCode, MethodInfo)`][0], and
`mono_unhandled_exception_method` is `null`.

`mono_unhandled_exception_method` is a `MethodInfo` to
[`Debugger.Mono_UnhandledException()`][1], which does not exist in
.NET 5 Mono, which is why it's `null` within .NET 5.

To fix `dotnet build -t:_Run` support, cleanup
`JNINativeWrapper.get_runtime_types()` to instead check for
`JNINativeWrapper.exception_handler_method`, as
`exception_handler_method` is consistently initialized properly on
both "legacy" and .NET 5 environments.

Furthermore, update `get_runtime_types()` so that
`mono_unhandled_exception_method` is not passed to `ILGenerator.Emit()`
when it is `null`.  This avoids the `ArgumentNullException`.

This surfaced another problem when using the `_Run` target by itself:

	Xamarin.Android.Common.Debugging.targets(518,2): error MSB3073: The command ""adb"  forward tcp:10000 tcp:10000" exited with code 9009.

The `$(_AndroidPlatformToolsDirectory)` property was blank when running
the `_Run` target by itself, but things work fine if you run
`Install,_Run` at the same time.

This behavior broke in commit fb637e0.  I accidentally replaced the
`AndroidPrepareForBuild` MSBuild target with [the version][2] in
`Xamarin.Android.Bindings.Core.targets`.

To fix this, I can just move the binding project version of
`AndroidPrepareForBuild` target to `Xamarin.Android.Bindings.targets`.

I added a new test verifying that breakpoints work, when running
under .NET 5.

[0]: https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.ilgenerator.emit?view=netcore-3.1#System_Reflection_Emit_ILGenerator_Emit_System_Reflection_Emit_OpCode_System_Reflection_MethodInfo_
[1]: https://github.com/mono/mono/blob/2ff424be2933f711207a8139c5792ab5d1b495a9/mcs/class/corlib/System.Diagnostics/Debugger.cs#L119-L127
[2]: https://github.com/xamarin/xamarin-android/blob/f99a3fad1b12d9674de2f624e243f296cfc40fc6/src/Xamarin.Android.Build.Tasks/MSBuild/Xamarin/Android/Xamarin.Android.Bindings.Core.targets#L47

Author: jonathanpeppers

src/Mono.Android/Android.Runtime/JNINativeWrapper.cs

@@ -13,7 +13,7 @@ public static class JNINativeWrapper {
 
 		static void get_runtime_types ()
 		{
-			if (mono_unhandled_exception_method != null)
+			if (exception_handler_method != null)
 				return;
 #if MONOANDROID1_0
 			mono_unhandled_exception_method = typeof (System.Diagnostics.Debugger).GetMethod (
@@ -70,10 +70,10 @@ public static Delegate CreateDelegate (Delegate dlg)
 			ig.Emit (OpCodes.Leave, label);
 
 			bool  filter = Debugger.IsAttached || !JNIEnv.PropagateExceptions;
-			if (filter) {
+			if (filter && mono_unhandled_exception_method != null) {
 				ig.BeginExceptFilterBlock ();
 
-				ig.Emit (OpCodes.Call, mono_unhandled_exception_method!);
+				ig.Emit (OpCodes.Call, mono_unhandled_exception_method);
 				ig.Emit (OpCodes.Ldc_I4_1);
 				ig.BeginCatchBlock (null!);
 			} else {

src/Xamarin.Android.Build.Tasks/MSBuild/Xamarin/Android/Xamarin.Android.Bindings.Core.targets

@@ -44,8 +44,6 @@ It is shared between "legacy" binding projects and .NET 5 projects.
     </PropertyGroup>
   </Target>
 
-  <Target Name="AndroidPrepareForBuild" DependsOnTargets="GetReferenceAssemblyPaths" />
-
   <Target Name="GenerateBindings"
       Condition=" '$(UsingAndroidNETSdk)' != 'true' Or '@(InputJar)' != '' Or '@(EmbeddedJar)' != '' "
       DependsOnTargets="ExportJarToXml;_ResolveMonoAndroidSdks"

src/Xamarin.Android.Build.Tasks/Xamarin.Android.Bindings.targets

@@ -75,6 +75,8 @@ Copyright (C) 2012 Xamarin Inc. All rights reserved.
 	<GenerateSerializationAssemblies>Off</GenerateSerializationAssemblies>
   </PropertyGroup>
 
+  <Target Name="AndroidPrepareForBuild" DependsOnTargets="GetReferenceAssemblyPaths" />
+
   <!-- Warn about deprecated configurations.
        Do it here because we want them to appear on every build,
        even if we aren't rerunning generator -->

tests/MSBuildDeviceIntegration/Tests/XASdkDeployTests.cs

@@ -1,7 +1,12 @@
 using System;
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
+using System.Net;
 using System.Reflection;
+using System.Threading;
+using Mono.Debugging.Client;
+using Mono.Debugging.Soft;
 using NUnit.Framework;
 using Xamarin.ProjectTools;
 
@@ -26,7 +31,6 @@ public void DotNetInstallAndRun ([Values (false, true)] bool isRelease, [Values
 					IsRelease = isRelease
 				};
 			}
-			proj.SetProperty (KnownProperties.AndroidSupportedAbis, DeviceAbi);
 			proj.SetRuntimeIdentifier (DeviceAbi);
 
 			var relativeProjDir = Path.Combine ("temp", TestName);
@@ -43,5 +47,77 @@ public void DotNetInstallAndRun ([Values (false, true)] bool isRelease, [Values
 			RunAdbCommand ($"uninstall {proj.PackageName}");
 			Assert.IsTrue(didLaunch, "Activity should have started.");
 		}
+
+		[Test]
+		public void DotNetDebug ()
+		{
+			if (!HasDevices)
+				Assert.Ignore ("Skipping Test. No devices available.");
+
+			XASdkProject proj;
+			proj = new XASdkProject ();
+			proj.SetRuntimeIdentifier (DeviceAbi);
+
+			var relativeProjDir = Path.Combine ("temp", TestName);
+			var fullProjDir = Path.Combine (Root, relativeProjDir);
+			TestOutputDirectories [TestContext.CurrentContext.Test.ID] = fullProjDir;
+			var files = proj.Save ();
+			proj.Populate (relativeProjDir, files);
+			proj.CopyNuGetConfig (relativeProjDir);
+			var dotnet = new DotNetCLI (proj, Path.Combine (fullProjDir, proj.ProjectFilePath));
+			Assert.IsTrue (dotnet.Build ("Install"), "`dotnet build` should succeed");
+
+			bool breakpointHit = false;
+			ManualResetEvent resetEvent = new ManualResetEvent (false);
+			var sw = new Stopwatch ();
+			// setup the debugger
+			var session = new SoftDebuggerSession ();
+			session.Breakpoints = new BreakpointStore {
+				{ Path.Combine (Root, dotnet.ProjectDirectory, "MainActivity.cs"),  19 },
+			};
+			session.TargetHitBreakpoint += (sender, e) => {
+				Console.WriteLine ($"BREAK {e.Type}");
+				breakpointHit = true;
+				session.Continue ();
+			};
+			var rnd = new Random ();
+			int port = rnd.Next (10000, 20000);
+			TestContext.Out.WriteLine ($"{port}");
+			var args = new SoftDebuggerConnectArgs ("", IPAddress.Loopback, port) {
+				MaxConnectionAttempts = 10,
+			};
+			var startInfo = new SoftDebuggerStartInfo (args) {
+				WorkingDirectory = Path.Combine (dotnet.ProjectDirectory, proj.IntermediateOutputPath, "android", "assets"),
+			};
+			var options = new DebuggerSessionOptions () {
+				EvaluationOptions = EvaluationOptions.DefaultOptions,
+			};
+			options.EvaluationOptions.UseExternalTypeResolver = true;
+			ClearAdbLogcat ();
+			Assert.True (dotnet.Build ("_Run", new string [] {
+				$"AndroidSdbTargetPort={port}",
+				$"AndroidSdbHostPort={port}",
+				"AndroidAttachDebugger=True",
+			}), "Project should have run.");
+
+			Assert.IsTrue (WaitForDebuggerToStart (Path.Combine (Root, dotnet.ProjectDirectory, "logcat.log")), "Activity should have started");
+			// we need to give a bit of time for the debug server to start up.
+			WaitFor (2000);
+			session.LogWriter += (isStderr, text) => { Console.WriteLine (text); };
+			session.OutputWriter += (isStderr, text) => { Console.WriteLine (text); };
+			session.DebugWriter += (level, category, message) => { Console.WriteLine (message); };
+			session.Run (startInfo, options);
+			WaitFor (TimeSpan.FromSeconds (30), () => session.IsConnected);
+			Assert.True (session.IsConnected, "Debugger should have connected but it did not.");
+			// we need to wait here for a while to allow the breakpoints to hit
+			// but we need to timeout
+			TimeSpan timeout = TimeSpan.FromSeconds (60);
+			while (session.IsConnected && !breakpointHit && timeout >= TimeSpan.Zero) {
+				Thread.Sleep (10);
+				timeout = timeout.Subtract (TimeSpan.FromMilliseconds (10));
+			}
+			WaitFor (2000);
+			Assert.IsTrue (breakpointHit, "Should have a breakpoint");
+		}
 	}
 }