Dogfood the modal navigation seam in the in-box Tizen backend

The seam was so far only exercised by tests and by external backends. This
makes the framework its own first consumer: the Tizen presentation now lives
in TizenModalNavigationPlatform, an IModalNavigationPlatform written entirely
against IModalNavigationHost with no access to ModalNavigationManager
internals. If the contract were insufficient for a real backend, this
refactor could not have been written — which is the point.

The Tizen partial keeps the platform hooks but delegates to that type, and
its stack bookkeeping now mirrors PushModalWithOverrideAsync /
PopModalWithOverrideAsync exactly, so the fallback path and the seam path
apply identical ordering.

This is a mechanical translation. Every call and its order is preserved: pop
still sends Disappearing, no-ops when the modal has no platform handler, pops
the native stack, sends Appearing on the revealed page and disposes the
handler; push still sends Disappearing, realizes the view, pushes, and sends
Appearing only if the modal is still current. The one reordering is moving
_platformModalPages.Add ahead of the platform call to satisfy the seam
contract, which is equivalent because CurrentPage is computed from the
requested stack, not from _platformModalPages.

Deliberately no DI registration: with no factory registered the built-in path
runs, and a registered IModalNavigationPlatformFactory still takes precedence
and short-circuits before this type is ever constructed. So this changes no
resolution behavior and needs no precedence rules.

Note on verification. Tizen has IncludeTizenTargetFrameworks=false in CI
("Disabled until net10.0-tizen is available") and the Tizen SDK pack is not
installable locally, so this code compiles nowhere in the normal build. It
was instead validated by compiling both files against the real seam
interfaces with stubs standing in only for the Tizen-native calls, which
checks interface conformance, signatures, nullability and name resolution;
the Tizen-native calls themselves are copied verbatim from the shipped file.

Adds a test asserting the no-factory path maintains PlatformModalStack with
the same ordering the seam promises, since the Tizen delegation now depends
on that invariant.

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

Author: Redth

src/Controls/src/Core/Platform/ModalNavigationManager/ModalNavigationManager.Tizen.cs

@@ -1,61 +1,47 @@
 #nullable enable
 
 using System.Threading.Tasks;
-using Tizen.UIExtensions.NUI;
 
 namespace Microsoft.Maui.Controls.Platform
 {
 	internal partial class ModalNavigationManager
 	{
-		NavigationStack _modalStack => WindowMauiContext.GetModalStack();
-		IPageController CurrentPageController => CurrentPage!;
+		TizenModalNavigationPlatform? _tizenPlatform;
+
+		// The built-in Tizen presentation is itself an IModalNavigationPlatform, so the fallback path
+		// exercises the same public contract an external backend implements. Created lazily because a
+		// registered IModalNavigationPlatformFactory takes precedence and these members never run.
+		TizenModalNavigationPlatform TizenPlatform =>
+			_tizenPlatform ??= new TizenModalNavigationPlatform(this);
 
 		Task SyncModalStackWhenPlatformIsReadyCoreAsync() =>
 			SyncPlatformModalStackAsync();
 
-		bool IsModalPlatformReadyCore => true;
+		bool IsModalPlatformReadyCore => TizenPlatform.IsReady;
 
-		partial void OnPageAttachedHandler()
-		{
-			WindowMauiContext.GetPlatformWindow().SetBackButtonPressedHandler(OnBackButtonPressed);
-		}
+		partial void OnPageAttachedHandler() =>
+			TizenPlatform.PageAttached();
 
 		async Task<Page> PopModalPlatformCoreAsync(bool animated)
 		{
 			Page modal = CurrentPlatformModalPage;
-			_platformModalPages.Remove(modal);
 
-			((IPageController)modal).SendDisappearing();
+			// Mirrors PopModalWithOverrideAsync: the framework owns the platform stack and removes the
+			// modal before the dismissal, so CurrentPlatformPage already refers to the revealed page.
+			_platformModalPages.Remove(modal);
 
-			var modalRenderer = modal.Handler as IPlatformViewHandler;
-			if (modalRenderer is not null)
-			{
-				await _modalStack.Pop(animated);
-				CurrentPageController?.SendAppearing();
-				(modal.Handler as IPlatformViewHandler)?.Dispose();
-			}
+			await TizenPlatform.PopModalAsync(modal, animated);
 			return modal;
 		}
 
-		async Task PushModalPlatformCoreAsync(Page modal, bool animated)
+		Task PushModalPlatformCoreAsync(Page modal, bool animated)
 		{
-			CurrentPageController?.SendDisappearing();
+			// Mirrors PushModalWithOverrideAsync. The add moved ahead of the platform call to match the
+			// seam contract; it is equivalent because CurrentPage is computed from the requested stack,
+			// not from _platformModalPages.
 			_platformModalPages.Add(modal);
 
-			var nativeView = modal.ToPlatform(WindowMauiContext);
-
-			await _modalStack.Push(nativeView, animated);
-
-			// Verify that the modal is still on the stack
-			if (CurrentPage == modal)
-				((IPageController)modal).SendAppearing();
-		}
-
-		bool OnBackButtonPressed()
-		{
-			bool handled = CurrentPage?.SendBackButtonPressed() ?? false;
-
-			return handled;
+			return TizenPlatform.PushModalAsync(modal, animated);
 		}
 	}
 }

src/Controls/src/Core/Platform/ModalNavigationManager/ModalNavigationPlatform.Tizen.cs

@@ -0,0 +1,78 @@
+#nullable enable
+
+using System.Threading.Tasks;
+using Tizen.UIExtensions.NUI;
+
+namespace Microsoft.Maui.Controls.Platform
+{
+	/// <summary>
+	/// The in-box Tizen modal presentation, written against the public
+	/// <see cref="IModalNavigationPlatform"/> seam.
+	/// </summary>
+	/// <remarks>
+	/// <para>
+	/// This is the framework's own consumer of the extensibility contract: everything Tizen needs to
+	/// present and dismiss a modal is expressed through <see cref="IModalNavigationHost"/>, with no
+	/// access to <c>ModalNavigationManager</c> internals. An external backend can be written the same
+	/// way, and this type is the reference for doing so.
+	/// </para>
+	/// <para>
+	/// It is used when no <see cref="IModalNavigationPlatformFactory"/> is registered. A registered
+	/// factory takes precedence and this type is never constructed.
+	/// </para>
+	/// </remarks>
+	internal sealed class TizenModalNavigationPlatform : IModalNavigationPlatform
+	{
+		readonly IModalNavigationHost _host;
+
+		public TizenModalNavigationPlatform(IModalNavigationHost host)
+		{
+			_host = host;
+		}
+
+		NavigationStack ModalStack => _host.MauiContext.GetModalStack();
+
+		public bool IsReady => true;
+
+		public void PageAttached() =>
+			_host.MauiContext.GetPlatformWindow().SetBackButtonPressedHandler(OnBackButtonPressed);
+
+		public async Task PushModalAsync(Page modal, bool animated)
+		{
+			// The framework has already put the modal on IModalNavigationHost.PlatformModalStack, which
+			// does not affect CurrentPage, so this still observes the page that is going away.
+			(_host.CurrentPage as IPageController)?.SendDisappearing();
+
+			var nativeView = modal.ToPlatform(_host.MauiContext);
+
+			await ModalStack.Push(nativeView, animated);
+
+			// Verify that the modal is still on the stack
+			if (_host.CurrentPage == modal)
+				((IPageController)modal).SendAppearing();
+		}
+
+		public async Task PopModalAsync(Page modal, bool animated)
+		{
+			((IPageController)modal).SendDisappearing();
+
+			// A modal with no platform handler was never realized, so there is nothing to dismiss. This
+			// is also what makes the method idempotent for a modal the platform already tore down.
+			if (modal.Handler is IPlatformViewHandler handler)
+			{
+				await ModalStack.Pop(animated);
+				(_host.CurrentPage as IPageController)?.SendAppearing();
+				handler.Dispose();
+			}
+		}
+
+		// The navigation stack and the platform window are owned by the window's platform side, not by
+		// this instance, so there is nothing of our own to release.
+		public void Dispose()
+		{
+		}
+
+		bool OnBackButtonPressed() =>
+			_host.CurrentPage?.SendBackButtonPressed() ?? false;
+	}
+}

src/Controls/tests/Core.UnitTests/ModalNavigationPlatformTests.cs

@@ -113,6 +113,37 @@ public async Task NoRegistrationUsesBuiltInPlatform()
 			Assert.Empty(Host(window).PlatformModalStack);
 		}
 
+		[Fact]
+		public async Task BuiltInPlatformMaintainsTheSameStackOrderingAsTheSeam()
+		{
+			// The in-box Tizen backend is implemented against IModalNavigationPlatform and relies on the
+			// fallback path applying the same stack bookkeeping the seam contract promises: the modal is
+			// on PlatformModalStack for the duration of a push, and off it for the duration of a pop.
+			// This guards that invariant on the no-factory path, which is what the built-in platforms use.
+			var window = CreateWindow();
+			var root = AttachRootPage(window);
+			var host = Host(window);
+
+			var first = new ContentPage();
+			var second = new ContentPage();
+
+			await window.Navigation.PushModalAsync(first);
+			Assert.Equal(new[] { first }, host.PlatformModalStack);
+			Assert.Same(first, host.CurrentPlatformPage);
+
+			await window.Navigation.PushModalAsync(second);
+			Assert.Equal(new[] { first, second }, host.PlatformModalStack);
+			Assert.Same(second, host.CurrentPlatformPage);
+
+			await window.Navigation.PopModalAsync();
+			Assert.Equal(new[] { first }, host.PlatformModalStack);
+			Assert.Same(first, host.CurrentPlatformPage);
+
+			await window.Navigation.PopModalAsync();
+			Assert.Empty(host.PlatformModalStack);
+			Assert.Same(root, host.CurrentPlatformPage);
+		}
+
 		[Fact]
 		public async Task CustomPlatformResolvedFromDependencyInjection()
 		{