[Android] MediaPicker: Fix photo picker completion from child activities

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

@@ -0,0 +1,140 @@
+using Microsoft.Maui.Media;
+
+namespace Maui.Controls.Sample.Issues;
+
+[Issue(IssueTracker.Github, 35826, "PickPhotosAsync hangs when called from a child activity", PlatformAffected.Android)]
+public class Issue35826 : ContentPage
+{
+	public Issue35826()
+	{
+		var instructions = new Label
+		{
+			AutomationId = "InstructionsLabel",
+			Text = "1. Tap 'Open Child Activity'\n" +
+			       "2. In the child activity, tap 'Pick Photos'\n" +
+			       "3. Press Back to cancel the picker\n" +
+			       "Expected: Status shows 'Cancelled'\n" +
+			       "Bug: Picker hangs indefinitely",
+			FontSize = 14
+		};
+
+		var openButton = new Button
+		{
+			AutomationId = "OpenChildActivityButton",
+			Text = "Open Child Activity",
+			HorizontalOptions = LayoutOptions.Fill
+		};
+		openButton.Clicked += OnOpenChildActivityClicked;
+
+		var statusLabel = new Label
+		{
+			AutomationId = "StatusLabel",
+			Text = "Status: Ready",
+			FontSize = 16,
+			FontAttributes = FontAttributes.Bold
+		};
+
+		Content = new VerticalStackLayout
+		{
+			Padding = 30,
+			Spacing = 25,
+			Children = { instructions, openButton, statusLabel }
+		};
+	}
+
+	void OnOpenChildActivityClicked(object sender, EventArgs e)
+	{
+#if ANDROID
+		var activity = Microsoft.Maui.ApplicationModel.Platform.CurrentActivity;
+		if (activity != null)
+		{
+			var intent = new Android.Content.Intent(activity, typeof(Issue35826ChildActivity));
+			activity.StartActivity(intent);
+		}
+#endif
+	}
+}
+
+#if ANDROID
+// A plain AppCompatActivity that calls MediaPicker.PickPhotosAsync().
+// Before the fix, Platform.Init() on this activity was silently ignored by the guard in
+// ActivityForResultRequest.Register(), so no launcher was registered for it and the
+// picker task never completed. After the fix each activity gets its own launcher entry
+// in the ConditionalWeakTable, so the result is delivered correctly.
+[Android.App.Activity(Label = "Issue35826 Child Activity", Theme = "@style/Maui.SplashTheme")]
+public class Issue35826ChildActivity : AndroidX.AppCompat.App.AppCompatActivity
+{
+	Android.Widget.TextView _resultLabel;
+
+	protected override void OnCreate(Android.OS.Bundle savedInstanceState)
+	{
+		base.OnCreate(savedInstanceState);
+
+		Microsoft.Maui.ApplicationModel.Platform.Init(this, savedInstanceState);
+
+		var layout = new Android.Widget.LinearLayout(this)
+		{
+			Orientation = Android.Widget.Orientation.Vertical
+		};
+		layout.SetPadding(50, 50, 50, 50);
+
+		_resultLabel = new Android.Widget.TextView(this)
+		{
+			Text = "Result: Ready"
+		};
+		_resultLabel.SetPadding(0, 0, 0, 50);
+		SetViewIdResourceName(_resultLabel, "ChildActivityResultLabel");
+
+		var pickButton = new Android.Widget.Button(this)
+		{
+			Text = "Pick Photos"
+		};
+		SetViewIdResourceName(pickButton, "ChildActivityPickButton");
+
+		pickButton.Click += async (_, _) =>
+		{
+			_resultLabel.Text = "Result: Picking...";
+			try
+			{
+				var result = await MediaPicker.PickPhotosAsync();
+				_resultLabel.Text = result?.Count > 0
+					? $"Result: Got {result.Count} photo(s)"
+					: "Result: Cancelled";
+			}
+			catch (OperationCanceledException)
+			{
+				_resultLabel.Text = "Result: Cancelled";
+			}
+			catch (Exception ex)
+			{
+				_resultLabel.Text = $"Result: Error - {ex.Message}";
+			}
+		};
+
+		layout.AddView(_resultLabel);
+		layout.AddView(pickButton);
+		SetContentView(layout);
+	}
+
+	// Sets ViewIdResourceName on a native Android view so Appium can locate it by
+	// resource-id (the same mechanism MAUI uses for AutomationId on Android).
+	void SetViewIdResourceName(Android.Views.View view, string automationId)
+	{
+		var resourceName = $"{PackageName}:id/{automationId}";
+		AndroidX.Core.View.ViewCompat.SetAccessibilityDelegate(view, new AutomationIdDelegate(resourceName));
+	}
+
+	class AutomationIdDelegate : AndroidX.Core.View.AccessibilityDelegateCompat
+	{
+		readonly string _resourceName;
+
+		public AutomationIdDelegate(string resourceName) => _resourceName = resourceName;
+
+		public override void OnInitializeAccessibilityNodeInfo(Android.Views.View host, AndroidX.Core.View.Accessibility.AccessibilityNodeInfoCompat info)
+		{
+			base.OnInitializeAccessibilityNodeInfo(host, info);
+			info.ViewIdResourceName = _resourceName;
+		}
+	}
+}
+#endif

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

@@ -0,0 +1,79 @@
+#if ANDROID
+using NUnit.Framework;
+using UITest.Appium;
+using UITest.Core;
+
+namespace Microsoft.Maui.TestCases.Tests.Issues;
+
+public class Issue35826 : _IssuesUITest
+{
+	public Issue35826(TestDevice device) : base(device) { }
+
+	public override string Issue => "PickPhotosAsync hangs when called from a child activity";
+
+	const string OpenChildActivityButton = "OpenChildActivityButton";
+	const string ChildActivityPickButton = "ChildActivityPickButton";
+	const string ChildActivityResultLabel = "ChildActivityResultLabel";
+
+	[Test]
+	[Category(UITestCategories.Essentials)]
+	public void PickPhotosAsyncShouldReturnFromChildActivity()
+	{
+		// This regression only manifests on Android API 36, where the ActivityResultLauncher
+		// ownership rules are enforced strictly enough that using the wrong activity's launcher
+		// causes the result to never be delivered, hanging the task indefinitely.
+		if (App is AppiumApp appiumApp)
+		{
+			var apiLevel = (long?)appiumApp.Driver.Capabilities.GetCapability("deviceApiLevel") ?? 0;
+			if (apiLevel < 36)
+			{
+				Assert.Ignore($"Issue #35826 only manifests on Android API 36+. Current device API: {apiLevel}.");
+			}
+		}
+
+		// Verify the host page loaded
+		App.WaitForElement(OpenChildActivityButton);
+
+		// Open the child (non-MAUI AppCompatActivity)
+		App.Tap(OpenChildActivityButton);
+
+		// Verify the child activity's UI is visible
+		App.WaitForElement(ChildActivityPickButton);
+		App.WaitForElement(ChildActivityResultLabel);
+
+		// Tap Pick Photos — calls MediaPicker.PickPhotosAsync() from the child activity.
+		// Before the fix the ActivityResultLauncher was never registered for child activities
+		// (the guard in ActivityForResultRequest.Register() blocked it), so the task hung
+		// indefinitely and the result label stayed on "Picking...".
+		App.Tap(ChildActivityPickButton);
+
+		// Cancel the system photo picker by pressing Back.
+		// After the fix each activity has its own launcher entry so the result is delivered.
+		App.Back();
+
+		// If the bug is present WaitForTextToBePresentInElement times out because the
+		// TaskCompletionSource is never resolved. With the fix it updates promptly to
+		// the expected cancellation state. Error indicates a launcher/ownership failure
+		// or another exception path and must fail this regression.
+		var returned = App.WaitForTextToBePresentInElement(ChildActivityResultLabel, "Cancelled",
+			timeout: TimeSpan.FromSeconds(120));
+
+		var resultText = App.FindElement(ChildActivityResultLabel).GetText();
+
+		Assert.That(returned, Is.True,
+			$"PickPhotosAsync must return from a child activity as a cancellation result after backing out of the picker. " +
+			$"Actual result label: '{resultText}'. " +
+			$"If this fails the result label is still showing 'Picking...' after 120 seconds or an exception path was hit.");
+
+		Assert.That(resultText, Does.Not.Contain("Picking"),
+			"PickPhotosAsync must not hang in a child activity.");
+
+		Assert.That(resultText, Does.Not.Contain("Error"),
+			$"PickPhotosAsync should cancel cleanly when backing out of the picker, not surface an exception. Actual result label: '{resultText}'.");
+
+		// Return to the host page
+		App.Back();
+		App.WaitForElement(OpenChildActivityButton);
+	}
+}
+#endif

src/Essentials/src/MediaPicker/MediaPicker.android.cs

@@ -8,6 +8,7 @@
 using Android.Content.PM;
 using Android.Graphics;
 using Android.Provider;
+using AndroidX.Activity;
 using AndroidX.Activity.Result;
 using AndroidX.Activity.Result.Contract;
 using Microsoft.Maui.ApplicationModel;
@@ -177,11 +178,14 @@ void OnResult(Intent intent)
 
 		async Task<FileResult> PickUsingPhotoPicker(MediaPickerOptions options, bool photo)
 		{
+			var launchingActivity = ActivityStateManager.Default.GetCurrentActivity(true) as ComponentActivity
+				?? throw new InvalidOperationException("The current activity must inherit from AndroidX.Activity.ComponentActivity.");
+
 			var pickVisualMediaRequest = new PickVisualMediaRequest.Builder()
 				.SetMediaType(photo ? ActivityResultContracts.PickVisualMedia.ImageOnly.Instance : ActivityResultContracts.PickVisualMedia.VideoOnly.Instance)
 				.Build();
 
-			var androidUri = await PickVisualMediaForResult.Instance.Launch(pickVisualMediaRequest);
+			var androidUri = await PickVisualMediaForResult.Instance.Launch(launchingActivity, pickVisualMediaRequest);
 
 			if (androidUri?.Equals(AndroidUri.Empty) ?? true)
 			{
@@ -208,6 +212,9 @@ async Task<FileResult> PickUsingPhotoPicker(MediaPickerOptions options, bool pho
 
 		async Task<List<FileResult>> PickMultipleUsingPhotoPicker(MediaPickerOptions options, bool photo)
 		{
+			var launchingActivity = ActivityStateManager.Default.GetCurrentActivity(true) as ComponentActivity
+				?? throw new InvalidOperationException("The current activity must inherit from AndroidX.Activity.ComponentActivity.");
+
 			// Android has a limitation that you need to use a different request for single and multiple picks.
 			// If the selection limit is 1, we can use the single pick method,
 			// otherwise we need to use the multiple pick method.
@@ -230,7 +237,7 @@ async Task<List<FileResult>> PickMultipleUsingPhotoPicker(MediaPickerOptions opt
 
 			var pickVisualMediaRequest = pickVisualMediaRequestBuilder.Build();
 
-			var androidUris = await PickMultipleVisualMediaForResult.Instance.Launch(pickVisualMediaRequest);
+			var androidUris = await PickMultipleVisualMediaForResult.Instance.Launch(launchingActivity, pickVisualMediaRequest);
 
 			if (androidUris?.IsEmpty ?? true)
 			{