Address Android activity review feedback

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot-Session: d00747b7-96f3-4e7a-8dfb-e3a48db04b2d

Author: Copilot CI

src/Controls/tests/TestCases.HostApp/Issues/Issue37706.cs

@@ -1,3 +1,5 @@
+namespace Maui.Controls.Sample.Issues;
+
 [Issue(
 	IssueTracker.Github,
 	37706,
@@ -33,7 +35,7 @@ public Issue37706()
 	protected override bool OnBackButtonPressed()
 	{
 		_backPressCount++;
-		_statusLabel.Text = $"OnBackButtonPressed called {_backPressCount} time";
+		_statusLabel.Text = $"OnBackButtonPressed called {_backPressCount} {(_backPressCount == 1 ? "time" : "times")}";
 		return true;
 	}
 }

src/Controls/tests/TestCases.Shared.Tests/Tests/Issues/Issue37706.cs

@@ -15,7 +15,7 @@ public Issue37706(TestDevice device) : base(device)
 
 	[Test]
 	[Category(UITestCategories.Navigation)]
-	public void RootPageBackButtonOverrideIsInvokedOnce()
+	public void RootPageBackButtonOverrideIsInvokedForEachPress()
 	{
 		App.WaitForElement("RootPageLabel");
 
@@ -26,6 +26,14 @@ public void RootPageBackButtonOverrideIsInvokedOnce()
 			Is.True,
 			"OnBackButtonPressed should be called exactly once.");
 		App.WaitForElement("RootPageLabel");
+
+		App.Back();
+
+		Assert.That(
+			App.WaitForTextToBePresentInElement("BackButtonPressedStatus", "OnBackButtonPressed called 2 times"),
+			Is.True,
+			"OnBackButtonPressed should be called once for each back press.");
+		App.WaitForElement("RootPageLabel");
 	}
 }
 #endif

src/Essentials/src/Platform/ActivityForResultRequest.android.cs

@@ -178,13 +178,27 @@ internal void ActivityDestroyed(ComponentActivity componentActivity)
 
 		if (componentActivity.IsFinishing
 			|| !_savedRequestOwners.TryGetValue(componentActivity, out _)
-			|| componentActivity.GetSystemService(global::Android.Content.Context.ActivityService) is not global::Android.App.ActivityManager activityManager
-			|| !IsTaskPresent(activityManager, componentActivity.TaskId))
+			|| componentActivity.GetSystemService(global::Android.Content.Context.ActivityService) is not global::Android.App.ActivityManager activityManager)
 		{
 			CancelPendingRequest(componentActivity);
 			return;
 		}
 
+		try
+		{
+			if (!IsTaskPresent(activityManager, componentActivity.TaskId))
+			{
+				CancelPendingRequest(componentActivity);
+				return;
+			}
+		}
+		catch (global::Java.Lang.SecurityException ex)
+		{
+			if (_requestState.TrySetException(requestOwner, ex))
+				StopTaskRemovalMonitor(requestOwner);
+			return;
+		}
+
 		// A saved owner can be adopted by a replacement activity, but task removal may
 		// happen later without another callback for this already-destroyed instance.
 		StartTaskRemovalMonitor(requestOwner, activityManager, componentActivity.TaskId);
@@ -202,34 +216,36 @@ void StartTaskRemovalMonitor(
 		int taskId)
 	{
 		var cancellation = new System.Threading.CancellationTokenSource();
+		var cancellationToken = cancellation.Token;
 		if (!_taskRemovalMonitors.TryAdd(requestOwner, cancellation))
 		{
 			cancellation.Dispose();
 			return;
 		}
 
-		_ = MonitorTaskPresenceAsync(requestOwner, activityManager, taskId, cancellation);
+		_ = MonitorTaskPresenceAsync(requestOwner, activityManager, taskId, cancellation, cancellationToken);
 	}
 
 	async Task MonitorTaskPresenceAsync(
 		string requestOwner,
 		global::Android.App.ActivityManager activityManager,
 		int taskId,
-		System.Threading.CancellationTokenSource cancellation)
+		System.Threading.CancellationTokenSource cancellation,
+		System.Threading.CancellationToken cancellationToken)
 	{
 		try
 		{
 			while (_requestState.HasPendingRequest(requestOwner))
 			{
-				await Task.Delay(TaskPresencePollInterval, cancellation.Token).ConfigureAwait(false);
+				await Task.Delay(TaskPresencePollInterval, cancellationToken).ConfigureAwait(false);
 				if (!IsTaskPresent(activityManager, taskId))
 				{
 					_requestState.TrySetCanceled(requestOwner);
 					break;
 				}
 			}
 		}
-		catch (OperationCanceledException) when (cancellation.IsCancellationRequested)
+		catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
 		{
 		}
 		catch (global::Java.Lang.SecurityException ex)
@@ -238,21 +254,30 @@ async Task MonitorTaskPresenceAsync(
 		}
 		finally
 		{
-			_taskRemovalMonitors.TryRemove(
-				new KeyValuePair<string, System.Threading.CancellationTokenSource>(requestOwner, cancellation));
-			cancellation.Dispose();
+			if (_taskRemovalMonitors.TryRemove(
+				new KeyValuePair<string, System.Threading.CancellationTokenSource>(requestOwner, cancellation)))
+			{
+				cancellation.Dispose();
+			}
 		}
 	}
 
 	void StopTaskRemovalMonitor(string requestOwner)
 	{
 		if (_taskRemovalMonitors.TryRemove(requestOwner, out var cancellation))
 		{
-			cancellation.Cancel();
+			try
+			{
+				cancellation.Cancel();
+			}
+			finally
+			{
+				cancellation.Dispose();
+			}
 		}
 	}
 
-	static bool IsTaskPresent(global::Android.App.ActivityManager activityManager, int taskId)
+	protected virtual bool IsTaskPresent(global::Android.App.ActivityManager activityManager, int taskId)
 	{
 		foreach (var appTask in activityManager.AppTasks ?? [])
 		{

src/Essentials/test/DeviceTests/Tests/ActivityStateManagerRecreation_Tests.Android.cs

@@ -86,6 +86,56 @@ await MainThread.InvokeOnMainThreadAsync(() =>
 		}
 	}
 
+	[Fact]
+	public async Task PendingRequest_FaultsWhenTaskPresenceCheckIsDenied()
+	{
+		var request = new RecreationActivityForResultRequest();
+		var manager = new ActivityStateManagerImplementation(request);
+		ActivityResultRecreationState.Begin(manager);
+
+		ActivityResultRecreationActivity? activity = null;
+
+		try
+		{
+			var hostActivity = MauiPlatform.CurrentActivity
+				?? throw new InvalidOperationException("The device-test host activity is unavailable.");
+
+			await MainThread.InvokeOnMainThreadAsync(() =>
+				hostActivity.StartActivity(new Intent(hostActivity, typeof(ActivityResultRecreationActivity))));
+			activity = await ActivityResultRecreationState.FirstActivity
+				.WaitAsync(TimeSpan.FromSeconds(15));
+
+			Task<JavaString>? pendingResult = null;
+			using var input = new JavaString("security-exception");
+			using var savedState = new Bundle();
+			await MainThread.InvokeOnMainThreadAsync(() =>
+			{
+				pendingResult = request.Launch(activity, input);
+				request.SaveInstanceState(activity, savedState);
+				request.DenyTaskPresenceCheck = true;
+				request.ActivityDestroyed(activity);
+			});
+			var pending = pendingResult
+				?? throw new InvalidOperationException("The activity-result request was not started.");
+
+			var exception = await Assert.ThrowsAsync<global::Java.Lang.SecurityException>(
+				() => pending.WaitAsync(TimeSpan.FromSeconds(15)));
+			Assert.Contains("task presence denied", exception.Message, StringComparison.Ordinal);
+		}
+		finally
+		{
+			activity ??= manager.GetCurrentActivity() as ActivityResultRecreationActivity;
+			await MainThread.InvokeOnMainThreadAsync(() =>
+			{
+				if (activity is { IsDestroyed: false, IsFinishing: false })
+					activity.Finish();
+			});
+
+			manager.Dispose();
+			ActivityResultRecreationState.Reset();
+		}
+	}
+
 	[Fact]
 	public async Task PendingRequest_IsCanceledWhenOwningTaskIsRemoved()
 	{
@@ -157,6 +207,8 @@ await MainThread.InvokeOnMainThreadAsync(() =>
 sealed class RecreationActivityForResultRequest
 	: ActivityForResultRequest<RecreationActivityResultContract, JavaString>
 {
+	internal bool DenyTaskPresenceCheck { get; set; }
+
 	protected override ActivityResultLauncher RegisterForActivityResult(
 		ComponentActivity componentActivity,
 		RecreationActivityResultContract contract,
@@ -165,6 +217,11 @@ protected override ActivityResultLauncher RegisterForActivityResult(
 		var activity = Assert.IsType<ActivityResultRecreationActivity>(componentActivity);
 		return activity.RegisterForActivityResult(contract, activity.ResultRegistry, callback);
 	}
+
+	protected override bool IsTaskPresent(ActivityManager activityManager, int taskId) =>
+		DenyTaskPresenceCheck
+			? throw new global::Java.Lang.SecurityException("task presence denied")
+			: base.IsTaskPresent(activityManager, taskId);
 }
 
 sealed class RecreationActivityResultContract : ActivityResultContract