From d631ab16dd7d8fef7b864260a6c2bfbc604fb373 Mon Sep 17 00:00:00 2001
From: Tamilarasan Paranthaman
<93904422+Tamilarasan-Paranthaman@users.noreply.github.com>
Date: Mon, 2 Mar 2026 17:57:03 +0530
Subject: [PATCH 01/26] Sandbox test sample
---
.../samples/Controls.Sample.Sandbox/App.xaml | 3 +-
.../Controls.Sample.Sandbox/App.xaml.cs | 26 +-
.../FlyoutTestPage.xaml | 149 ++++
.../FlyoutTestPage.xaml.cs | 244 +++++++
.../Controls.Sample.Sandbox/MainPage.xaml | 86 ++-
.../Controls.Sample.Sandbox/MainPage.xaml.cs | 680 +++++++++++++++++-
.../NavigationTestPage.xaml | 72 ++
.../NavigationTestPage.xaml.cs | 121 ++++
.../Resources/Styles/Colors.xaml | 58 ++
.../Resources/Styles/Styles.xaml | 583 +++++++++++++++
.../Controls.Sample.Sandbox/SandboxShell.xaml | 126 +++-
.../Controls.Sample.Sandbox/SettingsPage.xaml | 152 ++++
.../SettingsPage.xaml.cs | 198 +++++
.../TabbedPageTestPage.xaml | 248 +++++++
.../TabbedPageTestPage.xaml.cs | 80 +++
.../TabbedPageTopTabsTestPage.xaml | 245 +++++++
.../TabbedPageTopTabsTestPage.xaml.cs | 86 +++
.../ToolbarTestPage.xaml | 84 +++
.../ToolbarTestPage.xaml.cs | 93 +++
19 files changed, 3311 insertions(+), 23 deletions(-)
create mode 100644 src/Controls/samples/Controls.Sample.Sandbox/FlyoutTestPage.xaml
create mode 100644 src/Controls/samples/Controls.Sample.Sandbox/FlyoutTestPage.xaml.cs
create mode 100644 src/Controls/samples/Controls.Sample.Sandbox/NavigationTestPage.xaml
create mode 100644 src/Controls/samples/Controls.Sample.Sandbox/NavigationTestPage.xaml.cs
create mode 100644 src/Controls/samples/Controls.Sample.Sandbox/Resources/Styles/Colors.xaml
create mode 100644 src/Controls/samples/Controls.Sample.Sandbox/Resources/Styles/Styles.xaml
create mode 100644 src/Controls/samples/Controls.Sample.Sandbox/SettingsPage.xaml
create mode 100644 src/Controls/samples/Controls.Sample.Sandbox/SettingsPage.xaml.cs
create mode 100644 src/Controls/samples/Controls.Sample.Sandbox/TabbedPageTestPage.xaml
create mode 100644 src/Controls/samples/Controls.Sample.Sandbox/TabbedPageTestPage.xaml.cs
create mode 100644 src/Controls/samples/Controls.Sample.Sandbox/TabbedPageTopTabsTestPage.xaml
create mode 100644 src/Controls/samples/Controls.Sample.Sandbox/TabbedPageTopTabsTestPage.xaml.cs
create mode 100644 src/Controls/samples/Controls.Sample.Sandbox/ToolbarTestPage.xaml
create mode 100644 src/Controls/samples/Controls.Sample.Sandbox/ToolbarTestPage.xaml.cs
diff --git a/src/Controls/samples/Controls.Sample.Sandbox/App.xaml b/src/Controls/samples/Controls.Sample.Sandbox/App.xaml
index d5e9a66a4322..c72f57fa1c16 100644
--- a/src/Controls/samples/Controls.Sample.Sandbox/App.xaml
+++ b/src/Controls/samples/Controls.Sample.Sandbox/App.xaml
@@ -6,7 +6,8 @@
-
+
+
diff --git a/src/Controls/samples/Controls.Sample.Sandbox/App.xaml.cs b/src/Controls/samples/Controls.Sample.Sandbox/App.xaml.cs
index 9512dea98e39..9be336a2d319 100644
--- a/src/Controls/samples/Controls.Sample.Sandbox/App.xaml.cs
+++ b/src/Controls/samples/Controls.Sample.Sandbox/App.xaml.cs
@@ -9,16 +9,24 @@ public App()
protected override Window CreateWindow(IActivationState? activationState)
{
- // To test shell scenarios, change this to true
- bool useShell = false;
+ // Test mode selection:
+ // "shell" - Test Shell handler migration
+ // "tabbedpage" - Test TabbedPage with BottomNavigationManager
+ // "navigation" - Test NavigationPage
- if (!useShell)
- {
- return new Window(new NavigationPage(new MainPage()));
- }
- else
+ string testMode = "shell";
+
+ //string testMode = "tabbedpage";
+
+ //string testMode = "navigation";
+
+
+
+ return testMode switch
{
- return new Window(new SandboxShell());
- }
+ "tabbedpage" => new Window(new TabbedPageTestPage()),
+ "navigation" => new Window(new NavigationPage(new MainPage())),
+ _ => new Window(new SandboxShell()) // default: shell
+ };
}
}
diff --git a/src/Controls/samples/Controls.Sample.Sandbox/FlyoutTestPage.xaml b/src/Controls/samples/Controls.Sample.Sandbox/FlyoutTestPage.xaml
new file mode 100644
index 000000000000..e24a94f50db5
--- /dev/null
+++ b/src/Controls/samples/Controls.Sample.Sandbox/FlyoutTestPage.xaml
@@ -0,0 +1,149 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/Controls/samples/Controls.Sample.Sandbox/FlyoutTestPage.xaml.cs b/src/Controls/samples/Controls.Sample.Sandbox/FlyoutTestPage.xaml.cs
new file mode 100644
index 000000000000..a6498fdf5cc9
--- /dev/null
+++ b/src/Controls/samples/Controls.Sample.Sandbox/FlyoutTestPage.xaml.cs
@@ -0,0 +1,244 @@
+using Microsoft.Maui.Controls;
+#pragma warning disable IDE0031 // Use null propagation
+namespace Maui.Controls.Sample
+{
+ public partial class FlyoutTestPage : ContentPage
+ {
+ public FlyoutTestPage()
+ {
+ InitializeComponent();
+ UpdateFlyoutState();
+ }
+
+ protected override void OnAppearing()
+ {
+ base.OnAppearing();
+
+ if (Shell.Current is not null)
+ {
+ Shell.Current.PropertyChanged += OnShellPropertyChanged;
+ }
+ }
+
+ protected override void OnDisappearing()
+ {
+ base.OnDisappearing();
+ if (Shell.Current is not null)
+ {
+ Shell.Current.PropertyChanged -= OnShellPropertyChanged;
+ }
+ }
+
+ private void OnShellPropertyChanged(object? sender, System.ComponentModel.PropertyChangedEventArgs e)
+ {
+ if (e.PropertyName == nameof(Shell.FlyoutIsPresented))
+ {
+ UpdateFlyoutState();
+ }
+ }
+
+ private void UpdateFlyoutState()
+ {
+ if (Shell.Current != null)
+ {
+ FlyoutStateLabel.Text = $"Flyout State: {(Shell.Current.FlyoutIsPresented ? "Open" : "Closed")}";
+ }
+ }
+
+ private void OnOpenFlyoutClicked(object? sender, EventArgs e)
+ {
+ Shell.Current.FlyoutIsPresented = true;
+ StatusLabel.Text = "Status: Flyout opened";
+ }
+
+ private void OnCloseFlyoutClicked(object? sender, EventArgs e)
+ {
+ Shell.Current.FlyoutIsPresented = false;
+ StatusLabel.Text = "Status: Flyout closed";
+ }
+
+ private void OnToggleFlyoutClicked(object? sender, EventArgs e)
+ {
+ Shell.Current.FlyoutIsPresented = !Shell.Current.FlyoutIsPresented;
+ StatusLabel.Text = $"Status: Flyout toggled to {(Shell.Current.FlyoutIsPresented ? "Open" : "Closed")}";
+ }
+
+ private void OnSetBehaviorFlyout(object? sender, EventArgs e)
+ {
+ Shell.Current.FlyoutBehavior = FlyoutBehavior.Flyout;
+ StatusLabel.Text = "Status: FlyoutBehavior = Flyout (swipeable)";
+ }
+
+ private void OnSetBehaviorLocked(object? sender, EventArgs e)
+ {
+ Shell.Current.FlyoutBehavior = FlyoutBehavior.Locked;
+ StatusLabel.Text = "Status: FlyoutBehavior = Locked (always visible)";
+ }
+
+ private void OnSetBehaviorDisabled(object? sender, EventArgs e)
+ {
+ Shell.Current.FlyoutBehavior = FlyoutBehavior.Disabled;
+ StatusLabel.Text = "Status: FlyoutBehavior = Disabled (hidden)";
+ }
+
+ private void OnChangeFlyoutBackgroundRed(object? sender, EventArgs e)
+ {
+ Shell.Current.FlyoutBackgroundColor = Colors.Red;
+ StatusLabel.Text = "Status: Flyout background = Red";
+ }
+
+ private void OnChangeFlyoutBackgroundBlue(object? sender, EventArgs e)
+ {
+ Shell.Current.FlyoutBackgroundColor = Colors.Blue;
+ StatusLabel.Text = "Status: Flyout background = Blue";
+ }
+
+ private void OnResetFlyoutBackground(object? sender, EventArgs e)
+ {
+ Shell.Current.FlyoutBackgroundColor = null;
+ StatusLabel.Text = "Status: Flyout background reset to default";
+ }
+
+ private void OnSetWidth200(object? sender, EventArgs e)
+ {
+ Shell.Current.FlyoutWidth = 200;
+ StatusLabel.Text = "Status: Flyout width = 200";
+ }
+
+ private void OnSetWidth300(object? sender, EventArgs e)
+ {
+ Shell.Current.FlyoutWidth = 300;
+ StatusLabel.Text = "Status: Flyout width = 300";
+ }
+
+ private void OnResetWidth(object? sender, EventArgs e)
+ {
+ Shell.Current.FlyoutWidth = -1; // Default
+ StatusLabel.Text = "Status: Flyout width reset to default";
+ }
+
+ // Header/Footer Tests
+ private void OnAddHeaderClicked(object? sender, EventArgs e)
+ {
+ Shell.Current.FlyoutHeader = new Label
+ {
+ Text = "Flyout Header",
+ FontSize = 20,
+ FontAttributes = FontAttributes.Bold,
+ TextColor = Colors.White,
+ BackgroundColor = Colors.Blue,
+ Padding = new Thickness(10),
+ HorizontalOptions = LayoutOptions.Fill
+ };
+ StatusLabel.Text = "Status: Header added (Label)";
+ }
+
+ private void OnChangeHeaderClicked(object? sender, EventArgs e)
+ {
+ Shell.Current.FlyoutHeader = new Button
+ {
+ Text = "Header Button",
+ BackgroundColor = Colors.Green,
+ TextColor = Colors.White,
+ Margin = new Thickness(10)
+ };
+ StatusLabel.Text = "Status: Header changed (Button)";
+ }
+
+ private void OnRemoveHeaderClicked(object? sender, EventArgs e)
+ {
+ Shell.Current.FlyoutHeader = null;
+ StatusLabel.Text = "Status: Header removed";
+ }
+
+ private void OnAddFooterClicked(object? sender, EventArgs e)
+ {
+ Shell.Current.FlyoutFooter = new Label
+ {
+ Text = "Flyout Footer - Version 1.0",
+ FontSize = 12,
+ TextColor = Colors.Gray,
+ BackgroundColor = Colors.LightGray,
+ Padding = new Thickness(10),
+ HorizontalOptions = LayoutOptions.Fill,
+ HorizontalTextAlignment = TextAlignment.Center
+ };
+ StatusLabel.Text = "Status: Footer added";
+ }
+
+ private void OnRemoveFooterClicked(object? sender, EventArgs e)
+ {
+ Shell.Current.FlyoutFooter = null;
+ StatusLabel.Text = "Status: Footer removed";
+ }
+
+ // Header Behavior Tests
+ private void OnHeaderBehaviorDefault(object? sender, EventArgs e)
+ {
+ Shell.Current.FlyoutHeaderBehavior = FlyoutHeaderBehavior.Default;
+ StatusLabel.Text = "Status: Header behavior = Default";
+ }
+
+ private void OnHeaderBehaviorScroll(object? sender, EventArgs e)
+ {
+ Shell.Current.FlyoutHeaderBehavior = FlyoutHeaderBehavior.Scroll;
+ StatusLabel.Text = "Status: Header behavior = Scroll";
+ }
+
+ private void OnHeaderBehaviorCollapse(object? sender, EventArgs e)
+ {
+ Shell.Current.FlyoutHeaderBehavior = FlyoutHeaderBehavior.CollapseOnScroll;
+ StatusLabel.Text = "Status: Header behavior = CollapseOnScroll";
+ }
+
+ // Flyout Content Tests
+ private void OnSetCustomContentClicked(object? sender, EventArgs e)
+ {
+ var customContent = new CollectionView
+ {
+ ItemsSource = new[] { "Custom Item 1", "Custom Item 2", "Custom Item 3" },
+ BackgroundColor = Colors.LightYellow
+ };
+ Shell.Current.FlyoutContent = customContent;
+ StatusLabel.Text = "Status: Custom content set (ListView)";
+ }
+
+ private void OnResetContentClicked(object? sender, EventArgs e)
+ {
+ Shell.Current.FlyoutContent = null;
+ StatusLabel.Text = "Status: Content reset to default";
+ }
+
+ // Flyout Backdrop Tests
+ private void OnRedBackdropClicked(object? sender, EventArgs e)
+ {
+ Shell.Current.FlyoutBackdrop = new SolidColorBrush(Colors.Red);
+ StatusLabel.Text = "Status: Backdrop = Red";
+ }
+
+ private void OnBlackBackdropClicked(object? sender, EventArgs e)
+ {
+ Shell.Current.FlyoutBackdrop = new SolidColorBrush(Colors.Black.WithAlpha(0.5f));
+ StatusLabel.Text = "Status: Backdrop = Black semi-transparent";
+ }
+
+ private void OnRemoveBackdropClicked(object? sender, EventArgs e)
+ {
+ Shell.Current.FlyoutBackdrop = Brush.Transparent;
+ StatusLabel.Text = "Status: Backdrop removed (transparent)";
+ }
+
+ // Flow Direction Tests
+ private void OnFlowDirectionLTRClicked(object? sender, EventArgs e)
+ {
+ Shell.Current.FlowDirection = FlowDirection.LeftToRight;
+ StatusLabel.Text = "Status: Flow direction = LeftToRight";
+ }
+
+ private void OnFlowDirectionRTLClicked(object? sender, EventArgs e)
+ {
+ Shell.Current.FlowDirection = FlowDirection.RightToLeft;
+ StatusLabel.Text = "Status: Flow direction = RightToLeft";
+ }
+ }
+}
diff --git a/src/Controls/samples/Controls.Sample.Sandbox/MainPage.xaml b/src/Controls/samples/Controls.Sample.Sandbox/MainPage.xaml
index 03475e0227ed..ebde353b7279 100644
--- a/src/Controls/samples/Controls.Sample.Sandbox/MainPage.xaml
+++ b/src/Controls/samples/Controls.Sample.Sandbox/MainPage.xaml
@@ -1,3 +1,85 @@
-
-
\ No newline at end of file
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/Controls/samples/Controls.Sample.Sandbox/MainPage.xaml.cs b/src/Controls/samples/Controls.Sample.Sandbox/MainPage.xaml.cs
index b7744fa262ea..146cfbdb995a 100644
--- a/src/Controls/samples/Controls.Sample.Sandbox/MainPage.xaml.cs
+++ b/src/Controls/samples/Controls.Sample.Sandbox/MainPage.xaml.cs
@@ -1,9 +1,687 @@
-namespace Maui.Controls.Sample;
+using System.Threading.Tasks;
+
+namespace Maui.Controls.Sample;
public partial class MainPage : ContentPage
{
public MainPage()
{
InitializeComponent();
+ Console.WriteLine("SANDBOX: MainPage loaded successfully");
+
+ ToolbarItems.Add(new ToolbarItem
+ {
+ Text = "Info",
+ Order = ToolbarItemOrder.Secondary,
+ Command = new Command(() =>
+ {
+ Console.WriteLine("SANDBOX: Info toolbar item clicked");
+ DisplayAlertAsync("Info", "This is the Info button from toolbar", "OK");
+ })
+ });
+
+ ToolbarItems.Add(new ToolbarItem
+ {
+ Text = "Help",
+ Order = ToolbarItemOrder.Secondary,
+ Command = new Command(() =>
+ {
+ Console.WriteLine("SANDBOX: Help toolbar item clicked");
+ DisplayAlertAsync("Help", "This is the Help button from toolbar", "OK");
+ })
+ });
+ }
+
+ async void Button_Clicked(object? sender, EventArgs e)
+ {
+ Console.WriteLine("SANDBOX: Navigation button clicked");
+ await Navigation.PushAsync(new DetailsPage());
+ Console.WriteLine("SANDBOX: Navigated to DetailsPage");
+ }
+
+ async void ToggleFlyoutButton_Clicked(object? sender, EventArgs e)
+ {
+ Shell.Current.FlyoutIsPresented = !Shell.Current.FlyoutIsPresented;
+ }
+
+ async void ChangeFlyoutBackgroundButton_Clicked(object? sender, EventArgs e)
+ {
+ Console.WriteLine("SANDBOX: Change Flyout Background button clicked");
+ var random = new Random();
+ var color = Color.FromRgb(random.Next(256), random.Next(256), random.Next(256));
+ Shell.Current.FlyoutBackground = new SolidColorBrush(color);
+ Console.WriteLine($"SANDBOX: Flyout background changed to {color}");
+ }
+
+ void OnInfoClicked(object? sender, EventArgs e)
+ {
+ Console.WriteLine("SANDBOX: Info toolbar item clicked");
+ DisplayAlertAsync("Info", "This is the Info button from toolbar", "OK");
+ }
+
+ void OnHelpClicked(object? sender, EventArgs e)
+ {
+ Console.WriteLine("SANDBOX: Help toolbar item clicked");
+ DisplayAlertAsync("Help", "This is the Help button from toolbar", "OK");
+ }
+
+ // GoToAsync tests for single content mode
+ async void GoToSettings_Clicked(object? sender, EventArgs e)
+ {
+ Console.WriteLine("SANDBOX: GoToAsync → Settings");
+ await Shell.Current.GoToAsync("//Settings/SettingsPage");
+ }
+
+ async void GoToMultiTab1_Clicked(object? sender, EventArgs e)
+ {
+ Console.WriteLine("SANDBOX: GoToAsync → MultiTab/Content1");
+ await Shell.Current.GoToAsync("//MultiTab/Content1");
+ }
+
+ async void GoToMultiTab2_Clicked(object? sender, EventArgs e)
+ {
+ Console.WriteLine("SANDBOX: GoToAsync → MultiTab/Content2");
+ await Shell.Current.GoToAsync("//MultiTab/Content2");
+ }
+
+ async void GoToTests_Clicked(object? sender, EventArgs e)
+ {
+ Console.WriteLine("SANDBOX: GoToAsync → Tests/NavigationTest");
+ await Shell.Current.GoToAsync("//Tests/NavigationTest");
+ }
+}
+
+public partial class DetailsPage : ContentPage
+{
+ public DetailsPage()
+ {
+ //Shell.Current.SetValue(Shell.BackgroundColorProperty, Colors.Yellow);
+ Title = "Details Page";
+ ToolbarItems.Add(new ToolbarItem
+ {
+ Text = "Details Info",
+ Command = new Command(() =>
+ {
+ Console.WriteLine("SANDBOX: Details Info toolbar item clicked");
+ })
+ });
+
+ ToolbarItems.Add(new ToolbarItem
+ {
+ Text = "Details Help",
+ Command = new Command(() =>
+ {
+ Console.WriteLine("SANDBOX: Details Help toolbar item clicked");
+ })
+ });
+ Console.WriteLine("SANDBOX: DetailsPage constructor called");
+
+ var stackDepthLabel = new Label
+ {
+ Text = $"Navigation Stack Depth: {Shell.Current?.Navigation?.NavigationStack?.Count ?? 0}",
+ FontSize = 14,
+ FontAttributes = FontAttributes.Bold,
+ HorizontalOptions = LayoutOptions.Center,
+ TextColor = Colors.Blue
+ };
+
+ var label = new Label
+ {
+ Text = "This is the Details Page",
+ VerticalOptions = LayoutOptions.Center,
+ HorizontalOptions = LayoutOptions.Center
+ };
+
+ var instructionLabel = new Label
+ {
+ Text = "Try using the hardware back button!",
+ FontSize = 12,
+ HorizontalOptions = LayoutOptions.Center,
+ TextColor = Colors.Gray,
+ Margin = new Thickness(0, 10, 0, 0)
+ };
+
+ var backButton = new Button
+ {
+ Text = "Go Back",
+ VerticalOptions = LayoutOptions.Center,
+ HorizontalOptions = LayoutOptions.Center
+ };
+
+ var popToRootButton = new Button
+ {
+ Text = "Pop to Root",
+ AutomationId = "PopToRootButton",
+ VerticalOptions = LayoutOptions.Center,
+ HorizontalOptions = LayoutOptions.Center,
+ BackgroundColor = Colors.Green,
+ TextColor = Colors.White
+ };
+
+ var pushAnotherButton = new Button
+ {
+ Text = "Push Another Page",
+ AutomationId = "PushAnotherButton",
+ VerticalOptions = LayoutOptions.Center,
+ HorizontalOptions = LayoutOptions.Center
+ };
+
+ var insertBeforeButton = new Button
+ {
+ Text = "Insert Page Before This",
+ AutomationId = "InsertBeforeButton",
+ VerticalOptions = LayoutOptions.Center,
+ HorizontalOptions = LayoutOptions.Center,
+ BackgroundColor = Colors.Orange,
+ TextColor = Colors.White
+ };
+
+ var removePageButton = new Button
+ {
+ Text = "Remove Previous Page",
+ AutomationId = "RemovePageButton",
+ VerticalOptions = LayoutOptions.Center,
+ HorizontalOptions = LayoutOptions.Center,
+ BackgroundColor = Colors.Red,
+ TextColor = Colors.White
+ };
+
+ label.HorizontalOptions = LayoutOptions.Center;
+ label.VerticalOptions = LayoutOptions.Center;
+ backButton.HorizontalOptions = LayoutOptions.Center;
+ backButton.VerticalOptions = LayoutOptions.Center;
+ backButton.Clicked += async (s, e) =>
+ {
+ Console.WriteLine("SANDBOX: Back button clicked");
+ await Navigation.PopAsync();
+ Console.WriteLine("SANDBOX: Navigated back to MainPage");
+ };
+
+ popToRootButton.Clicked += async (s, e) =>
+ {
+ Console.WriteLine("SANDBOX: PopToRoot button clicked");
+ await Navigation.PopToRootAsync();
+ Console.WriteLine("SANDBOX: Popped to root");
+ };
+
+ pushAnotherButton.Clicked += async (s, e) =>
+ {
+ Console.WriteLine("SANDBOX: Push another page button clicked");
+ await Navigation.PushAsync(new DetailsPage());
+
+ //await Navigation.PushAsync(new Content1Page());
+ Console.WriteLine("SANDBOX: Pushed another DetailsPage");
+ };
+
+ insertBeforeButton.Clicked += async (s, e) =>
+ {
+ Console.WriteLine("SANDBOX: Insert before button clicked");
+ try
+ {
+
+ var label = new Label
+ {
+ Text = "This page was inserted!",
+ VerticalOptions = LayoutOptions.Center,
+ HorizontalOptions = LayoutOptions.Center
+ };
+ // Insert a new page before the current page
+ var insertedPage = new ContentPage
+ {
+ Title = "Inserted Page",
+ Content = new VerticalStackLayout
+ {
+ Spacing = 20,
+ Padding = new Thickness(30, 0),
+ Children = { label }
+ }
+
+
+ };
+ Navigation.InsertPageBefore(insertedPage, this);
+ Console.WriteLine("SANDBOX: Page inserted successfully");
+ }
+ catch (Exception ex)
+ {
+ Console.WriteLine($"SANDBOX: Insert failed: {ex.Message}");
+ }
+ };
+
+ removePageButton.Clicked += (s, e) =>
+ {
+ Console.WriteLine("SANDBOX: Remove page button clicked");
+ try
+ {
+ var stack = Navigation.NavigationStack;
+ if (stack.Count > 2)
+ {
+ // Remove the previous page (one before current)
+ var pageToRemove = stack[stack.Count - 2];
+ Navigation.RemovePage(pageToRemove);
+ Console.WriteLine($"SANDBOX: Removed page: {pageToRemove.GetType().Name}");
+ }
+ else
+ {
+ Console.WriteLine("SANDBOX: Not enough pages to remove");
+ }
+ }
+ catch (Exception ex)
+ {
+ Console.WriteLine($"SANDBOX: Remove failed: {ex.Message}");
+ }
+ };
+
+ Content = new VerticalStackLayout
+ {
+ Spacing = 25,
+ Padding = new Thickness(30, 0),
+ Children = { stackDepthLabel, label, instructionLabel, backButton, popToRootButton, pushAnotherButton, insertBeforeButton, removePageButton }
+ };
+
+ // Update stack depth label when page appears
+ this.Appearing += (s, e) =>
+ {
+ stackDepthLabel.Text = $"Navigation Stack Depth: {Shell.Current?.Navigation?.NavigationStack?.Count ?? 0}";
+ };
+
+ Console.WriteLine("SANDBOX: DetailsPage loaded successfully");
+ }
+}
+
+// Phase 4 Test Pages: Multiple ShellContent within a Tab
+// APPEARANCE TEST: Each page has different Shell.BackgroundColor
+public partial class Content1Page : ContentPage
+{
+ public Content1Page()
+ {
+ Title = "Content 1";
+
+ // Set per-page Shell appearance - RED toolbar
+ Shell.SetBackgroundColor(this, Colors.DarkRed);
+ Shell.SetForegroundColor(this, Colors.White);
+ Shell.SetTitleColor(this, Colors.White);
+
+ Content = new VerticalStackLayout
+ {
+ Spacing = 20,
+ Padding = new Thickness(30, 0),
+ Children =
+ {
+ new Label
+ {
+ Text = "Content 1 - RED Toolbar",
+ FontSize = 24,
+ FontAttributes = FontAttributes.Bold,
+ HorizontalOptions = LayoutOptions.Center,
+ VerticalOptions = LayoutOptions.Center,
+ TextColor = Colors.DarkRed
+ },
+ new Label
+ {
+ Text = "Swipe left/right to test appearance changes",
+ FontSize = 14,
+ HorizontalOptions = LayoutOptions.Center,
+ TextColor = Colors.Gray
+ },
+ new Label
+ {
+ Text = "✓ Toolbar should be DARK RED",
+ FontSize = 16,
+ HorizontalOptions = LayoutOptions.Center,
+ TextColor = Colors.DarkRed,
+ FontAttributes = FontAttributes.Bold
+ },
+ new Button
+ {
+ Text = "Push Page (Test Navigation Appearance)",
+ HorizontalOptions = LayoutOptions.Center,
+ Command = new Command(async () => await Navigation.PushAsync(new AppearanceDetailPage("Pushed from Content 1", Colors.Purple)))
+ },
+ new Button
+ {
+ Text = "GoToAsync to Content2",
+ HorizontalOptions = LayoutOptions.Center,
+ Command = new Command(async () => await Shell.Current.GoToAsync("//MultiTab/Content2"))
+ }
+ }
+ };
+ Console.WriteLine("SANDBOX: Content1Page loaded - Shell.BackgroundColor = DarkRed");
+ }
+}
+
+public partial class Content2Page : ContentPage
+{
+ public Content2Page()
+ {
+ Title = "Content 2";
+
+ // Set per-page Shell appearance - BLUE toolbar
+ Shell.SetBackgroundColor(this, Colors.DarkBlue);
+ Shell.SetForegroundColor(this, Colors.White);
+ Shell.SetTitleColor(this, Colors.Yellow);
+
+ Content = new VerticalStackLayout
+ {
+ Spacing = 20,
+ Padding = new Thickness(30, 0),
+ Children =
+ {
+ new Label
+ {
+ Text = "Content 2 - BLUE Toolbar",
+ FontSize = 24,
+ FontAttributes = FontAttributes.Bold,
+ HorizontalOptions = LayoutOptions.Center,
+ VerticalOptions = LayoutOptions.Center,
+ TextColor = Colors.DarkBlue
+ },
+ new Label
+ {
+ Text = "Each content maintains its own appearance",
+ FontSize = 14,
+ HorizontalOptions = LayoutOptions.Center,
+ TextColor = Colors.Gray
+ },
+ new Label
+ {
+ Text = "✓ Toolbar should be DARK BLUE with YELLOW title",
+ FontSize = 16,
+ HorizontalOptions = LayoutOptions.Center,
+ TextColor = Colors.DarkBlue,
+ FontAttributes = FontAttributes.Bold
+ },
+ new Entry
+ {
+ Placeholder = "Type something to test state preservation",
+ HorizontalOptions = LayoutOptions.Center,
+ WidthRequest = 300
+ },
+ new Button
+ {
+ Text = "Push Page (Test Navigation Appearance)",
+ HorizontalOptions = LayoutOptions.Center,
+ Command = new Command(async () => await Navigation.PushAsync(new AppearanceDetailPage("Pushed from Content 2", Colors.Orange)))
+ }
+ }
+ };
+ Console.WriteLine("SANDBOX: Content2Page loaded - Shell.BackgroundColor = DarkBlue");
+ }
+}
+
+public partial class Content3Page : ContentPage
+{
+ public Content3Page()
+ {
+ Title = "Content 3";
+
+ // Set per-page Shell appearance - GREEN toolbar
+ Shell.SetBackgroundColor(this, Colors.DarkGreen);
+ Shell.SetForegroundColor(this, Colors.White);
+ Shell.SetTitleColor(this, Colors.LightGreen);
+
+ Content = new VerticalStackLayout
+ {
+ Spacing = 20,
+ Padding = new Thickness(30, 0),
+ Children =
+ {
+ new Label
+ {
+ Text = "Content 3 - GREEN Toolbar",
+ FontSize = 24,
+ FontAttributes = FontAttributes.Bold,
+ HorizontalOptions = LayoutOptions.Center,
+ VerticalOptions = LayoutOptions.Center,
+ TextColor = Colors.DarkGreen
+ },
+ new Label
+ {
+ Text = "Testing ViewPager2 + TabLayout integration",
+ FontSize = 14,
+ HorizontalOptions = LayoutOptions.Center,
+ TextColor = Colors.Gray
+ },
+ new Label
+ {
+ Text = "✓ Toolbar should be DARK GREEN with LIGHT GREEN title",
+ FontSize = 16,
+ HorizontalOptions = LayoutOptions.Center,
+ TextColor = Colors.DarkGreen,
+ FontAttributes = FontAttributes.Bold
+ },
+ new BoxView
+ {
+ Color = Colors.DarkGreen,
+ HeightRequest = 100,
+ WidthRequest = 100,
+ HorizontalOptions = LayoutOptions.Center
+ },
+ new Button
+ {
+ Text = "Push Page (Test Navigation Appearance)",
+ HorizontalOptions = LayoutOptions.Center,
+ Command = new Command(async () => await Navigation.PushAsync(new AppearanceDetailPage("Pushed from Content 3", Colors.Brown)))
+ }
+ }
+ };
+ Console.WriteLine("SANDBOX: Content3Page loaded - Shell.BackgroundColor = DarkGreen");
+ }
+}
+
+// Appearance test detail page - used to test navigation appearance changes
+public partial class AppearanceDetailPage : ContentPage
+{
+ public AppearanceDetailPage(string fromPage, Color toolbarColor)
+ {
+ Title = "Detail Page";
+
+ // Set different appearance for pushed page
+ Shell.SetBackgroundColor(this, toolbarColor);
+ Shell.SetForegroundColor(this, Colors.White);
+ Shell.SetTitleColor(this, Colors.White);
+
+ Content = new VerticalStackLayout
+ {
+ Spacing = 20,
+ Padding = new Thickness(30, 0),
+ VerticalOptions = LayoutOptions.Center,
+ Children =
+ {
+ new Label
+ {
+ Text = $"Detail Page",
+ FontSize = 24,
+ FontAttributes = FontAttributes.Bold,
+ HorizontalOptions = LayoutOptions.Center
+ },
+ new Label
+ {
+ Text = fromPage,
+ FontSize = 16,
+ HorizontalOptions = LayoutOptions.Center
+ },
+ new Label
+ {
+ Text = $"✓ Toolbar should be {GetColorName(toolbarColor)}",
+ FontSize = 16,
+ HorizontalOptions = LayoutOptions.Center,
+ TextColor = toolbarColor,
+ FontAttributes = FontAttributes.Bold
+ },
+ new Label
+ {
+ Text = "Press back to return and verify appearance restores",
+ FontSize = 14,
+ HorizontalOptions = LayoutOptions.Center,
+ TextColor = Colors.Gray
+ },
+ new Button
+ {
+ Text = "Push Another Page",
+ HorizontalOptions = LayoutOptions.Center,
+ Command = new Command(async () => await Navigation.PushAsync(new AppearanceDetailPage("Pushed from Detail", Colors.Teal)))
+ },
+ new Button
+ {
+ Text = "Pop Back",
+ HorizontalOptions = LayoutOptions.Center,
+ Command = new Command(async () => await Navigation.PopAsync())
+ }
+ }
+ };
+ Console.WriteLine($"SANDBOX: AppearanceDetailPage loaded - Shell.BackgroundColor = {GetColorName(toolbarColor)}");
+ }
+
+ static string GetColorName(Color color)
+ {
+ if (color == Colors.Purple)
+ return "PURPLE";
+ if (color == Colors.Orange)
+ return "ORANGE";
+ if (color == Colors.Brown)
+ return "BROWN";
+ if (color == Colors.Teal)
+ return "TEAL";
+ return color.ToString();
+ }
+}
+
+// Phase 5 Test Page: SearchHandler
+public partial class SearchTestPage : ContentPage
+{
+ private Label _resultsLabel;
+ private Label _queryLabel;
+
+ public SearchTestPage()
+ {
+ Title = "Search Test";
+
+ _queryLabel = new Label
+ {
+ Text = "Query: (none)",
+ FontSize = 16,
+ FontAttributes = FontAttributes.Bold,
+ HorizontalOptions = LayoutOptions.Center,
+ Margin = new Thickness(0, 20, 0, 0)
+ };
+
+ _resultsLabel = new Label
+ {
+ Text = "Selected: (none)",
+ FontSize = 16,
+ HorizontalOptions = LayoutOptions.Center,
+ Margin = new Thickness(0, 10, 0, 0)
+ };
+
+ // Create SearchHandler
+ var searchHandler = new TestSearchHandler(_queryLabel, _resultsLabel)
+ {
+ Placeholder = "Search for fruits...",
+ ShowsResults = true,
+ SearchBoxVisibility = SearchBoxVisibility.Expanded,
+ IsSearchEnabled = true,
+ BackgroundColor = Colors.LightBlue,
+ TextColor = Colors.Black,
+ PlaceholderColor = Colors.Gray
+ };
+
+ Shell.SetSearchHandler(this, searchHandler);
+
+ Content = new VerticalStackLayout
+ {
+ Spacing = 20,
+ Padding = new Thickness(30, 0),
+ Children =
+ {
+ new Label
+ {
+ Text = "Phase 5: SearchHandler Test",
+ FontSize = 24,
+ FontAttributes = FontAttributes.Bold,
+ HorizontalOptions = LayoutOptions.Center,
+ Margin = new Thickness(0, 40, 0, 0)
+ },
+ new Label
+ {
+ Text = "Search functionality should appear in the toolbar above",
+ FontSize = 14,
+ HorizontalOptions = LayoutOptions.Center,
+ TextColor = Colors.Gray
+ },
+ _queryLabel,
+ _resultsLabel,
+ new Label
+ {
+ Text = "Try searching for: Apple, Banana, Orange, Grape, Mango",
+ FontSize = 12,
+ HorizontalOptions = LayoutOptions.Center,
+ TextColor = Colors.Blue,
+ Margin = new Thickness(0, 20, 0, 0)
+ }
+ }
+ };
+
+ Console.WriteLine("SANDBOX: SearchTestPage loaded with SearchHandler");
+ }
+}
+
+// Custom SearchHandler for testing
+public class TestSearchHandler : SearchHandler
+{
+ private readonly List _fruits = new List
+ {
+ "Apple", "Apricot", "Avocado",
+ "Banana", "Blackberry", "Blueberry",
+ "Orange", "Olive",
+ "Grape", "Grapefruit", "Guava",
+ "Mango", "Melon"
+ };
+
+ private readonly Label _queryLabel;
+ private readonly Label _resultsLabel;
+
+ public TestSearchHandler(Label queryLabel, Label resultsLabel)
+ {
+ _queryLabel = queryLabel;
+ _resultsLabel = resultsLabel;
+ ClearIconHelpText = "Clear search";
+ ClearIconName = "clear";
+ ClearPlaceholderHelpText = "Clear";
+ }
+
+ protected override void OnQueryChanged(string oldValue, string newValue)
+ {
+ base.OnQueryChanged(oldValue, newValue);
+
+ _queryLabel.Text = $"Query: {newValue ?? "(none)"}";
+ Console.WriteLine($"SANDBOX: SearchHandler Query changed: {newValue}");
+
+ if (string.IsNullOrWhiteSpace(newValue))
+ {
+ ItemsSource = null;
+ }
+ else
+ {
+ ItemsSource = _fruits
+ .Where(f => f.Contains(newValue, StringComparison.OrdinalIgnoreCase))
+ .ToList();
+ }
+ }
+
+ protected override void OnItemSelected(object item)
+ {
+ base.OnItemSelected(item);
+
+ if (item is string fruit)
+ {
+ _resultsLabel.Text = $"Selected: {fruit}";
+ Console.WriteLine($"SANDBOX: SearchHandler Item selected: {fruit}");
+ }
+ }
+
+ protected override void OnQueryConfirmed()
+ {
+ base.OnQueryConfirmed();
+ Console.WriteLine($"SANDBOX: SearchHandler Query confirmed: {Query}");
}
}
\ No newline at end of file
diff --git a/src/Controls/samples/Controls.Sample.Sandbox/NavigationTestPage.xaml b/src/Controls/samples/Controls.Sample.Sandbox/NavigationTestPage.xaml
new file mode 100644
index 000000000000..4823f0fdf69a
--- /dev/null
+++ b/src/Controls/samples/Controls.Sample.Sandbox/NavigationTestPage.xaml
@@ -0,0 +1,72 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/Controls/samples/Controls.Sample.Sandbox/NavigationTestPage.xaml.cs b/src/Controls/samples/Controls.Sample.Sandbox/NavigationTestPage.xaml.cs
new file mode 100644
index 000000000000..d94d758c6648
--- /dev/null
+++ b/src/Controls/samples/Controls.Sample.Sandbox/NavigationTestPage.xaml.cs
@@ -0,0 +1,121 @@
+using System;
+using Microsoft.Maui.Controls;
+using Microsoft.Maui.Graphics;
+
+namespace Maui.Controls.Sample
+{
+ public partial class NavigationTestPage : ContentPage
+ {
+ public NavigationTestPage()
+ {
+ InitializeComponent();
+ UpdateNavigationStackInfo();
+ }
+
+ protected override void OnAppearing()
+ {
+ base.OnAppearing();
+ UpdateNavigationStackInfo();
+ }
+
+ private void UpdateNavigationStackInfo()
+ {
+ if (Navigation?.NavigationStack != null)
+ {
+ NavigationStackLabel.Text = $"Navigation Stack: {Navigation.NavigationStack.Count} pages";
+ }
+ }
+
+ private async void OnPushDetailClicked(object? sender, EventArgs e)
+ {
+ await Navigation.PushAsync(new DetailPage());
+ UpdateNavigationStackInfo();
+ }
+
+ private async void OnPushModalClicked(object? sender, EventArgs e)
+ {
+ await Navigation.PushModalAsync(new NavigationPage(new DetailPage()));
+ }
+
+ private async void OnNavigateToMainClicked(object? sender, EventArgs e)
+ {
+ await Shell.Current.GoToAsync("//MainPage");
+ }
+
+ private async void OnNavigateToSettingsClicked(object? sender, EventArgs e)
+ {
+ await Shell.Current.GoToAsync("//Settings");
+ }
+
+ private async void OnGoToMainAsyncClicked(object? sender, EventArgs e)
+ {
+ await Shell.Current.GoToAsync("//MainPage");
+ }
+
+ private async void OnGoToSettingsAsyncClicked(object? sender, EventArgs e)
+ {
+ await Shell.Current.GoToAsync("//Settings");
+ }
+
+ private async void OnGoToWithQueryClicked(object? sender, EventArgs e)
+ {
+ await Shell.Current.GoToAsync($"//MainPage?message=Hello from Navigation Test");
+ }
+
+ private async void OnNavigateDeepClicked(object? sender, EventArgs e)
+ {
+ await Navigation.PushAsync(new DetailPage { Title = "Level 1" });
+ await Navigation.PushAsync(new DetailPage { Title = "Level 2" });
+ await Navigation.PushAsync(new DetailPage { Title = "Level 3" });
+ UpdateNavigationStackInfo();
+ }
+
+ private async void OnPopClicked(object? sender, EventArgs e)
+ {
+ if (Navigation.NavigationStack.Count > 1)
+ {
+ await Navigation.PopAsync();
+ UpdateNavigationStackInfo();
+ }
+ }
+
+ private async void OnPopToRootClicked(object? sender, EventArgs e)
+ {
+ await Navigation.PopToRootAsync();
+ UpdateNavigationStackInfo();
+ }
+ }
+
+ public class DetailPage : ContentPage
+ {
+ public DetailPage()
+ {
+ var layout = new VerticalStackLayout();
+ layout.Padding = new Thickness(20);
+ layout.Spacing = 15;
+
+ var titleLabel = new Label();
+ titleLabel.Text = "Detail Page";
+ titleLabel.FontSize = 24;
+ titleLabel.FontAttributes = FontAttributes.Bold;
+ layout.Children.Add(titleLabel);
+
+ var backButton = new Button();
+ backButton.Text = "Go Back";
+ backButton.Command = new Command(async () => await Navigation.PopAsync());
+ layout.Children.Add(backButton);
+
+ var popModalButton = new Button();
+ popModalButton.Text = "Pop Modal";
+ popModalButton.Command = new Command(async () => await Navigation.PopModalAsync());
+ layout.Children.Add(popModalButton);
+
+ var pushButton = new Button();
+ pushButton.Text = "Push Another";
+ pushButton.Command = new Command(async () => await Navigation.PushAsync(new DetailPage()));
+ layout.Children.Add(pushButton);
+
+ Content = layout;
+ }
+ }
+}
diff --git a/src/Controls/samples/Controls.Sample.Sandbox/Resources/Styles/Colors.xaml b/src/Controls/samples/Controls.Sample.Sandbox/Resources/Styles/Colors.xaml
new file mode 100644
index 000000000000..ed47472ce314
--- /dev/null
+++ b/src/Controls/samples/Controls.Sample.Sandbox/Resources/Styles/Colors.xaml
@@ -0,0 +1,58 @@
+
+
+
+
+
+ #512BD4
+ #ac99ea
+ #242424
+ #DFD8F7
+ #9880e5
+ #2B0B98
+ Red
+
+ White
+ Black
+ #D600AA
+ #190649
+ #1f1f1f
+
+ #E1E1E1
+ #C8C8C8
+ #ACACAC
+ #919191
+ #6E6E6E
+ #404040
+ #212121
+ #141414
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/Controls/samples/Controls.Sample.Sandbox/Resources/Styles/Styles.xaml b/src/Controls/samples/Controls.Sample.Sandbox/Resources/Styles/Styles.xaml
new file mode 100644
index 000000000000..0cc5833585bf
--- /dev/null
+++ b/src/Controls/samples/Controls.Sample.Sandbox/Resources/Styles/Styles.xaml
@@ -0,0 +1,583 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/Controls/samples/Controls.Sample.Sandbox/SandboxShell.xaml b/src/Controls/samples/Controls.Sample.Sandbox/SandboxShell.xaml
index 358b0b04ef63..a617858a090c 100644
--- a/src/Controls/samples/Controls.Sample.Sandbox/SandboxShell.xaml
+++ b/src/Controls/samples/Controls.Sample.Sandbox/SandboxShell.xaml
@@ -3,20 +3,126 @@
xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
x:Class="Maui.Controls.Sample.SandboxShell"
xmlns:local="clr-namespace:Maui.Controls.Sample"
- x:Name="shell">
+ x:Name="shell"
+ Shell.FlyoutBehavior="Flyout"
+ Title="Shell Handler Tests">
+
+
+
+
-
+ Shell.TabBarUnselectedColor="Red">
+
+
+
+ Title="Home"
+ ContentTemplate="{DataTemplate local:MainPage}"
+ Route="MainPage"/>
-
+
+
+
+ Title="Navigation"
+ ContentTemplate="{DataTemplate local:NavigationTestPage}"
+ Route="NavigationTest"/>
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/Controls/samples/Controls.Sample.Sandbox/SettingsPage.xaml b/src/Controls/samples/Controls.Sample.Sandbox/SettingsPage.xaml
new file mode 100644
index 000000000000..76b4bbbc2c5c
--- /dev/null
+++ b/src/Controls/samples/Controls.Sample.Sandbox/SettingsPage.xaml
@@ -0,0 +1,152 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Collapsible
+ Expanded
+ Hidden
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/Controls/samples/Controls.Sample.Sandbox/SettingsPage.xaml.cs b/src/Controls/samples/Controls.Sample.Sandbox/SettingsPage.xaml.cs
new file mode 100644
index 000000000000..76e3c72b43ce
--- /dev/null
+++ b/src/Controls/samples/Controls.Sample.Sandbox/SettingsPage.xaml.cs
@@ -0,0 +1,198 @@
+using System.Collections.ObjectModel;
+using System.Text;
+
+namespace Maui.Controls.Sample;
+
+public partial class SettingsPage : ContentPage
+{
+ private readonly StringBuilder _logBuilder = new();
+ private readonly Random _random = new();
+
+ // Predefined color themes for SearchHandler
+ private static readonly (string Name, Color Background, Color Text, Color Placeholder, Color CancelButton)[] ColorThemes =
+ [
+ ("Blue", Color.FromArgb("#E3F2FD"), Color.FromArgb("#1565C0"), Color.FromArgb("#64B5F6"), Color.FromArgb("#1976D2")),
+ ("Green", Color.FromArgb("#E8F5E9"), Color.FromArgb("#2E7D32"), Color.FromArgb("#81C784"), Color.FromArgb("#388E3C")),
+ ("Purple", Color.FromArgb("#F3E5F5"), Color.FromArgb("#7B1FA2"), Color.FromArgb("#BA68C8"), Color.FromArgb("#8E24AA")),
+ ("Orange", Color.FromArgb("#FFF3E0"), Color.FromArgb("#E65100"), Color.FromArgb("#FFB74D"), Color.FromArgb("#F57C00")),
+ ("Red", Color.FromArgb("#FFEBEE"), Color.FromArgb("#C62828"), Color.FromArgb("#EF9A9A"), Color.FromArgb("#D32F2F")),
+ ("Teal", Color.FromArgb("#E0F2F1"), Color.FromArgb("#00695C"), Color.FromArgb("#80CBC4"), Color.FromArgb("#00897B")),
+ ("Pink", Color.FromArgb("#FCE4EC"), Color.FromArgb("#AD1457"), Color.FromArgb("#F48FB1"), Color.FromArgb("#C2185B")),
+ ("Amber", Color.FromArgb("#FFF8E1"), Color.FromArgb("#FF6F00"), Color.FromArgb("#FFD54F"), Color.FromArgb("#FFB300")),
+ ];
+
+ public SettingsPage()
+ {
+ InitializeComponent();
+
+ // Set initial picker value to Expanded (index 1)
+ visibilityPicker.SelectedIndex = 1; // Expanded
+
+ // Subscribe to search handler events
+ searchHandler.QueryChangedEvent += OnSearchQueryChanged;
+ searchHandler.ItemSelectedEvent += OnSearchItemSelected;
+ }
+
+ async void Button_Clicked(object? sender, EventArgs e)
+ {
+ Log("PopToRootAsync called");
+ await Navigation.PopToRootAsync();
+ }
+
+ async void OnPushDetailsClicked(object? sender, EventArgs e)
+ {
+ Log("Pushing DetailsPage...");
+ await Navigation.PushAsync(new DetailsPage());
+ }
+
+ void OnSearchQueryChanged(object? sender, string query)
+ {
+ currentQueryLabel.Text = string.IsNullOrEmpty(query) ? "(empty)" : query;
+ Log($"QueryChanged: '{query}'");
+ }
+
+ void OnSearchItemSelected(object? sender, object? item)
+ {
+ if (item is SearchItem searchItem)
+ {
+ Log($"ItemSelected: {searchItem.Name} ({searchItem.Category})");
+ DisplayAlertAsync("Selected", $"You selected: {searchItem.Name}\nCategory: {searchItem.Category}", "OK");
+ }
+ }
+
+ void OnVisibilityChanged(object? sender, EventArgs e)
+ {
+ if (visibilityPicker.SelectedItem is string visibility)
+ {
+ var searchBoxVisibility = visibility switch
+ {
+ "Collapsible" => SearchBoxVisibility.Collapsible,
+ "Expanded" => SearchBoxVisibility.Expanded,
+ "Hidden" => SearchBoxVisibility.Hidden,
+ _ => SearchBoxVisibility.Collapsible
+ };
+
+ searchHandler.SearchBoxVisibility = searchBoxVisibility;
+ Log($"SearchBoxVisibility changed to: {visibility}");
+ }
+ }
+
+ void OnShowsResultsToggled(object? sender, ToggledEventArgs e)
+ {
+ searchHandler.ShowsResults = e.Value;
+ Log($"ShowsResults changed to: {e.Value}");
+ }
+
+ void OnIsEnabledToggled(object? sender, ToggledEventArgs e)
+ {
+ searchHandler.IsSearchEnabled = e.Value;
+ Log($"IsSearchEnabled changed to: {e.Value}");
+ }
+
+ void OnClearLogClicked(object? sender, EventArgs e)
+ {
+ _logBuilder.Clear();
+ logLabel.Text = "Log cleared.";
+ }
+
+ void OnRandomizeColorsClicked(object? sender, EventArgs e)
+ {
+ // Pick a random color theme
+ var theme = ColorThemes[_random.Next(ColorThemes.Length)];
+
+ // Apply to SearchHandler
+ searchHandler.BackgroundColor = theme.Background;
+ searchHandler.TextColor = theme.Text;
+ searchHandler.PlaceholderColor = theme.Placeholder;
+ searchHandler.CancelButtonColor = theme.CancelButton;
+
+ // Update UI
+ currentColorsLabel.Text = $"{theme.Name} theme";
+ currentColorsLabel.TextColor = theme.Text;
+
+ Log($"Colors changed to: {theme.Name} (BG: {theme.Background.ToHex()}, Text: {theme.Text.ToHex()})");
+ }
+
+ void Log(string message)
+ {
+ var timestamp = DateTime.Now.ToString("HH:mm:ss.fff");
+ _logBuilder.Insert(0, $"[{timestamp}] {message}\n");
+ logLabel.Text = _logBuilder.ToString();
+ Console.WriteLine($"SANDBOX SearchHandler: {message}");
+ }
+}
+
+///
+/// Custom SearchHandler that exposes events for query and item selection changes.
+/// SearchHandler uses virtual methods, so we override them and raise events.
+///
+public class SandboxSearchHandler : SearchHandler
+{
+ private static readonly ObservableCollection _allItems = new()
+ {
+ new SearchItem { Name = "Apple", Category = "Fruit" },
+ new SearchItem { Name = "Banana", Category = "Fruit" },
+ new SearchItem { Name = "Cherry", Category = "Fruit" },
+ new SearchItem { Name = "Date", Category = "Fruit" },
+ new SearchItem { Name = "Elderberry", Category = "Fruit" },
+ new SearchItem { Name = "Carrot", Category = "Vegetable" },
+ new SearchItem { Name = "Broccoli", Category = "Vegetable" },
+ new SearchItem { Name = "Spinach", Category = "Vegetable" },
+ new SearchItem { Name = "Settings", Category = "App" },
+ new SearchItem { Name = "Search", Category = "App" },
+ new SearchItem { Name = "Shell", Category = "MAUI" },
+ new SearchItem { Name = "Handler", Category = "MAUI" },
+ new SearchItem { Name = "Navigation", Category = "MAUI" },
+ };
+
+ public event EventHandler? QueryChangedEvent;
+ public event EventHandler? ItemSelectedEvent;
+
+ protected override void OnQueryChanged(string oldValue, string newValue)
+ {
+ base.OnQueryChanged(oldValue, newValue);
+
+ Console.WriteLine($"SANDBOX SearchHandler.OnQueryChanged: '{oldValue}' -> '{newValue}'");
+
+ // Raise event for UI updates
+ QueryChangedEvent?.Invoke(this, newValue ?? string.Empty);
+
+ // Filter and update ItemsSource
+ if (string.IsNullOrWhiteSpace(newValue))
+ {
+ ItemsSource = null;
+ }
+ else
+ {
+ var results = _allItems
+ .Where(item => item.Name.Contains(newValue, StringComparison.OrdinalIgnoreCase))
+ .ToList();
+
+ ItemsSource = results;
+ Console.WriteLine($"SANDBOX SearchHandler: Found {results.Count} results");
+ }
+ }
+
+ protected override void OnItemSelected(object item)
+ {
+ base.OnItemSelected(item);
+
+ Console.WriteLine($"SANDBOX SearchHandler.OnItemSelected: {item}");
+
+ // Raise event for UI updates
+ ItemSelectedEvent?.Invoke(this, item);
+
+ // Clear the search
+ Query = string.Empty;
+ }
+}
+
+///
+/// Simple item class for search results
+///
+public class SearchItem
+{
+ public string Name { get; set; } = string.Empty;
+ public string Category { get; set; } = string.Empty;
+}
+
diff --git a/src/Controls/samples/Controls.Sample.Sandbox/TabbedPageTestPage.xaml b/src/Controls/samples/Controls.Sample.Sandbox/TabbedPageTestPage.xaml
new file mode 100644
index 000000000000..3b4f724bbb07
--- /dev/null
+++ b/src/Controls/samples/Controls.Sample.Sandbox/TabbedPageTestPage.xaml
@@ -0,0 +1,248 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/Controls/samples/Controls.Sample.Sandbox/TabbedPageTestPage.xaml.cs b/src/Controls/samples/Controls.Sample.Sandbox/TabbedPageTestPage.xaml.cs
new file mode 100644
index 000000000000..d3ca4e63a423
--- /dev/null
+++ b/src/Controls/samples/Controls.Sample.Sandbox/TabbedPageTestPage.xaml.cs
@@ -0,0 +1,80 @@
+namespace Maui.Controls.Sample;
+
+public partial class TabbedPageTestPage : TabbedPage
+{
+ private readonly Random _random = new();
+
+ // Color palettes for testing
+ private static readonly Color[] BarColors =
+ [
+ Color.FromArgb("#6200EE"), // Purple
+ Color.FromArgb("#03DAC5"), // Teal
+ Color.FromArgb("#FF5722"), // Deep Orange
+ Color.FromArgb("#2196F3"), // Blue
+ Color.FromArgb("#4CAF50"), // Green
+ Color.FromArgb("#E91E63"), // Pink
+ ];
+
+ private static readonly (Color Selected, Color Unselected)[] TabColorPairs =
+ [
+ (Color.FromArgb("#03DAC5"), Color.FromArgb("#BB86FC")), // Teal / Light Purple
+ (Color.FromArgb("#FFFFFF"), Color.FromArgb("#80FFFFFF")), // White / Semi-transparent
+ (Color.FromArgb("#FFD700"), Color.FromArgb("#FFA500")), // Gold / Orange
+ (Color.FromArgb("#00FF00"), Color.FromArgb("#90EE90")), // Green / Light Green
+ (Color.FromArgb("#FF1493"), Color.FromArgb("#FFB6C1")), // Deep Pink / Light Pink
+ ];
+
+ public TabbedPageTestPage()
+ {
+ InitializeComponent();
+ }
+
+ async void OnInfoClicked(object? sender, EventArgs e)
+ {
+ await DisplayAlertAsync("TabbedPage Test Info",
+ "This page tests the BottomNavigationManager refactoring.\n\n" +
+ "Both Shell's ShellItemHandler and TabbedPage's TabbedPageManager now use the shared BottomNavigationManager class for:\n" +
+ "• Tab setup and menu creation\n" +
+ "• Tab selection callbacks\n" +
+ "• Color management\n" +
+ "• Background updates",
+ "OK");
+ }
+
+ void OnChangeBarColorClicked(object? sender, EventArgs e)
+ {
+ var newColor = BarColors[_random.Next(BarColors.Length)];
+ BarBackgroundColor = newColor;
+
+ Console.WriteLine($"SANDBOX TabbedPage: BarBackgroundColor changed to {newColor.ToHex()}");
+ }
+
+ void OnChangeTabColorsClicked(object? sender, EventArgs e)
+ {
+ var colorPair = TabColorPairs[_random.Next(TabColorPairs.Length)];
+ SelectedTabColor = colorPair.Selected;
+ UnselectedTabColor = colorPair.Unselected;
+
+ Console.WriteLine($"SANDBOX TabbedPage: SelectedTabColor={colorPair.Selected.ToHex()}, UnselectedTabColor={colorPair.Unselected.ToHex()}");
+ }
+
+ void OnBottomTabsClicked(object? sender, EventArgs e)
+ {
+ Console.WriteLine("SANDBOX TabbedPage: Switching to Bottom Tabs");
+ if (Application.Current?.Windows.Count > 0)
+ {
+ // Create new TabbedPage with Bottom placement (default in XAML)
+ Application.Current.Windows[0].Page = new TabbedPageTestPage();
+ }
+ }
+
+ void OnTopTabsClicked(object? sender, EventArgs e)
+ {
+ Console.WriteLine("SANDBOX TabbedPage: Switching to Top Tabs");
+ if (Application.Current?.Windows.Count > 0)
+ {
+ // Create TabbedPage with Top placement
+ Application.Current.Windows[0].Page = new TabbedPageTopTabsTestPage();
+ }
+ }
+}
diff --git a/src/Controls/samples/Controls.Sample.Sandbox/TabbedPageTopTabsTestPage.xaml b/src/Controls/samples/Controls.Sample.Sandbox/TabbedPageTopTabsTestPage.xaml
new file mode 100644
index 000000000000..2c2227ce7bb4
--- /dev/null
+++ b/src/Controls/samples/Controls.Sample.Sandbox/TabbedPageTopTabsTestPage.xaml
@@ -0,0 +1,245 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/Controls/samples/Controls.Sample.Sandbox/TabbedPageTopTabsTestPage.xaml.cs b/src/Controls/samples/Controls.Sample.Sandbox/TabbedPageTopTabsTestPage.xaml.cs
new file mode 100644
index 000000000000..73badb5b2dba
--- /dev/null
+++ b/src/Controls/samples/Controls.Sample.Sandbox/TabbedPageTopTabsTestPage.xaml.cs
@@ -0,0 +1,86 @@
+namespace Maui.Controls.Sample;
+
+public partial class TabbedPageTopTabsTestPage : TabbedPage
+{
+ private readonly Random _random = new();
+
+ // Color palettes for testing
+ private static readonly Color[] BarColors =
+ [
+ Color.FromArgb("#2196F3"), // Blue
+ Color.FromArgb("#6200EE"), // Purple
+ Color.FromArgb("#FF5722"), // Deep Orange
+ Color.FromArgb("#4CAF50"), // Green
+ Color.FromArgb("#E91E63"), // Pink
+ Color.FromArgb("#009688"), // Teal
+ ];
+
+ private static readonly (Color Selected, Color Unselected)[] TabColorPairs =
+ [
+ (Color.FromArgb("#FFEB3B"), Color.FromArgb("#90CAF9")), // Yellow / Light Blue
+ (Color.FromArgb("#FFFFFF"), Color.FromArgb("#80FFFFFF")), // White / Semi-transparent
+ (Color.FromArgb("#FF5722"), Color.FromArgb("#FFCCBC")), // Deep Orange / Light Orange
+ (Color.FromArgb("#00FF00"), Color.FromArgb("#90EE90")), // Green / Light Green
+ (Color.FromArgb("#E91E63"), Color.FromArgb("#F8BBD9")), // Pink / Light Pink
+ ];
+
+ public TabbedPageTopTabsTestPage()
+ {
+ InitializeComponent();
+ }
+
+ async void OnInfoClicked(object? sender, EventArgs e)
+ {
+ await DisplayAlertAsync("TabbedPage Top Tabs Info",
+ "This page tests the TOP tab placement.\n\n" +
+ "Top tabs use TabLayout + TabLayoutMediator.\n" +
+ "Bottom tabs use BottomNavigationManager (shared with Shell).\n\n" +
+ "TabbedPageManager handles both placements, but only bottom tabs share code with Shell's ShellItemHandler.",
+ "OK");
+ }
+
+ void OnChangeBarColorClicked(object? sender, EventArgs e)
+ {
+ var newColor = BarColors[_random.Next(BarColors.Length)];
+ BarBackgroundColor = newColor;
+
+ Console.WriteLine($"SANDBOX TabbedPage (Top): BarBackgroundColor changed to {newColor.ToHex()}");
+ }
+
+ void OnChangeTabColorsClicked(object? sender, EventArgs e)
+ {
+ var colorPair = TabColorPairs[_random.Next(TabColorPairs.Length)];
+ SelectedTabColor = colorPair.Selected;
+ UnselectedTabColor = colorPair.Unselected;
+
+ Console.WriteLine($"SANDBOX TabbedPage (Top): SelectedTabColor={colorPair.Selected.ToHex()}, UnselectedTabColor={colorPair.Unselected.ToHex()}");
+ }
+
+ void OnBottomTabsClicked(object? sender, EventArgs e)
+ {
+ Console.WriteLine("SANDBOX TabbedPage: Switching to Bottom Tabs");
+ if (Application.Current?.Windows.Count > 0)
+ {
+ Application.Current.Windows[0].Page = new TabbedPageTestPage();
+ }
+ }
+
+ void OnTopTabsClicked(object? sender, EventArgs e)
+ {
+ Console.WriteLine("SANDBOX TabbedPage: Already on Top Tabs");
+ // Already on top tabs, just refresh
+ if (Application.Current?.Windows.Count > 0)
+ {
+ Application.Current.Windows[0].Page = new TabbedPageTopTabsTestPage();
+ }
+ }
+
+ void OnBackToShellClicked(object? sender, EventArgs e)
+ {
+ Console.WriteLine("SANDBOX TabbedPage: Going back to Shell");
+ if (Application.Current?.Windows.Count > 0)
+ {
+ Application.Current.Windows[0].Page = new SandboxShell();
+ }
+ }
+}
diff --git a/src/Controls/samples/Controls.Sample.Sandbox/ToolbarTestPage.xaml b/src/Controls/samples/Controls.Sample.Sandbox/ToolbarTestPage.xaml
new file mode 100644
index 000000000000..9e4284047dd4
--- /dev/null
+++ b/src/Controls/samples/Controls.Sample.Sandbox/ToolbarTestPage.xaml
@@ -0,0 +1,84 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/Controls/samples/Controls.Sample.Sandbox/ToolbarTestPage.xaml.cs b/src/Controls/samples/Controls.Sample.Sandbox/ToolbarTestPage.xaml.cs
new file mode 100644
index 000000000000..304e432ea58e
--- /dev/null
+++ b/src/Controls/samples/Controls.Sample.Sandbox/ToolbarTestPage.xaml.cs
@@ -0,0 +1,93 @@
+using Microsoft.Maui.Controls;
+
+namespace Maui.Controls.Sample
+{
+ public partial class ToolbarTestPage : ContentPage
+ {
+ private int _toolbarItemCounter = 1;
+
+ public ToolbarTestPage()
+ {
+ InitializeComponent();
+ }
+
+ private void OnAddClicked(object? sender, EventArgs e)
+ {
+ StatusLabel.Text = "Status: Add clicked";
+ }
+
+ private void OnEditClicked(object? sender, EventArgs e)
+ {
+ StatusLabel.Text = "Status: Edit clicked";
+ }
+
+ private void OnDeleteClicked(object? sender, EventArgs e)
+ {
+ StatusLabel.Text = "Status: Delete clicked";
+ }
+
+ private void OnShareClicked(object? sender, EventArgs e)
+ {
+ StatusLabel.Text = "Status: Share clicked";
+ }
+
+ private void OnMoreClicked(object? sender, EventArgs e)
+ {
+ StatusLabel.Text = "Status: More clicked";
+ }
+
+ private void OnAddToolbarItemClicked(object? sender, EventArgs e)
+ {
+ var newItem = new ToolbarItem
+ {
+ Text = $"Dynamic {_toolbarItemCounter++}",
+ Order = ToolbarItemOrder.Secondary
+ };
+ newItem.Clicked += (s, args) => StatusLabel.Text = $"Status: {newItem.Text} clicked";
+ ToolbarItems.Add(newItem);
+ StatusLabel.Text = $"Status: Added {newItem.Text} toolbar item";
+ }
+
+ private void OnRemoveToolbarItemClicked(object? sender, EventArgs e)
+ {
+ if (ToolbarItems.Count > 0)
+ {
+ var lastItem = ToolbarItems[ToolbarItems.Count - 1];
+ ToolbarItems.Remove(lastItem);
+ StatusLabel.Text = $"Status: Removed toolbar item";
+ }
+ else
+ {
+ StatusLabel.Text = "Status: No toolbar items to remove";
+ }
+ }
+
+ private void OnToggleEnabledClicked(object? sender, EventArgs e)
+ {
+ if (ToolbarItems.Count > 0)
+ {
+ var firstItem = ToolbarItems[0];
+ firstItem.IsEnabled = !firstItem.IsEnabled;
+ StatusLabel.Text = $"Status: First toolbar item enabled = {firstItem.IsEnabled}";
+ }
+ }
+
+ private void OnChangeTitleClicked(object? sender, EventArgs e)
+ {
+ Title = $"Changed {DateTime.Now:HH:mm:ss}";
+ StatusLabel.Text = $"Status: Title changed to '{Title}'";
+ }
+
+ private void OnLongTitleClicked(object? sender, EventArgs e)
+ {
+ Title = "This is a Very Long Title That Should Test Text Wrapping or Truncation";
+ StatusLabel.Text = "Status: Long title set";
+ }
+
+ private void OnResetTitleClicked(object? sender, EventArgs e)
+ {
+ Title = "Toolbar Test";
+ StatusLabel.Text = "Status: Title reset";
+ }
+ }
+}
From ef1f21fa3cd964c182027477d6f3731219d9ef23 Mon Sep 17 00:00:00 2001
From: Tamilarasan Paranthaman
<93904422+Tamilarasan-Paranthaman@users.noreply.github.com>
Date: Mon, 2 Mar 2026 18:39:21 +0530
Subject: [PATCH 02/26] Android Shell Handler
---
.../ShellFlyoutTemplatedContentRenderer.cs | 74 +-
.../Shell/Android/ShellToolbarTracker.cs | 22 +-
.../Shell/ShellContentHandler.Android.cs | 59 +
.../Handlers/Shell/ShellContentHandler.cs | 42 +
.../Handlers/Shell/ShellHandler.Android.cs | 475 ++++++++
.../Shell/ShellItemHandler.Android.cs | 1045 ++++++++++++++++
.../Shell/ShellSectionHandler.Android.cs | 1078 +++++++++++++++++
.../Core/Hosting/AppHostBuilderExtensions.cs | 4 +-
.../Android/BottomNavigationManager.cs | 486 ++++++++
.../src/Core/Platform/Android/ITabItem.cs | 97 ++
.../Platform/Android/TabbedPageManager.cs | 278 +++--
.../FlyoutView/FlyoutViewHandler.Android.cs | 195 +--
.../src/Platform/Android/MauiDrawerLayout.cs | 546 +++++++++
.../Navigation/StackNavigationManager.cs | 60 +-
.../net-android/PublicAPI.Unshipped.txt | 61 +
15 files changed, 4200 insertions(+), 322 deletions(-)
create mode 100644 src/Controls/src/Core/Handlers/Shell/ShellContentHandler.Android.cs
create mode 100644 src/Controls/src/Core/Handlers/Shell/ShellContentHandler.cs
create mode 100644 src/Controls/src/Core/Handlers/Shell/ShellHandler.Android.cs
create mode 100644 src/Controls/src/Core/Handlers/Shell/ShellItemHandler.Android.cs
create mode 100644 src/Controls/src/Core/Handlers/Shell/ShellSectionHandler.Android.cs
create mode 100644 src/Controls/src/Core/Platform/Android/BottomNavigationManager.cs
create mode 100644 src/Controls/src/Core/Platform/Android/ITabItem.cs
create mode 100644 src/Core/src/Platform/Android/MauiDrawerLayout.cs
diff --git a/src/Controls/src/Core/Compatibility/Handlers/Shell/Android/ShellFlyoutTemplatedContentRenderer.cs b/src/Controls/src/Core/Compatibility/Handlers/Shell/Android/ShellFlyoutTemplatedContentRenderer.cs
index 75c19f1ffb26..7ea1606cc362 100644
--- a/src/Controls/src/Core/Compatibility/Handlers/Shell/Android/ShellFlyoutTemplatedContentRenderer.cs
+++ b/src/Controls/src/Core/Compatibility/Handlers/Shell/Android/ShellFlyoutTemplatedContentRenderer.cs
@@ -21,6 +21,7 @@
using AView = Android.Views.View;
using LP = Android.Views.ViewGroup.LayoutParams;
+#pragma warning disable RS0016 // Add public types and members to the declared API
namespace Microsoft.Maui.Controls.Platform.Compatibility
{
public class ShellFlyoutTemplatedContentRenderer : Java.Lang.Object, IShellFlyoutContentRenderer
@@ -211,11 +212,6 @@ protected virtual void LoadView(IShellContext shellContext)
MauiWindowInsetListener.SetupViewWithLocalListener(coordinator, _windowsListener);
UpdateFlyoutHeaderBehavior();
- _shellContext.Shell.PropertyChanged += OnShellPropertyChanged;
-
- UpdateFlyoutBackground();
-
- UpdateVerticalScrollMode();
UpdateFlyoutFooter();
@@ -265,33 +261,7 @@ protected void OnElementSelected(Element element)
((IShellController)_shellContext.Shell).OnFlyoutItemSelected(element);
}
- protected virtual void OnShellPropertyChanged(object sender, PropertyChangedEventArgs e)
- {
- if (e.PropertyName == Shell.FlyoutHeaderBehaviorProperty.PropertyName)
- UpdateFlyoutHeaderBehavior();
- else if (e.IsOneOf(
- Shell.FlyoutBackgroundColorProperty,
- Shell.FlyoutBackgroundProperty,
- Shell.FlyoutBackgroundImageProperty,
- Shell.FlyoutBackgroundImageAspectProperty))
- UpdateFlyoutBackground();
- else if (e.Is(Shell.FlyoutVerticalScrollModeProperty))
- UpdateVerticalScrollMode();
- else if (e.IsOneOf(
- Shell.FlyoutHeaderProperty,
- Shell.FlyoutHeaderTemplateProperty))
- UpdateFlyoutHeader();
- else if (e.IsOneOf(
- Shell.FlyoutFooterProperty,
- Shell.FlyoutFooterTemplateProperty))
- UpdateFlyoutFooter();
- else if (e.IsOneOf(
- Shell.FlyoutContentProperty,
- Shell.FlyoutContentTemplateProperty))
- UpdateFlyoutContent();
- }
-
- protected virtual void UpdateFlyoutContent()
+ public virtual void UpdateFlyoutContent()
{
if (!_rootView.IsAlive())
return;
@@ -362,7 +332,7 @@ AView CreateFlyoutContent(ViewGroup rootView)
return _contentView.PlatformView;
}
- protected virtual void UpdateFlyoutHeader()
+ public virtual void UpdateFlyoutHeader()
{
if (_headerView != null)
{
@@ -374,10 +344,7 @@ protected virtual void UpdateFlyoutHeader()
oldHeaderView.Dispose();
}
- if (_flyoutHeader != null)
- {
- _flyoutHeader.MeasureInvalidated -= OnFlyoutHeaderMeasureInvalidated;
- }
+ _flyoutHeader?.MeasureInvalidated -= OnFlyoutHeaderMeasureInvalidated;
_flyoutHeader = ((IShellController)_shellContext.Shell).FlyoutHeader;
if (_flyoutHeader != null)
@@ -414,7 +381,7 @@ void OnHeaderViewLayoutChange(object sender, AView.LayoutChangeEventArgs e)
UpdateContentPadding();
}
- protected virtual void UpdateFlyoutFooter()
+ public virtual void UpdateFlyoutFooter()
{
if (_footerView != null)
{
@@ -427,9 +394,8 @@ protected virtual void UpdateFlyoutFooter()
var footer = ((IShellController)_shellContext.Shell).FlyoutFooter;
- if (footer == null)
+ if (footer is null)
{
- UpdateContentPadding();
return;
}
@@ -592,7 +558,7 @@ void OnFlyoutViewLayoutChanging()
}
}
- void UpdateVerticalScrollMode()
+ public virtual void UpdateVerticalScrollMode()
{
if (_flyoutContentView is RecyclerView rv && rv.GetLayoutManager() is ScrollLayoutManager lm)
{
@@ -600,10 +566,9 @@ void UpdateVerticalScrollMode()
}
}
- protected virtual void UpdateFlyoutBackground()
+ public virtual void UpdateFlyoutBackground()
{
var brush = _shellContext.Shell.FlyoutBackground;
-
if (Brush.IsNullOrEmpty(brush))
{
var color = _shellContext.Shell.FlyoutBackgroundColor;
@@ -672,7 +637,7 @@ void UpdateFlyoutBgImageAsync()
});
}
- protected virtual void UpdateFlyoutHeaderBehavior()
+ public virtual void UpdateFlyoutHeaderBehavior()
{
if (_headerView == null)
return;
@@ -734,11 +699,7 @@ internal void Disconnect()
MauiWindowInsetListener.RemoveViewWithLocalListener(coordinator);
}
- if (_shellContext?.Shell != null)
- _shellContext.Shell.PropertyChanged -= OnShellPropertyChanged;
-
- if (_flyoutHeader != null)
- _flyoutHeader.MeasureInvalidated -= OnFlyoutHeaderMeasureInvalidated;
+ _flyoutHeader?.MeasureInvalidated -= OnFlyoutHeaderMeasureInvalidated;
_flyoutHeader = null;
@@ -775,8 +736,7 @@ protected override void Dispose(bool disposing)
if (View != null && View is ShellFlyoutLayout sfl)
sfl.LayoutChanging -= OnFlyoutViewLayoutChanging;
- if (_headerView != null)
- _headerView.LayoutChange -= OnHeaderViewLayoutChange;
+ _headerView?.LayoutChange -= OnHeaderViewLayoutChange;
_contentView?.View = null;
@@ -814,8 +774,7 @@ public HeaderContainer(Context context, View view, IMauiContext mauiContext) : b
void Initialize(View view)
{
- if (view != null)
- view.PropertyChanged += OnViewPropertyChanged;
+ view?.PropertyChanged += OnViewPropertyChanged;
}
void OnViewPropertyChanged(object sender, PropertyChangedEventArgs e)
@@ -874,11 +833,8 @@ protected override void Dispose(bool disposing)
internal void Disconnect()
{
- if (View != null)
- {
- View.PropertyChanged -= OnViewPropertyChanged;
- View = null;
- }
+ View?.PropertyChanged -= OnViewPropertyChanged;
+ View = null;
}
internal void SetFlyoutHeaderBehavior(FlyoutHeaderBehavior flyoutHeaderBehavior)
@@ -984,4 +940,4 @@ public override bool CanScrollVertically()
}
}
}
-}
+}
\ No newline at end of file
diff --git a/src/Controls/src/Core/Compatibility/Handlers/Shell/Android/ShellToolbarTracker.cs b/src/Controls/src/Core/Compatibility/Handlers/Shell/Android/ShellToolbarTracker.cs
index d9a5480a7140..5a62c8a7d011 100644
--- a/src/Controls/src/Core/Compatibility/Handlers/Shell/Android/ShellToolbarTracker.cs
+++ b/src/Controls/src/Core/Compatibility/Handlers/Shell/Android/ShellToolbarTracker.cs
@@ -31,6 +31,7 @@
using Paint = Android.Graphics.Paint;
using R = Android.Resource;
+#pragma warning disable IDE0031 // Use null propagation
namespace Microsoft.Maui.Controls.Platform.Compatibility
{
public class ShellToolbarTracker : Java.Lang.Object, AView.IOnClickListener, IShellToolbarTracker, IFlyoutBehaviorObserver
@@ -102,7 +103,10 @@ public bool CanNavigateBack
{
get
{
- if (_page?.Navigation?.NavigationStack?.Count > 1)
+ var navStackCount = _page?.Navigation?.NavigationStack?.Count ?? 0;
+ var canNavFromStack = navStackCount > 1;
+
+ if (canNavFromStack)
return true;
return _canNavigateBack;
@@ -478,7 +482,9 @@ protected virtual async void UpdateLeftBarButtonItem(Context context, AToolbar t
defaultDrawerArrowDrawable = true;
}
- icon?.Progress = (CanNavigateBack) ? 1 : 0;
+ var canNav = CanNavigateBack;
+ var progress = canNav ? 1 : 0;
+ icon?.Progress = progress;
if (command != null || CanNavigateBack)
{
@@ -507,6 +513,11 @@ protected virtual async void UpdateLeftBarButtonItem(Context context, AToolbar t
_drawerToggle.SyncState();
+ // Re-apply icon Progress AFTER SyncState since SyncState resets it to 0
+ if (icon is not null)
+ {
+ icon.Progress = progress;
+ }
//this needs to be set after SyncState
UpdateToolbarIconAccessibilityText(toolbar, _shell);
@@ -691,6 +702,13 @@ protected virtual void UpdateToolbarItems(AToolbar toolbar, Page page)
}
else
{
+ // BUG FIX: Remove the collapsible search menu item when navigating to a page without SearchHandler
+ // Previously, only _searchView was cleaned up, but the menu item remained visible
+ if (menu.FindItem(_placeholderMenuItemId) is not null)
+ {
+ menu.RemoveItem(_placeholderMenuItemId);
+ }
+
if (_searchView != null)
{
_searchView.View.RemoveFromParent();
diff --git a/src/Controls/src/Core/Handlers/Shell/ShellContentHandler.Android.cs b/src/Controls/src/Core/Handlers/Shell/ShellContentHandler.Android.cs
new file mode 100644
index 000000000000..52f08974adfe
--- /dev/null
+++ b/src/Controls/src/Core/Handlers/Shell/ShellContentHandler.Android.cs
@@ -0,0 +1,59 @@
+#nullable disable
+#if ANDROID
+using System;
+using Android.Views;
+using Microsoft.Maui.Handlers;
+using Microsoft.Maui.Platform;
+using AView = Android.Views.View;
+
+#pragma warning disable RS0016 // Add public types and members to the declared API
+namespace Microsoft.Maui.Controls.Handlers
+{
+ ///
+ /// Android implementation of ShellContentHandler.
+ ///
+ /// This handler simply returns the content page's platform view.
+ /// It provides a clean separation between Shell structure and page content.
+ ///
+ public partial class ShellContentHandler : ElementHandler
+ {
+ ///
+ /// Creates the platform view for the ShellContent.
+ /// Returns the content page's Android view.
+ ///
+ protected override AView CreatePlatformElement()
+ {
+ // Get the page from ShellContent and convert it to platform view
+ var page = ((IShellContentController)VirtualView).GetOrCreateContent();
+
+ if (page is null)
+ {
+ // Return empty view if no content
+ return new AView(MauiContext?.Context);
+ }
+
+ // Convert the page to its Android platform view
+ return page.ToPlatform(MauiContext);
+ }
+
+ ///
+ /// Connects the handler to the platform view.
+ /// Minimal setup needed since this is just a wrapper.
+ ///
+ protected override void ConnectHandler(AView platformView)
+ {
+ base.ConnectHandler(platformView);
+ }
+
+ ///
+ /// Disconnects the handler from the platform view.
+ /// Cleanup any resources.
+ ///
+ protected override void DisconnectHandler(AView platformView)
+ {
+
+ base.DisconnectHandler(platformView);
+ }
+ }
+}
+#endif
diff --git a/src/Controls/src/Core/Handlers/Shell/ShellContentHandler.cs b/src/Controls/src/Core/Handlers/Shell/ShellContentHandler.cs
new file mode 100644
index 000000000000..24da56c9618c
--- /dev/null
+++ b/src/Controls/src/Core/Handlers/Shell/ShellContentHandler.cs
@@ -0,0 +1,42 @@
+#nullable disable
+#if ANDROID
+using System;
+using Microsoft.Maui.Handlers;
+
+#pragma warning disable RS0016 // Add public types and members to the declared API
+namespace Microsoft.Maui.Controls.Handlers
+{
+ ///
+ /// Handler for ShellContent - lightweight wrapper for page content.
+ /// Phase 4 of Shell Handler Migration.
+ ///
+ public partial class ShellContentHandler
+ {
+
+ public static PropertyMapper Mapper =
+ new PropertyMapper(ElementMapper)
+ {
+ [nameof(ShellContent.Title)] = MapTitle
+ };
+
+ public static CommandMapper CommandMapper =
+ new CommandMapper(ElementCommandMapper);
+
+ public ShellContentHandler() : base(Mapper, CommandMapper)
+ {
+ }
+
+ ///
+ /// Maps the Title property to notify parent handlers to update.
+ ///
+ internal static void MapTitle(ShellContentHandler handler, ShellContent item)
+ {
+ // Notify parent ShellSection/ShellItem handlers that title changed
+ var shellSection = item?.Parent as ShellSection;
+ var shellItem = shellSection?.Parent as ShellItem;
+ var shellItemHandler = shellItem?.Handler as ShellItemHandler;
+ // shellItemHandler?.UpdateTitle();
+ }
+ }
+}
+#endif
diff --git a/src/Controls/src/Core/Handlers/Shell/ShellHandler.Android.cs b/src/Controls/src/Core/Handlers/Shell/ShellHandler.Android.cs
new file mode 100644
index 000000000000..0f4dd7b66ca8
--- /dev/null
+++ b/src/Controls/src/Core/Handlers/Shell/ShellHandler.Android.cs
@@ -0,0 +1,475 @@
+#nullable disable
+#if ANDROID
+using System;
+using Android.Content;
+using Android.Views;
+using Android.Widget;
+using AndroidX.DrawerLayout.Widget;
+using AndroidX.Fragment.App;
+using Microsoft.Maui.Controls.Platform;
+using Microsoft.Maui.Controls.Platform.Compatibility;
+using Microsoft.Maui.Handlers;
+using Microsoft.Maui.Platform;
+using AView = Android.Views.View;
+using AToolbar = AndroidX.AppCompat.Widget.Toolbar;
+using LP = Android.Views.ViewGroup.LayoutParams;
+
+#pragma warning disable RS0016 // Add public types and members to the declared API
+
+namespace Microsoft.Maui.Controls.Handlers
+{
+ ///
+ /// Shell handler that uses MauiDrawerLayout (same infrastructure as FlyoutViewHandler).
+ /// This replaces the old ShellFlyoutRenderer-based approach.
+ ///
+ public partial class ShellHandler : ViewHandler, IShellContext, IAppearanceObserver
+ {
+ // MauiDrawerLayout is now the PlatformView (same as FlyoutViewHandler)
+ MauiDrawerLayout MauiDrawerLayout => PlatformView;
+
+ // Content frame that hosts ShellItem views
+ FrameLayout _contentFrame;
+
+ // Flyout content view (Shell's flyout menu)
+ AView _flyoutContentView;
+ IShellFlyoutContentRenderer _flyoutContentRenderer;
+
+ // Current shell item renderer
+ IShellItemRenderer _currentShellItemRenderer;
+
+ // Track flyout behavior for IShellContext
+ FlyoutBehavior _currentBehavior = FlyoutBehavior.Flyout;
+
+ public static PropertyMapper Mapper =
+ new PropertyMapper(ElementMapper)
+ {
+ [nameof(Shell.CurrentItem)] = MapCurrentItem,
+ [nameof(Shell.FlyoutIsPresented)] = MapFlyoutIsPresented,
+ [nameof(Shell.FlyoutBehavior)] = MapFlyoutBehavior,
+ [nameof(Shell.FlyoutWidth)] = MapFlyoutWidth,
+ [nameof(Shell.FlowDirection)] = MapFlowDirection,
+ [nameof(Shell.FlyoutBackdrop)] = MapFlyoutBackdrop,
+ [nameof(Shell.FlyoutBackground)] = MapFlyoutBackground,
+ [nameof(Shell.FlyoutBackgroundColor)] = MapFlyoutBackground,
+ [nameof(Shell.FlyoutBackgroundImage)] = MapFlyoutBackgroundImage,
+ [nameof(Shell.FlyoutBackgroundImageAspect)] = MapFlyoutBackgroundImage,
+ [nameof(Shell.FlyoutHeader)] = MapFlyoutHeader,
+ [nameof(Shell.FlyoutHeaderTemplate)] = MapFlyoutHeader,
+ [nameof(Shell.FlyoutFooter)] = MapFlyoutFooter,
+ [nameof(Shell.FlyoutFooterTemplate)] = MapFlyoutFooter,
+ [nameof(Shell.FlyoutHeaderBehavior)] = MapFlyoutHeaderBehavior,
+ [nameof(Shell.FlyoutVerticalScrollMode)] = MapFlyoutVerticalScrollMode,
+ [nameof(Shell.FlyoutContent)] = MapFlyoutContent,
+ [nameof(Shell.FlyoutContentTemplate)] = MapFlyoutContent,
+ };
+
+ public static CommandMapper CommandMapper =
+ new CommandMapper(ElementCommandMapper);
+
+ public ShellHandler() : base(Mapper, CommandMapper)
+ {
+ }
+
+ protected override MauiDrawerLayout CreatePlatformView()
+ {
+ // Create MauiDrawerLayout (same as FlyoutViewHandler)
+ var drawerLayout = new MauiDrawerLayout(Context);
+
+ // Create the content frame that will host shell items
+ _contentFrame = new FrameLayout(Context)
+ {
+ LayoutParameters = new LP(LP.MatchParent, LP.MatchParent),
+ Id = AView.GenerateViewId(),
+ };
+
+ // Set the content frame as the main content
+ drawerLayout.SetContentView(_contentFrame);
+
+ return drawerLayout;
+ }
+
+ protected override void ConnectHandler(MauiDrawerLayout platformView)
+ {
+ base.ConnectHandler(platformView);
+
+ VirtualView.PropertyChanged += OnShellPropertyChanged;
+
+ // Add appearance observer similar to ShellRenderer
+ ((IShellController)VirtualView).AddAppearanceObserver(this, VirtualView);
+
+ // Subscribe to drawer state changes
+ platformView.OnPresentedChanged += OnFlyoutPresentedChanged;
+
+ // Initialize flyout behavior
+ var behavior = (VirtualView as IFlyoutView)?.FlyoutBehavior ?? FlyoutBehavior.Flyout;
+ _currentBehavior = behavior;
+ UpdateFlyoutBehaviorInternal(behavior);
+
+ // Initialize with current item if it exists
+ if (VirtualView.CurrentItem is not null)
+ {
+ SwitchToItem(VirtualView.CurrentItem, animate: false);
+ }
+ }
+
+ protected override void DisconnectHandler(MauiDrawerLayout platformView)
+ {
+ if (VirtualView is not null)
+ {
+ VirtualView.PropertyChanged -= OnShellPropertyChanged;
+ ((IShellController)VirtualView).RemoveAppearanceObserver(this);
+ }
+
+ platformView.OnPresentedChanged -= OnFlyoutPresentedChanged;
+
+ _currentShellItemRenderer?.Dispose();
+ _currentShellItemRenderer = null;
+
+ if (_flyoutContentRenderer is IDisposable disposable)
+ {
+ disposable.Dispose();
+ }
+ _flyoutContentRenderer = null;
+ _flyoutContentView = null;
+
+ // Disconnect MauiDrawerLayout
+ platformView.Disconnect();
+
+ base.DisconnectHandler(platformView);
+ }
+
+ void OnFlyoutPresentedChanged(bool isPresented)
+ {
+ // Sync the Shell's FlyoutIsPresented property with actual drawer state
+ if (_currentBehavior == FlyoutBehavior.Flyout)
+ {
+ VirtualView.SetValueFromRenderer(Shell.FlyoutIsPresentedProperty, isPresented);
+ }
+ }
+
+ void OnShellPropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
+ {
+ // Property changes are handled via PropertyMapper
+ }
+
+ void SwitchToItem(ShellItem newItem, bool animate)
+ {
+ if (newItem is null)
+ {
+ return;
+ }
+
+ var fragmentManager = VirtualView.FindMauiContext()?.GetFragmentManager();
+ if (fragmentManager is null || _contentFrame is null)
+ {
+ return;
+ }
+
+ var previousRenderer = _currentShellItemRenderer;
+
+ _currentShellItemRenderer = CreateShellItemRenderer(newItem);
+ _currentShellItemRenderer.ShellItem = newItem;
+
+ var fragment = _currentShellItemRenderer.Fragment;
+ var transaction = fragmentManager.BeginTransactionEx();
+
+ if (animate)
+ {
+ transaction.SetTransitionEx((int)global::Android.App.FragmentTransit.FragmentOpen);
+ }
+
+ transaction.ReplaceEx(_contentFrame.Id, fragment);
+ transaction.SetReorderingAllowedEx(true);
+ transaction.CommitAllowingStateLossEx();
+
+ // Force the fragment transaction to complete synchronously
+ fragmentManager.ExecutePendingTransactions();
+
+ if (previousRenderer is not null)
+ {
+ void OnDestroyed(object sender, EventArgs args)
+ {
+ previousRenderer.Destroyed -= OnDestroyed;
+ previousRenderer = null;
+ }
+ previousRenderer.Destroyed += OnDestroyed;
+ }
+ }
+
+ public static void MapCurrentItem(ShellHandler handler, Shell shell)
+ {
+ handler.SwitchToItem(shell.CurrentItem, animate: true);
+ }
+
+ public static void MapFlyoutIsPresented(ShellHandler handler, Shell shell)
+ {
+ // Use MauiDrawerLayout's open/close methods
+ if (handler.MauiDrawerLayout is not null)
+ {
+ if (shell.FlyoutIsPresented)
+ {
+ handler.MauiDrawerLayout.OpenFlyout();
+ }
+ else
+ {
+ handler.MauiDrawerLayout.CloseFlyout();
+ }
+ }
+ }
+
+ public static void MapFlyoutBehavior(ShellHandler handler, Shell shell)
+ {
+ var behavior = (shell as IFlyoutView).FlyoutBehavior;
+ handler.UpdateFlyoutBehaviorInternal(behavior);
+ }
+
+ void UpdateFlyoutBehaviorInternal(FlyoutBehavior behavior)
+ {
+ _currentBehavior = behavior;
+
+ // Ensure flyout content is added for non-disabled behaviors
+ if (behavior != FlyoutBehavior.Disabled)
+ {
+ EnsureFlyoutContentCreated();
+ }
+
+ // Use MauiDrawerLayout's SetBehavior method
+ MauiDrawerLayout?.SetBehavior(behavior);
+
+ // Update content padding for locked mode
+ if (behavior == FlyoutBehavior.Locked && _contentFrame is not null)
+ {
+ var padding = MauiDrawerLayout?.GetLockedContentPadding() ?? 0;
+ _contentFrame.SetPadding(padding, _contentFrame.PaddingTop, _contentFrame.PaddingRight, _contentFrame.PaddingBottom);
+ }
+ else
+ {
+ _contentFrame?.SetPadding(0, _contentFrame.PaddingTop, _contentFrame.PaddingRight, _contentFrame.PaddingBottom);
+ }
+
+ // Sync Shell property
+ if (behavior == FlyoutBehavior.Locked)
+ {
+ VirtualView?.SetValueFromRenderer(Shell.FlyoutIsPresentedProperty, true);
+ }
+ else if (behavior == FlyoutBehavior.Disabled)
+ {
+ VirtualView?.SetValueFromRenderer(Shell.FlyoutIsPresentedProperty, false);
+ }
+ }
+
+ void EnsureFlyoutContentCreated()
+ {
+ if (_flyoutContentView is not null)
+ return;
+
+ // Create the flyout content renderer
+ _flyoutContentRenderer = CreateShellFlyoutContentRenderer();
+ _flyoutContentView = _flyoutContentRenderer.AndroidView;
+
+ if (_flyoutContentView is not null)
+ {
+ // Set flyout width from MauiDrawerLayout's default calculation
+ var flyoutWidth = VirtualView.FlyoutWidth;
+ if (flyoutWidth == -1)
+ {
+ flyoutWidth = MauiDrawerLayout.DefaultFlyoutWidth;
+ }
+ else
+ {
+ flyoutWidth = Context.ToPixels(flyoutWidth);
+ }
+
+ MauiDrawerLayout.FlyoutWidth = flyoutWidth;
+ MauiDrawerLayout.SetFlyoutView(_flyoutContentView);
+ }
+ }
+
+ public static void MapFlyoutWidth(ShellHandler handler, Shell shell)
+ {
+ // Update the flyout width using MauiDrawerLayout
+ if (handler.MauiDrawerLayout is not null)
+ {
+ var width = shell.FlyoutWidth;
+ if (width == -1)
+ {
+ width = handler.MauiDrawerLayout.DefaultFlyoutWidth;
+ }
+ else
+ {
+ width = handler.Context.ToPixels(width);
+ }
+
+ handler.MauiDrawerLayout.FlyoutWidth = width;
+
+ // Update the flyout view's layout params
+ if (handler._flyoutContentView?.LayoutParameters is not null)
+ {
+ handler._flyoutContentView.LayoutParameters.Width = (int)width;
+ handler._flyoutContentView.RequestLayout();
+ }
+ }
+ }
+
+ public static void MapFlowDirection(ShellHandler handler, Shell shell)
+ {
+ // Update the flow direction on the MauiDrawerLayout
+ if (handler.MauiDrawerLayout is null)
+ {
+ return;
+ }
+
+ handler.MauiDrawerLayout.LayoutDirection = shell.FlowDirection.ToLayoutDirection();
+ }
+
+ public static void MapFlyoutBackdrop(ShellHandler handler, Shell shell)
+ {
+ // TODO: Implement scrim/backdrop for MauiDrawerLayout
+ // For now, use default DrawerLayout scrim
+ }
+
+ public static void MapFlyoutBackground(ShellHandler handler, Shell shell)
+ {
+ // Update the flyout content renderer when background changes
+ if (handler._flyoutContentRenderer is ShellFlyoutTemplatedContentRenderer templatedRenderer)
+ {
+ templatedRenderer.UpdateFlyoutBackground();
+ }
+ }
+
+ public static void MapFlyoutBackgroundImage(ShellHandler handler, Shell shell)
+ {
+ // Update the flyout content renderer when background image changes
+ if (handler._flyoutContentRenderer is ShellFlyoutTemplatedContentRenderer templatedRenderer)
+ {
+ templatedRenderer.UpdateFlyoutBackground();
+ }
+ }
+
+ public static void MapFlyoutHeader(ShellHandler handler, Shell shell)
+ {
+ // Update the flyout header when it changes
+ if (handler._flyoutContentRenderer is ShellFlyoutTemplatedContentRenderer templatedRenderer)
+ {
+ templatedRenderer.UpdateFlyoutHeader();
+ }
+ }
+
+ public static void MapFlyoutFooter(ShellHandler handler, Shell shell)
+ {
+ // Update the flyout footer when it changes
+ if (handler._flyoutContentRenderer is ShellFlyoutTemplatedContentRenderer templatedRenderer)
+ {
+ templatedRenderer.UpdateFlyoutFooter();
+ }
+ }
+
+ public static void MapFlyoutHeaderBehavior(ShellHandler handler, Shell shell)
+ {
+ // Update the flyout header behavior when it changes
+ if (handler._flyoutContentRenderer is ShellFlyoutTemplatedContentRenderer templatedRenderer)
+ {
+ templatedRenderer.UpdateFlyoutHeaderBehavior();
+ }
+ }
+
+ public static void MapFlyoutVerticalScrollMode(ShellHandler handler, Shell shell)
+ {
+ // Update the flyout vertical scroll mode when it changes
+ if (handler._flyoutContentRenderer is ShellFlyoutTemplatedContentRenderer templatedRenderer)
+ {
+ templatedRenderer.UpdateVerticalScrollMode();
+ }
+ }
+
+ public static void MapFlyoutContent(ShellHandler handler, Shell shell)
+ {
+ // Update the flyout content when it changes
+ if (handler._flyoutContentRenderer is ShellFlyoutTemplatedContentRenderer templatedRenderer)
+ {
+ templatedRenderer.UpdateFlyoutContent();
+ }
+ }
+
+ protected virtual IShellItemRenderer CreateShellItemRenderer(ShellItem shellItem)
+ {
+ // Use the new handler-based architecture
+ var handler = new ShellItemHandler();
+ handler.SetMauiContext(MauiContext);
+ handler.SetVirtualView(shellItem);
+
+ // Wrap it in an adapter to make it compatible with IShellItemRenderer
+ return new ShellItemHandlerAdapter(handler, MauiContext);
+ }
+
+ protected virtual IShellFlyoutContentRenderer CreateShellFlyoutContentRenderer()
+ {
+ return new ShellFlyoutTemplatedContentRenderer(this);
+ }
+
+ #region IShellContext Implementation
+
+ Context IShellContext.AndroidContext => Context;
+
+ // Return MauiDrawerLayout (which IS a DrawerLayout)
+ DrawerLayout IShellContext.CurrentDrawerLayout => MauiDrawerLayout;
+
+ Shell IShellContext.Shell => VirtualView;
+
+ IShellObservableFragment IShellContext.CreateFragmentForPage(Page page)
+ {
+ return new ShellContentFragment(this, page);
+ }
+
+ IShellFlyoutContentRenderer IShellContext.CreateShellFlyoutContentRenderer()
+ {
+ return new ShellFlyoutTemplatedContentRenderer(this);
+ }
+
+ IShellItemRenderer IShellContext.CreateShellItemRenderer(ShellItem shellItem)
+ {
+ return CreateShellItemRenderer(shellItem);
+ }
+
+ IShellSectionRenderer IShellContext.CreateShellSectionRenderer(ShellSection shellSection)
+ {
+ var handler = new ShellSectionHandler();
+ handler.SetMauiContext(MauiContext);
+ handler.SetVirtualView(shellSection);
+
+ return new ShellSectionHandlerAdapter(handler, MauiContext);
+ }
+
+ IShellToolbarTracker IShellContext.CreateTrackerForToolbar(AToolbar toolbar)
+ {
+ return new ShellToolbarTracker(this, toolbar, MauiDrawerLayout);
+ }
+
+ IShellToolbarAppearanceTracker IShellContext.CreateToolbarAppearanceTracker()
+ {
+ return new ShellToolbarAppearanceTracker(this);
+ }
+
+ IShellTabLayoutAppearanceTracker IShellContext.CreateTabLayoutAppearanceTracker(ShellSection shellSection)
+ {
+ return new ShellTabLayoutAppearanceTracker(this);
+ }
+
+ IShellBottomNavViewAppearanceTracker IShellContext.CreateBottomNavViewAppearanceTracker(ShellItem shellItem)
+ {
+ return new ShellBottomNavViewAppearanceTracker(this, shellItem);
+ }
+
+ #endregion
+
+ #region IAppearanceObserver
+
+ void IAppearanceObserver.OnAppearanceChanged(ShellAppearance appearance)
+ {
+ // Appearance changes handled by appearance trackers
+ }
+
+ #endregion
+ }
+}
+#endif
diff --git a/src/Controls/src/Core/Handlers/Shell/ShellItemHandler.Android.cs b/src/Controls/src/Core/Handlers/Shell/ShellItemHandler.Android.cs
new file mode 100644
index 000000000000..4360a3dffdd5
--- /dev/null
+++ b/src/Controls/src/Core/Handlers/Shell/ShellItemHandler.Android.cs
@@ -0,0 +1,1045 @@
+#nullable disable
+#if ANDROID
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Android.Content;
+using Android.OS;
+using Android.Views;
+using Android.Widget;
+using AndroidX.CoordinatorLayout.Widget;
+using AndroidX.Fragment.App;
+using AndroidX.RecyclerView.Widget;
+using AndroidX.ViewPager2.Adapter;
+using AndroidX.ViewPager2.Widget;
+using Google.Android.Material.AppBar;
+using Google.Android.Material.BottomNavigation;
+using Google.Android.Material.Navigation;
+using Microsoft.Maui.Controls.Internals;
+using Microsoft.Maui.Controls.Platform;
+using Microsoft.Maui.Controls.Platform.Compatibility;
+using Microsoft.Maui.Handlers;
+using Microsoft.Maui.Platform;
+using AToolbar = AndroidX.AppCompat.Widget.Toolbar;
+using AView = Android.Views.View;
+using LP = Android.Views.ViewGroup.LayoutParams;
+
+#pragma warning disable RS0016 // Add public types and members to the declared API
+
+namespace Microsoft.Maui.Controls.Handlers
+{
+ ///
+ /// Handler for ShellItem on Android. Uses ViewPager2 for tab navigation (same as TabbedPageManager).
+ /// Now also manages the shared toolbar for all sections (moved from ShellSectionHandler).
+ ///
+ public partial class ShellItemHandler : ElementHandler, IAppearanceObserver
+ {
+ ViewPager2 _viewPager;
+ BottomNavigationView _bottomNavigationView;
+ BottomNavigationManager _bottomNavigationManager; // Shared component for bottom nav management
+ ShellSectionFragmentAdapter _adapter;
+ ShellItemPageChangeCallback _pageChangeCallback;
+ IShellContext _shellContext;
+ Fragment _parentFragment; // The wrapper fragment that hosts this handler
+ IShellBottomNavViewAppearanceTracker _appearanceTracker;
+ ShellSection _shellSection;
+ Page _displayedPage;
+ bool _isNavigating; // Prevent recursive navigation
+
+ // Shared toolbar components (moved from ShellSectionHandler)
+ internal Toolbar _shellToolbar; // Virtual Toolbar view
+ internal AToolbar _toolbar; // Native platform toolbar
+ internal IShellToolbarTracker _toolbarTracker;
+ IShellToolbarAppearanceTracker _toolbarAppearanceTracker;
+ internal AppBarLayout _appBarLayout;
+
+ ///
+ /// Property mapper for ShellItem properties.
+ ///
+ public static PropertyMapper Mapper = new PropertyMapper(ElementMapper)
+ {
+ [nameof(ShellItem.CurrentItem)] = MapCurrentItem,
+ };
+
+ ///
+ /// Command mapper for ShellItem commands.
+ ///
+ public static CommandMapper CommandMapper = new CommandMapper(ElementCommandMapper);
+
+ ///
+ /// Initializes a new instance of the ShellItemHandler class.
+ ///
+ public ShellItemHandler() : base(Mapper, CommandMapper)
+ {
+ }
+
+ ///
+ /// Sets the parent fragment that hosts this handler. Used for child fragment management.
+ ///
+ internal void SetParentFragment(Fragment fragment)
+ {
+ _parentFragment = fragment;
+ }
+
+ ///
+ /// Creates the platform element (ViewPager2) for the ShellItem.
+ /// This is the same pattern as TabbedPageManager.
+ ///
+ protected override ViewPager2 CreatePlatformElement()
+ {
+ var context = MauiContext?.Context ?? throw new InvalidOperationException("MauiContext cannot be null");
+
+ // Use shared factory methods for ViewPager2 and BottomNavigationView creation
+ _viewPager = BottomNavigationManager.CreateViewPager2(context);
+ _bottomNavigationView = BottomNavigationManager.CreateBottomNavigationView(context);
+
+ return _viewPager;
+ }
+
+ ///
+ /// Gets the BottomNavigationView for external layout management.
+ /// The parent (ShellHandler or wrapper) should add this to the layout.
+ ///
+ public BottomNavigationView BottomNavigationView => _bottomNavigationView;
+
+ ///
+ /// Gets the IShellContext from the ShellHandler.
+ ///
+ IShellContext GetShellContext()
+ {
+ var shell = VirtualView?.FindParentOfType();
+ if (shell?.Handler is IShellContext context)
+ return context;
+
+ throw new InvalidOperationException("ShellHandler must implement IShellContext");
+ }
+
+ ///
+ /// Sets up the ViewPager2 adapter for ShellSections.
+ /// Called from OnViewCreated in the wrapper fragment.
+ ///
+ internal void SetupViewPagerAdapter()
+ {
+ if (_viewPager is null || VirtualView is null || _parentFragment is null)
+ return;
+
+ var shellSections = ((IShellItemController)VirtualView).GetItems();
+ if (shellSections is null || shellSections.Count == 0)
+ return;
+
+ _shellContext ??= GetShellContext();
+
+ // Create adapter with child fragment manager
+ _adapter = new ShellSectionFragmentAdapter(
+ _parentFragment.ChildFragmentManager,
+ _parentFragment.Lifecycle,
+ shellSections,
+ _shellContext);
+
+ _viewPager.Adapter = _adapter;
+
+ // Register page change callback
+ _pageChangeCallback = new ShellItemPageChangeCallback(this);
+ _viewPager.RegisterOnPageChangeCallback(_pageChangeCallback);
+ }
+
+ ///
+ /// Sets up the bottom navigation view with section tabs using BottomNavigationManager.
+ /// This enables code sharing with TabbedPage bottom navigation.
+ ///
+ void SetupBottomNavigation()
+ {
+ if (_bottomNavigationView is null || VirtualView is null || MauiContext is null)
+ {
+ return;
+ }
+
+ var shellSections = ((IShellItemController)VirtualView).GetItems();
+
+ if (shellSections is null || shellSections.Count == 0)
+ {
+ return;
+ }
+
+ // Create BottomNavigationManager if not already created
+ _bottomNavigationManager ??= new BottomNavigationManager(MauiContext, _bottomNavigationView);
+
+ // Set up the tab selection callback
+ _bottomNavigationManager.OnTabSelected = OnTabSelected;
+
+ // Convert ShellSections to ITabItem using the adapter
+ var tabItems = new List();
+ foreach (var section in shellSections)
+ {
+ tabItems.Add(new ShellSectionTabItem(section));
+ }
+
+ // Get current selection index
+ var currentIndex = shellSections.IndexOf(VirtualView.CurrentItem);
+
+ // Use the shared manager to setup tabs
+ _bottomNavigationManager.SetupTabs(tabItems, currentIndex >= 0 ? currentIndex : 0);
+ }
+
+ ///
+ /// Handles tab selection from BottomNavigationManager callback.
+ ///
+ void OnTabSelected(int index)
+ {
+ if (VirtualView is null || _isNavigating)
+ {
+ return;
+ }
+
+ var items = ((IShellItemController)VirtualView).GetItems();
+
+ if (items is null || index < 0 || index >= items.Count)
+ {
+ return;
+ }
+
+ // Update ViewPager2 position
+ if (_viewPager?.CurrentItem != index)
+ {
+ _isNavigating = true;
+ _viewPager.SetCurrentItem(index, true);
+ _isNavigating = false;
+ }
+
+ var selectedSection = items[index];
+
+ if (selectedSection != VirtualView.CurrentItem)
+ {
+ VirtualView.CurrentItem = selectedSection;
+ }
+ }
+
+ ///
+ /// Called when ViewPager2 page changes.
+ ///
+ internal void OnPageSelected(int position)
+ {
+ if (VirtualView is null)
+ return;
+
+ var items = ((IShellItemController)VirtualView).GetItems();
+ if (items is null || position < 0 || position >= items.Count)
+ return;
+
+ var selectedSection = items[position];
+
+ // Skip the rest if we're already navigating programmatically
+ if (_isNavigating)
+ return;
+
+ _isNavigating = true;
+
+ // Update bottom navigation selection
+ _bottomNavigationManager?.SetSelectedItem(position);
+
+ // CRITICAL: Update CurrentItem BEFORE updating toolbar
+ // This ensures Shell.Navigation.NavigationStack returns the NEW section's stack
+ // when ShellToolbar.ApplyChanges() calculates BackButtonVisible
+ if (selectedSection != VirtualView.CurrentItem)
+ {
+ VirtualView.CurrentItem = selectedSection;
+ }
+
+ // Track the current section
+ _shellSection = selectedSection;
+
+ // Track displayed page changes
+ ((IShellSectionController)selectedSection).AddDisplayedPageObserver(this, UpdateDisplayedPage);
+
+ _isNavigating = false;
+
+ // Update toolbar title/items for the new section AFTER CurrentItem is set
+ // This handles title updates - appearance is updated via the observer pattern
+ UpdateToolbarForSection(selectedSection);
+ }
+
+ ///
+ /// Legacy method kept for compatibility - icon loading now handled by BottomNavigationManager via ITabItem.
+ ///
+ [Obsolete("Icon loading is now handled by BottomNavigationManager via ShellSectionTabItem")]
+ async void SetMenuItemIconAsync(IMenuItem menuItem, ShellSection section)
+ {
+ if (section.Icon is null)
+ {
+ return;
+ }
+
+ try
+ {
+ var context = MauiContext?.Context;
+
+ if (context is null)
+ {
+ return;
+ }
+
+ var icon = await section.Icon.GetPlatformImageAsync(MauiContext);
+
+ if (icon is not null && menuItem is not null)
+ {
+ menuItem.SetIcon(icon.Value);
+ }
+ }
+ catch (Exception ex)
+ {
+ System.Diagnostics.Debug.WriteLine($"ShellItemHandler: Failed to load icon for {section.Title}: {ex.Message}");
+ }
+ }
+
+ ///
+ /// Switches to a new ShellSection using ViewPager2.
+ /// The ViewPager2 adapter handles the fragment management.
+ ///
+ internal void SwitchToSection(ShellSection newSection, bool animate)
+ {
+ if (newSection is null || _viewPager is null || VirtualView is null)
+ return;
+
+ var items = ((IShellItemController)VirtualView).GetItems();
+ if (items is null)
+ return;
+
+ var index = items.IndexOf(newSection);
+ if (index < 0)
+ return;
+
+ // Switch ViewPager2 to the new section
+ if (_viewPager.CurrentItem != index)
+ {
+ _isNavigating = true;
+ _viewPager.SetCurrentItem(index, animate);
+ _isNavigating = false;
+ }
+
+ // Update bottom navigation
+ _bottomNavigationManager?.SetSelectedItem(index);
+
+ // Track the current section
+ _shellSection = newSection;
+
+ // Track displayed page changes
+ ((IShellSectionController)newSection).AddDisplayedPageObserver(this, UpdateDisplayedPage);
+ }
+
+ #region Navigation Support
+
+ ///
+ /// Hook up navigation events for a shell section.
+ /// NOTE: Navigation is now handled by ShellSectionHandler's StackNavigationManager
+ /// We no longer need to subscribe to NavigationRequested at the ShellItem level
+ ///
+ protected virtual void HookChildEvents(ShellSection shellSection)
+ {
+ // No longer needed - ShellSectionHandler handles its own navigation
+ }
+
+ ///
+ /// Unhook navigation events for a shell section.
+ ///
+ protected virtual void UnhookChildEvents(ShellSection shellSection)
+ {
+ if (shellSection is null)
+ {
+ return;
+ }
+
+ ((IShellSectionController)shellSection).RemoveDisplayedPageObserver(this);
+ }
+
+ ///
+ /// Helper method to count non-null pages and get the top page from a stack.
+ /// Returns (topPage, canNavigateBack).
+ ///
+ static (Page topPage, bool canNavigateBack) GetStackInfo(IReadOnlyList stack)
+ {
+ if (stack is null || stack.Count == 0)
+ return (null, false);
+
+ Page topPage = null;
+ int nonNullCount = 0;
+
+ // Single pass: find top page and count non-null pages
+ for (int i = stack.Count - 1; i >= 0; i--)
+ {
+ var page = stack[i];
+ if (page is not null)
+ {
+ nonNullCount++;
+ topPage ??= page; // First non-null from top is the current page
+ }
+ }
+
+ return (topPage, nonNullCount > 1);
+ }
+
+ ///
+ /// Updates the displayed page reference AND updates the toolbar.
+ /// This is the key callback from Shell that ensures the toolbar reflects the currently displayed page.
+ ///
+ void UpdateDisplayedPage(Page page)
+ {
+ if (page is null || _displayedPage == page)
+ return;
+
+ _displayedPage = page;
+
+ // Get navigation state from the section's stack
+ var section = page.FindParentOfType();
+ var (_, canNavigateBack) = section is not null ? GetStackInfo(section.Stack) : (null, false);
+
+ // Update toolbar with page and navigation state
+ UpdateToolbar(page, canNavigateBack);
+ }
+
+ ///
+ /// Handles the back button press. Returns true if navigation was handled, false otherwise.
+ /// Back navigation is delegated to the current section's StackNavigationManager.
+ ///
+ internal bool OnBackButtonPressed()
+ {
+ if (_shellSection is null)
+ {
+ return false;
+ }
+
+ var stack = _shellSection.Stack;
+
+ // If we're at the root page, don't handle back - let the system handle it
+ if (stack.Count <= 1)
+ {
+ return false;
+ }
+
+ // We have pages in the stack, so we can pop
+ Task.Run(async () =>
+ {
+ try
+ {
+ await _shellSection.Navigation.PopAsync();
+ }
+ catch (Exception ex)
+ {
+ System.Diagnostics.Debug.WriteLine($"ShellItemHandler: Error handling back press: {ex}");
+ }
+ });
+
+ return true; // We handled the back press
+ }
+
+ #endregion Navigation Support
+
+ ///
+ /// Maps the CurrentItem property to switch the displayed section.
+ ///
+ public static void MapCurrentItem(ShellItemHandler handler, ShellItem shellItem)
+ {
+ if (handler is null || shellItem is null)
+ {
+ return;
+ }
+
+ handler.SwitchToSection(shellItem.CurrentItem, animate: true);
+ }
+
+ ///
+ /// Connects the handler to the platform view.
+ ///
+ protected override void ConnectHandler(ViewPager2 platformView)
+ {
+ base.ConnectHandler(platformView);
+
+ // Subscribe to ShellItem property changes to detect CurrentItem changes from navigation
+ if (VirtualView is not null)
+ {
+ VirtualView?.PropertyChanged += OnShellItemPropertyChanged;
+ }
+
+ // Setup ViewPager2 adapter (requires parent fragment to be set first)
+ // This is called from OnViewCreated in the wrapper fragment
+
+ SetupBottomNavigation();
+
+ // Initialize appearance tracker
+ _shellContext ??= GetShellContext();
+ _appearanceTracker = _shellContext.CreateBottomNavViewAppearanceTracker(VirtualView);
+
+ // Register as appearance observer to receive appearance change notifications
+ var shell = VirtualView?.FindParentOfType();
+ if (shell is not null)
+ {
+ ((IShellController)shell).AddAppearanceObserver(this, VirtualView);
+ // Note: Shell will call OnAppearanceChanged with the current appearance automatically
+ }
+
+ // Note: Initial section switching is done in OnViewCreated of the wrapper fragment
+ // to ensure the fragment manager is ready
+ }
+
+ void OnShellItemPropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
+ {
+ if (e.PropertyName == ShellItem.CurrentItemProperty.PropertyName)
+ {
+ // Update bottom navigation selection
+ UpdateBottomNavigationSelection();
+ }
+ }
+
+ void UpdateBottomNavigationSelection()
+ {
+ if (_bottomNavigationManager is null || VirtualView is null)
+ {
+ return;
+ }
+
+ var items = ((IShellItemController)VirtualView).GetItems();
+ if (items is null)
+ {
+ return;
+ }
+
+ var currentIndex = items.IndexOf(VirtualView.CurrentItem);
+ if (currentIndex >= 0)
+ {
+ _bottomNavigationManager.SetSelectedItem(currentIndex);
+ }
+ }
+
+ ///
+ /// Disconnects the handler from the platform view.
+ /// Comprehensive cleanup of resources
+ ///
+ protected override void DisconnectHandler(ViewPager2 platformView)
+ {
+ if (VirtualView is not null)
+ {
+ VirtualView?.PropertyChanged -= OnShellItemPropertyChanged;
+ }
+
+ if (_shellSection is not null)
+ {
+ UnhookChildEvents(_shellSection);
+ _shellSection = null;
+ }
+
+ _displayedPage = null;
+
+ // Unregister appearance observer
+ var shell = VirtualView?.FindParentOfType();
+ if (shell is not null)
+ {
+ ((IShellController)shell).RemoveAppearanceObserver(this);
+ }
+
+ // Clear BottomNavigationManager listener
+ _bottomNavigationManager?.ClearListener();
+ _bottomNavigationManager = null;
+
+ // Dispose appearance tracker (bottom navigation)
+ _appearanceTracker?.Dispose();
+ _appearanceTracker = null;
+
+ // Dispose toolbar resources
+ _toolbarAppearanceTracker?.Dispose();
+ _toolbarAppearanceTracker = null;
+
+ _toolbarTracker?.Dispose();
+ _toolbarTracker = null;
+
+ _toolbar = null;
+ _shellToolbar = null;
+ _appBarLayout = null;
+
+ // Unregister page change callback
+ if (_pageChangeCallback is not null)
+ {
+ platformView.UnregisterOnPageChangeCallback(_pageChangeCallback);
+ _pageChangeCallback = null;
+ }
+
+ // Clear adapter
+ platformView.Adapter = null;
+ _adapter = null;
+
+ // Clear references
+ _shellContext = null;
+ _parentFragment = null;
+
+ base.DisconnectHandler(platformView);
+ }
+
+ #region IAppearanceObserver
+
+ ///
+ /// Called when Shell appearance changes (colors, styles, etc.)
+ ///
+ void IAppearanceObserver.OnAppearanceChanged(ShellAppearance appearance)
+ {
+ UpdateAppearance(appearance);
+ UpdateToolbarAppearance(appearance);
+ }
+
+ ///
+ /// Updates the bottom navigation view appearance based on Shell appearance
+ ///
+ void UpdateAppearance(ShellAppearance appearance)
+ {
+ if (_bottomNavigationView is null || _bottomNavigationView.Visibility != ViewStates.Visible)
+ {
+ return;
+ }
+
+ if (_appearanceTracker is not null && appearance is not null)
+ {
+ _appearanceTracker.SetAppearance(_bottomNavigationView, appearance);
+ }
+ }
+
+ #endregion IAppearanceObserver
+
+ #region Toolbar Management
+
+ ///
+ /// Sets up the shared toolbar at the ShellItem level.
+ /// The toolbar is now managed here instead of at the ShellSection level,
+ /// so it persists across section switches within the same ShellItem.
+ ///
+ internal void SetupToolbar()
+ {
+ if (_appBarLayout is null)
+ {
+ return;
+ }
+
+ var shell = VirtualView?.FindParentOfType();
+ if (shell is null)
+ {
+ return;
+ }
+
+ _shellContext ??= GetShellContext();
+
+ // Create Toolbar virtual view with proper context using current item
+ _shellToolbar = new Toolbar(VirtualView?.CurrentItem);
+
+ // Apply toolbar changes from Shell
+ ShellToolbarTracker.ApplyToolbarChanges(shell.Toolbar, _shellToolbar);
+
+ // Create the platform toolbar
+ _toolbar = (AToolbar)_shellToolbar.ToPlatform(shell.Handler.MauiContext);
+
+ // Set up toolbar tracker and appearance tracker
+ _toolbarTracker = _shellContext.CreateTrackerForToolbar(_toolbar);
+ _toolbarAppearanceTracker = _shellContext.CreateToolbarAppearanceTracker();
+
+ // Set the toolbar reference
+ if (_toolbarTracker is not null && _shellToolbar is not null)
+ {
+ _toolbarTracker.SetToolbar(_shellToolbar);
+ }
+
+ // Add toolbar to AppBarLayout
+ _appBarLayout.AddView(_toolbar);
+ }
+
+ ///
+ /// Updates the toolbar title and items for the current section.
+ /// Called when the current section changes (e.g., switching between bottom nav tabs).
+ ///
+ void UpdateToolbarForSection(ShellSection section)
+ {
+ if (_toolbarTracker is null || section is null)
+ return;
+
+ Page currentPage = null;
+ bool canNavigateBack = false;
+
+ // Check if _displayedPage belongs to this section (fast path)
+ if (_displayedPage is not null)
+ {
+ var pageSection = _displayedPage.FindParentOfType();
+ if (pageSection == section)
+ {
+ currentPage = _displayedPage;
+ // Still need to calculate canNavigateBack from stack
+ (_, canNavigateBack) = GetStackInfo(section.Stack);
+ }
+ }
+
+ // If not found via _displayedPage, get from section's stack
+ if (currentPage is null)
+ {
+ (currentPage, canNavigateBack) = GetStackInfo(section.Stack);
+ }
+
+ // If still not found, use the root content page
+ if (currentPage is null && section.CurrentItem is not null)
+ {
+ currentPage = ((IShellContentController)section.CurrentItem).GetOrCreateContent();
+ canNavigateBack = false; // Root page
+ }
+
+ // Update toolbar with page and navigation state
+ if (currentPage is not null)
+ {
+ UpdateToolbar(currentPage, canNavigateBack);
+ }
+ }
+
+ ///
+ /// Consolidated toolbar update method. Single point of entry for all toolbar updates.
+ ///
+ void UpdateToolbar(Page page, bool canNavigateBack)
+ {
+ if (_toolbarTracker is null || page is null)
+ return;
+
+ // Update navigation state first
+ _toolbarTracker.CanNavigateBack = canNavigateBack;
+
+ // Update the page reference
+ _toolbarTracker.Page = page;
+
+ // Cache shell reference to avoid repeated FindParentOfType calls
+ var shell = VirtualView?.FindParentOfType();
+ if (shell is null)
+ return;
+
+ // Apply toolbar configuration
+ if (_shellToolbar is not null)
+ {
+ ShellToolbarTracker.ApplyToolbarChanges(shell.Toolbar, _shellToolbar);
+ _toolbarTracker.SetToolbar(_shellToolbar);
+ }
+
+ // Update shell toolbar
+ if (shell.Toolbar is ShellToolbar shellToolbar)
+ {
+ shellToolbar.ApplyChanges();
+ }
+
+ // Force back button visibility update
+ _shellToolbar?.Handler?.UpdateValue(nameof(IToolbar.BackButtonVisible));
+
+ // Trigger appearance update (observers handle the rest)
+ ((IShellController)shell).AppearanceChanged(page, false);
+ }
+
+ ///
+ /// Updates the toolbar for a specific page.
+ /// Called when content tabs change within a multi-content ShellSection.
+ ///
+ internal void UpdateToolbarForPage(Page page)
+ {
+ if (page is null)
+ return;
+
+ // Get navigation state from the page's section
+ var section = page.FindParentOfType();
+ var (_, canNavigateBack) = section is not null ? GetStackInfo(section.Stack) : (null, false);
+
+ UpdateToolbar(page, canNavigateBack);
+ }
+
+ ///
+ /// Updates the toolbar appearance based on Shell appearance.
+ /// Called via IAppearanceObserver.OnAppearanceChanged - the single source of truth for appearance.
+ ///
+ void UpdateToolbarAppearance(ShellAppearance appearance)
+ {
+ if (_toolbarAppearanceTracker is null || _toolbar is null)
+ {
+ return;
+ }
+
+ _toolbarAppearanceTracker.SetAppearance(_toolbar, _toolbarTracker, appearance);
+ }
+
+ #endregion Toolbar Management
+ }
+
+ ///
+ /// Adapter that bridges ShellItemHandler with IShellItemRenderer interface.
+ /// This allows the new handler architecture to work with existing Shell infrastructure.
+ ///
+ internal class ShellItemHandlerAdapter : IShellItemRenderer
+ {
+ readonly ShellItemHandler _handler;
+ ShellItemWrapperFragment _wrapperFragment;
+
+ public ShellItemHandlerAdapter(ShellItemHandler handler, IMauiContext mauiContext)
+ {
+ _handler = handler ?? throw new ArgumentNullException(nameof(handler));
+ }
+
+ public Fragment Fragment
+ {
+ get
+ {
+ // Lazily create the wrapper fragment when needed
+ if (_wrapperFragment is null)
+ {
+ _wrapperFragment = new ShellItemWrapperFragment(_handler);
+ }
+ return _wrapperFragment;
+ }
+ }
+
+ public ShellItem ShellItem
+ {
+ get => _handler.VirtualView;
+ set
+ {
+ if (_handler.VirtualView != value)
+ {
+ _handler.SetVirtualView(value);
+ }
+ }
+ }
+
+ public event EventHandler Destroyed;
+
+ public void Dispose()
+ {
+ Destroyed?.Invoke(this, EventArgs.Empty);
+ _wrapperFragment?.Dispose();
+ _wrapperFragment = null;
+ }
+
+ ///
+ /// Wrapper Fragment that hosts the ShellItemHandler's ViewPager2 and BottomNavigationView.
+ /// Creates a CoordinatorLayout with AppBarLayout (Toolbar) + ViewPager2 + BottomNavigationView.
+ /// The toolbar is now managed at the ShellItem level (shared across all sections).
+ ///
+ class ShellItemWrapperFragment : Fragment
+ {
+ readonly ShellItemHandler _handler;
+ CoordinatorLayout _rootLayout;
+ LinearLayout _bottomContainer; // Contains ViewPager2 + BottomNav
+ ShellBackPressedCallback _backPressedCallback;
+
+ public ShellItemWrapperFragment(ShellItemHandler handler)
+ {
+ _handler = handler;
+ // Let the handler know about its parent fragment for child fragment management
+ _handler.SetParentFragment(this);
+ }
+
+ public override AView OnCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState)
+ {
+ var context = Context ?? RequireContext();
+
+ // Create root CoordinatorLayout for AppBarLayout scrolling behavior
+ _rootLayout = new CoordinatorLayout(context)
+ {
+ LayoutParameters = new LP(LP.MatchParent, LP.MatchParent)
+ };
+
+ // Setup window insets for safe area handling
+ MauiWindowInsetListener.SetupViewWithLocalListener(_rootLayout);
+
+ // Create AppBarLayout for toolbar
+ _handler._appBarLayout = new AppBarLayout(context)
+ {
+ LayoutParameters = new CoordinatorLayout.LayoutParams(LP.MatchParent, LP.WrapContent)
+ };
+ _rootLayout.AddView(_handler._appBarLayout);
+
+ // Create bottom container (LinearLayout) for ViewPager2 + BottomNav
+ // This container uses ScrollingViewBehavior to scroll with AppBarLayout
+ _bottomContainer = new LinearLayout(context)
+ {
+ Orientation = Orientation.Vertical,
+ LayoutParameters = new CoordinatorLayout.LayoutParams(LP.MatchParent, LP.MatchParent)
+ {
+ Behavior = new AppBarLayout.ScrollingViewBehavior()
+ }
+ };
+ _rootLayout.AddView(_bottomContainer);
+
+ // Get the ViewPager2 from the handler
+ var viewPager = _handler.PlatformView ?? _handler.ToPlatform() as ViewPager2;
+ if (viewPager is not null)
+ {
+ // Set layout params for ViewPager2 to take remaining space
+ viewPager.LayoutParameters = new LinearLayout.LayoutParams(LP.MatchParent, 0)
+ {
+ Weight = 1
+ };
+ _bottomContainer.AddView(viewPager);
+ }
+
+ // Add BottomNavigationView from handler
+ var bottomNav = _handler.BottomNavigationView;
+ if (bottomNav is not null)
+ {
+ bottomNav.LayoutParameters = new LP(LP.MatchParent, LP.WrapContent);
+ _bottomContainer.AddView(bottomNav);
+ }
+
+ return _rootLayout;
+ }
+
+ public override void OnViewCreated(AView view, Bundle savedInstanceState)
+ {
+ base.OnViewCreated(view, savedInstanceState);
+
+ // Setup back button handling
+ _backPressedCallback = new ShellBackPressedCallback(_handler);
+ RequireActivity().OnBackPressedDispatcher.AddCallback(ViewLifecycleOwner, _backPressedCallback);
+
+ // Setup the shared toolbar
+ _handler.SetupToolbar();
+
+ // Now that the fragment is attached, setup the ViewPager2 adapter
+ _handler.SetupViewPagerAdapter();
+
+ // Trigger the initial section switch if needed
+ if (_handler.VirtualView?.CurrentItem is not null)
+ {
+ _handler.SwitchToSection(_handler.VirtualView.CurrentItem, animate: false);
+ }
+ }
+
+ protected override void Dispose(bool disposing)
+ {
+ if (disposing)
+ {
+ if (_backPressedCallback is not null)
+ {
+ _backPressedCallback.Remove();
+ _backPressedCallback.Dispose();
+ _backPressedCallback = null;
+ }
+
+ // Remove window insets listener
+ if (_rootLayout is not null)
+ {
+ MauiWindowInsetListener.RemoveViewWithLocalListener(_rootLayout);
+ }
+
+ _rootLayout = null;
+ _bottomContainer = null;
+ }
+ base.Dispose(disposing);
+ }
+
+ ///
+ /// Custom OnBackPressedCallback for Shell navigation
+ ///
+ sealed class ShellBackPressedCallback : AndroidX.Activity.OnBackPressedCallback
+ {
+ readonly ShellItemHandler _handler;
+
+ public ShellBackPressedCallback(ShellItemHandler handler) : base(true)
+ {
+ _handler = handler;
+ }
+
+ public override void HandleOnBackPressed()
+ {
+ // Let the handler try to handle the back press
+ if (!_handler.OnBackButtonPressed())
+ {
+ // Handler didn't handle it (we're at root), let system handle it
+ this.Enabled = false;
+ // The system will handle app exit
+ this.Enabled = true;
+ }
+ }
+ }
+ }
+ }
+
+ ///
+ /// ViewPager2 page change callback for ShellItemHandler.
+ ///
+ internal class ShellItemPageChangeCallback : ViewPager2.OnPageChangeCallback
+ {
+ readonly ShellItemHandler _handler;
+
+ public ShellItemPageChangeCallback(ShellItemHandler handler)
+ {
+ _handler = handler;
+ }
+
+ public override void OnPageSelected(int position)
+ {
+ _handler.OnPageSelected(position);
+ }
+ }
+
+ ///
+ /// FragmentStateAdapter for ShellSections in ViewPager2.
+ /// Each page hosts a ShellSection's fragment.
+ ///
+ internal class ShellSectionFragmentAdapter : FragmentStateAdapter
+ {
+ readonly IList _sections;
+ readonly IShellContext _shellContext;
+ readonly Dictionary _renderers = new Dictionary();
+
+ public ShellSectionFragmentAdapter(
+ FragmentManager fragmentManager,
+ AndroidX.Lifecycle.Lifecycle lifecycle,
+ IList sections,
+ IShellContext shellContext)
+ : base(fragmentManager, lifecycle)
+ {
+ _sections = sections ?? throw new ArgumentNullException(nameof(sections));
+ _shellContext = shellContext ?? throw new ArgumentNullException(nameof(shellContext));
+ }
+
+ public override int ItemCount => _sections.Count;
+
+ public override Fragment CreateFragment(int position)
+ {
+ var section = _sections[position];
+
+ // Create or reuse section renderer
+ if (!_renderers.TryGetValue(position, out var renderer))
+ {
+ renderer = _shellContext.CreateShellSectionRenderer(section);
+ renderer.ShellSection = section;
+ _renderers[position] = renderer;
+ }
+
+ // Get the fragment from the renderer
+ if (renderer is IShellObservableFragment observableFragment)
+ {
+ return observableFragment.Fragment;
+ }
+
+ throw new InvalidOperationException($"ShellSectionRenderer for {section.Title} is not an IShellObservableFragment");
+ }
+
+ public IShellSectionRenderer GetRenderer(int position)
+ {
+ _renderers.TryGetValue(position, out var renderer);
+ return renderer;
+ }
+ }
+
+ ///
+ /// Helper class to implement NavigationBarView.IOnItemSelectedListener
+ ///
+ internal class GenericNavigationItemSelectedListener : Java.Lang.Object, NavigationBarView.IOnItemSelectedListener
+ {
+ readonly Func _callback;
+
+ public GenericNavigationItemSelectedListener(Func callback)
+ {
+ _callback = callback ?? throw new ArgumentNullException(nameof(callback));
+ }
+
+ public bool OnNavigationItemSelected(IMenuItem item)
+ {
+ return _callback(item);
+ }
+ }
+}
+#endif
diff --git a/src/Controls/src/Core/Handlers/Shell/ShellSectionHandler.Android.cs b/src/Controls/src/Core/Handlers/Shell/ShellSectionHandler.Android.cs
new file mode 100644
index 000000000000..2d1e381d32b0
--- /dev/null
+++ b/src/Controls/src/Core/Handlers/Shell/ShellSectionHandler.Android.cs
@@ -0,0 +1,1078 @@
+#nullable disable
+#if ANDROID
+#pragma warning disable CS0067 // Event is never used
+using System;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.Linq;
+using System.Threading.Tasks;
+using Android.OS;
+using Android.Views;
+using Android.Widget;
+using AndroidX.CoordinatorLayout.Widget;
+using AndroidX.Fragment.App;
+using AndroidX.ViewPager2.Adapter;
+using AndroidX.ViewPager2.Widget;
+using Google.Android.Material.AppBar;
+using Google.Android.Material.Tabs;
+using Microsoft.Maui.Controls.Internals;
+using Microsoft.Maui.Controls.Platform;
+using Microsoft.Maui.Controls.Platform.Compatibility;
+using Microsoft.Maui.Graphics;
+using Microsoft.Maui.Handlers;
+using Microsoft.Maui.Platform;
+using AToolbar = AndroidX.AppCompat.Widget.Toolbar;
+using AView = Android.Views.View;
+using LP = Android.Views.ViewGroup.LayoutParams;
+
+#pragma warning disable RS0016 // Add public types and members to the declared API
+
+namespace Microsoft.Maui.Controls.Handlers
+{
+ ///
+ /// UNIFIED Handler for ShellSection on Android.
+ /// Always uses ViewPager2 for content switching - works for both single and multiple ShellContents.
+ /// TabLayout visibility is controlled by item count (hidden if 1 item).
+ /// Each ShellContent gets its own StackNavigationManager for independent navigation.
+ ///
+ public partial class ShellSectionHandler : ElementHandler, IAppearanceObserver
+ {
+ Fragment _parentFragment; // The wrapper fragment that hosts this handler
+ IShellContext _shellContext;
+ IShellTabLayoutAppearanceTracker _tabLayoutAppearanceTracker;
+ LinearLayout _rootLayout;
+ ViewPager2 _viewPager;
+ TabLayout _contentTabLayout;
+ AppBarLayout _tabAppBarLayout;
+ ShellContentFragmentAdapter _adapter;
+ TabLayoutMediator _tabLayoutMediator;
+
+ ///
+ /// Gets the toolbar tracker from the parent ShellItemHandler.
+ /// The toolbar is managed at ShellItem level.
+ ///
+ internal IShellToolbarTracker ToolbarTracker
+ {
+ get
+ {
+ var shellItem = VirtualView?.FindParentOfType();
+ if (shellItem?.Handler is ShellItemHandler itemHandler)
+ {
+ return itemHandler._toolbarTracker;
+ }
+ return null;
+ }
+ }
+
+ ///
+ /// Gets the virtual toolbar from the parent ShellItemHandler.
+ ///
+ internal Toolbar ShellToolbar
+ {
+ get
+ {
+ var shellItem = VirtualView?.FindParentOfType();
+ if (shellItem?.Handler is ShellItemHandler itemHandler)
+ {
+ return itemHandler._shellToolbar;
+ }
+ return null;
+ }
+ }
+
+ ///
+ /// Property mapper for ShellSection properties.
+ ///
+ public static PropertyMapper Mapper = new PropertyMapper(ElementMapper)
+ {
+ [nameof(ShellSection.CurrentItem)] = MapCurrentItem,
+ };
+
+ ///
+ /// Command mapper for ShellSection commands.
+ ///
+ public static CommandMapper CommandMapper = new CommandMapper(ElementCommandMapper)
+ {
+ };
+
+ ///
+ /// Initializes a new instance of the ShellSectionHandler class.
+ ///
+ public ShellSectionHandler() : base(Mapper, CommandMapper)
+ {
+ }
+
+ ///
+ /// Sets the parent fragment that hosts this handler. Used for child fragment management.
+ ///
+ internal void SetParentFragment(Fragment fragment)
+ {
+ _parentFragment = fragment;
+ }
+
+ ///
+ /// Gets the IShellContext from the parent Shell.
+ ///
+ IShellContext GetShellContext()
+ {
+ var shell = VirtualView?.FindParentOfType();
+ if (shell?.Handler is IShellContext context)
+ {
+ return context;
+ }
+ throw new InvalidOperationException("ShellHandler must implement IShellContext");
+ }
+
+ ///
+ /// Creates the platform element - always returns the unified layout.
+ ///
+ protected override AView CreatePlatformElement()
+ {
+ var context = MauiContext?.Context ?? throw new InvalidOperationException("MauiContext cannot be null");
+
+ // Create root LinearLayout (always the same structure)
+ _rootLayout = new LinearLayout(context)
+ {
+ Orientation = Orientation.Vertical,
+ LayoutParameters = new LP(LP.MatchParent, LP.MatchParent)
+ };
+
+ // Create AppBarLayout to hold TabLayout (for scrolling behavior with CoordinatorLayout parent)
+ _tabAppBarLayout = new AppBarLayout(context)
+ {
+ LayoutParameters = new LinearLayout.LayoutParams(LP.MatchParent, LP.WrapContent)
+ };
+ _rootLayout.AddView(_tabAppBarLayout);
+
+ // Create TabLayout (visibility controlled by item count)
+ int actionBarHeight = context.GetActionBarHeight();
+ _contentTabLayout = PlatformInterop.CreateShellTabLayout(context, _tabAppBarLayout, actionBarHeight);
+
+ // Create ViewPager2 (always present)
+ _viewPager = new ViewPager2(context)
+ {
+ Id = AView.GenerateViewId(),
+ LayoutParameters = new LinearLayout.LayoutParams(LP.MatchParent, 0) { Weight = 1 }
+ };
+ _rootLayout.AddView(_viewPager);
+
+ return _rootLayout;
+ }
+
+ protected override void ConnectHandler(AView platformView)
+ {
+ base.ConnectHandler(platformView);
+
+ _shellContext = GetShellContext();
+
+ // Subscribe to ShellSection.Items collection changes
+ if (VirtualView is INotifyCollectionChanged collectionChanged)
+ {
+ collectionChanged.CollectionChanged += OnItemsCollectionChanged;
+ }
+
+ // Wait for the view to be attached before setting up the adapter
+ // This ensures the parent fragment is set
+ _rootLayout.ViewAttachedToWindow += OnRootLayoutAttachedToWindow;
+
+ // Try to setup immediately if already attached
+ if (_rootLayout.IsAttachedToWindow && _parentFragment is not null)
+ {
+ SetupViewPagerAdapter();
+ }
+ }
+
+ void OnRootLayoutAttachedToWindow(object sender, AView.ViewAttachedToWindowEventArgs e)
+ {
+ _rootLayout.ViewAttachedToWindow -= OnRootLayoutAttachedToWindow;
+ SetupViewPagerAdapter();
+ }
+
+ ///
+ /// Sets up the ViewPager2 adapter and TabLayoutMediator.
+ /// Called when the view is attached and parent fragment is available.
+ ///
+ internal void SetupViewPagerAdapter()
+ {
+ if (_adapter is not null || _parentFragment is null || VirtualView is null)
+ {
+ return;
+ }
+
+ // Create scoped context with parent fragment's ChildFragmentManager
+ var scopedContext = MauiContext.MakeScoped(fragmentManager: _parentFragment.ChildFragmentManager);
+
+ // Create adapter
+ _adapter = new ShellContentFragmentAdapter(VirtualView, _parentFragment, scopedContext)
+ {
+ Handler = this
+ };
+ _viewPager.Adapter = _adapter;
+
+ // Setup TabLayoutMediator
+ _tabLayoutMediator = new TabLayoutMediator(
+ _contentTabLayout,
+ _viewPager,
+ new ShellTabConfigurationStrategy(VirtualView));
+ _tabLayoutMediator.Attach();
+
+ // Register page change callback
+ var pageChangedCallback = new ViewPagerPageChangeCallback(this);
+ _viewPager.RegisterOnPageChangeCallback(pageChangedCallback);
+
+ // Update TabLayout visibility based on item count
+ UpdateTabLayoutVisibility();
+
+ // Disable user swiping if only one item
+ UpdateViewPagerUserInput();
+
+ // Set initial position
+ SetInitialPosition();
+
+ // Setup TabLayout appearance tracker
+ _tabLayoutAppearanceTracker = _shellContext.CreateTabLayoutAppearanceTracker(VirtualView);
+
+ // Register as appearance observer for TabLayout updates
+ var shell = VirtualView.FindParentOfType();
+ if (shell is not null)
+ {
+ ((IShellController)shell).AddAppearanceObserver(this, VirtualView);
+ }
+
+ // Trigger initial appearance update
+ var currentContent = VirtualView.CurrentItem;
+ if (currentContent is not null)
+ {
+ var page = ((IShellContentController)currentContent).GetOrCreateContent();
+ if (page is not null && shell is not null)
+ {
+ // Update toolbar tracker with current page
+ var toolbarTracker = ToolbarTracker;
+ toolbarTracker?.Page = page;
+
+ ((IShellController)shell).AppearanceChanged(page, false);
+ }
+ }
+ }
+
+ void SetInitialPosition()
+ {
+ if (VirtualView?.CurrentItem is null || VirtualView.Items is null)
+ {
+ return;
+ }
+
+ var currentIndex = VirtualView.Items.IndexOf(VirtualView.CurrentItem);
+ if (currentIndex >= 0 && _viewPager.CurrentItem != currentIndex)
+ {
+ _viewPager.SetCurrentItem(currentIndex, false);
+ }
+ }
+
+ void UpdateTabLayoutVisibility()
+ {
+ if (_contentTabLayout is null || VirtualView?.Items is null)
+ {
+ return;
+ }
+
+ // Hide TabLayout if only 1 content
+ bool showTabs = VirtualView.Items.Count > 1;
+ _contentTabLayout.Visibility = showTabs ? ViewStates.Visible : ViewStates.Gone;
+ _tabAppBarLayout.Visibility = showTabs ? ViewStates.Visible : ViewStates.Gone;
+ }
+
+ void UpdateViewPagerUserInput()
+ {
+ if (_viewPager is null || VirtualView?.Items is null)
+ {
+ return;
+ }
+
+ // Disable user swiping if only 1 content
+ bool enableUserInput = VirtualView.Items.Count > 1;
+ _viewPager.UserInputEnabled = enableUserInput;
+ }
+
+ ///
+ /// Exposes the content TabLayout for toolbar tracker updates.
+ /// Used to hide tabs when navigated deeper than root page.
+ ///
+ internal TabLayout ContentTabLayout => _contentTabLayout;
+
+ protected override void DisconnectHandler(AView platformView)
+ {
+ // Unsubscribe from events
+ _rootLayout.ViewAttachedToWindow -= OnRootLayoutAttachedToWindow;
+
+ if (VirtualView is INotifyCollectionChanged collectionChanged)
+ {
+ collectionChanged.CollectionChanged -= OnItemsCollectionChanged;
+ }
+
+ // Detach TabLayoutMediator
+ _tabLayoutMediator?.Detach();
+ _tabLayoutMediator = null;
+
+ // Cleanup adapter
+ _adapter = null;
+ _viewPager.Adapter = null;
+ _viewPager = null;
+
+ // Cleanup TabLayout
+ _contentTabLayout = null;
+ _tabAppBarLayout = null;
+
+ // Unregister appearance observer
+ var shell = VirtualView?.FindParentOfType();
+ if (shell is not null)
+ {
+ ((IShellController)shell).RemoveAppearanceObserver(this);
+ }
+
+ // Dispose TabLayout appearance tracker
+ _tabLayoutAppearanceTracker?.Dispose();
+ _tabLayoutAppearanceTracker = null;
+
+ _rootLayout = null;
+ _shellContext = null;
+
+ base.DisconnectHandler(platformView);
+ }
+
+ ///
+ /// Maps CurrentItem property changes - just update ViewPager2 position.
+ ///
+ public static void MapCurrentItem(ShellSectionHandler handler, ShellSection shellSection)
+ {
+ if (handler is null || shellSection?.CurrentItem is null || handler._viewPager is null)
+ {
+ return;
+ }
+
+ var items = shellSection.Items;
+ var currentItem = shellSection.CurrentItem;
+
+ if (items is not null && currentItem is not null)
+ {
+ var targetIndex = items.IndexOf(currentItem);
+ if (targetIndex >= 0 && handler._viewPager.CurrentItem != targetIndex)
+ {
+ handler._viewPager.SetCurrentItem(targetIndex, true);
+ }
+ }
+ }
+
+ void OnItemsCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
+ {
+ if (_adapter is null)
+ {
+ return;
+ }
+
+ _adapter.NotifyDataSetChanged();
+ UpdateTabLayoutVisibility();
+ UpdateViewPagerUserInput();
+ }
+
+ ///
+ /// Checks if this ShellSection is currently the active one in the Shell hierarchy.
+ ///
+ internal bool IsCurrentlyActiveSection()
+ {
+ if (VirtualView is null)
+ return false;
+
+ var shellItem = VirtualView.FindParentOfType();
+ if (shellItem is null || shellItem.CurrentItem != VirtualView)
+ return false;
+
+ var shell = shellItem.FindParentOfType();
+ if (shell is null || shell.CurrentItem != shellItem)
+ return false;
+
+ return true;
+ }
+
+ #region IAppearanceObserver - TabLayout Appearance Only
+
+ ///
+ /// Called when Shell appearance changes.
+ /// ONLY updates TabLayout appearance.
+ /// Toolbar appearance is handled by ShellItemHandler.
+ ///
+ void IAppearanceObserver.OnAppearanceChanged(ShellAppearance appearance)
+ {
+ if (_tabLayoutAppearanceTracker is not null && _contentTabLayout is not null)
+ {
+ if (appearance is not null)
+ {
+ _tabLayoutAppearanceTracker.SetAppearance(_contentTabLayout, appearance);
+ }
+ else
+ {
+ _tabLayoutAppearanceTracker.ResetAppearance(_contentTabLayout);
+ }
+ }
+ }
+
+ #endregion
+ }
+
+ #region ViewPager2 Support Classes
+
+ ///
+ /// FragmentStateAdapter for managing ShellContent fragments in ViewPager2
+ ///
+ internal class ShellContentFragmentAdapter : FragmentStateAdapter
+ {
+ readonly ShellSection _shellSection;
+ readonly IMauiContext _mauiContext;
+
+ public ShellContentFragmentAdapter(ShellSection shellSection, Fragment parentFragment, IMauiContext mauiContext)
+ : base(parentFragment)
+ {
+ _shellSection = shellSection;
+ _mauiContext = mauiContext;
+ }
+
+ public override int ItemCount => _shellSection?.Items?.Count ?? 0;
+
+ public ShellSectionHandler Handler { get; set; }
+
+ public override Fragment CreateFragment(int position)
+ {
+ if (_shellSection?.Items is null || position >= _shellSection.Items.Count)
+ {
+ return null;
+ }
+
+ var shellContent = _shellSection.Items[position];
+ return new ShellContentNavigationFragment(shellContent, _mauiContext, Handler);
+ }
+
+ public override long GetItemId(int position)
+ {
+ if (_shellSection?.Items is null || position >= _shellSection.Items.Count)
+ {
+ return -1;
+ }
+ return _shellSection.Items[position].GetHashCode();
+ }
+
+ public override bool ContainsItem(long itemId)
+ {
+ if (_shellSection?.Items is null)
+ {
+ return false;
+ }
+ foreach (var item in _shellSection.Items)
+ {
+ if (item.GetHashCode() == itemId)
+ {
+ return true;
+ }
+ }
+ return false;
+ }
+ }
+
+ ///
+ /// ViewPager2 page change callback to update toolbar when swiping between content tabs.
+ ///
+ internal class ViewPagerPageChangeCallback : ViewPager2.OnPageChangeCallback
+ {
+ readonly ShellSectionHandler _handler;
+
+ public ViewPagerPageChangeCallback(ShellSectionHandler handler)
+ {
+ _handler = handler;
+ }
+
+ public override void OnPageSelected(int position)
+ {
+ base.OnPageSelected(position);
+
+ if (_handler.VirtualView is null || position >= _handler.VirtualView.Items.Count)
+ return;
+
+ // Only update toolbar if this section is currently active
+ if (!_handler.IsCurrentlyActiveSection())
+ return;
+
+ var newCurrentItem = _handler.VirtualView.Items[position];
+ var page = ((IShellContentController)newCurrentItem).GetOrCreateContent();
+
+ if (page is null)
+ return;
+
+ // Update toolbar title
+ var toolbarTracker = _handler.ToolbarTracker;
+ toolbarTracker?.Page = page;
+
+ // Update CurrentItem
+ if (_handler.VirtualView.CurrentItem != newCurrentItem)
+ {
+ _handler.VirtualView.CurrentItem = newCurrentItem;
+ }
+
+ // Trigger appearance update
+ var shell = _handler.VirtualView.FindParentOfType();
+ if (shell is not null)
+ {
+ ((IShellController)shell).AppearanceChanged(page, false);
+ }
+ }
+ }
+
+ ///
+ /// Fragment that hosts a ShellContent page with its own StackNavigationManager.
+ /// This enables each content tab to have independent navigation.
+ ///
+ internal class ShellContentNavigationFragment : Fragment, IStackNavigation
+ {
+ readonly ShellContent _shellContent;
+ readonly IMauiContext _mauiContext;
+ readonly ShellSectionHandler _handler;
+ StackNavigationManager _stackNavigationManager;
+ FragmentContainerView _navigationContainer;
+ Page _rootPage;
+ int _navigationContainerId;
+ ShellContentStackNavigationView _navigationViewAdapter;
+
+ public ShellContentNavigationFragment(ShellContent shellContent, IMauiContext mauiContext, ShellSectionHandler handler)
+ {
+ _shellContent = shellContent;
+ _mauiContext = mauiContext;
+ _handler = handler;
+ }
+
+ public override void OnCreate(Bundle savedInstanceState)
+ {
+ // Don't pass saved state to prevent stale fragment restoration
+ base.OnCreate(null);
+ }
+
+ public override AView OnCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState)
+ {
+ if (_navigationContainer is not null)
+ {
+ // Check if NavHostFragment needs recreation
+ var existingNavHost = ChildFragmentManager.FindFragmentById(_navigationContainerId);
+ if (existingNavHost is null && _stackNavigationManager is not null)
+ {
+ var recreatedNavHost = new MauiNavHostFragment()
+ {
+ StackNavigationManager = _stackNavigationManager
+ };
+ ChildFragmentManager
+ .BeginTransactionEx()
+ .AddEx(_navigationContainerId, recreatedNavHost)
+ .CommitNowAllowingStateLoss();
+ }
+
+ return _navigationContainer;
+ }
+
+ // Get the root page for this ShellContent
+ _rootPage = ((IShellContentController)_shellContent)?.GetOrCreateContent();
+ if (_rootPage is null)
+ {
+ return null;
+ }
+
+ // Subscribe to navigation events EARLY - before anything else
+ // This ensures we catch any navigation requests that come before the view is attached
+ var shellSection = _shellContent.Parent as ShellSection;
+ if (shellSection is not null && !_subscribedToNavigationRequested)
+ {
+ ((IShellSectionController)shellSection).NavigationRequested += OnNavigationRequested;
+ _subscribedToNavigationRequested = true;
+ }
+
+ // Create FragmentContainerView for navigation stack
+ if (_navigationContainerId == 0)
+ {
+ _navigationContainerId = AView.GenerateViewId();
+ }
+
+ _navigationContainer = new FragmentContainerView(_mauiContext.Context)
+ {
+ Id = _navigationContainerId,
+ LayoutParameters = new LP(LP.MatchParent, LP.MatchParent)
+ };
+
+ // Create StackNavigationManager with scoped context
+ var scopedContext = _mauiContext.MakeScoped(fragmentManager: ChildFragmentManager);
+ _stackNavigationManager = new StackNavigationManager(scopedContext);
+
+ // Create NavHostFragment
+ var navHostFragment = new MauiNavHostFragment()
+ {
+ StackNavigationManager = _stackNavigationManager
+ };
+
+ ChildFragmentManager
+ .BeginTransactionEx()
+ .AddEx(_navigationContainerId, navHostFragment)
+ .CommitNowAllowingStateLoss();
+
+ _navigationContainer.ViewAttachedToWindow += OnNavigationContainerAttached;
+
+ if (_navigationContainer.IsAttachedToWindow)
+ {
+ ConnectAndInitialize();
+ }
+
+ return _navigationContainer;
+ }
+
+ bool _subscribedToNavigationRequested;
+
+ void OnNavigationContainerAttached(object sender, AView.ViewAttachedToWindowEventArgs e)
+ {
+ _navigationContainer.ViewAttachedToWindow -= OnNavigationContainerAttached;
+ ConnectAndInitialize();
+ }
+
+ void ConnectAndInitialize()
+ {
+ if (_stackNavigationManager is null || _rootPage is null)
+ {
+ return;
+ }
+
+ // Create adapter that wraps the root page and delegates NavigationFinished to this fragment
+ _navigationViewAdapter = new ShellContentStackNavigationView(_rootPage, this);
+
+ // Connect using the adapter (which properly implements IStackNavigationView via page delegation)
+ _stackNavigationManager.Connect(_navigationViewAdapter, _navigationContainer);
+
+ // Subscribe to navigation events if not already subscribed
+ // (may have already been done in OnCreateView)
+ var shellSection = _shellContent.Parent as ShellSection;
+ if (shellSection is not null && !_subscribedToNavigationRequested)
+ {
+ ((IShellSectionController)shellSection).NavigationRequested += OnNavigationRequested;
+ _subscribedToNavigationRequested = true;
+ }
+
+ // Initialize with root page
+ var initialStack = new List { _rootPage };
+ _stackNavigationManager.RequestNavigation(new NavigationRequest(initialStack, false));
+
+ // Process any pending navigation request that came before we were ready
+ if (_pendingNavigationRequest is not null)
+ {
+ var pending = _pendingNavigationRequest;
+ _pendingNavigationRequest = null;
+ OnNavigationRequested(this, pending);
+ }
+ }
+
+ void OnNavigationRequested(object sender, NavigationRequestedEventArgs e)
+ {
+ // Only handle navigation for THIS ShellContent
+ // Note: Don't check IsVisible - ViewPager2 may report pages as not visible
+ // even when they are the current item
+ if (_stackNavigationManager is null)
+ {
+ return;
+ }
+
+ var shellSection = _shellContent?.Parent as ShellSection;
+ if (shellSection is null || shellSection.CurrentItem != _shellContent)
+ {
+ return;
+ }
+
+ // Check if StackNavigationManager is ready (has NavHost)
+ if (!_stackNavigationManager.HasNavHost)
+ {
+ // Queue the navigation request to be processed after initialization
+ _pendingNavigationRequest = e;
+ return;
+ }
+
+ var requestedStack = BuildNavigationStack(e);
+ if (requestedStack is not null && requestedStack.Count > 0)
+ {
+ _stackNavigationManager.RequestNavigation(new NavigationRequest(requestedStack, e.Animated));
+ }
+ }
+
+ NavigationRequestedEventArgs _pendingNavigationRequest;
+
+ List BuildNavigationStack(NavigationRequestedEventArgs e)
+ {
+ var currentStack = _stackNavigationManager?.NavigationStack ?? new List();
+
+ switch (e.RequestType)
+ {
+ case NavigationRequestType.Push:
+ var pushStack = new List(currentStack);
+ if (e.Page is not null)
+ {
+ pushStack.Add(e.Page);
+ }
+ return pushStack;
+
+ case NavigationRequestType.Pop:
+ if (currentStack.Count > 1)
+ {
+ var popStack = new List(currentStack);
+ popStack.RemoveAt(popStack.Count - 1);
+ return popStack;
+ }
+ return currentStack.ToList();
+
+ case NavigationRequestType.PopToRoot:
+ if (currentStack.Count > 0)
+ {
+ return new List { currentStack[0] };
+ }
+ break;
+
+ case NavigationRequestType.Insert:
+ case NavigationRequestType.Remove:
+ var section = _shellContent.Parent as ShellSection;
+ if (section is not null)
+ {
+ var resultStack = new List();
+ foreach (var page in section.Stack)
+ {
+ resultStack.Add(page ?? _rootPage);
+ }
+ return resultStack;
+ }
+ break;
+ }
+
+ return currentStack.ToList();
+ }
+
+ void IStackNavigation.RequestNavigation(NavigationRequest request)
+ {
+ _stackNavigationManager?.RequestNavigation(request);
+ }
+
+ // IStackNavigation.NavigationFinished - delegates to the internal method
+ void IStackNavigation.NavigationFinished(IReadOnlyList newStack)
+ {
+ OnNavigationFinished(newStack);
+ }
+
+ ///
+ /// Called by ShellContentStackNavigationView when navigation completes.
+ /// Updates toolbar and tab visibility based on the new navigation stack.
+ ///
+ internal void OnNavigationFinished(IReadOnlyList newStack)
+ {
+ if (!IsVisible || _handler is null)
+ {
+ return;
+ }
+
+ // Check if this content is currently active
+ var shellSection = _shellContent?.Parent as ShellSection;
+ var shellItem = shellSection?.Parent as ShellItem;
+ var shell = shellItem?.Parent as Shell;
+
+ if (shellSection is null || shellItem is null || shell is null)
+ return;
+ if (shell.CurrentItem != shellItem)
+ return;
+ if (shellItem.CurrentItem != shellSection)
+ return;
+ if (shellSection.CurrentItem != _shellContent)
+ return;
+
+ // Update toolbar
+ if (newStack.Count > 0 && newStack[newStack.Count - 1] is Page currentPage)
+ {
+ var toolbarTracker = _handler.ToolbarTracker;
+ var shellToolbar = _handler.ShellToolbar;
+ if (toolbarTracker is not null && shellToolbar is not null)
+ {
+ toolbarTracker.CanNavigateBack = newStack.Count > 1;
+
+ if (toolbarTracker.Page != currentPage)
+ {
+ toolbarTracker.Page = currentPage;
+ }
+
+ shellToolbar.Handler?.UpdateValue(nameof(IToolbar.BackButtonVisible));
+
+ if (shell?.Toolbar is ShellToolbar st)
+ {
+ st.ApplyChanges();
+ }
+
+ ((IShellController)shell).AppearanceChanged(currentPage, false);
+ }
+ }
+
+ // Hide/show content tabs based on navigation depth
+ if (_handler.ContentTabLayout is not null)
+ {
+ var shouldShowTabs = newStack.Count == 1 && shellSection.Items.Count > 1;
+ _handler.ContentTabLayout.Visibility = shouldShowTabs ? ViewStates.Visible : ViewStates.Gone;
+ }
+ }
+
+ protected override void Dispose(bool disposing)
+ {
+ if (disposing)
+ {
+ _navigationContainer.ViewAttachedToWindow -= OnNavigationContainerAttached;
+
+ if (_subscribedToNavigationRequested)
+ {
+ var shellSection = _shellContent?.Parent as ShellSection;
+ if (shellSection is not null)
+ {
+ ((IShellSectionController)shellSection).NavigationRequested -= OnNavigationRequested;
+ }
+ _subscribedToNavigationRequested = false;
+ }
+
+ _pendingNavigationRequest = null;
+ _navigationViewAdapter = null;
+ _stackNavigationManager?.Disconnect();
+ _stackNavigationManager = null;
+ _navigationContainer = null;
+ _rootPage = null;
+ }
+ base.Dispose(disposing);
+ }
+ }
+
+ ///
+ /// Adapter that wraps a Page (which is an IView) and adds IStackNavigation behavior
+ /// by delegating NavigationFinished to the owning fragment.
+ /// This is a cleaner approach than having the Fragment implement IStackNavigationView
+ /// with 40+ stub properties.
+ ///
+ internal class ShellContentStackNavigationView : IStackNavigationView
+ {
+ readonly Page _page;
+ readonly ShellContentNavigationFragment _fragment;
+
+ public ShellContentStackNavigationView(Page page, ShellContentNavigationFragment fragment)
+ {
+ _page = page ?? throw new ArgumentNullException(nameof(page));
+ _fragment = fragment ?? throw new ArgumentNullException(nameof(fragment));
+ }
+
+ // IStackNavigation - delegate to fragment
+ void IStackNavigation.RequestNavigation(NavigationRequest request)
+ {
+ // Navigation requests go through the fragment
+ ((IStackNavigation)_fragment).RequestNavigation(request);
+ }
+
+ // IStackNavigationView - delegate to fragment for the callback
+ public void NavigationFinished(IReadOnlyList newStack)
+ {
+ _fragment.OnNavigationFinished(newStack);
+ }
+
+ // IView - delegate all properties to the underlying Page
+ public Size Arrange(Rect bounds) => ((IView)_page).Arrange(bounds);
+ public Size Measure(double widthConstraint, double heightConstraint) => ((IView)_page).Measure(widthConstraint, heightConstraint);
+ public void InvalidateMeasure() => ((IView)_page).InvalidateMeasure();
+ public void InvalidateArrange() => ((IView)_page).InvalidateArrange();
+ public bool Focus() => ((IView)_page).Focus();
+ public void Unfocus() => ((IView)_page).Unfocus();
+
+ public string AutomationId => ((IView)_page).AutomationId;
+ public FlowDirection FlowDirection => ((IView)_page).FlowDirection;
+ public Primitives.LayoutAlignment HorizontalLayoutAlignment => ((IView)_page).HorizontalLayoutAlignment;
+ public Primitives.LayoutAlignment VerticalLayoutAlignment => ((IView)_page).VerticalLayoutAlignment;
+ public Semantics Semantics => ((IView)_page).Semantics;
+ public IShape Clip => ((IView)_page).Clip;
+ public IShadow Shadow => ((IView)_page).Shadow;
+ public bool IsEnabled => ((IView)_page).IsEnabled;
+ public bool IsFocused { get => ((IView)_page).IsFocused; set => ((IView)_page).IsFocused = value; }
+ public Visibility Visibility => ((IView)_page).Visibility;
+ public double Opacity => ((IView)_page).Opacity;
+ public Paint Background => ((IView)_page).Background;
+ public Rect Frame { get => ((IView)_page).Frame; set => ((IView)_page).Frame = value; }
+ public double Width => ((IView)_page).Width;
+ public double MinimumWidth => ((IView)_page).MinimumWidth;
+ public double MaximumWidth => ((IView)_page).MaximumWidth;
+ public double Height => ((IView)_page).Height;
+ public double MinimumHeight => ((IView)_page).MinimumHeight;
+ public double MaximumHeight => ((IView)_page).MaximumHeight;
+ public Thickness Margin => ((IView)_page).Margin;
+ public Size DesiredSize => ((IView)_page).DesiredSize;
+ public int ZIndex => ((IView)_page).ZIndex;
+ public IViewHandler Handler { get => _page.Handler; set => _page.Handler = value; }
+ public bool InputTransparent => ((IView)_page).InputTransparent;
+ IElementHandler IElement.Handler { get => _page.Handler; set => _page.Handler = (IViewHandler)value; }
+ public IElement Parent => ((IElement)_page).Parent;
+ public double TranslationX => ((IView)_page).TranslationX;
+ public double TranslationY => ((IView)_page).TranslationY;
+ public double Scale => ((IView)_page).Scale;
+ public double ScaleX => ((IView)_page).ScaleX;
+ public double ScaleY => ((IView)_page).ScaleY;
+ public double Rotation => ((IView)_page).Rotation;
+ public double RotationX => ((IView)_page).RotationX;
+ public double RotationY => ((IView)_page).RotationY;
+ public double AnchorX => ((IView)_page).AnchorX;
+ public double AnchorY => ((IView)_page).AnchorY;
+ }
+
+ ///
+ /// TabLayout configuration strategy for ShellContent tabs
+ ///
+ internal class ShellTabConfigurationStrategy : Java.Lang.Object, TabLayoutMediator.ITabConfigurationStrategy
+ {
+ readonly ShellSection _shellSection;
+
+ public ShellTabConfigurationStrategy(ShellSection shellSection)
+ {
+ _shellSection = shellSection;
+ }
+
+ public void OnConfigureTab(TabLayout.Tab tab, int position)
+ {
+ if (_shellSection?.Items is null || position >= _shellSection.Items.Count)
+ return;
+
+ var shellContent = _shellSection.Items[position];
+ tab.SetText(shellContent.Title);
+ }
+ }
+
+ #endregion ViewPager2 Support Classes
+
+ ///
+ /// Adapter that bridges ShellSectionHandler with IShellSectionRenderer interface.
+ ///
+ internal class ShellSectionHandlerAdapter : IShellSectionRenderer
+ {
+ readonly ShellSectionHandler _handler;
+ ShellSectionWrapperFragment _wrapperFragment;
+
+ public ShellSectionHandlerAdapter(ShellSectionHandler handler, IMauiContext mauiContext)
+ {
+ _handler = handler ?? throw new ArgumentNullException(nameof(handler));
+ }
+
+ public Fragment Fragment
+ {
+ get
+ {
+ if (_wrapperFragment is null)
+ {
+ _wrapperFragment = new ShellSectionWrapperFragment(_handler);
+ }
+ return _wrapperFragment;
+ }
+ }
+
+ public ShellSection ShellSection
+ {
+ get => _handler.VirtualView;
+ set
+ {
+ if (_handler.VirtualView != value)
+ {
+ _handler.SetVirtualView(value);
+ }
+ }
+ }
+
+ public event EventHandler AnimationFinished;
+ public event EventHandler Destroyed;
+
+ public void Dispose()
+ {
+ Destroyed?.Invoke(this, EventArgs.Empty);
+ _wrapperFragment?.Dispose();
+ _wrapperFragment = null;
+ }
+
+ ///
+ /// Simple wrapper fragment - just returns the handler's unified view.
+ ///
+ class ShellSectionWrapperFragment : Fragment
+ {
+ readonly ShellSectionHandler _handler;
+ AView _view;
+
+ public ShellSectionWrapperFragment(ShellSectionHandler handler)
+ {
+ _handler = handler;
+ _handler.SetParentFragment(this);
+ }
+
+ public override void OnCreate(Bundle savedInstanceState)
+ {
+ base.OnCreate(null);
+ }
+
+ public override AView OnCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState)
+ {
+ if (_view is null)
+ {
+ _view = _handler.PlatformView ?? _handler.ToPlatform();
+ }
+
+ // Remove from parent if it has one (fragment recreation scenario)
+ if (_view.Parent is ViewGroup parent)
+ {
+ parent.RemoveView(_view);
+ }
+
+ return _view;
+ }
+
+ public override void OnViewCreated(AView view, Bundle savedInstanceState)
+ {
+ base.OnViewCreated(view, savedInstanceState);
+
+ // Setup adapter now that fragment is attached
+ _handler.SetupViewPagerAdapter();
+ }
+
+ public override void OnResume()
+ {
+ base.OnResume();
+
+ if (_handler.VirtualView is null)
+ return;
+
+ if (!_handler.IsCurrentlyActiveSection())
+ return;
+
+ var shell = _handler.VirtualView.FindParentOfType();
+ var currentContent = _handler.VirtualView.CurrentItem;
+
+ if (shell is null || currentContent is null)
+ return;
+
+ var page = ((IShellContentController)currentContent).GetOrCreateContent();
+ if (page is null)
+ return;
+
+ // Update toolbar
+ var toolbarTracker = _handler.ToolbarTracker;
+ toolbarTracker?.Page = page;
+
+ ((IShellController)shell).AppearanceChanged(page, false);
+ }
+
+ protected override void Dispose(bool disposing)
+ {
+ if (disposing)
+ {
+ _view = null;
+ }
+ base.Dispose(disposing);
+ }
+ }
+ }
+}
+#endif
diff --git a/src/Controls/src/Core/Hosting/AppHostBuilderExtensions.cs b/src/Controls/src/Core/Hosting/AppHostBuilderExtensions.cs
index cb496527128f..385183198268 100644
--- a/src/Controls/src/Core/Hosting/AppHostBuilderExtensions.cs
+++ b/src/Controls/src/Core/Hosting/AppHostBuilderExtensions.cs
@@ -221,9 +221,9 @@ internal static IMauiHandlersCollection AddControlsHandlers(this IMauiHandlersCo
handlersCollection.AddHandler();
#endif
-#if ANDROID || IOS || MACCATALYST
+#if IOS || MACCATALYST
handlersCollection.AddHandler();
-#elif WINDOWS
+#elif WINDOWS || ANDROID
handlersCollection.AddHandler();
handlersCollection.AddHandler();
handlersCollection.AddHandler();
diff --git a/src/Controls/src/Core/Platform/Android/BottomNavigationManager.cs b/src/Controls/src/Core/Platform/Android/BottomNavigationManager.cs
new file mode 100644
index 000000000000..884b10a512a3
--- /dev/null
+++ b/src/Controls/src/Core/Platform/Android/BottomNavigationManager.cs
@@ -0,0 +1,486 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Android.Content;
+using Android.Content.Res;
+using Android.Views;
+using AndroidX.Core.Content;
+using AndroidX.ViewPager2.Widget;
+using Google.Android.Material.BottomNavigation;
+using Google.Android.Material.BottomSheet;
+using Microsoft.Maui.ApplicationModel;
+using Microsoft.Maui.Graphics;
+using ColorStateList = Android.Content.Res.ColorStateList;
+
+namespace Microsoft.Maui.Controls.Platform;
+#pragma warning disable RS0016 // Add public types and members to the declared API
+///
+/// Manages a BottomNavigationView with shared functionality for both TabbedPage and Shell.
+/// This class extracts common bottom navigation patterns to enable code reuse.
+///
+public class BottomNavigationManager
+{
+ private readonly IMauiContext _mauiContext;
+ private readonly BottomNavigationView _bottomNavigationView;
+
+ private ColorStateList? _originalItemTextColors;
+ private ColorStateList? _originalItemIconTintColors;
+ private ColorStateList? _currentItemTextColors;
+ private ColorStateList? _currentItemIconTintColors;
+
+ private readonly int[] _checkedStateSet = new int[] { global::Android.Resource.Attribute.StateChecked };
+ private readonly int[] _emptyStateSet = Array.Empty();
+
+ ///
+ /// Callback invoked when a tab item is selected.
+ ///
+ public Action? OnTabSelected { get; set; }
+
+ ///
+ /// Callback invoked when the "More" button is clicked (for overflow scenarios).
+ ///
+ public Action? OnMoreClicked { get; set; }
+
+ ///
+ /// Gets the underlying BottomNavigationView.
+ ///
+ public BottomNavigationView BottomNavigationView => _bottomNavigationView;
+
+ ///
+ /// Gets the current dark theme state.
+ ///
+ public static bool IsDarkTheme => (Application.Current?.RequestedTheme ?? AppInfo.RequestedTheme) == AppTheme.Dark;
+
+ #region Factory Methods
+
+ ///
+ /// Creates a standard BottomNavigationView with common settings used by both Shell and TabbedPage.
+ ///
+ /// The Android context.
+ /// Optional layout parameters. If null, uses MatchParent width and WrapContent height.
+ /// A configured BottomNavigationView.
+ public static BottomNavigationView CreateBottomNavigationView(
+ Context context,
+ ViewGroup.LayoutParams? layoutParams = null)
+ {
+ var bottomNav = new BottomNavigationView(context, null, Resource.Attribute.bottomNavigationViewStyle)
+ {
+ LayoutParameters = layoutParams ?? new ViewGroup.LayoutParams(
+ ViewGroup.LayoutParams.MatchParent,
+ ViewGroup.LayoutParams.WrapContent),
+ LabelVisibilityMode = Google.Android.Material.BottomNavigation.LabelVisibilityMode.LabelVisibilityLabeled
+ };
+
+ return bottomNav;
+ }
+
+ ///
+ /// Creates a standard ViewPager2 with common settings used by both Shell and TabbedPage.
+ ///
+ /// The Android context.
+ /// Optional layout parameters. If null, uses MatchParent for both width and height.
+ /// A configured ViewPager2.
+ public static ViewPager2 CreateViewPager2(
+ Context context,
+ ViewGroup.LayoutParams? layoutParams = null)
+ {
+ return new ViewPager2(context)
+ {
+ OverScrollMode = OverScrollMode.Never,
+ LayoutParameters = layoutParams ?? new ViewGroup.LayoutParams(
+ ViewGroup.LayoutParams.MatchParent,
+ ViewGroup.LayoutParams.MatchParent)
+ };
+ }
+
+ #endregion
+
+ ///
+ /// Creates a new BottomNavigationManager.
+ ///
+ /// The MAUI context.
+ /// The BottomNavigationView to manage.
+ public BottomNavigationManager(
+ IMauiContext mauiContext,
+ BottomNavigationView bottomNavigationView)
+ {
+ _mauiContext = mauiContext ?? throw new ArgumentNullException(nameof(mauiContext));
+ _bottomNavigationView = bottomNavigationView ?? throw new ArgumentNullException(nameof(bottomNavigationView));
+
+ // Store original colors for restoration
+ _originalItemTextColors = bottomNavigationView.ItemTextColor;
+ _originalItemIconTintColors = bottomNavigationView.ItemIconTintList;
+ }
+
+ ///
+ /// Sets up the bottom navigation with the provided tab items.
+ ///
+ /// The tab items to display.
+ /// The initially selected index.
+ public void SetupTabs(IReadOnlyList items, int selectedIndex = 0)
+ {
+ var menu = _bottomNavigationView.Menu;
+ menu.Clear();
+
+ if (items is null || items.Count == 0)
+ {
+ return;
+ }
+
+ // Hide if only one item
+ if (items.Count == 1)
+ {
+ _bottomNavigationView.Visibility = ViewStates.Gone;
+ return;
+ }
+
+ _bottomNavigationView.Visibility = ViewStates.Visible;
+
+ // Setup listener
+ _bottomNavigationView.SetOnItemSelectedListener(new ItemSelectedListener(this));
+
+ // Add menu items
+ int maxItems = _bottomNavigationView.MaxItemCount;
+ bool showMore = items.Count > maxItems;
+ int end = showMore ? maxItems - 1 : items.Count;
+
+ for (int i = 0; i < end; i++)
+ {
+ var item = items[i];
+ var title = !string.IsNullOrWhiteSpace(item.Title) ? item.Title : $"Tab {i + 1}";
+ var menuItem = menu.Add(0, i, i, title);
+
+ if (menuItem is null)
+ {
+ continue;
+ }
+
+ if (!item.IsEnabled)
+ {
+ menuItem.SetEnabled(false);
+ }
+
+ // Load icon asynchronously
+ LoadMenuItemIconAsync(menuItem, item);
+ }
+
+ // Add "More" item if needed
+ if (showMore)
+ {
+ var moreItem = menu.Add(0, BottomNavigationViewUtils.MoreTabId, maxItems - 1, "More");
+ moreItem?.SetIcon(Resource.Drawable.abc_ic_menu_overflow_material);
+ }
+
+ // Set initial selection
+ if (selectedIndex >= 0 && selectedIndex < items.Count)
+ {
+ int targetId = selectedIndex >= end ? BottomNavigationViewUtils.MoreTabId : selectedIndex;
+ _bottomNavigationView.SelectedItemId = targetId;
+ }
+
+ // Apply shift mode fix
+ _bottomNavigationView.SetShiftMode(false, false);
+ }
+
+ ///
+ /// Updates a specific tab item's properties.
+ ///
+ /// The index of the tab to update.
+ /// The updated tab item data.
+ public void UpdateTab(int index, ITabItem item)
+ {
+ if (index < 0 || index >= _bottomNavigationView.Menu.Size())
+ {
+ return;
+ }
+
+ var menuItem = _bottomNavigationView.Menu.GetItem(index);
+ if (menuItem is null)
+ {
+ return;
+ }
+
+ menuItem.SetTitle(item.Title ?? string.Empty);
+ menuItem.SetEnabled(item.IsEnabled);
+ LoadMenuItemIconAsync(menuItem, item);
+ }
+
+ ///
+ /// Updates the selected item programmatically.
+ ///
+ /// The index to select.
+ public void SetSelectedItem(int index)
+ {
+ if (index >= 0 && _bottomNavigationView.SelectedItemId != index)
+ {
+ _bottomNavigationView.SelectedItemId = index;
+ }
+ }
+
+ ///
+ /// Updates the background color of the bottom navigation view.
+ ///
+ /// The background color, or null to use default.
+ public void UpdateBackgroundColor(Color? backgroundColor)
+ {
+ if (backgroundColor is null)
+ {
+ _bottomNavigationView.SetBackground(null);
+ }
+ else
+ {
+ _bottomNavigationView.SetBackgroundColor(backgroundColor.ToPlatform());
+ }
+ }
+
+ ///
+ /// Updates the background with a brush.
+ ///
+ /// The brush to apply as background.
+ public void UpdateBackground(Brush? brush)
+ {
+ _bottomNavigationView.UpdateBackground(brush);
+ }
+
+ ///
+ /// Updates the item text and icon colors.
+ ///
+ /// The color for unselected items.
+ /// The color for the selected item.
+ public void UpdateItemColors(Color? unselectedColor, Color? selectedColor)
+ {
+ _currentItemTextColors = null;
+ _currentItemIconTintColors = null;
+
+ if (unselectedColor is null && selectedColor is null)
+ {
+ // Restore original colors
+ _bottomNavigationView.ItemTextColor = _originalItemTextColors;
+ _bottomNavigationView.ItemIconTintList = _originalItemIconTintColors;
+ return;
+ }
+
+ int unselectedArgb = unselectedColor?.ToPlatform().ToArgb() ?? GetDefaultUnselectedColor();
+ int selectedArgb = selectedColor?.ToPlatform().ToArgb() ?? GetDefaultSelectedColor();
+
+ var colorStateList = CreateColorStateList(unselectedArgb, selectedArgb);
+
+ _currentItemTextColors = colorStateList;
+ _currentItemIconTintColors = colorStateList;
+
+ _bottomNavigationView.ItemTextColor = colorStateList;
+ _bottomNavigationView.ItemIconTintList = colorStateList;
+ }
+
+ ///
+ /// Clears the tab listener to prevent memory leaks.
+ ///
+ public void ClearListener()
+ {
+ _bottomNavigationView.SetOnItemSelectedListener(null);
+ }
+
+ ///
+ /// Shows a "More" bottom sheet for overflow items.
+ ///
+ /// The list of all tab items (title, icon, enabled).
+ /// Callback when an item is selected.
+ /// Optional callback when the sheet is dismissed.
+ public void ShowMoreSheet(
+ IReadOnlyList<(string title, ImageSource icon, bool tabEnabled)> items,
+ Action onItemSelected,
+ Action? onDismissed = null)
+ {
+ var bottomSheetDialog = BottomNavigationViewUtils.CreateMoreBottomSheet(
+ onItemSelected,
+ _mauiContext,
+ items as List<(string title, ImageSource icon, bool tabEnabled)> ?? new List<(string, ImageSource, bool)>(items),
+ _bottomNavigationView.MaxItemCount);
+
+ if (onDismissed is not null)
+ {
+ bottomSheetDialog.DismissEvent += (s, e) => onDismissed(bottomSheetDialog);
+ }
+
+ bottomSheetDialog.Show();
+ }
+
+ ///
+ /// Sets the icon tint for a specific item at the given index.
+ /// Uses the obsolete BottomNavigationItemView approach for per-item customization.
+ ///
+ /// The index of the item to update.
+ /// The color state list to apply, or null to clear.
+ public void SetItemIconTint(int index, ColorStateList? colors)
+ {
+#pragma warning disable XAOBS001 // Type or member is obsolete
+ if (_bottomNavigationView.GetChildAt(0) is BottomNavigationMenuView menuView)
+ {
+ if (index >= 0 && index < menuView.ChildCount)
+ {
+ var itemView = menuView.GetChildAt(index) as BottomNavigationItemView;
+ itemView?.SetIconTintList(colors);
+ }
+ }
+#pragma warning restore XAOBS001 // Type or member is obsolete
+ }
+
+ ///
+ /// Marks an item as checked after sheet dismissal.
+ ///
+ /// The index to check.
+ public void SetItemChecked(int index)
+ {
+ var menu = _bottomNavigationView.Menu;
+ int targetIndex = Math.Min(index, menu.Size() - 1);
+ if (targetIndex < 0)
+ return;
+
+ var menuItem = menu.GetItem(targetIndex);
+ menuItem?.SetChecked(true);
+ }
+
+ #region Public Helpers
+
+ ///
+ /// Gets the default color from the current theme for bottom navigation items.
+ ///
+ /// The Android context.
+ /// The default ARGB color value.
+ public static int GetDefaultColorFromTheme(Context? context)
+ {
+ if (context?.Theme is null)
+ {
+ return IsDarkTheme ? unchecked((int)0xB3FFFFFF) : unchecked((int)0x99000000);
+ }
+
+ var styledAttributes = context.Theme.ObtainStyledAttributes(
+ null,
+ Resource.Styleable.NavigationBarView,
+ Resource.Attribute.bottomNavigationStyle,
+ 0);
+
+ try
+ {
+ var defaultColors = styledAttributes.GetColorStateList(
+ Resource.Styleable.NavigationBarView_itemIconTint);
+
+ if (defaultColors is not null)
+ {
+ return defaultColors.DefaultColor;
+ }
+
+ // Fallback to hardcoded values
+ if (IsDarkTheme)
+ {
+ return AndroidX.Core.Graphics.ColorUtils.SetAlphaComponent(
+ ContextCompat.GetColor(context, Resource.Color.primary_dark_material_light),
+ 153);
+ }
+ else
+ {
+ return AndroidX.Core.Graphics.ColorUtils.SetAlphaComponent(
+ ContextCompat.GetColor(context, Resource.Color.primary_dark_material_dark),
+ 153);
+ }
+ }
+ finally
+ {
+ styledAttributes.Recycle();
+ }
+ }
+
+ ///
+ /// Creates a ColorStateList for checked/unchecked states.
+ ///
+ /// The ARGB color for unselected state.
+ /// The ARGB color for selected state.
+ /// A new ColorStateList.
+ public static ColorStateList CreateCheckedColorStateList(int unselectedColor, int selectedColor)
+ {
+ int[][] states = new int[2][];
+ int[] colors = new int[2];
+
+ states[0] = new int[] { global::Android.Resource.Attribute.StateChecked };
+ colors[0] = selectedColor;
+ states[1] = Array.Empty();
+ colors[1] = unselectedColor;
+
+#pragma warning disable RS0030 // Do not use banned APIs
+ return new ColorStateList(states, colors);
+#pragma warning restore RS0030
+ }
+
+ #endregion
+
+ #region Private Helpers
+
+ private async void LoadMenuItemIconAsync(IMenuItem menuItem, ITabItem item)
+ {
+ try
+ {
+ var drawable = await item.GetIconDrawableAsync(_mauiContext);
+ if (drawable is not null && menuItem.IsAlive())
+ {
+ menuItem.SetIcon(drawable);
+ }
+ }
+ catch (Exception ex)
+ {
+ System.Diagnostics.Debug.WriteLine($"BottomNavigationManager: Failed to load icon: {ex.Message}");
+ }
+ }
+
+ private ColorStateList CreateColorStateList(int unselectedColor, int selectedColor)
+ {
+ int[][] states = new int[2][];
+ int[] colors = new int[2];
+
+ states[0] = _checkedStateSet;
+ colors[0] = selectedColor;
+ states[1] = _emptyStateSet;
+ colors[1] = unselectedColor;
+
+#pragma warning disable RS0030 // Do not use banned APIs
+ return new ColorStateList(states, colors);
+#pragma warning restore RS0030
+ }
+
+ private int GetDefaultUnselectedColor()
+ {
+ return GetDefaultColorFromTheme(_mauiContext.Context);
+ }
+
+ private int GetDefaultSelectedColor()
+ {
+ return GetDefaultColorFromTheme(_mauiContext.Context);
+ }
+
+ #endregion
+
+ #region Item Selected Listener
+
+ private class ItemSelectedListener : Java.Lang.Object, Google.Android.Material.Navigation.NavigationBarView.IOnItemSelectedListener
+ {
+ private readonly BottomNavigationManager _manager;
+
+ public ItemSelectedListener(BottomNavigationManager manager)
+ {
+ _manager = manager;
+ }
+
+ public bool OnNavigationItemSelected(IMenuItem item)
+ {
+ if (item.ItemId == BottomNavigationViewUtils.MoreTabId)
+ {
+ _manager.OnMoreClicked?.Invoke();
+ return true;
+ }
+
+ _manager.OnTabSelected?.Invoke(item.ItemId);
+ return true;
+ }
+ }
+
+ #endregion
+}
diff --git a/src/Controls/src/Core/Platform/Android/ITabItem.cs b/src/Controls/src/Core/Platform/Android/ITabItem.cs
new file mode 100644
index 000000000000..9575a31019af
--- /dev/null
+++ b/src/Controls/src/Core/Platform/Android/ITabItem.cs
@@ -0,0 +1,97 @@
+using System.Threading.Tasks;
+using Android.Graphics.Drawables;
+#pragma warning disable RS0016 // Add public types and members to the declared API
+namespace Microsoft.Maui.Controls.Platform;
+
+///
+/// Represents an item that can be displayed in a bottom navigation view or tab layout.
+/// This interface enables code sharing between TabbedPage and Shell tab handling.
+///
+public interface ITabItem
+{
+ ///
+ /// Gets the title text to display for this tab item.
+ ///
+ string Title { get; }
+
+ ///
+ /// Gets the icon image source for this tab item.
+ ///
+ ImageSource? Icon { get; }
+
+ ///
+ /// Gets whether this tab item is enabled and can be selected.
+ ///
+ bool IsEnabled { get; }
+}
+
+///
+/// Provides extension methods for loading tab item icons.
+///
+public static class TabItemExtensions
+{
+ ///
+ /// Loads the icon drawable for a tab item asynchronously.
+ ///
+ /// The tab item to load the icon for.
+ /// The MAUI context for image loading.
+ /// The loaded drawable, or null if no icon is set.
+ public static async Task GetIconDrawableAsync(this ITabItem tabItem, IMauiContext mauiContext)
+ {
+ if (tabItem.Icon is null)
+ {
+ return null;
+ }
+
+ var result = await tabItem.Icon.GetPlatformImageAsync(mauiContext);
+ return result?.Value;
+ }
+}
+
+///
+/// Adapter that wraps a TabbedPage child Page as an ITabItem.
+///
+internal class PageTabItem : ITabItem
+{
+ private readonly Page _page;
+
+ public PageTabItem(Page page)
+ {
+ _page = page ?? throw new System.ArgumentNullException(nameof(page));
+ }
+
+ public string Title => _page.Title ?? string.Empty;
+
+ public ImageSource? Icon => _page.IconImageSource;
+
+ public bool IsEnabled => _page.IsEnabled;
+
+ ///
+ /// Gets the underlying Page.
+ ///
+ public Page Page => _page;
+}
+
+///
+/// Adapter that wraps a ShellSection as an ITabItem.
+///
+internal class ShellSectionTabItem : ITabItem
+{
+ private readonly ShellSection _section;
+
+ public ShellSectionTabItem(ShellSection section)
+ {
+ _section = section ?? throw new System.ArgumentNullException(nameof(section));
+ }
+
+ public string Title => !string.IsNullOrWhiteSpace(_section.Title) ? _section.Title : "Tab";
+
+ public ImageSource? Icon => _section.Icon;
+
+ public bool IsEnabled => _section.IsEnabled;
+
+ ///
+ /// Gets the underlying ShellSection.
+ ///
+ public ShellSection Section => _section;
+}
diff --git a/src/Controls/src/Core/Platform/Android/TabbedPageManager.cs b/src/Controls/src/Core/Platform/Android/TabbedPageManager.cs
index d1f243c972c5..1f124bc0d4bc 100644
--- a/src/Controls/src/Core/Platform/Android/TabbedPageManager.cs
+++ b/src/Controls/src/Core/Platform/Android/TabbedPageManager.cs
@@ -41,6 +41,7 @@ public class TabbedPageManager
FragmentManager _fragmentManager;
TabLayout _tabLayout;
BottomNavigationView _bottomNavigationView;
+ BottomNavigationManager _bottomNavigationManager;
ViewPager2 _viewPager;
protected Page previousPage;
int[] _checkedStateSet = null;
@@ -71,27 +72,26 @@ public TabbedPageManager(IMauiContext context)
{
_context = context;
_listeners = new Listeners(this);
- _viewPager = new ViewPager2(context.Context)
- {
- OverScrollMode = OverScrollMode.Never,
- LayoutParameters = new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MatchParent, ViewGroup.LayoutParams.MatchParent)
- };
+ // Use shared factory method for ViewPager2 creation
+ _viewPager = BottomNavigationManager.CreateViewPager2(context.Context);
_viewPager.RegisterOnPageChangeCallback(_listeners);
}
internal IMauiContext MauiContext => _context;
protected FragmentManager FragmentManager => _fragmentManager ??= _context.GetFragmentManager();
- public bool IsBottomTabPlacement => (Element != null) ? Element.OnThisPlatform().GetToolbarPlacement() == ToolbarPlacement.Bottom : false;
+ public bool IsBottomTabPlacement => (Element is not null) ? Element.OnThisPlatform().GetToolbarPlacement() == ToolbarPlacement.Bottom : false;
public Color BarItemColor
{
get
{
- if (Element != null)
+ if (Element is not null)
{
if (Element.IsSet(TabbedPage.UnselectedTabColorProperty))
+ {
return Element.UnselectedTabColor;
+ }
}
return null;
@@ -102,10 +102,12 @@ public Color BarSelectedItemColor
{
get
{
- if (Element != null)
+ if (Element is not null)
{
if (Element.IsSet(TabbedPage.SelectedTabColorProperty))
+ {
return Element.SelectedTabColor;
+ }
}
return null;
@@ -130,6 +132,7 @@ public virtual void SetElement(TabbedPage tabbedPage)
}
Element = tabbedPage;
+
if (Element is not null)
{
_viewPager.LayoutChange += OnLayoutChanged;
@@ -139,17 +142,22 @@ public virtual void SetElement(TabbedPage tabbedPage)
if (IsBottomTabPlacement)
{
- _bottomNavigationView = new BottomNavigationView(_context.Context)
- {
- LayoutParameters = new CoordinatorLayout.LayoutParams(AppBarLayout.LayoutParams.MatchParent, AppBarLayout.LayoutParams.WrapContent)
+ // Use shared factory method for BottomNavigationView creation
+ _bottomNavigationView = BottomNavigationManager.CreateBottomNavigationView(
+ _context.Context,
+ new CoordinatorLayout.LayoutParams(AppBarLayout.LayoutParams.MatchParent, AppBarLayout.LayoutParams.WrapContent)
{
Gravity = (int)GravityFlags.Bottom
- }
- };
+ });
+
+ // Create BottomNavigationManager for shared tab management
+ _bottomNavigationManager = new BottomNavigationManager(_context, _bottomNavigationView);
+ _bottomNavigationManager.OnTabSelected = OnBottomTabSelected;
+ _bottomNavigationManager.OnMoreClicked = OnMoreClicked;
}
else
{
- if (_tabLayout == null)
+ if (_tabLayout is null)
{
var layoutInflater = Element.Handler.MauiContext.GetLayoutInflater();
_tabLayout = new TabLayout(_context.Context)
@@ -183,7 +191,7 @@ void RemoveTabs()
_pendingFragment?.Dispose();
_pendingFragment = null;
- if (_tabLayoutFragment != null)
+ if (_tabLayoutFragment is not null)
{
var fragment = _tabLayoutFragment;
_tabLayoutFragment = null;
@@ -245,7 +253,7 @@ internal void SetTabLayout()
_context.GetNavigationRootManager();
_tabItemStyleLoaded = false;
- if (rootManager.RootView == null)
+ if (rootManager.RootView is null)
{
rootManager.RootViewChanged += RootViewChanged;
return;
@@ -299,7 +307,7 @@ void SetContentBottomMargin(int bottomMargin)
{
var rootManager = _context.GetNavigationRootManager();
var layoutContent = rootManager.RootView?.FindViewById(Resource.Id.navigationlayout_content);
- if (layoutContent != null && layoutContent.LayoutParameters is ViewGroup.MarginLayoutParams cl)
+ if (layoutContent is not null && layoutContent.LayoutParameters is ViewGroup.MarginLayoutParams cl)
{
cl.BottomMargin = bottomMargin;
}
@@ -325,11 +333,12 @@ protected virtual void OnChildrenCollectionChanged(object sender, NotifyCollecti
if (Element.Children.Count == 0)
{
bottomNavigationView.Menu.Clear();
+ _bottomNavigationManager?.ClearListener();
}
else
{
+ // BottomNavigationManager.SetupTabs handles listener setup
SetupBottomNavigationView();
- bottomNavigationView.SetOnItemSelectedListener(_listeners);
}
UpdateIgnoreContainerAreas();
@@ -348,7 +357,7 @@ protected virtual void OnChildrenCollectionChanged(object sender, NotifyCollecti
}
else
{
- if (_tabLayoutMediator == null)
+ if (_tabLayoutMediator is null)
{
_tabLayoutMediator = new TabLayoutMediator(tabs, _viewPager, _listeners);
_tabLayoutMediator.Attach();
@@ -382,12 +391,16 @@ protected void NotifyDataSetChanged()
protected virtual void TabSelected(TabLayout.Tab tab)
{
- if (Element == null)
+ if (Element is null)
+ {
return;
+ }
int selectedIndex = tab.Position;
if (Element.Children.Count > selectedIndex && selectedIndex >= 0)
+ {
Element.CurrentPage = Element.Children[selectedIndex];
+ }
SetIconColorFilter(Element.CurrentPage, tab, true);
}
@@ -405,7 +418,9 @@ void SetupPage(Page page)
void Reset()
{
foreach (var page in Element.Children)
+ {
SetupPage(page);
+ }
}
protected virtual void OnPagePropertyChanged(Page page, PropertyChangedEventArgs e)
@@ -454,8 +469,10 @@ void OnPagePropertyChanged(object sender, PropertyChangedEventArgs e)
internal void ScrollToCurrentPage()
{
- if (Element.CurrentPage == null)
+ if (Element.CurrentPage is null)
+ {
return;
+ }
// TODO MAUI
//if (Platform != null)
@@ -474,7 +491,9 @@ internal void ScrollToCurrentPage()
void UpdateIgnoreContainerAreas()
{
foreach (IPageController child in Element.Children)
+ {
child.IgnoresContainerArea = child is NavigationPage;
+ }
}
[Obsolete]
@@ -503,21 +522,55 @@ internal void UpdateSwipePaging()
protected virtual void SetupBottomNavigationView()
{
+ if (_bottomNavigationManager is null)
+ {
+ return;
+ }
+
var currentIndex = Element.Children.IndexOf(Element.CurrentPage);
- var items = CreateTabList();
- BottomNavigationViewUtils.SetupMenu(
- _bottomNavigationView.Menu,
- _bottomNavigationView.MaxItemCount,
- items,
- currentIndex,
- _bottomNavigationView,
- Element.FindMauiContext());
+ // Convert Pages to ITabItem list
+ var tabItems = new List();
+ foreach (var page in Element.Children)
+ {
+ tabItems.Add(new PageTabItem(page));
+ }
+
+ // Use BottomNavigationManager for shared tab setup
+ _bottomNavigationManager.SetupTabs(tabItems, currentIndex);
if (Element.CurrentPage == null && Element.Children.Count > 0)
Element.CurrentPage = Element.Children[0];
}
+ ///
+ /// Callback invoked when a bottom tab is selected via BottomNavigationManager.
+ ///
+ void OnBottomTabSelected(int index)
+ {
+ if (Element is null || index < 0 || index >= Element.Children.Count)
+ {
+ return;
+ }
+
+ if (_bottomNavigationView.SelectedItemId != index || Element.CurrentPage != Element.Children[index])
+ {
+ Element.CurrentPage = Element.Children[index];
+ }
+ }
+
+ ///
+ /// Callback invoked when the "More" button is clicked in bottom navigation.
+ ///
+ void OnMoreClicked()
+ {
+ var items = CreateTabList();
+ _bottomNavigationManager?.ShowMoreSheet(
+ items,
+ OnMoreItemSelected,
+ OnMoreSheetDismissedInternal);
+ }
+
protected virtual void UpdateTabIcons()
{
TabLayout tabs = _tabLayout;
@@ -551,24 +604,24 @@ void SetTabIconImageSource(Page page, TabLayout.Tab tab)
public virtual void UpdateBarBackgroundColor()
{
- if (Element.BarBackground != null)
+ if (Element.BarBackground is not null)
+ {
return;
+ }
if (IsBottomTabPlacement)
{
- Color tintColor = Element.BarBackgroundColor;
-
- if (tintColor == null)
- _bottomNavigationView.SetBackground(null);
- else if (tintColor != null)
- _bottomNavigationView.SetBackgroundColor(tintColor.ToPlatform());
+ // Use BottomNavigationManager for consistent color handling
+ _bottomNavigationManager?.UpdateBackgroundColor(Element.BarBackgroundColor);
}
else
{
Color tintColor = Element.BarBackgroundColor;
- if (tintColor == null)
+ if (tintColor is null)
+ {
_tabLayout.BackgroundTintMode = null;
+ }
else
{
_tabLayout.BackgroundTintMode = PorterDuff.Mode.Src;
@@ -580,7 +633,9 @@ public virtual void UpdateBarBackgroundColor()
public virtual void UpdateBarBackground()
{
if (_currentBarBackground == Element.BarBackground)
+ {
return;
+ }
if (_currentBarBackground is GradientBrush oldGradientBrush)
{
@@ -607,15 +662,21 @@ void OnBarBackgroundChanged(object sender, EventArgs e)
protected virtual void RefreshBarBackground()
{
if (IsBottomTabPlacement)
- _bottomNavigationView.UpdateBackground(_currentBarBackground);
+ {
+ _bottomNavigationManager?.UpdateBackground(_currentBarBackground);
+ }
else
+ {
_tabLayout.UpdateBackground(_currentBarBackground);
+ }
}
protected virtual ColorStateList GetItemTextColorStates()
{
if (_originalTabTextColors is null)
+ {
_originalTabTextColors = IsBottomTabPlacement ? _bottomNavigationView.ItemTextColor : _tabLayout.TabTextColors;
+ }
Color barItemColor = BarItemColor;
Color barTextColor = Element.BarTextColor;
@@ -710,69 +771,34 @@ protected virtual ColorStateList GetItemIconTintColorState(Page page)
int GetDefaultColor()
{
- int defaultColor;
- var styledAttributes =
- _context.Context.Theme.ObtainStyledAttributes(
- null,
- Resource.Styleable.NavigationBarView,
- Resource.Attribute.bottomNavigationStyle,
- 0);
-
- try
- {
- var defaultColors = styledAttributes.GetColorStateList(Resource.Styleable.NavigationBarView_itemIconTint);
- if (defaultColors is not null)
- {
- defaultColor = defaultColors.DefaultColor;
- }
- else
- {
- // These are the defaults currently set inside android
- // It's very unlikely we'll hit this path because the
- // NavigationBarView_itemIconTint should always resolve
- // But just in case, we'll just hard code to some defaults
- // instead of leaving the application in a broken state
- if (IsDarkTheme)
- {
- defaultColor = AndroidX.Core.Graphics.ColorUtils.SetAlphaComponent(
- ContextCompat.GetColor(_context.Context, Resource.Color.primary_dark_material_light),
- 153); // 60% opacity
- }
- else
- {
- defaultColor = AndroidX.Core.Graphics.ColorUtils.SetAlphaComponent(
- ContextCompat.GetColor(_context.Context, Resource.Color.primary_dark_material_dark),
- 153); // 60% opacity
- }
- }
- }
- finally
- {
- styledAttributes.Recycle();
- }
- return defaultColor;
+ // Use shared implementation from BottomNavigationManager
+ return BottomNavigationManager.GetDefaultColorFromTheme(_context.Context);
}
protected virtual void OnMoreSheetDismissed(object sender, EventArgs e)
{
var index = Element.Children.IndexOf(Element.CurrentPage);
- using (var menu = _bottomNavigationView.Menu)
- {
- index = Math.Min(index, menu.Size() - 1);
- if (index < 0)
- return;
- using (var menuItem = menu.GetItem(index))
- menuItem.SetChecked(true);
- }
+ // Use shared implementation from BottomNavigationManager
+ _bottomNavigationManager?.SetItemChecked(index);
if (sender is BottomSheetDialog bsd)
+ {
bsd.DismissEvent -= OnMoreSheetDismissed;
+ }
+ }
+
+ void OnMoreSheetDismissedInternal(BottomSheetDialog dialog)
+ {
+ var index = Element.Children.IndexOf(Element.CurrentPage);
+ _bottomNavigationManager?.SetItemChecked(index);
}
protected virtual void OnMoreItemSelected(int selectedIndex, BottomSheetDialog dialog)
{
if (selectedIndex >= 0 && _bottomNavigationView.SelectedItemId != selectedIndex && Element.Children.Count > selectedIndex)
+ {
Element.CurrentPage = Element.Children[selectedIndex];
+ }
dialog.Dismiss();
dialog.DismissEvent -= OnMoreSheetDismissed;
@@ -805,24 +831,9 @@ void UpdateItemIconColor()
void SetupBottomNavigationViewIconColor(Page page, IMenuItem menuItem, int i)
{
- // Updating the icon color of each BottomNavigationView item individually works correctly.
- // This is necessary because `ItemIconTintList` applies the color globally to all items,
- // which doesn't allow for per-item customization.
- // Currently, there is no modern API that provides the desired behavior.
- // Therefore, the obsolete `BottomNavigationItemView` approach is used.
-#pragma warning disable XAOBS001 // Type or member is obsolete
- if (_bottomNavigationView.GetChildAt(0) is BottomNavigationMenuView menuView)
- {
- var itemView = menuView.GetChildAt(i) as BottomNavigationItemView;
-
- if (itemView != null && itemView.Id == menuItem.ItemId)
- {
- ColorStateList colors = GetItemIconTintColorState(page);
-
- itemView.SetIconTintList(colors);
- }
- }
-#pragma warning restore XAOBS001 // Type or member is obsolete
+ // Use shared implementation from BottomNavigationManager for per-item icon tinting
+ ColorStateList colors = GetItemIconTintColorState(page);
+ _bottomNavigationManager?.SetItemIconTint(i, colors);
}
protected virtual void UpdateStyleForTabItem()
@@ -844,8 +855,16 @@ protected virtual void UpdateStyleForTabItem()
_currentBarTextColor = Element.BarTextColor;
_currentBarSelectedItemColor = BarSelectedItemColor;
- UpdateBarTextColor();
- UpdateItemIconColor();
+ if (IsBottomTabPlacement)
+ {
+ // Use BottomNavigationManager for consistent color handling
+ _bottomNavigationManager?.UpdateItemColors(barItemColor, barSelectedItemColor);
+ }
+ else
+ {
+ UpdateBarTextColor();
+ UpdateItemIconColor();
+ }
}
internal void UpdateTabItemStyle()
@@ -859,9 +878,13 @@ void UpdateBarTextColor()
_currentBarTextColorStateList = GetItemTextColorStates() ?? _originalTabTextColors;
if (IsBottomTabPlacement)
+ {
_bottomNavigationView.ItemTextColor = _currentBarTextColorStateList;
+ }
else
+ {
_tabLayout.TabTextColors = _currentBarTextColorStateList;
+ }
}
void SetIconColorFilter(Page page, TabLayout.Tab tab)
@@ -872,23 +895,34 @@ void SetIconColorFilter(Page page, TabLayout.Tab tab)
protected virtual void SetIconColorFilter(Page page, TabLayout.Tab tab, bool selected)
{
var icon = tab.Icon;
- if (icon == null)
+ if (icon is null)
+ {
return;
+ }
ColorStateList colors = GetItemIconTintColorState(page);
- if (colors == null)
+
+ if (colors is null)
+ {
ADrawableCompat.SetTintList(icon, null);
+ }
else
{
int[] _stateSet = null;
if (selected)
+ {
_stateSet = GetSelectedStateSet();
+ }
else
+ {
_stateSet = GetEmptyStateSet();
+ }
if (colors.GetColorForState(_stateSet, _defaultAndroidColor) == _defaultARGBColor)
+ {
ADrawableCompat.SetTintList(icon, null);
+ }
else
{
var wrappedIcon = ADrawableCompat.Wrap(icon);
@@ -917,15 +951,19 @@ int[] GetSelectedStateSet()
{
if (IsBottomTabPlacement)
{
- if (_checkedStateSet == null)
+ if (_checkedStateSet is null)
+ {
_checkedStateSet = new int[] { global::Android.Resource.Attribute.StateChecked };
+ }
return _checkedStateSet;
}
else
{
- if (_selectedStateSet == null)
+ if (_selectedStateSet is null)
+ {
_selectedStateSet = GetStateSet(new TempView(_context.Context).SelectedStateSet);
+ }
return _selectedStateSet;
}
@@ -933,8 +971,10 @@ int[] GetSelectedStateSet()
int[] GetEmptyStateSet()
{
- if (_emptyStateSet == null)
+ if (_emptyStateSet is null)
+ {
_emptyStateSet = GetStateSet(new TempView(_context.Context).EmptyStateSet);
+ }
return _emptyStateSet;
}
@@ -953,7 +993,9 @@ int[] GetStateSet(IList stateSet)
{
var results = new int[stateSet.Count];
for (int i = 0; i < results.Length; i++)
+ {
results[i] = stateSet[i];
+ }
return results;
}
@@ -994,8 +1036,10 @@ public override void OnPageSelected(int position)
var Element = _tabbedPageManager.Element;
- if (Element == null)
+ if (Element is null)
+ {
return;
+ }
var _previousPage = _tabbedPageManager.previousPage;
var IsBottomTabPlacement = _tabbedPageManager.IsBottomTabPlacement;
@@ -1016,7 +1060,9 @@ public override void OnPageSelected(int position)
}
if (IsBottomTabPlacement)
+ {
_bottomNavigationView.SelectedItemId = position;
+ }
}
void TabLayoutMediator.ITabConfigurationStrategy.OnConfigureTab(TabLayout.Tab p0, int p1)
@@ -1026,8 +1072,10 @@ void TabLayoutMediator.ITabConfigurationStrategy.OnConfigureTab(TabLayout.Tab p0
bool NavigationBarView.IOnItemSelectedListener.OnNavigationItemSelected(IMenuItem item)
{
- if (_tabbedPageManager.Element == null)
+ if (_tabbedPageManager.Element is null)
+ {
return false;
+ }
var id = item.ItemId;
if (id == BottomNavigationViewUtils.MoreTabId)
@@ -1040,7 +1088,9 @@ bool NavigationBarView.IOnItemSelectedListener.OnNavigationItemSelected(IMenuIte
else
{
if (_tabbedPageManager._bottomNavigationView.SelectedItemId != item.ItemId && _tabbedPageManager.Element.Children.Count > item.ItemId)
+ {
_tabbedPageManager.Element.CurrentPage = _tabbedPageManager.Element.Children[item.ItemId];
+ }
}
return true;
diff --git a/src/Core/src/Handlers/FlyoutView/FlyoutViewHandler.Android.cs b/src/Core/src/Handlers/FlyoutView/FlyoutViewHandler.Android.cs
index fac7d6e86772..9477e269b4b9 100644
--- a/src/Core/src/Handlers/FlyoutView/FlyoutViewHandler.Android.cs
+++ b/src/Core/src/Handlers/FlyoutView/FlyoutViewHandler.Android.cs
@@ -9,31 +9,38 @@
using AndroidX.DrawerLayout.Widget;
using AndroidX.Fragment.App;
using AndroidX.Lifecycle;
+using Microsoft.Maui.Platform;
+#pragma warning disable RS0016 // Add public types and members to the declared API
namespace Microsoft.Maui.Handlers
{
- public partial class FlyoutViewHandler : ViewHandler
+ public partial class FlyoutViewHandler : ViewHandler
{
View? _flyoutView;
const uint DefaultScrimColor = 0x99000000;
View? _navigationRoot;
- LinearLayoutCompat? _sideBySideView;
- DrawerLayout DrawerLayout => (DrawerLayout)PlatformView;
ScopedFragment? _detailViewFragment;
- protected override View CreatePlatformView()
+ // MauiDrawerLayout provides: _sideBySideView, layout methods, lock modes
+ MauiDrawerLayout MauiDrawerLayout => PlatformView;
+
+ protected override MauiDrawerLayout CreatePlatformView()
{
var li = MauiContext?.GetLayoutInflater();
_ = li ?? throw new InvalidOperationException($"LayoutInflater cannot be null");
- var dl = li.Inflate(Resource.Layout.drawer_layout, null)
- .JavaCast()
- ?? throw new InvalidOperationException($"Resource.Layout.drawer_layout missing");
+ // Create MauiDrawerLayout instead of raw DrawerLayout
+ var dl = new MauiDrawerLayout(Context);
+ // Create navigation root from XML
_navigationRoot = li.Inflate(Resource.Layout.navigationlayout, null)
?? throw new InvalidOperationException($"Resource.Layout.navigationlayout missing");
_navigationRoot.Id = View.GenerateViewId();
+
+ // Set navigation root as content view in MauiDrawerLayout
+ dl.SetContentView(_navigationRoot);
+
return dl;
}
@@ -138,127 +145,44 @@ void UpdateFlyout()
_flyoutView.SetBackgroundColor(new global::Android.Graphics.Color(colors.GetColor(0, 0)));
}
- LayoutViews();
+ // Use MauiDrawerLayout to set the flyout view
+ MauiDrawerLayout.FlyoutWidth = FlyoutWidth;
+ MauiDrawerLayout.SetFlyoutView(_flyoutView);
+
+ // Set layout mode based on behavior
+ UpdateFlyoutBehavior();
}
void LayoutViews()
{
+ // Layout is now handled by MauiDrawerLayout internally
+ // Just ensure behavior is set correctly
if (_flyoutView == null)
return;
- if (VirtualView.FlyoutBehavior == FlyoutBehavior.Locked)
- LayoutSideBySide();
- else
- LayoutAsFlyout();
- }
-
- void LayoutSideBySide()
- {
- var flyoutView = _flyoutView;
- if (MauiContext == null || _navigationRoot == null || flyoutView == null)
- return;
-
- if (_sideBySideView == null)
- {
- _sideBySideView = new LinearLayoutCompat(Context)
- {
- Orientation = LinearLayoutCompat.Horizontal,
- LayoutParameters = new DrawerLayout.LayoutParams(
- DrawerLayout.LayoutParams.MatchParent,
- DrawerLayout.LayoutParams.MatchParent)
- };
- }
-
- if (_navigationRoot.Parent != _sideBySideView)
- {
- _navigationRoot.RemoveFromParent();
-
- var layoutParameters =
- new LinearLayoutCompat.LayoutParams(
- LinearLayoutCompat.LayoutParams.MatchParent,
- LinearLayoutCompat.LayoutParams.MatchParent,
- 1);
-
- _sideBySideView.AddView(_navigationRoot, layoutParameters);
- UpdateDetailsFragmentView();
- }
-
- if (flyoutView.Parent != _sideBySideView)
- {
- // When the Flyout is acting as a flyout Android will set the Visibility to GONE when it's off screen
- // This makes sure it's visible
- flyoutView.Visibility = ViewStates.Visible;
- flyoutView.RemoveFromParent();
- var layoutParameters =
- new LinearLayoutCompat.LayoutParams(
- (int)FlyoutWidth,
- LinearLayoutCompat.LayoutParams.MatchParent,
- 0);
-
- _sideBySideView.AddView(flyoutView, 0, layoutParameters);
- }
-
- if (_sideBySideView.Parent != PlatformView)
- DrawerLayout.AddView(_sideBySideView);
- else
- UpdateDetailsFragmentView();
-
- if (VirtualView is IToolbarElement te && te.Toolbar?.Handler is ToolbarHandler th)
- th.SetupWithDrawerLayout(null);
- }
-
- void LayoutAsFlyout()
- {
- var flyoutView = _flyoutView;
- if (MauiContext == null || _navigationRoot == null || flyoutView == null)
- return;
-
- _sideBySideView?.RemoveAllViews();
- _sideBySideView?.RemoveFromParent();
-
- if (_navigationRoot.Parent != PlatformView)
- {
- _navigationRoot.RemoveFromParent();
-
- var layoutParameters =
- new LinearLayoutCompat.LayoutParams(
- LinearLayoutCompat.LayoutParams.MatchParent,
- LinearLayoutCompat.LayoutParams.MatchParent);
-
- DrawerLayout.AddView(_navigationRoot, 0, layoutParameters);
- }
+ MauiDrawerLayout.FlyoutLayoutModeValue = VirtualView.FlyoutBehavior == FlyoutBehavior.Locked
+ ? MauiDrawerLayout.FlyoutLayoutMode.SideBySide
+ : MauiDrawerLayout.FlyoutLayoutMode.Flyout;
+ // Update fragment view after layout
UpdateDetailsFragmentView();
- if (flyoutView.Parent != PlatformView)
+ // Update toolbar integration
+ if (VirtualView is IToolbarElement te && te.Toolbar?.Handler is ToolbarHandler th)
{
- flyoutView.RemoveFromParent();
-
- var layoutParameters =
- new DrawerLayout.LayoutParams(
- (int)FlyoutWidth,
- DrawerLayout.LayoutParams.MatchParent,
- (int)GravityFlags.Start);
-
- // Flyout has to get added after the content otherwise clicking anywhere
- // on the flyout will cause it to close and gesture
- // recognizers inside the flyout won't fire
- DrawerLayout.AddView(flyoutView, layoutParameters);
+ th.SetupWithDrawerLayout(VirtualView.FlyoutBehavior == FlyoutBehavior.Locked ? null : MauiDrawerLayout);
}
-
- if (VirtualView is IToolbarElement te && te.Toolbar?.Handler is ToolbarHandler th)
- th.SetupWithDrawerLayout(DrawerLayout);
}
+ // LayoutSideBySide and LayoutAsFlyout are now handled by MauiDrawerLayout
+
void UpdateIsPresented()
{
- if (_flyoutView?.Parent == DrawerLayout)
- {
- if (VirtualView.IsPresented)
- DrawerLayout.OpenDrawer(_flyoutView);
- else
- DrawerLayout.CloseDrawer(_flyoutView);
- }
+ // Use MauiDrawerLayout's open/close methods
+ if (VirtualView.IsPresented)
+ MauiDrawerLayout.OpenFlyout();
+ else
+ MauiDrawerLayout.CloseFlyout();
}
void UpdateFlyoutBehavior()
@@ -270,20 +194,17 @@ void UpdateFlyoutBehavior()
// Important to create the layout views before setting the lock mode
LayoutViews();
- switch (behavior)
+ // Use MauiDrawerLayout's SetBehavior method for consistent behavior handling
+ MauiDrawerLayout.SetBehavior(behavior);
+
+ // Also set gesture enabled state
+ if (behavior == FlyoutBehavior.Flyout)
{
- case FlyoutBehavior.Disabled:
- case FlyoutBehavior.Locked:
- DrawerLayout.CloseDrawers();
- DrawerLayout.SetDrawerLockMode(DrawerLayout.LockModeLockedClosed);
- break;
- case FlyoutBehavior.Flyout:
- DrawerLayout.SetDrawerLockMode(VirtualView.IsGestureEnabled ? DrawerLayout.LockModeUnlocked : DrawerLayout.LockModeLockedClosed);
- break;
+ MauiDrawerLayout.SetGestureEnabled(VirtualView.IsGestureEnabled);
}
}
- protected override void ConnectHandler(View platformView)
+ protected override void ConnectHandler(MauiDrawerLayout platformView)
{
MauiWindowInsetListener.RegisterParentForChildViews(platformView);
@@ -292,14 +213,12 @@ protected override void ConnectHandler(View platformView)
MauiWindowInsetListener.SetupViewWithLocalListener(cl);
}
- if (platformView is DrawerLayout dl)
- {
- dl.DrawerStateChanged += OnDrawerStateChanged;
- dl.ViewAttachedToWindow += DrawerLayoutAttached;
- }
+ // Subscribe to MauiDrawerLayout events
+ platformView.OnPresentedChanged += HandlePresentedChanged;
+ platformView.ViewAttachedToWindow += DrawerLayoutAttached;
}
- protected override void DisconnectHandler(View platformView)
+ protected override void DisconnectHandler(MauiDrawerLayout platformView)
{
MauiWindowInsetListener.UnregisterView(platformView);
if (_navigationRoot is CoordinatorLayout cl)
@@ -308,11 +227,12 @@ protected override void DisconnectHandler(View platformView)
_navigationRoot = null;
}
- if (platformView is DrawerLayout dl)
- {
- dl.DrawerStateChanged -= OnDrawerStateChanged;
- dl.ViewAttachedToWindow -= DrawerLayoutAttached;
- }
+ // Unsubscribe from MauiDrawerLayout events
+ platformView.OnPresentedChanged -= HandlePresentedChanged;
+ platformView.ViewAttachedToWindow -= DrawerLayoutAttached;
+
+ // Use MauiDrawerLayout's Disconnect method for cleanup
+ platformView.Disconnect();
if (VirtualView is IToolbarElement te)
{
@@ -325,10 +245,11 @@ void DrawerLayoutAttached(object? sender, View.ViewAttachedToWindowEventArgs e)
UpdateDetailsFragmentView();
}
- void OnDrawerStateChanged(object? sender, DrawerLayout.DrawerStateChangedEventArgs e)
+ void HandlePresentedChanged(bool isPresented)
{
- if (e.NewState == DrawerLayout.StateIdle && VirtualView.FlyoutBehavior == FlyoutBehavior.Flyout && _flyoutView != null)
- VirtualView.IsPresented = DrawerLayout.IsDrawerVisible(_flyoutView);
+ // Sync the virtual view's IsPresented property with the actual drawer state
+ if (VirtualView.FlyoutBehavior == FlyoutBehavior.Flyout)
+ VirtualView.IsPresented = isPresented;
}
public static void MapDetail(IFlyoutViewHandler handler, IFlyoutView flyoutView)
@@ -376,7 +297,7 @@ public static void MapToolbar(IFlyoutViewHandler handler, IFlyoutView view)
handler.VirtualView is IToolbarElement te &&
te.Toolbar?.Handler is ToolbarHandler th)
{
- th.SetupWithDrawerLayout(platformHandler.DrawerLayout);
+ th.SetupWithDrawerLayout(platformHandler.MauiDrawerLayout);
}
}
diff --git a/src/Core/src/Platform/Android/MauiDrawerLayout.cs b/src/Core/src/Platform/Android/MauiDrawerLayout.cs
new file mode 100644
index 000000000000..4a179f45621d
--- /dev/null
+++ b/src/Core/src/Platform/Android/MauiDrawerLayout.cs
@@ -0,0 +1,546 @@
+using System;
+using Android.Content;
+using Android.Runtime;
+using Android.Util;
+using Android.Views;
+using AndroidX.AppCompat.Widget;
+using AndroidX.DrawerLayout.Widget;
+using AView = Android.Views.View;
+
+namespace Microsoft.Maui.Platform
+{
+ ///
+ /// Shared DrawerLayout wrapper for FlyoutViewHandler and ShellHandler.
+ /// Provides common flyout functionality following Google Material Design guidelines.
+ ///
+#pragma warning disable RS0016 // Add public types and members to the declared API
+ public class MauiDrawerLayout : DrawerLayout
+ {
+ AView? _flyoutView;
+ AView? _contentView;
+ LinearLayoutCompat? _sideBySideView;
+ FlyoutBehavior _currentBehavior = FlyoutBehavior.Flyout;
+ bool _gestureEnabled = true;
+ double _flyoutWidth = -1;
+ double _defaultFlyoutWidth;
+ FlyoutLayoutMode _layoutMode = FlyoutLayoutMode.Flyout;
+ bool _isListening;
+
+ ///
+ /// Defines how the flyout is laid out when in Locked behavior.
+ ///
+ public enum FlyoutLayoutMode
+ {
+ ///
+ /// Standard flyout mode - drawer slides over content.
+ ///
+ Flyout,
+
+ ///
+ /// Side-by-side mode - flyout and content are placed horizontally.
+ /// Used by FlyoutViewHandler for tablet locked mode.
+ ///
+ SideBySide,
+
+ ///
+ /// Padding mode - content is padded to make room for flyout.
+ /// Used by ShellFlyoutRenderer for locked mode.
+ ///
+ Padding
+ }
+
+ #region Constructors
+
+ public MauiDrawerLayout(Context context) : base(context)
+ {
+ Initialize(context);
+ }
+
+ public MauiDrawerLayout(Context context, IAttributeSet? attrs) : base(context, attrs)
+ {
+ Initialize(context);
+ }
+
+ public MauiDrawerLayout(Context context, IAttributeSet? attrs, int defStyleAttr) : base(context, attrs, defStyleAttr)
+ {
+ Initialize(context);
+ }
+
+ protected MauiDrawerLayout(IntPtr javaReference, JniHandleOwnership transfer) : base(javaReference, transfer)
+ {
+ }
+
+ void Initialize(Context context)
+ {
+ _defaultFlyoutWidth = CalculateDefaultFlyoutWidth(context);
+ }
+
+ #endregion
+
+ #region Properties
+
+ ///
+ /// Gets the current flyout view.
+ ///
+ public AView? FlyoutView => _flyoutView;
+
+ ///
+ /// Gets the current content view.
+ ///
+ public AView? ContentView => _contentView;
+
+ ///
+ /// Gets whether the flyout is currently open.
+ ///
+ public bool IsFlyoutOpen => _flyoutView != null && IsDrawerOpen(_flyoutView);
+
+ ///
+ /// Gets or sets the flyout width. -1 for default width.
+ ///
+ public double FlyoutWidth
+ {
+ get => _flyoutWidth == -1 ? _defaultFlyoutWidth : _flyoutWidth;
+ set
+ {
+ _flyoutWidth = value;
+ UpdateFlyoutViewWidth();
+ }
+ }
+
+ ///
+ /// Gets the default flyout width calculated from Google design guidelines.
+ ///
+ public double DefaultFlyoutWidth => _defaultFlyoutWidth;
+
+ ///
+ /// Gets or sets the flyout layout mode for locked behavior.
+ ///
+ public FlyoutLayoutMode FlyoutLayoutModeValue
+ {
+ get => _layoutMode;
+ set
+ {
+ if (_layoutMode != value)
+ {
+ _layoutMode = value;
+ if (_currentBehavior == FlyoutBehavior.Locked)
+ {
+ UpdateLayout();
+ }
+ }
+ }
+ }
+
+ ///
+ /// Gets the current flyout behavior.
+ ///
+ public FlyoutBehavior CurrentBehavior => _currentBehavior;
+
+ ///
+ /// Gets whether gesture-based opening is enabled.
+ ///
+ public bool IsGestureEnabled => _gestureEnabled;
+
+ #endregion
+
+ #region Events
+
+ ///
+ /// Raised when the flyout presented state changes.
+ ///
+ public event Action? OnPresentedChanged;
+
+ ///
+ /// Raised when the drawer slides.
+ ///
+ public event Action? OnSlide;
+
+ #endregion
+
+ #region Public Methods
+
+ ///
+ /// Sets the content view (the main content behind the flyout).
+ ///
+ public void SetContentView(AView contentView)
+ {
+ if (_contentView == contentView)
+ {
+ return;
+ }
+
+ _contentView?.RemoveFromParent();
+ _contentView = contentView;
+
+ UpdateLayout();
+ }
+
+ ///
+ /// Sets the flyout view (the drawer content).
+ ///
+ public void SetFlyoutView(AView flyoutView)
+ {
+ if (_flyoutView == flyoutView)
+ {
+ return;
+ }
+
+ _flyoutView?.RemoveFromParent();
+ _flyoutView = flyoutView;
+
+ UpdateLayout();
+ EnsureListening();
+ }
+
+ ///
+ /// Opens the flyout drawer.
+ ///
+ public void OpenFlyout(bool animate = true)
+ {
+ if (_flyoutView is null || _flyoutView.Parent != this)
+ {
+ return;
+ }
+
+ if (animate)
+ {
+ OpenDrawer(_flyoutView);
+ }
+ else
+ {
+ OpenDrawer(_flyoutView, false);
+ }
+ }
+
+ ///
+ /// Closes the flyout drawer.
+ ///
+ public void CloseFlyout(bool animate = true)
+ {
+ if (_flyoutView is null)
+ {
+ CloseDrawers();
+ return;
+ }
+
+ if (_flyoutView.Parent != this)
+ {
+ return;
+ }
+
+ if (animate)
+ {
+ CloseDrawer(_flyoutView);
+ }
+ else
+ {
+ CloseDrawer(_flyoutView, false);
+ }
+ }
+
+ ///
+ /// Sets the flyout behavior (Disabled/Flyout/Locked).
+ ///
+ public void SetBehavior(FlyoutBehavior behavior)
+ {
+ bool closeAfterUpdate = (behavior == FlyoutBehavior.Flyout && _currentBehavior == FlyoutBehavior.Locked);
+ _currentBehavior = behavior;
+
+ UpdateLayout();
+ UpdateLockMode();
+
+ if (closeAfterUpdate && _flyoutView != null && _flyoutView.Parent == this)
+ {
+ CloseDrawer(_flyoutView, false);
+ }
+ }
+
+ ///
+ /// Sets whether gesture-based flyout opening is enabled.
+ ///
+ public void SetGestureEnabled(bool enabled)
+ {
+ _gestureEnabled = enabled;
+
+ if (_currentBehavior == FlyoutBehavior.Flyout)
+ {
+ UpdateLockMode();
+ }
+ }
+
+ ///
+ /// Gets the left padding needed for content when flyout is locked open (padding mode).
+ ///
+ public int GetLockedContentPadding()
+ {
+ return _currentBehavior == FlyoutBehavior.Locked && _layoutMode == FlyoutLayoutMode.Padding
+ ? (int)FlyoutWidth
+ : 0;
+ }
+
+ ///
+ /// Disconnects event listeners and cleans up.
+ ///
+ public virtual void Disconnect()
+ {
+ if (_isListening)
+ {
+ DrawerStateChanged -= OnDrawerStateChanged;
+ DrawerOpened -= OnDrawerOpened;
+ DrawerClosed -= OnDrawerClosed;
+ DrawerSlide -= OnDrawerSlide;
+ _isListening = false;
+ }
+
+ OnPresentedChanged = null;
+ OnSlide = null;
+ }
+
+ #endregion
+
+ #region Layout Methods
+
+ void UpdateLayout()
+ {
+ if (_flyoutView is null || _contentView is null)
+ {
+ return;
+ }
+
+ if (_currentBehavior == FlyoutBehavior.Locked && _layoutMode == FlyoutLayoutMode.SideBySide)
+ {
+ LayoutSideBySide();
+ }
+ else
+ {
+ LayoutAsFlyout();
+ }
+ }
+
+ ///
+ /// Layouts the flyout and content side by side (for tablets in locked mode).
+ ///
+ protected virtual void LayoutSideBySide()
+ {
+ if (_flyoutView is null || _contentView is null)
+ {
+ return;
+ }
+
+ // Create side-by-side container if needed
+ if (_sideBySideView is null)
+ {
+ _sideBySideView = new LinearLayoutCompat(Context!)
+ {
+ Orientation = LinearLayoutCompat.Horizontal,
+ LayoutParameters = new LayoutParams(
+ LayoutParams.MatchParent,
+ LayoutParams.MatchParent)
+ };
+ }
+
+ // Add content to side-by-side view
+ if (_contentView.Parent != _sideBySideView)
+ {
+ _contentView.RemoveFromParent();
+
+ var contentParams = new LinearLayoutCompat.LayoutParams(
+ LinearLayoutCompat.LayoutParams.MatchParent,
+ LinearLayoutCompat.LayoutParams.MatchParent,
+ 1); // weight 1 to fill remaining space
+
+ _sideBySideView.AddView(_contentView, contentParams);
+ }
+
+ // Add flyout to side-by-side view
+ if (_flyoutView.Parent != _sideBySideView)
+ {
+ _flyoutView.Visibility = ViewStates.Visible;
+ _flyoutView.RemoveFromParent();
+
+ var flyoutParams = new LinearLayoutCompat.LayoutParams(
+ (int)FlyoutWidth,
+ LinearLayoutCompat.LayoutParams.MatchParent,
+ 0); // weight 0 for fixed width
+
+ _sideBySideView.AddView(_flyoutView, 0, flyoutParams); // Add at index 0 (left)
+ }
+
+ // Add side-by-side view to drawer
+ if (_sideBySideView.Parent != this)
+ {
+ AddView(_sideBySideView);
+ }
+ }
+
+ ///
+ /// Layouts as a standard flyout (drawer over content).
+ ///
+ protected virtual void LayoutAsFlyout()
+ {
+ if (_flyoutView is null || _contentView is null)
+ {
+ return;
+ }
+
+ // Remove side-by-side view
+ _sideBySideView?.RemoveAllViews();
+ _sideBySideView?.RemoveFromParent();
+
+ // Add content to drawer
+ if (_contentView.Parent != this)
+ {
+ _contentView.RemoveFromParent();
+
+ var contentParams = new LayoutParams(
+ LayoutParams.MatchParent,
+ LayoutParams.MatchParent);
+
+ AddView(_contentView, 0, contentParams);
+ }
+
+ // Add flyout to drawer (must be after content for proper gesture handling)
+ if (_flyoutView.Parent != this)
+ {
+ _flyoutView.RemoveFromParent();
+
+ var flyoutParams = new LayoutParams(
+ (int)FlyoutWidth,
+ LayoutParams.MatchParent,
+ (int)GravityFlags.Start);
+
+ AddView(_flyoutView, flyoutParams);
+ }
+ }
+
+ #endregion
+
+ #region Lock Mode
+
+ void UpdateLockMode()
+ {
+ int lockMode = _currentBehavior switch
+ {
+ FlyoutBehavior.Disabled => LockModeLockedClosed,
+ FlyoutBehavior.Locked => _layoutMode == FlyoutLayoutMode.SideBySide
+ ? LockModeLockedClosed // In side-by-side, drawer is not used
+ : LockModeLockedOpen,
+ FlyoutBehavior.Flyout => _gestureEnabled
+ ? LockModeUnlocked
+ : LockModeLockedClosed,
+ _ => LockModeUnlocked
+ };
+
+ SetDrawerLockMode(lockMode);
+
+ if (_currentBehavior == FlyoutBehavior.Disabled)
+ {
+ CloseDrawers();
+ }
+ }
+
+ #endregion
+
+ #region Event Handling
+
+ void EnsureListening()
+ {
+ if (_isListening)
+ {
+ return;
+ }
+
+ DrawerStateChanged += OnDrawerStateChanged;
+ DrawerOpened += OnDrawerOpened;
+ DrawerClosed += OnDrawerClosed;
+ DrawerSlide += OnDrawerSlide;
+ _isListening = true;
+ }
+
+ void OnDrawerStateChanged(object? sender, DrawerStateChangedEventArgs e)
+ {
+ if (_flyoutView is null)
+ {
+ return;
+ }
+
+ if (StateIdle == e.NewState)
+ {
+ var isOpen = IsDrawerOpen(_flyoutView);
+ OnPresentedChanged?.Invoke(isOpen);
+ }
+ }
+
+ void OnDrawerOpened(object? sender, DrawerOpenedEventArgs e)
+ {
+ OnPresentedChanged?.Invoke(true);
+ }
+
+ void OnDrawerClosed(object? sender, DrawerClosedEventArgs e)
+ {
+ OnPresentedChanged?.Invoke(false);
+ }
+
+ void OnDrawerSlide(object? sender, DrawerSlideEventArgs e)
+ {
+ OnSlide?.Invoke(e.SlideOffset);
+ }
+
+ #endregion
+
+ #region Width Calculation
+
+ void UpdateFlyoutViewWidth()
+ {
+ if (_flyoutView?.LayoutParameters is null)
+ {
+ return;
+ }
+
+ _flyoutView.LayoutParameters.Width = (int)FlyoutWidth;
+ _flyoutView.RequestLayout();
+ }
+
+ ///
+ /// Calculates the default flyout width based on Google Material Design guidelines.
+ ///
+ ///
+ /// The right edge of the drawer should be Max(56dp, actionBarSize) from the right edge.
+ /// Maximum width is 6 * actionBarSize.
+ ///
+ static double CalculateDefaultFlyoutWidth(Context context)
+ {
+ var metrics = context.Resources?.DisplayMetrics;
+ if (metrics is null)
+ {
+ return 300; // fallback
+ }
+
+ var width = Math.Min(metrics.WidthPixels, metrics.HeightPixels);
+ var actionBarHeight = (int)context.GetActionBarHeight();
+
+ width -= actionBarHeight;
+
+ var maxWidth = actionBarHeight * 6;
+ width = Math.Min(width, maxWidth);
+
+ return width;
+ }
+
+ #endregion
+
+ #region Dispose
+
+ protected override void Dispose(bool disposing)
+ {
+ if (disposing)
+ {
+ Disconnect();
+ }
+
+ base.Dispose(disposing);
+ }
+
+ #endregion
+ }
+}
diff --git a/src/Core/src/Platform/Android/Navigation/StackNavigationManager.cs b/src/Core/src/Platform/Android/Navigation/StackNavigationManager.cs
index a7c298ad5067..fd29866c95b4 100644
--- a/src/Core/src/Platform/Android/Navigation/StackNavigationManager.cs
+++ b/src/Core/src/Platform/Android/Navigation/StackNavigationManager.cs
@@ -1,5 +1,6 @@
using System;
using System.Collections.Generic;
+using System.Threading.Tasks;
using Android.Content;
using Android.OS;
using Android.Views;
@@ -22,6 +23,9 @@ public class StackNavigationManager
FragmentManager? _fragmentManager;
FragmentContainerView? _fragmentContainerView;
Type _navigationViewFragmentType = typeof(NavigationViewFragment);
+ Queue _navigationQueue = new Queue();
+
+ bool _processingQueue;
internal IView? VirtualView { get; private set; }
internal IStackNavigation? NavigationView { get; private set; }
@@ -83,10 +87,10 @@ void ApplyNavigationRequest(NavigationRequest args)
{
if (IsNavigating && OnResumeRequestedArgs is null)
{
- // This should really never fire for the developer. Our xplat code should be handling waiting for navigation to
- // complete before requesting another navigation from Core
- // Maybe some day we'll put a navigation queue into Core? For now we won't
- throw new InvalidOperationException("Previous Navigation Request is still Processing");
+ // Queue the navigation request to be processed after the current one completes
+ System.Diagnostics.Debug.WriteLine($"[StackNavigationManager] Navigation in progress, queueing request. Queue size: {_navigationQueue.Count}");
+ _navigationQueue.Enqueue(args);
+ return;
}
if (args.NavigationStack.Count == 0)
@@ -253,6 +257,30 @@ internal void NavigationFinished(IStackNavigation? navigationView)
IsPopping = null;
ActiveRequestedArgs = null;
navigationView?.NavigationFinished(NavigationStack);
+
+ // Process queued navigation requests
+ ProcessNavigationQueue();
+ }
+
+ void ProcessNavigationQueue()
+ {
+ if (_processingQueue || _navigationQueue.Count == 0)
+ return;
+
+ _processingQueue = true;
+
+ try
+ {
+ while (_navigationQueue.Count > 0 && !IsNavigating)
+ {
+ var nextRequest = _navigationQueue.Dequeue();
+ ApplyNavigationRequest(nextRequest);
+ }
+ }
+ finally
+ {
+ _processingQueue = false;
+ }
}
// This occurs when the navigation page is first being renderer so we sync up the
@@ -323,23 +351,39 @@ public virtual void Disconnect()
_fragmentManager = null;
}
- public virtual void Connect(IView navigationView)
+ internal virtual void Connect(IView navigationView, FragmentContainerView? fragmentContainerView = null)
{
VirtualView = navigationView;
NavigationView = (IStackNavigation)navigationView;
- _fragmentContainerView = navigationView.Handler?.PlatformView as FragmentContainerView;
+ // For Shell sections the FragmentContainerView is created externally
+ // so we accept it as a parameter.
+ if (fragmentContainerView is not null)
+ {
+ _fragmentContainerView = fragmentContainerView;
+ }
+ else
+ {
+ _fragmentContainerView = navigationView.Handler?.PlatformView as FragmentContainerView;
+ }
_fragmentManager = MauiContext?.GetFragmentManager();
_ = _fragmentManager ?? throw new InvalidOperationException($"GetFragmentManager returned null");
_ = NavigationView ?? throw new InvalidOperationException($"VirtualView cannot be null");
- var navHostFragment = _fragmentManager.FindFragmentById(Resource.Id.nav_host);
+ // Use the container's actual ID instead of hardcoded Resource.Id.nav_host
+ // This allows each Shell tab to have its own unique navigation container
+ var containerId = _fragmentContainerView?.Id ?? Resource.Id.nav_host;
+
+ var navHostFragment = _fragmentManager.FindFragmentById(containerId);
+
SetNavHost(navHostFragment as NavHostFragment);
- if (_navHost == null)
+ if (_navHost is null)
+ {
throw new InvalidOperationException($"No NavHostFragment found");
+ }
if (_fragmentContainerView is not null)
{
diff --git a/src/Core/src/PublicAPI/net-android/PublicAPI.Unshipped.txt b/src/Core/src/PublicAPI/net-android/PublicAPI.Unshipped.txt
index 91219f7e7d3c..45925293d496 100644
--- a/src/Core/src/PublicAPI/net-android/PublicAPI.Unshipped.txt
+++ b/src/Core/src/PublicAPI/net-android/PublicAPI.Unshipped.txt
@@ -9,5 +9,66 @@ override Microsoft.Maui.PlatformDrawable.ThresholdType.get -> System.Type!
*REMOVED*override Microsoft.Maui.Graphics.MauiDrawable.OnBoundsChange(Android.Graphics.Rect! bounds) -> void
*REMOVED*override Microsoft.Maui.Graphics.MauiDrawable.OnDraw(Android.Graphics.Drawables.Shapes.Shape? shape, Android.Graphics.Canvas? canvas, Android.Graphics.Paint? paint) -> void
override Microsoft.Maui.Handlers.LabelHandler.GetDesiredSize(double widthConstraint, double heightConstraint) -> Microsoft.Maui.Graphics.Size
+override Microsoft.Maui.Platform.MauiDrawerLayout.Dispose(bool disposing) -> void
static Microsoft.Maui.GridLength.implicit operator Microsoft.Maui.GridLength(string! value) -> Microsoft.Maui.GridLength
Microsoft.Maui.Handlers.PickerHandler._dialog -> AndroidX.AppCompat.App.AlertDialog?
+Microsoft.Maui.ITab
+Microsoft.Maui.ITab.Icon.get -> Microsoft.Maui.IImageSource?
+Microsoft.Maui.ITab.IsEnabled.get -> bool
+Microsoft.Maui.ITab.Title.get -> string!
+Microsoft.Maui.ITabbedView.BarBackground.get -> object!
+Microsoft.Maui.ITabbedView.BarBackgroundColor.get -> Microsoft.Maui.Graphics.Color?
+Microsoft.Maui.ITabbedView.BarTextColor.get -> Microsoft.Maui.Graphics.Color?
+Microsoft.Maui.ITabbedView.CurrentTab.get -> Microsoft.Maui.ITab?
+Microsoft.Maui.ITabbedView.CurrentTab.set -> void
+Microsoft.Maui.ITabbedView.IsSmoothScrollEnabled.get -> bool
+Microsoft.Maui.ITabbedView.IsSwipePagingEnabled.get -> bool
+Microsoft.Maui.ITabbedView.OffscreenPageLimit.get -> int
+Microsoft.Maui.ITabbedView.SelectedTabColor.get -> Microsoft.Maui.Graphics.Color?
+Microsoft.Maui.ITabbedView.TabBarPlacement.get -> Microsoft.Maui.TabBarPlacement
+Microsoft.Maui.ITabbedView.Tabs.get -> System.Collections.Generic.IReadOnlyList!
+Microsoft.Maui.ITabbedView.TabsChanged -> System.Collections.Specialized.NotifyCollectionChangedEventHandler?
+Microsoft.Maui.ITabbedView.UnselectedTabColor.get -> Microsoft.Maui.Graphics.Color?
+Microsoft.Maui.Platform.MauiDrawerLayout
+Microsoft.Maui.Platform.MauiDrawerLayout.CloseFlyout(bool animate = true) -> void
+Microsoft.Maui.Platform.MauiDrawerLayout.ContentView.get -> Android.Views.View?
+Microsoft.Maui.Platform.MauiDrawerLayout.CurrentBehavior.get -> Microsoft.Maui.FlyoutBehavior
+Microsoft.Maui.Platform.MauiDrawerLayout.DefaultFlyoutWidth.get -> double
+Microsoft.Maui.Platform.MauiDrawerLayout.FlyoutLayoutMode
+Microsoft.Maui.Platform.MauiDrawerLayout.FlyoutLayoutMode.Flyout = 0 -> Microsoft.Maui.Platform.MauiDrawerLayout.FlyoutLayoutMode
+Microsoft.Maui.Platform.MauiDrawerLayout.FlyoutLayoutMode.Padding = 2 -> Microsoft.Maui.Platform.MauiDrawerLayout.FlyoutLayoutMode
+Microsoft.Maui.Platform.MauiDrawerLayout.FlyoutLayoutMode.SideBySide = 1 -> Microsoft.Maui.Platform.MauiDrawerLayout.FlyoutLayoutMode
+Microsoft.Maui.Platform.MauiDrawerLayout.FlyoutLayoutModeValue.get -> Microsoft.Maui.Platform.MauiDrawerLayout.FlyoutLayoutMode
+Microsoft.Maui.Platform.MauiDrawerLayout.FlyoutLayoutModeValue.set -> void
+Microsoft.Maui.Platform.MauiDrawerLayout.FlyoutView.get -> Android.Views.View?
+Microsoft.Maui.Platform.MauiDrawerLayout.FlyoutWidth.get -> double
+Microsoft.Maui.Platform.MauiDrawerLayout.FlyoutWidth.set -> void
+Microsoft.Maui.Platform.MauiDrawerLayout.GetLockedContentPadding() -> int
+Microsoft.Maui.Platform.MauiDrawerLayout.IsFlyoutOpen.get -> bool
+Microsoft.Maui.Platform.MauiDrawerLayout.IsGestureEnabled.get -> bool
+Microsoft.Maui.Platform.MauiDrawerLayout.MauiDrawerLayout(Android.Content.Context! context) -> void
+Microsoft.Maui.Platform.MauiDrawerLayout.MauiDrawerLayout(Android.Content.Context! context, Android.Util.IAttributeSet? attrs) -> void
+Microsoft.Maui.Platform.MauiDrawerLayout.MauiDrawerLayout(Android.Content.Context! context, Android.Util.IAttributeSet? attrs, int defStyleAttr) -> void
+Microsoft.Maui.Platform.MauiDrawerLayout.MauiDrawerLayout(nint javaReference, Android.Runtime.JniHandleOwnership transfer) -> void
+Microsoft.Maui.Platform.MauiDrawerLayout.OnPresentedChanged -> System.Action?
+Microsoft.Maui.Platform.MauiDrawerLayout.OnSlide -> System.Action?
+Microsoft.Maui.Platform.MauiDrawerLayout.OpenFlyout(bool animate = true) -> void
+Microsoft.Maui.Platform.MauiDrawerLayout.SetBehavior(Microsoft.Maui.FlyoutBehavior behavior) -> void
+Microsoft.Maui.Platform.MauiDrawerLayout.SetContentView(Android.Views.View! contentView) -> void
+Microsoft.Maui.Platform.MauiDrawerLayout.SetFlyoutView(Android.Views.View! flyoutView) -> void
+Microsoft.Maui.Platform.MauiDrawerLayout.SetGestureEnabled(bool enabled) -> void
+Microsoft.Maui.TabBarPlacement
+Microsoft.Maui.TabBarPlacement.Bottom = 1 -> Microsoft.Maui.TabBarPlacement
+Microsoft.Maui.TabBarPlacement.Top = 0 -> Microsoft.Maui.TabBarPlacement
+*REMOVED*override Microsoft.Maui.Handlers.FlyoutViewHandler.ConnectHandler(Android.Views.View! platformView) -> void
+override Microsoft.Maui.Handlers.FlyoutViewHandler.ConnectHandler(Microsoft.Maui.Platform.MauiDrawerLayout! platformView) -> void
+*REMOVED*override Microsoft.Maui.Handlers.FlyoutViewHandler.CreatePlatformView() -> Android.Views.View!
+override Microsoft.Maui.Handlers.FlyoutViewHandler.CreatePlatformView() -> Microsoft.Maui.Platform.MauiDrawerLayout!
+*REMOVED*override Microsoft.Maui.Handlers.FlyoutViewHandler.DisconnectHandler(Android.Views.View! platformView) -> void
+override Microsoft.Maui.Handlers.FlyoutViewHandler.DisconnectHandler(Microsoft.Maui.Platform.MauiDrawerLayout! platformView) -> void
+override Microsoft.Maui.Platform.MauiDrawerLayout.Dispose(bool disposing) -> void
+override Microsoft.Maui.Platform.MauiDrawerLayout.OnInterceptTouchEvent(Android.Views.MotionEvent? ev) -> bool
+virtual Microsoft.Maui.Platform.MauiDrawerLayout.Disconnect() -> void
+virtual Microsoft.Maui.Platform.MauiDrawerLayout.LayoutAsFlyout() -> void
+virtual Microsoft.Maui.Platform.MauiDrawerLayout.LayoutSideBySide() -> void
+*REMOVED*virtual Microsoft.Maui.Platform.StackNavigationManager.Connect(Microsoft.Maui.IView! navigationView) -> void
From d319e88152b369ecbe7a99a2e84d0e39d55e1b94 Mon Sep 17 00:00:00 2001
From: Tamilarasan Paranthaman
<93904422+Tamilarasan-Paranthaman@users.noreply.github.com>
Date: Tue, 3 Mar 2026 16:35:36 +0530
Subject: [PATCH 03/26] Update ShellFlyoutTemplatedContentRenderer.cs
---
.../ShellFlyoutTemplatedContentRenderer.cs | 36 +++++++++++++++++++
1 file changed, 36 insertions(+)
diff --git a/src/Controls/src/Core/Compatibility/Handlers/Shell/Android/ShellFlyoutTemplatedContentRenderer.cs b/src/Controls/src/Core/Compatibility/Handlers/Shell/Android/ShellFlyoutTemplatedContentRenderer.cs
index 7ea1606cc362..345c8aa353f1 100644
--- a/src/Controls/src/Core/Compatibility/Handlers/Shell/Android/ShellFlyoutTemplatedContentRenderer.cs
+++ b/src/Controls/src/Core/Compatibility/Handlers/Shell/Android/ShellFlyoutTemplatedContentRenderer.cs
@@ -213,6 +213,12 @@ protected virtual void LoadView(IShellContext shellContext)
UpdateFlyoutHeaderBehavior();
+ _shellContext.Shell.PropertyChanged += OnShellPropertyChanged;
+
+ UpdateFlyoutBackground();
+
+ UpdateVerticalScrollMode();
+
UpdateFlyoutFooter();
if (FlyoutView.FlyoutBehavior == FlyoutBehavior.Locked)
@@ -261,6 +267,32 @@ protected void OnElementSelected(Element element)
((IShellController)_shellContext.Shell).OnFlyoutItemSelected(element);
}
+ protected virtual void OnShellPropertyChanged(object sender, PropertyChangedEventArgs e)
+ {
+ if (e.PropertyName == Shell.FlyoutHeaderBehaviorProperty.PropertyName)
+ UpdateFlyoutHeaderBehavior();
+ else if (e.IsOneOf(
+ Shell.FlyoutBackgroundColorProperty,
+ Shell.FlyoutBackgroundProperty,
+ Shell.FlyoutBackgroundImageProperty,
+ Shell.FlyoutBackgroundImageAspectProperty))
+ UpdateFlyoutBackground();
+ else if (e.Is(Shell.FlyoutVerticalScrollModeProperty))
+ UpdateVerticalScrollMode();
+ else if (e.IsOneOf(
+ Shell.FlyoutHeaderProperty,
+ Shell.FlyoutHeaderTemplateProperty))
+ UpdateFlyoutHeader();
+ else if (e.IsOneOf(
+ Shell.FlyoutFooterProperty,
+ Shell.FlyoutFooterTemplateProperty))
+ UpdateFlyoutFooter();
+ else if (e.IsOneOf(
+ Shell.FlyoutContentProperty,
+ Shell.FlyoutContentTemplateProperty))
+ UpdateFlyoutContent();
+ }
+
public virtual void UpdateFlyoutContent()
{
if (!_rootView.IsAlive())
@@ -396,6 +428,7 @@ public virtual void UpdateFlyoutFooter()
if (footer is null)
{
+ UpdateContentPadding();
return;
}
@@ -699,6 +732,9 @@ internal void Disconnect()
MauiWindowInsetListener.RemoveViewWithLocalListener(coordinator);
}
+ if (_shellContext?.Shell != null)
+ _shellContext.Shell.PropertyChanged -= OnShellPropertyChanged;
+
_flyoutHeader?.MeasureInvalidated -= OnFlyoutHeaderMeasureInvalidated;
_flyoutHeader = null;
From 0de1817056e043d124670f3ad9302852aa521571 Mon Sep 17 00:00:00 2001
From: Tamilarasan Paranthaman
<93904422+Tamilarasan-Paranthaman@users.noreply.github.com>
Date: Wed, 4 Mar 2026 18:08:10 +0530
Subject: [PATCH 04/26] Fix shell section switching issue
---
.../Shell/Android/ShellSearchViewAdapter.cs | 7 ++-
.../Android/ShellToolbarAppearanceTracker.cs | 5 +++
.../Handlers/Shell/ShellHandler.Android.cs | 12 ++++-
.../Shell/ShellItemHandler.Android.cs | 13 +++++-
.../Shell/ShellSectionHandler.Android.cs | 44 +++++++++++++++++--
5 files changed, 74 insertions(+), 7 deletions(-)
diff --git a/src/Controls/src/Core/Compatibility/Handlers/Shell/Android/ShellSearchViewAdapter.cs b/src/Controls/src/Core/Compatibility/Handlers/Shell/Android/ShellSearchViewAdapter.cs
index ee545a21f279..b6c4493a3759 100644
--- a/src/Controls/src/Core/Compatibility/Handlers/Shell/Android/ShellSearchViewAdapter.cs
+++ b/src/Controls/src/Core/Compatibility/Handlers/Shell/Android/ShellSearchViewAdapter.cs
@@ -154,6 +154,11 @@ class CustomFilter : Filter
{
private readonly BaseAdapter _adapter;
+ // Required by Android JNI bridge for native handle activation
+ protected CustomFilter(IntPtr javaReference, global::Android.Runtime.JniHandleOwnership transfer) : base(javaReference, transfer)
+ {
+ }
+
public CustomFilter(BaseAdapter adapter)
{
_adapter = adapter;
@@ -169,7 +174,7 @@ protected override FilterResults PerformFiltering(ICharSequence constraint)
protected override void PublishResults(ICharSequence constraint, FilterResults results)
{
- _adapter.NotifyDataSetChanged();
+ _adapter?.NotifyDataSetChanged();
}
}
diff --git a/src/Controls/src/Core/Compatibility/Handlers/Shell/Android/ShellToolbarAppearanceTracker.cs b/src/Controls/src/Core/Compatibility/Handlers/Shell/Android/ShellToolbarAppearanceTracker.cs
index 597a57ddb6ea..97623b17ac79 100644
--- a/src/Controls/src/Core/Compatibility/Handlers/Shell/Android/ShellToolbarAppearanceTracker.cs
+++ b/src/Controls/src/Core/Compatibility/Handlers/Shell/Android/ShellToolbarAppearanceTracker.cs
@@ -20,6 +20,11 @@ public ShellToolbarAppearanceTracker(IShellContext shellContext)
public virtual void SetAppearance(AToolbar toolbar, IShellToolbarTracker toolbarTracker, ShellAppearance appearance)
{
+ if (appearance is null)
+ {
+ return;
+ }
+
var foreground = appearance.ForegroundColor;
var background = appearance.BackgroundColor;
var titleColor = appearance.TitleColor;
diff --git a/src/Controls/src/Core/Handlers/Shell/ShellHandler.Android.cs b/src/Controls/src/Core/Handlers/Shell/ShellHandler.Android.cs
index 0f4dd7b66ca8..2834642a9a3a 100644
--- a/src/Controls/src/Core/Handlers/Shell/ShellHandler.Android.cs
+++ b/src/Controls/src/Core/Handlers/Shell/ShellHandler.Android.cs
@@ -106,9 +106,13 @@ protected override void ConnectHandler(MauiDrawerLayout platformView)
UpdateFlyoutBehaviorInternal(behavior);
// Initialize with current item if it exists
+ // Post to ensure the view hierarchy is fully attached before adding fragments
if (VirtualView.CurrentItem is not null)
{
- SwitchToItem(VirtualView.CurrentItem, animate: false);
+ platformView.Post(new Java.Lang.Runnable(() =>
+ {
+ SwitchToItem(VirtualView.CurrentItem, animate: false);
+ }));
}
}
@@ -165,6 +169,12 @@ void SwitchToItem(ShellItem newItem, bool animate)
return;
}
+ // Ensure the content frame has a valid ID and is attached to the window
+ if (_contentFrame.Id == AView.NoId || !_contentFrame.IsAttachedToWindow)
+ {
+ return;
+ }
+
var previousRenderer = _currentShellItemRenderer;
_currentShellItemRenderer = CreateShellItemRenderer(newItem);
diff --git a/src/Controls/src/Core/Handlers/Shell/ShellItemHandler.Android.cs b/src/Controls/src/Core/Handlers/Shell/ShellItemHandler.Android.cs
index 4360a3dffdd5..ab754b75c552 100644
--- a/src/Controls/src/Core/Handlers/Shell/ShellItemHandler.Android.cs
+++ b/src/Controls/src/Core/Handlers/Shell/ShellItemHandler.Android.cs
@@ -138,6 +138,12 @@ internal void SetupViewPagerAdapter()
_viewPager.Adapter = _adapter;
+ // Keep ALL section fragments alive to prevent FragmentStateAdapter from
+ // saving/restoring fragment state. Restored fragments lose MAUI-specific state
+ // (StackNavigationManager, etc.) causing crashes. The renderer approach avoids
+ // this by using direct fragment transactions instead of ViewPager2.
+ _viewPager.OffscreenPageLimit = Math.Max(shellSections.Count, 1);
+
// Register page change callback
_pageChangeCallback = new ShellItemPageChangeCallback(this);
_viewPager.RegisterOnPageChangeCallback(_pageChangeCallback);
@@ -588,6 +594,11 @@ void IAppearanceObserver.OnAppearanceChanged(ShellAppearance appearance)
///
void UpdateAppearance(ShellAppearance appearance)
{
+ if (appearance is null)
+ {
+ return;
+ }
+
if (_bottomNavigationView is null || _bottomNavigationView.Visibility != ViewStates.Visible)
{
return;
@@ -751,7 +762,7 @@ internal void UpdateToolbarForPage(Page page)
///
void UpdateToolbarAppearance(ShellAppearance appearance)
{
- if (_toolbarAppearanceTracker is null || _toolbar is null)
+ if (_toolbarAppearanceTracker is null || _toolbar is null || appearance is null)
{
return;
}
diff --git a/src/Controls/src/Core/Handlers/Shell/ShellSectionHandler.Android.cs b/src/Controls/src/Core/Handlers/Shell/ShellSectionHandler.Android.cs
index 2d1e381d32b0..eb474460c245 100644
--- a/src/Controls/src/Core/Handlers/Shell/ShellSectionHandler.Android.cs
+++ b/src/Controls/src/Core/Handlers/Shell/ShellSectionHandler.Android.cs
@@ -209,6 +209,12 @@ internal void SetupViewPagerAdapter()
};
_viewPager.Adapter = _adapter;
+ // Keep ALL content fragments alive to prevent FragmentStateAdapter from
+ // saving/restoring fragment state. Restored fragments lose MAUI-specific state
+ // (StackNavigationManager, etc.) causing crashes.
+ var itemCount = VirtualView?.Items?.Count ?? 1;
+ _viewPager.OffscreenPageLimit = Math.Max(itemCount, 1);
+
// Setup TabLayoutMediator
_tabLayoutMediator = new TabLayoutMediator(
_contentTabLayout,
@@ -531,15 +537,22 @@ public override void OnPageSelected(int position)
///
internal class ShellContentNavigationFragment : Fragment, IStackNavigation
{
- readonly ShellContent _shellContent;
- readonly IMauiContext _mauiContext;
- readonly ShellSectionHandler _handler;
+ ShellContent _shellContent;
+ IMauiContext _mauiContext;
+ ShellSectionHandler _handler;
StackNavigationManager _stackNavigationManager;
FragmentContainerView _navigationContainer;
Page _rootPage;
int _navigationContainerId;
ShellContentStackNavigationView _navigationViewAdapter;
+ // Default constructor required by Android's FragmentManager for fragment restoration.
+ // When FragmentStateAdapter (ViewPager2) saves and restores fragment state during tab switches,
+ // it uses Fragment.instantiate() which requires a parameterless constructor.
+ public ShellContentNavigationFragment()
+ {
+ }
+
public ShellContentNavigationFragment(ShellContent shellContent, IMauiContext mauiContext, ShellSectionHandler handler)
{
_shellContent = shellContent;
@@ -549,12 +562,21 @@ public ShellContentNavigationFragment(ShellContent shellContent, IMauiContext ma
public override void OnCreate(Bundle savedInstanceState)
{
- // Don't pass saved state to prevent stale fragment restoration
+ // Always pass null to prevent restoring stale child fragment state.
+ // OffscreenPageLimit keeps fragments alive so restoration shouldn't occur,
+ // but this is defense-in-depth.
base.OnCreate(null);
}
public override AView OnCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState)
{
+ // If this fragment was restored by FragmentManager without proper data,
+ // return an empty view. The ViewPager2 adapter will recreate it properly.
+ if (_shellContent is null || _mauiContext is null)
+ {
+ return new FrameLayout(inflater.Context);
+ }
+
if (_navigationContainer is not null)
{
// Check if NavHostFragment needs recreation
@@ -1002,6 +1024,12 @@ class ShellSectionWrapperFragment : Fragment
readonly ShellSectionHandler _handler;
AView _view;
+ // Default constructor required by Android's FragmentManager for fragment restoration
+ public ShellSectionWrapperFragment()
+ {
+ _handler = null;
+ }
+
public ShellSectionWrapperFragment(ShellSectionHandler handler)
{
_handler = handler;
@@ -1010,11 +1038,19 @@ public ShellSectionWrapperFragment(ShellSectionHandler handler)
public override void OnCreate(Bundle savedInstanceState)
{
+ // Always pass null to prevent restoring stale child fragment state.
+ // OffscreenPageLimit keeps fragments alive so restoration shouldn't occur,
+ // but this is defense-in-depth.
base.OnCreate(null);
}
public override AView OnCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState)
{
+ // If restored without proper handler reference, return empty view
+ if (_handler is null)
+ {
+ return new FrameLayout(inflater.Context);
+ }
if (_view is null)
{
_view = _handler.PlatformView ?? _handler.ToPlatform();
From 589245674d10b01e220c7cbcd2c1df3a81044364 Mon Sep 17 00:00:00 2001
From: Tamilarasan Paranthaman
<93904422+Tamilarasan-Paranthaman@users.noreply.github.com>
Date: Tue, 10 Mar 2026 11:01:25 +0530
Subject: [PATCH 05/26] Fix shell handler issues
---
.../Handlers/Shell/ShellHandler.Android.cs | 134 ++++++++++--
.../Shell/ShellItemHandler.Android.cs | 202 +++++++++++-------
.../Shell/ShellSectionHandler.Android.cs | 40 ++--
.../Resources/Layout/shellitemlayout.axml | 52 +++++
.../Resources/Layout/shellsectionlayout.axml | 43 ++++
.../Android/Resources/values/styles.xml | 7 +
6 files changed, 354 insertions(+), 124 deletions(-)
create mode 100644 src/Core/src/Platform/Android/Resources/Layout/shellitemlayout.axml
create mode 100644 src/Core/src/Platform/Android/Resources/Layout/shellsectionlayout.axml
diff --git a/src/Controls/src/Core/Handlers/Shell/ShellHandler.Android.cs b/src/Controls/src/Core/Handlers/Shell/ShellHandler.Android.cs
index 2834642a9a3a..b53ba5139beb 100644
--- a/src/Controls/src/Core/Handlers/Shell/ShellHandler.Android.cs
+++ b/src/Controls/src/Core/Handlers/Shell/ShellHandler.Android.cs
@@ -13,6 +13,7 @@
using AView = Android.Views.View;
using AToolbar = AndroidX.AppCompat.Widget.Toolbar;
using LP = Android.Views.ViewGroup.LayoutParams;
+using Microsoft.Maui.Graphics;
#pragma warning disable RS0016 // Add public types and members to the declared API
@@ -40,6 +41,14 @@ public partial class ShellHandler : ViewHandler, IShell
// Track flyout behavior for IShellContext
FlyoutBehavior _currentBehavior = FlyoutBehavior.Flyout;
+ // Track the current scrim brush from appearance observer (matches old ShellFlyoutRenderer pattern).
+ // Initialized to Brush.Transparent because the appearance observer fires with null first.
+ Brush _scrimBrush = Brush.Transparent;
+
+ // Deferred item switch (when view isn't attached to window yet)
+ ShellItem _pendingSwitchItem;
+ bool _pendingSwitchAnimate;
+
public static PropertyMapper Mapper =
new PropertyMapper(ElementMapper)
{
@@ -75,6 +84,11 @@ protected override MauiDrawerLayout CreatePlatformView()
// Create MauiDrawerLayout (same as FlyoutViewHandler)
var drawerLayout = new MauiDrawerLayout(Context);
+ // Use Padding layout mode to match old ShellFlyoutRenderer behavior.
+ // In locked mode, the content is padded left by the flyout width
+ // (the drawer stays open and content shifts right).
+ drawerLayout.FlyoutLayoutModeValue = MauiDrawerLayout.FlyoutLayoutMode.Padding;
+
// Create the content frame that will host shell items
_contentFrame = new FrameLayout(Context)
{
@@ -82,7 +96,14 @@ protected override MauiDrawerLayout CreatePlatformView()
Id = AView.GenerateViewId(),
};
- // Set the content frame as the main content
+ // Add _contentFrame directly as a child so it's in the view hierarchy
+ // immediately. MauiDrawerLayout.SetContentView + UpdateLayout requires both
+ // content AND flyout views to be set before it parents the content frame.
+ // But we need the content frame to be a child now so fragment transactions
+ // can find it by ID when the FragmentManager processes them.
+ drawerLayout.AddView(_contentFrame, new LP(LP.MatchParent, LP.MatchParent));
+
+ // Also set it as the content view for MauiDrawerLayout's internal tracking
drawerLayout.SetContentView(_contentFrame);
return drawerLayout;
@@ -105,15 +126,8 @@ protected override void ConnectHandler(MauiDrawerLayout platformView)
_currentBehavior = behavior;
UpdateFlyoutBehaviorInternal(behavior);
- // Initialize with current item if it exists
- // Post to ensure the view hierarchy is fully attached before adding fragments
- if (VirtualView.CurrentItem is not null)
- {
- platformView.Post(new Java.Lang.Runnable(() =>
- {
- SwitchToItem(VirtualView.CurrentItem, animate: false);
- }));
- }
+ // MapCurrentItem mapper will handle initial item switching.
+ // If the view isn't attached yet, SwitchToItem defers automatically via Post().
}
protected override void DisconnectHandler(MauiDrawerLayout platformView)
@@ -136,6 +150,11 @@ protected override void DisconnectHandler(MauiDrawerLayout platformView)
_flyoutContentRenderer = null;
_flyoutContentView = null;
+ // Clean up deferred switch listener
+ PlatformView?.ViewAttachedToWindow -= OnPlatformViewAttachedToWindow;
+
+ _pendingSwitchItem = null;
+
// Disconnect MauiDrawerLayout
platformView.Disconnect();
@@ -169,9 +188,18 @@ void SwitchToItem(ShellItem newItem, bool animate)
return;
}
- // Ensure the content frame has a valid ID and is attached to the window
- if (_contentFrame.Id == AView.NoId || !_contentFrame.IsAttachedToWindow)
+ // If MauiDrawerLayout isn't attached to the window yet (e.g., during initial property mapping),
+ // defer until it's in the Activity's hierarchy. We check PlatformView (not _contentFrame)
+ // because ViewAttachedToWindow dispatches parent-first — when the callback fires,
+ // PlatformView.IsAttachedToWindow is true but children haven't been dispatched yet.
+ // The FragmentManager finds containers by searching from the Activity, so once the parent
+ // is attached, children are reachable via findViewById.
+ if (!PlatformView.IsAttachedToWindow)
{
+ _pendingSwitchItem = newItem;
+ _pendingSwitchAnimate = animate;
+ PlatformView.ViewAttachedToWindow -= OnPlatformViewAttachedToWindow;
+ PlatformView.ViewAttachedToWindow += OnPlatformViewAttachedToWindow;
return;
}
@@ -206,6 +234,20 @@ void OnDestroyed(object sender, EventArgs args)
}
}
+ void OnPlatformViewAttachedToWindow(object sender, AView.ViewAttachedToWindowEventArgs e)
+ {
+ PlatformView.ViewAttachedToWindow -= OnPlatformViewAttachedToWindow;
+
+ var item = _pendingSwitchItem;
+ var animate = _pendingSwitchAnimate;
+ _pendingSwitchItem = null;
+
+ if (item is not null && VirtualView is not null && _contentFrame is not null)
+ {
+ SwitchToItem(item, animate);
+ }
+ }
+
public static void MapCurrentItem(ShellHandler handler, Shell shell)
{
handler.SwitchToItem(shell.CurrentItem, animate: true);
@@ -266,6 +308,12 @@ void UpdateFlyoutBehaviorInternal(FlyoutBehavior behavior)
{
VirtualView?.SetValueFromRenderer(Shell.FlyoutIsPresentedProperty, false);
}
+
+ // Re-evaluate scrim for behavior change (locked = no scrim)
+ if (VirtualView is not null)
+ {
+ UpdateScrim(_scrimBrush);
+ }
}
void EnsureFlyoutContentCreated()
@@ -332,10 +380,55 @@ public static void MapFlowDirection(ShellHandler handler, Shell shell)
handler.MauiDrawerLayout.LayoutDirection = shell.FlowDirection.ToLayoutDirection();
}
+ const uint DefaultScrimColor = 0x99000000;
+
public static void MapFlyoutBackdrop(ShellHandler handler, Shell shell)
{
- // TODO: Implement scrim/backdrop for MauiDrawerLayout
- // For now, use default DrawerLayout scrim
+ if (handler.MauiDrawerLayout is null)
+ {
+ return;
+ }
+
+ handler._scrimBrush = shell.FlyoutBackdrop;
+ handler.UpdateScrim(handler._scrimBrush);
+ }
+
+ void UpdateScrim(Brush backdrop)
+ {
+ if (MauiDrawerLayout is null)
+ {
+ return;
+ }
+
+ if (_currentBehavior == FlyoutBehavior.Locked)
+ {
+ MauiDrawerLayout.SetScrimColor(Colors.Transparent.ToPlatform());
+ return;
+ }
+
+ if (backdrop is SolidColorBrush solidColor)
+ {
+ var backdropColor = solidColor.Color;
+ if (backdropColor is null)
+ {
+ unchecked
+ {
+ MauiDrawerLayout.SetScrimColor((int)DefaultScrimColor);
+ }
+ }
+ else
+ {
+ MauiDrawerLayout.SetScrimColor(backdropColor.ToPlatform());
+ }
+ }
+ else
+ {
+ // Default scrim for null/default/gradient brushes
+ unchecked
+ {
+ MauiDrawerLayout.SetScrimColor((int)DefaultScrimColor);
+ }
+ }
}
public static void MapFlyoutBackground(ShellHandler handler, Shell shell)
@@ -476,7 +569,18 @@ IShellBottomNavViewAppearanceTracker IShellContext.CreateBottomNavViewAppearance
void IAppearanceObserver.OnAppearanceChanged(ShellAppearance appearance)
{
- // Appearance changes handled by appearance trackers
+ // Match old ShellFlyoutRenderer: null appearance → transparent scrim,
+ // non-null appearance → use FlyoutBackdrop from appearance.
+ if (appearance is null)
+ {
+ _scrimBrush = Brush.Transparent;
+ }
+ else
+ {
+ _scrimBrush = appearance.FlyoutBackdrop;
+ }
+
+ UpdateScrim(_scrimBrush);
}
#endregion
diff --git a/src/Controls/src/Core/Handlers/Shell/ShellItemHandler.Android.cs b/src/Controls/src/Core/Handlers/Shell/ShellItemHandler.Android.cs
index ab754b75c552..e4a849fe2e49 100644
--- a/src/Controls/src/Core/Handlers/Shell/ShellItemHandler.Android.cs
+++ b/src/Controls/src/Core/Handlers/Shell/ShellItemHandler.Android.cs
@@ -34,8 +34,8 @@ namespace Microsoft.Maui.Controls.Handlers
///
public partial class ShellItemHandler : ElementHandler, IAppearanceObserver
{
- ViewPager2 _viewPager;
- BottomNavigationView _bottomNavigationView;
+ internal ViewPager2 _viewPager;
+ internal BottomNavigationView _bottomNavigationView;
BottomNavigationManager _bottomNavigationManager; // Shared component for bottom nav management
ShellSectionFragmentAdapter _adapter;
ShellItemPageChangeCallback _pageChangeCallback;
@@ -59,6 +59,7 @@ public partial class ShellItemHandler : ElementHandler, I
public static PropertyMapper Mapper = new PropertyMapper(ElementMapper)
{
[nameof(ShellItem.CurrentItem)] = MapCurrentItem,
+ [Shell.TabBarIsVisibleProperty.PropertyName] = MapTabBarIsVisible,
};
///
@@ -83,15 +84,17 @@ internal void SetParentFragment(Fragment fragment)
///
/// Creates the platform element (ViewPager2) for the ShellItem.
- /// This is the same pattern as TabbedPageManager.
+ /// Note: The actual ViewPager2 used at runtime comes from shellitemlayout.axml
+ /// (inflated in ShellItemWrapperFragment). This method satisfies the ElementHandler
+ /// contract. The fragment assigns the real ViewPager2 to _viewPager.
///
protected override ViewPager2 CreatePlatformElement()
{
var context = MauiContext?.Context ?? throw new InvalidOperationException("MauiContext cannot be null");
- // Use shared factory methods for ViewPager2 and BottomNavigationView creation
- _viewPager = BottomNavigationManager.CreateViewPager2(context);
- _bottomNavigationView = BottomNavigationManager.CreateBottomNavigationView(context);
+ // Create a placeholder ViewPager2 to satisfy the handler contract.
+ // The ShellItemWrapperFragment replaces _viewPager with the one from XML layout.
+ _viewPager = new ViewPager2(context);
return _viewPager;
}
@@ -138,6 +141,12 @@ internal void SetupViewPagerAdapter()
_viewPager.Adapter = _adapter;
+ // Disable swipe on the ShellItem ViewPager2. Bottom tabs should only switch
+ // via BottomNavigationView tapping (matching Shell renderer behavior). This also
+ // fixes nested ViewPager2 conflict: without this, the outer ViewPager2 captures
+ // horizontal swipes before the inner ShellSection ViewPager2 (content tabs).
+ _viewPager.UserInputEnabled = false;
+
// Keep ALL section fragments alive to prevent FragmentStateAdapter from
// saving/restoring fragment state. Restored fragments lose MAUI-specific state
// (StackNavigationManager, etc.) causing crashes. The renderer approach avoids
@@ -153,7 +162,7 @@ internal void SetupViewPagerAdapter()
/// Sets up the bottom navigation view with section tabs using BottomNavigationManager.
/// This enables code sharing with TabbedPage bottom navigation.
///
- void SetupBottomNavigation()
+ internal void SetupBottomNavigation()
{
if (_bottomNavigationView is null || VirtualView is null || MauiContext is null)
{
@@ -400,6 +409,25 @@ void UpdateDisplayedPage(Page page)
// Update toolbar with page and navigation state
UpdateToolbar(page, canNavigateBack);
+
+ // Re-evaluate tab bar visibility for the new page
+ UpdateTabBarVisibility();
+ }
+
+ void UpdateTabBarVisibility()
+ {
+ if (_bottomNavigationView is null || _displayedPage is null || VirtualView is null)
+ {
+ return;
+ }
+
+ var showTabs = ((IShellItemController)VirtualView).ShowTabs;
+ _bottomNavigationView.Visibility = showTabs ? ViewStates.Visible : ViewStates.Gone;
+ }
+
+ static void MapTabBarIsVisible(ShellItemHandler handler, ShellItem item)
+ {
+ handler.UpdateTabBarVisibility();
}
///
@@ -465,25 +493,16 @@ protected override void ConnectHandler(ViewPager2 platformView)
VirtualView?.PropertyChanged += OnShellItemPropertyChanged;
}
- // Setup ViewPager2 adapter (requires parent fragment to be set first)
- // This is called from OnViewCreated in the wrapper fragment
-
- SetupBottomNavigation();
-
- // Initialize appearance tracker
+ // Initialize shell context and appearance tracker early
_shellContext ??= GetShellContext();
_appearanceTracker = _shellContext.CreateBottomNavViewAppearanceTracker(VirtualView);
- // Register as appearance observer to receive appearance change notifications
- var shell = VirtualView?.FindParentOfType();
- if (shell is not null)
- {
- ((IShellController)shell).AddAppearanceObserver(this, VirtualView);
- // Note: Shell will call OnAppearanceChanged with the current appearance automatically
- }
-
- // Note: Initial section switching is done in OnViewCreated of the wrapper fragment
- // to ensure the fragment manager is ready
+ // NOTE: Appearance observer registration is deferred to RegisterAppearanceObserver()
+ // called from OnViewCreated in the wrapper fragment. At ConnectHandler time,
+ // the BottomNavigationView and Toolbar from the XML layout are not yet inflated.
+ // Registering here causes the initial OnAppearanceChanged callback to be lost
+ // because the views aren't ready. The old ShellItemRenderer registered in
+ // OnCreateView() AFTER creating all views — we match that pattern.
}
void OnShellItemPropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
@@ -582,36 +601,77 @@ protected override void DisconnectHandler(ViewPager2 platformView)
///
/// Called when Shell appearance changes (colors, styles, etc.)
+ /// Shell sends null appearance when the displayed page has no custom Shell colors,
+ /// signaling that appearance should reset to defaults.
///
void IAppearanceObserver.OnAppearanceChanged(ShellAppearance appearance)
{
- UpdateAppearance(appearance);
- UpdateToolbarAppearance(appearance);
+ if (appearance is not null)
+ {
+ UpdateAppearance(appearance);
+ UpdateToolbarAppearance(appearance);
+ }
+ else
+ {
+ ResetAppearance();
+ ResetToolbarAppearance();
+ }
}
///
- /// Updates the bottom navigation view appearance based on Shell appearance
+ /// Updates the bottom navigation view appearance based on Shell appearance.
///
void UpdateAppearance(ShellAppearance appearance)
{
- if (appearance is null)
+ if (_bottomNavigationView is null || _bottomNavigationView.Visibility != ViewStates.Visible)
{
return;
}
- if (_bottomNavigationView is null || _bottomNavigationView.Visibility != ViewStates.Visible)
+ _appearanceTracker?.SetAppearance(_bottomNavigationView, appearance);
+ }
+
+ ///
+ /// Resets the bottom navigation view appearance to defaults.
+ /// Called when Shell sends null appearance (page has no custom Shell colors).
+ ///
+ void ResetAppearance()
+ {
+ if (_bottomNavigationView is not null && _appearanceTracker is not null)
{
- return;
+ _appearanceTracker.ResetAppearance(_bottomNavigationView);
}
+ }
- if (_appearanceTracker is not null && appearance is not null)
+ ///
+ /// Resets the toolbar appearance to defaults.
+ /// Called when Shell sends null appearance (page has no custom Shell colors).
+ ///
+ void ResetToolbarAppearance()
+ {
+ if (_toolbarAppearanceTracker is not null && _toolbar is not null && _toolbarTracker is not null)
{
- _appearanceTracker.SetAppearance(_bottomNavigationView, appearance);
+ _toolbarAppearanceTracker.ResetAppearance(_toolbar, _toolbarTracker);
}
}
#endregion IAppearanceObserver
+ ///
+ /// Registers as an appearance observer with the Shell. Must be called AFTER
+ /// BottomNavigationView and Toolbar are created (from OnViewCreated), so the
+ /// initial OnAppearanceChanged callback can apply appearance to the ready views.
+ /// Matches the old ShellItemRenderer pattern of registering in OnCreateView.
+ ///
+ internal void RegisterAppearanceObserver()
+ {
+ var shell = VirtualView?.FindParentOfType();
+ if (shell is not null)
+ {
+ ((IShellController)shell).AddAppearanceObserver(this, VirtualView);
+ }
+ }
+
#region Toolbar Management
///
@@ -822,15 +882,15 @@ public void Dispose()
}
///
- /// Wrapper Fragment that hosts the ShellItemHandler's ViewPager2 and BottomNavigationView.
- /// Creates a CoordinatorLayout with AppBarLayout (Toolbar) + ViewPager2 + BottomNavigationView.
- /// The toolbar is now managed at the ShellItem level (shared across all sections).
+ /// Wrapper Fragment that hosts the ShellItemHandler's layout.
+ /// Inflates shellitemlayout.axml consistent with NavigationViewHandler and FlyoutViewHandler patterns.
+ /// The toolbar is managed at the ShellItem level (shared across all sections).
///
class ShellItemWrapperFragment : Fragment
{
readonly ShellItemHandler _handler;
CoordinatorLayout _rootLayout;
- LinearLayout _bottomContainer; // Contains ViewPager2 + BottomNav
+ LinearLayout _bottomContainer;
ShellBackPressedCallback _backPressedCallback;
public ShellItemWrapperFragment(ShellItemHandler handler)
@@ -842,57 +902,29 @@ public ShellItemWrapperFragment(ShellItemHandler handler)
public override AView OnCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState)
{
- var context = Context ?? RequireContext();
-
- // Create root CoordinatorLayout for AppBarLayout scrolling behavior
- _rootLayout = new CoordinatorLayout(context)
- {
- LayoutParameters = new LP(LP.MatchParent, LP.MatchParent)
- };
+ // Inflate from XML layout — consistent with NavigationViewHandler/FlyoutViewHandler pattern
+ var rootView = inflater.Inflate(Resource.Layout.shellitemlayout, container, false)
+ ?? throw new InvalidOperationException("shellitemlayout inflation failed");
- // Setup window insets for safe area handling
- MauiWindowInsetListener.SetupViewWithLocalListener(_rootLayout);
-
- // Create AppBarLayout for toolbar
- _handler._appBarLayout = new AppBarLayout(context)
- {
- LayoutParameters = new CoordinatorLayout.LayoutParams(LP.MatchParent, LP.WrapContent)
- };
- _rootLayout.AddView(_handler._appBarLayout);
+ // Get references from inflated layout
+ _rootLayout = rootView.FindViewById(Resource.Id.shellitem_coordinator);
+ _handler._appBarLayout = rootView.FindViewById(Resource.Id.shellitem_appbar);
+ _bottomContainer = rootView.FindViewById(Resource.Id.shellitem_content);
- // Create bottom container (LinearLayout) for ViewPager2 + BottomNav
- // This container uses ScrollingViewBehavior to scroll with AppBarLayout
- _bottomContainer = new LinearLayout(context)
- {
- Orientation = Orientation.Vertical,
- LayoutParameters = new CoordinatorLayout.LayoutParams(LP.MatchParent, LP.MatchParent)
- {
- Behavior = new AppBarLayout.ScrollingViewBehavior()
- }
- };
- _rootLayout.AddView(_bottomContainer);
+ // Get ViewPager2 and BottomNavigationView from the inflated layout
+ // and assign them to the handler so it can manage adapters and selection
+ _handler._viewPager = rootView.FindViewById(Resource.Id.shellitem_viewpager);
+ _handler._bottomNavigationView = rootView.FindViewById(Resource.Id.shellitem_bottomnavigation);
- // Get the ViewPager2 from the handler
- var viewPager = _handler.PlatformView ?? _handler.ToPlatform() as ViewPager2;
- if (viewPager is not null)
- {
- // Set layout params for ViewPager2 to take remaining space
- viewPager.LayoutParameters = new LinearLayout.LayoutParams(LP.MatchParent, 0)
- {
- Weight = 1
- };
- _bottomContainer.AddView(viewPager);
- }
+ // Set initial background to WHITE to match old ShellItemRenderer behavior.
+ // PlatformInterop.createNavigationBar() explicitly calls setBackgroundColor(WHITE).
+ // The appearance tracker will override this when Shell appearance is applied.
+ _handler._bottomNavigationView?.SetBackgroundColor(global::Android.Graphics.Color.White);
- // Add BottomNavigationView from handler
- var bottomNav = _handler.BottomNavigationView;
- if (bottomNav is not null)
- {
- bottomNav.LayoutParameters = new LP(LP.MatchParent, LP.WrapContent);
- _bottomContainer.AddView(bottomNav);
- }
+ // Setup window insets for safe area handling
+ MauiWindowInsetListener.SetupViewWithLocalListener(_rootLayout);
- return _rootLayout;
+ return rootView;
}
public override void OnViewCreated(AView view, Bundle savedInstanceState)
@@ -906,9 +938,17 @@ public override void OnViewCreated(AView view, Bundle savedInstanceState)
// Setup the shared toolbar
_handler.SetupToolbar();
+ // Setup bottom navigation (BottomNavigationView now comes from XML layout)
+ _handler.SetupBottomNavigation();
+
// Now that the fragment is attached, setup the ViewPager2 adapter
_handler.SetupViewPagerAdapter();
+ // Register as appearance observer NOW that all views are ready.
+ // This must happen after SetupToolbar and SetupBottomNavigation so that
+ // when Shell calls OnAppearanceChanged, the views can receive appearance updates.
+ _handler.RegisterAppearanceObserver();
+
// Trigger the initial section switch if needed
if (_handler.VirtualView?.CurrentItem is not null)
{
diff --git a/src/Controls/src/Core/Handlers/Shell/ShellSectionHandler.Android.cs b/src/Controls/src/Core/Handlers/Shell/ShellSectionHandler.Android.cs
index eb474460c245..d71fb571b712 100644
--- a/src/Controls/src/Core/Handlers/Shell/ShellSectionHandler.Android.cs
+++ b/src/Controls/src/Core/Handlers/Shell/ShellSectionHandler.Android.cs
@@ -40,7 +40,7 @@ public partial class ShellSectionHandler : ElementHandler,
Fragment _parentFragment; // The wrapper fragment that hosts this handler
IShellContext _shellContext;
IShellTabLayoutAppearanceTracker _tabLayoutAppearanceTracker;
- LinearLayout _rootLayout;
+ CoordinatorLayout _rootLayout;
ViewPager2 _viewPager;
TabLayout _contentTabLayout;
AppBarLayout _tabAppBarLayout;
@@ -124,39 +124,23 @@ IShellContext GetShellContext()
}
///
- /// Creates the platform element - always returns the unified layout.
+ /// Creates the platform element by inflating shellsectionlayout.axml.
+ /// Uses XML layout inflation consistent with NavigationViewHandler and FlyoutViewHandler patterns.
///
protected override AView CreatePlatformElement()
{
- var context = MauiContext?.Context ?? throw new InvalidOperationException("MauiContext cannot be null");
+ var li = MauiContext?.GetLayoutInflater()
+ ?? throw new InvalidOperationException("LayoutInflater cannot be null");
- // Create root LinearLayout (always the same structure)
- _rootLayout = new LinearLayout(context)
- {
- Orientation = Orientation.Vertical,
- LayoutParameters = new LP(LP.MatchParent, LP.MatchParent)
- };
+ var rootView = li.Inflate(Resource.Layout.shellsectionlayout, null)
+ ?? throw new InvalidOperationException("shellsectionlayout inflation failed");
- // Create AppBarLayout to hold TabLayout (for scrolling behavior with CoordinatorLayout parent)
- _tabAppBarLayout = new AppBarLayout(context)
- {
- LayoutParameters = new LinearLayout.LayoutParams(LP.MatchParent, LP.WrapContent)
- };
- _rootLayout.AddView(_tabAppBarLayout);
-
- // Create TabLayout (visibility controlled by item count)
- int actionBarHeight = context.GetActionBarHeight();
- _contentTabLayout = PlatformInterop.CreateShellTabLayout(context, _tabAppBarLayout, actionBarHeight);
-
- // Create ViewPager2 (always present)
- _viewPager = new ViewPager2(context)
- {
- Id = AView.GenerateViewId(),
- LayoutParameters = new LinearLayout.LayoutParams(LP.MatchParent, 0) { Weight = 1 }
- };
- _rootLayout.AddView(_viewPager);
+ _rootLayout = rootView.FindViewById(Resource.Id.shellsection_coordinator);
+ _tabAppBarLayout = rootView.FindViewById(Resource.Id.shellsection_appbar);
+ _contentTabLayout = rootView.FindViewById(Resource.Id.shellsection_tablayout);
+ _viewPager = rootView.FindViewById(Resource.Id.shellsection_viewpager);
- return _rootLayout;
+ return rootView;
}
protected override void ConnectHandler(AView platformView)
diff --git a/src/Core/src/Platform/Android/Resources/Layout/shellitemlayout.axml b/src/Core/src/Platform/Android/Resources/Layout/shellitemlayout.axml
new file mode 100644
index 000000000000..06217d1eff6f
--- /dev/null
+++ b/src/Core/src/Platform/Android/Resources/Layout/shellitemlayout.axml
@@ -0,0 +1,52 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/Core/src/Platform/Android/Resources/Layout/shellsectionlayout.axml b/src/Core/src/Platform/Android/Resources/Layout/shellsectionlayout.axml
new file mode 100644
index 000000000000..3d26e749ce24
--- /dev/null
+++ b/src/Core/src/Platform/Android/Resources/Layout/shellsectionlayout.axml
@@ -0,0 +1,43 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/Core/src/Platform/Android/Resources/values/styles.xml b/src/Core/src/Platform/Android/Resources/values/styles.xml
index 2c49a4c21f79..311d7adc47b7 100644
--- a/src/Core/src/Platform/Android/Resources/values/styles.xml
+++ b/src/Core/src/Platform/Android/Resources/values/styles.xml
@@ -21,6 +21,13 @@
+
+
+
+
From ab75cba798d8fd8b8e7a68eb210d5a5b1a68cc80 Mon Sep 17 00:00:00 2001
From: Tamilarasan Paranthaman
<93904422+Tamilarasan-Paranthaman@users.noreply.github.com>
Date: Tue, 10 Mar 2026 11:03:03 +0530
Subject: [PATCH 06/26] Updating Sandbox test sample
---
.../FlyoutTestPage.xaml | 286 ++---
.../FlyoutTestPage.xaml.cs | 51 +-
.../Resources/Images/bookmark.png | Bin 0 -> 384 bytes
.../Resources/Images/chart_histogram.png | Bin 0 -> 379 bytes
.../Resources/Images/envelope.png | Bin 0 -> 421 bytes
.../Resources/Images/home.png | Bin 0 -> 387 bytes
.../Resources/Images/paper_plane.png | Bin 0 -> 624 bytes
.../Resources/Images/refresh.png | Bin 0 -> 522 bytes
.../Resources/Images/rocket_launch.png | Bin 0 -> 691 bytes
.../Resources/Images/search.png | Bin 0 -> 517 bytes
.../Resources/Images/tab_folder.png | Bin 0 -> 316 bytes
.../Resources/Images/trash.png | Bin 0 -> 331 bytes
.../Resources/Styles/Colors.xaml | 99 +-
.../Resources/Styles/Styles.xaml | 1056 ++++++++---------
.../Controls.Sample.Sandbox/SandboxShell.xaml | 26 +-
.../SandboxShell.xaml.cs | 5 +
.../ShellEventsTestPage.xaml | 81 ++
.../ShellEventsTestPage.xaml.cs | 157 +++
.../ShellFeaturesTestPage.xaml | 75 ++
.../ShellFeaturesTestPage.xaml.cs | 212 ++++
20 files changed, 1328 insertions(+), 720 deletions(-)
create mode 100644 src/Controls/samples/Controls.Sample.Sandbox/Resources/Images/bookmark.png
create mode 100644 src/Controls/samples/Controls.Sample.Sandbox/Resources/Images/chart_histogram.png
create mode 100644 src/Controls/samples/Controls.Sample.Sandbox/Resources/Images/envelope.png
create mode 100644 src/Controls/samples/Controls.Sample.Sandbox/Resources/Images/home.png
create mode 100644 src/Controls/samples/Controls.Sample.Sandbox/Resources/Images/paper_plane.png
create mode 100644 src/Controls/samples/Controls.Sample.Sandbox/Resources/Images/refresh.png
create mode 100644 src/Controls/samples/Controls.Sample.Sandbox/Resources/Images/rocket_launch.png
create mode 100644 src/Controls/samples/Controls.Sample.Sandbox/Resources/Images/search.png
create mode 100644 src/Controls/samples/Controls.Sample.Sandbox/Resources/Images/tab_folder.png
create mode 100644 src/Controls/samples/Controls.Sample.Sandbox/Resources/Images/trash.png
create mode 100644 src/Controls/samples/Controls.Sample.Sandbox/ShellEventsTestPage.xaml
create mode 100644 src/Controls/samples/Controls.Sample.Sandbox/ShellEventsTestPage.xaml.cs
create mode 100644 src/Controls/samples/Controls.Sample.Sandbox/ShellFeaturesTestPage.xaml
create mode 100644 src/Controls/samples/Controls.Sample.Sandbox/ShellFeaturesTestPage.xaml.cs
diff --git a/src/Controls/samples/Controls.Sample.Sandbox/FlyoutTestPage.xaml b/src/Controls/samples/Controls.Sample.Sandbox/FlyoutTestPage.xaml
index e24a94f50db5..a3089fdc8317 100644
--- a/src/Controls/samples/Controls.Sample.Sandbox/FlyoutTestPage.xaml
+++ b/src/Controls/samples/Controls.Sample.Sandbox/FlyoutTestPage.xaml
@@ -3,147 +3,167 @@
xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
x:Class="Maui.Controls.Sample.FlyoutTestPage"
Title="Flyout Test">
-
-
-
+
+
+
-
-
-
-
-
+
+
+
+
+
-
-
-
-
-
-
+
+
+
+
+
+
-
-
-
-
-
-
+
+
+
+
+
+
-
-
-
-
-
-
+
+
+
+
+
+
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
-
-
-
-
-
+
+
+
+
+
-
-
-
-
-
-
+
+
+
+
+
+
-
-
-
-
-
+
+
+
+
+
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/Controls/samples/Controls.Sample.Sandbox/FlyoutTestPage.xaml.cs b/src/Controls/samples/Controls.Sample.Sandbox/FlyoutTestPage.xaml.cs
index a6498fdf5cc9..cc77a7b9a899 100644
--- a/src/Controls/samples/Controls.Sample.Sandbox/FlyoutTestPage.xaml.cs
+++ b/src/Controls/samples/Controls.Sample.Sandbox/FlyoutTestPage.xaml.cs
@@ -83,8 +83,8 @@ private void OnSetBehaviorDisabled(object? sender, EventArgs e)
private void OnChangeFlyoutBackgroundRed(object? sender, EventArgs e)
{
- Shell.Current.FlyoutBackgroundColor = Colors.Red;
- StatusLabel.Text = "Status: Flyout background = Red";
+ Shell.Current.FlyoutBackgroundColor = Colors.Yellow;
+ StatusLabel.Text = "Status: Flyout background = Yellow";
}
private void OnChangeFlyoutBackgroundBlue(object? sender, EventArgs e)
@@ -191,6 +191,14 @@ private void OnHeaderBehaviorCollapse(object? sender, EventArgs e)
StatusLabel.Text = "Status: Header behavior = CollapseOnScroll";
}
+ private void OnResetHeaderBehaviorTestClicked(object? sender, EventArgs e)
+ {
+ Shell.Current.FlyoutHeader = null;
+ Shell.Current.FlyoutContent = null;
+ Shell.Current.FlyoutHeaderBehavior = FlyoutHeaderBehavior.Default;
+ StatusLabel.Text = "Status: Header behavior test reset";
+ }
+
// Flyout Content Tests
private void OnSetCustomContentClicked(object? sender, EventArgs e)
{
@@ -212,8 +220,8 @@ private void OnResetContentClicked(object? sender, EventArgs e)
// Flyout Backdrop Tests
private void OnRedBackdropClicked(object? sender, EventArgs e)
{
- Shell.Current.FlyoutBackdrop = new SolidColorBrush(Colors.Red);
- StatusLabel.Text = "Status: Backdrop = Red";
+ Shell.Current.FlyoutBackdrop = new SolidColorBrush(Colors.Yellow);
+ StatusLabel.Text = "Status: Backdrop = Yellow";
}
private void OnBlackBackdropClicked(object? sender, EventArgs e)
@@ -240,5 +248,40 @@ private void OnFlowDirectionRTLClicked(object? sender, EventArgs e)
Shell.Current.FlowDirection = FlowDirection.RightToLeft;
StatusLabel.Text = "Status: Flow direction = RightToLeft";
}
+
+ // Add many flyout items to make flyout scrollable (for header behavior testing)
+ private void OnAddManyFlyoutItemsClicked(object? sender, EventArgs e)
+ {
+ var items = new List();
+ for (int i = 1; i <= 30; i++)
+ items.Add($"Test Item {i}");
+
+ Shell.Current.FlyoutContent = new CollectionView
+ {
+ ItemsSource = items,
+ ItemTemplate = new DataTemplate(() =>
+ {
+ var label = new Label { Padding = new Thickness(15, 10), FontSize = 16 };
+ label.SetBinding(Label.TextProperty, ".");
+ return label;
+ })
+ };
+ StatusLabel.Text = "Status: 30 flyout items added (scrollable)";
+ }
+
+ // Reset all flyout settings to defaults
+ private void OnResetAllFlyoutClicked(object? sender, EventArgs e)
+ {
+ Shell.Current.FlyoutHeader = null;
+ Shell.Current.FlyoutFooter = null;
+ Shell.Current.FlyoutContent = null;
+ Shell.Current.FlyoutHeaderBehavior = FlyoutHeaderBehavior.Default;
+ Shell.Current.FlyoutBackdrop = null;
+ Shell.Current.FlyoutBackground = null;
+ Shell.Current.FlyoutWidth = -1;
+ Shell.Current.FlyoutBehavior = FlyoutBehavior.Flyout;
+ Shell.Current.FlowDirection = FlowDirection.LeftToRight;
+ StatusLabel.Text = "Status: All flyout settings reset to defaults";
+ }
}
}
diff --git a/src/Controls/samples/Controls.Sample.Sandbox/Resources/Images/bookmark.png b/src/Controls/samples/Controls.Sample.Sandbox/Resources/Images/bookmark.png
new file mode 100644
index 0000000000000000000000000000000000000000..0aa3d01948293c5e09a94ae49b801dd4b88b860c
GIT binary patch
literal 384
zcmeAS@N?(olHy`uVBq!ia0vp^5+KaM1|%Pp+x`GjoCO|{#Xx!^2s0kj_3Q;QBuiW)
zN`mv#O3D+9QW?t2%k?tzvWt@w3sUv+i_&Mmvyoz8VC405aSZY3d^^?GkI7NME&j$K
z#tF_27Hon4?r>I%$uaOP;OLBTJmfi{TSD)E+e{XdwnE3LQyzc$lN#2d|I)YgY_;v&
z67xU4(h-bu50=Zwec&=FOqs>_O6sw~9$n%22Lx8^2os#xRkK_CTJPK#&%!B;GG_uJ
zyrb`Uebi!ijEs=qwxW7^INvGlCmg(IT?+)~EL^~KWmCtbIZxO&Jg!hIORB2(FA8cr
zv{m14lGg>H1^j1Hj(7@jud}@S-Z;2^$}RB=XSE6rHc!fbpttrxSlDys^NIy$o1H)T
zFW~o+eIfZng=t;oqb;$ui9ZhP&W)O}zrgN};KjF_lJlg!4sah&&*Qzbydj(Ifb<5z
cFu@1xZ;D&~Diy!!0frufr>mdKI;Vst0DNPYH2?qr
literal 0
HcmV?d00001
diff --git a/src/Controls/samples/Controls.Sample.Sandbox/Resources/Images/chart_histogram.png b/src/Controls/samples/Controls.Sample.Sandbox/Resources/Images/chart_histogram.png
new file mode 100644
index 0000000000000000000000000000000000000000..4bac26070779668da18d464d78f6e83d7faaa4d6
GIT binary patch
literal 379
zcmeAS@N?(olHy`uVBq!ia0vp^5+KaM1|%Pp+x`GjEX7WqAsj$Z!;#Vf2?-
zjUdc;OxLp)$dD{?jVKAuPb(=;EJ|f4FE7{2%*!rLPAo{(%P&fw{mw=TsOX2Mi(`mK
z=iAG+Ud)a%tRLcg5|UGWMEDm!|DZDO0C%Rs)ME|3NA%b)c&%Z%c+RPtC*|hcnX-o)
zdinnywR={3=FJ%f?(8`$+d0!JTHhO(o((@({Bw3g;EbTpp+Da7N+jQkFz1b#SQ+mS
z{6%hA@&x1atXo{&6MyaSysaTNAvYM}4{TV&4+rD}I*{{N!w`P6BmOy4@nJqh7
z&))W8J90r#?ZQWG-WyqW{gMJRZz~;{HMMA?lB;`2ueWTV=^yq#wFmUH{b7E&r@cd0
SMMne}1`M9AelF{r5}E*X>6VfJ
literal 0
HcmV?d00001
diff --git a/src/Controls/samples/Controls.Sample.Sandbox/Resources/Images/envelope.png b/src/Controls/samples/Controls.Sample.Sandbox/Resources/Images/envelope.png
new file mode 100644
index 0000000000000000000000000000000000000000..16dfd034d2c971a3568997566072f63d7f58ab98
GIT binary patch
literal 421
zcmV;W0b2fvP)CE4;
zJ4s+k$t3s~Hx(=@nFcQu%qz*mcXIVY0c`vES9)6yzm6T;V#7i{Nt$
zU=z1VUzRu6DEKZQ)Dn2Dpc(eCANybMI-@^i(0K)mMu2+7&|gtEx+I`cAvZg5y}Hpk
zhvNzb8LPwSdJ7ohT)CArB4Zet2U(%5`YZDyZ*LjhK>ZTXKJL<)|9N}?xh2G>0l>=}
P00000NkvXXu0mjfW2UYS
literal 0
HcmV?d00001
diff --git a/src/Controls/samples/Controls.Sample.Sandbox/Resources/Images/home.png b/src/Controls/samples/Controls.Sample.Sandbox/Resources/Images/home.png
new file mode 100644
index 0000000000000000000000000000000000000000..64f8ea7b02ed0003e6f372f1fa6103af7c52ff7c
GIT binary patch
literal 387
zcmV-}0et?6P)sA7r1H9#y8w4#1>vDq%6EtNL9F1h$}odWc&i}Ilzs2BrW_6aMon#0d6!D^91nF
zB=8szi1{!Bv*=SXK+SSco*bHc?W+a_5
zatS!f3sbyM-q9uCPu@q0*N}J33n=QMq7ExOYuiPY^_GB0@E&bZc6L!}id>uP9!H;@}#<
z;Y|FyTTxuej5oIkCuMLMmnw=*={lD2q`=8a;P5zXhI3`FY936WZI$qLe8XbBKzmhh
z)QMHVVNcl2RTO!o?=TkQozZto>AxE@QW=>qa4;18WIYF@@<3W@4xg3wvZq@Emf12h-_0000<
KMNUMnLSTXeycW;^
literal 0
HcmV?d00001
diff --git a/src/Controls/samples/Controls.Sample.Sandbox/Resources/Images/refresh.png b/src/Controls/samples/Controls.Sample.Sandbox/Resources/Images/refresh.png
new file mode 100644
index 0000000000000000000000000000000000000000..a2b667c060388fc7d45aa737fd5c204f88d391da
GIT binary patch
literal 522
zcmV+l0`>igP)ywAO;eUJ6tKpFtxgHhvk@sF<(`T9c4S_y)v=
z3KDHF5v>$-*W%shPS)8SCSgu8naP`b&Utg^zI$7SV;r-%iyJtLQGCG`*6|jf3!F`K
zaJx$QHGZR8aUJ3XE(ABP55zovM9=}2F^379!f9N`0#+iXi|?4JGI$oB*F_swhV3M9
z4ex`Kxupj45zxVtBM2AK!t-GU<9caXtRcLq{J-q=2QJ5p)p{GZF+lubG3c^XEx#~U
z)1VR~Qk|c`2kbUsFdfe;$1R?*E9Gvg3Gq?s$nRjg34>M>qEhNVN~PZjCZx3Qj5K6$
zEACrO8QhEeS`*@9Qina%cW~$M)&EC-qozSScrW{3?3IXjrD`}T9tCG#Zvg#67W{*!
zHFph#;b5iFD;!gDn&M!k;Y#hneU|bJBc$miK}>kH+my;Kh_4K
zIEl_kyWdRWK>z>%
M07*qoM6N<$f(cdO(f|Me
literal 0
HcmV?d00001
diff --git a/src/Controls/samples/Controls.Sample.Sandbox/Resources/Images/rocket_launch.png b/src/Controls/samples/Controls.Sample.Sandbox/Resources/Images/rocket_launch.png
new file mode 100644
index 0000000000000000000000000000000000000000..3cbeee59e2861502bfd09ef7253f67425b7c35bf
GIT binary patch
literal 691
zcmV;k0!;mhP)M3R%9Vd3rjL63Ja1**;r_nwv3t3
zAeYQS3M043eK0O@EPl`N9_M}MeP29vI_Esk_xV2O_xnAU!~e-Rtj9@Q!z+BlQ|v?Q
zzY@>H34BIY=i2kP#I5MWmmv6o9&ATDreZXfhW*LkkWZ1eA;V9c!kl5SZGrpJEcq-9
zgwrD|Z-Ad3*q6ZU_^b|mUoB%BHlhpt7z*%hDQjRZdhsdlb4wgM!smEV
z*@A8OpgJ3#VNwCxQ?mDz0$dLLx?C{=XH^ccS4zVS-&ODVU@5?0!8T9Iu0f2=m7OYw
zvN{6h8FN6jTr35+Sg@TA-LYITCnA2u{LpO<&;#jA$}$_>_!#%up>K~J7?Lsx91OC<
z@!l$>Vup?yZF|A-9gZ)wpXHr+4&@6db@*oGL
zGwG1BtGLSkX1;j0)X)avIUg1aRca(phzwU%im|IvfZeM1J|7mNO8Q6G6syTw#)f+2
zqwzj~E3hn{pB6AV`If@U)<{M5LG5DvEo)Ws7gnmCMtOi-7D@9r!`6D_uveuW_Z7%G
zYXn$=Bhp~ca7OCFb*0;%d;Au={P{;vKA#_fX;|qkcqkp*rMS+ko~0Sy1@;1tN>$rX
ZegS?5*sZPIp@;wg002ovPDHLkV1l~gI{yFw
literal 0
HcmV?d00001
diff --git a/src/Controls/samples/Controls.Sample.Sandbox/Resources/Images/search.png b/src/Controls/samples/Controls.Sample.Sandbox/Resources/Images/search.png
new file mode 100644
index 0000000000000000000000000000000000000000..6b7db9bab48cd0c7552aafce676746dba7679023
GIT binary patch
literal 517
zcmV+g0{Z=lP)+{3C)|*!hc;9;u>1wD1qH35eE$g^i8>f{hk(
zBC!iG;tvF|5Cw^@#eA1t;@s`-UFCyi2IkFsb8l`Qd5o}$r#QeNe&GY2V2q_Hds{Ka
zdz3BT0XF&w4{^UC@CrAv8mArN3~pi4;O(I3Vo-_y#1@Xt;1;+M+!FWN#K#Ts^)9Cg
ztT#+9Pa}=gnQ!$Fudp3^_pzKKY^pP#70Waf>N~lbTf7wW2SMtKKX@4PYdONZ5MG@_
zyuw;&?B*5^V=2?&*u$v3E~>7yn=*NI&$eit|#9m$=wQ-ck3_w%KtF
zaHk>u87plDh17~w4Ns(MUX%Xk$8i>S)tOh~C0=(iAzjpdLtxssC&jW7;=N3kaRra1
z=l=~~@fMHb5Q7GPE|b1Ep>EY(ocwQ1nsL2Yq~O|2p5fD9%J6)$7s{ID00000NkvXX
Hu0mjf`$_4X
literal 0
HcmV?d00001
diff --git a/src/Controls/samples/Controls.Sample.Sandbox/Resources/Images/tab_folder.png b/src/Controls/samples/Controls.Sample.Sandbox/Resources/Images/tab_folder.png
new file mode 100644
index 0000000000000000000000000000000000000000..d6745844fdef17f0741791da8e32e43ba67db5d5
GIT binary patch
literal 316
zcmeAS@N?(olHy`uVBq!ia0vp^5+KaM1|%Pp+x`GjoCO|{#S9F5he4R}c>anMprB-l
zYeY$Kep*R+Vo@qXd3m{BW?pu2a$-TMUVc&f>~}U&Kt(4#T^vI^I^Rw);}h$X_Mg&jvFOWec)fGa&5EBvpIWEOzv8;YR>68F
zm5X`LoIi{{4T2Lae~Qoe$-0g0&N0>vrPr^j-YMmq(I~TJ%XPgIA~zeC>{U|ot%$!M
zUK0Kx^{7=*s;d-LP|mavBPe+q>juuRciu+$*Q=_Pw-@9a%0lB}|To?`HH
L^>bP0l+XkKm%@B;
literal 0
HcmV?d00001
diff --git a/src/Controls/samples/Controls.Sample.Sandbox/Resources/Images/trash.png b/src/Controls/samples/Controls.Sample.Sandbox/Resources/Images/trash.png
new file mode 100644
index 0000000000000000000000000000000000000000..e9af7fbb68c1a088fe95c515cd2dbe08a972283e
GIT binary patch
literal 331
zcmeAS@N?(olHy`uVBq!ia0vp^5+KaM1|%Pp+x`GjoCO|{#Xx!^2s0kj_3Q;QBuiW)
zN`mv#O3D+9QW?t2%k?tzvWt@w3sUv+i_&MmvylQSy5Z^K7~;|ScItVqCI^9I^)CGn
zPR1=;_qVbo&WYc#gsW=xrIx;ZK9kt3Bihprs$7o@mdKI;Vst0F@hxD*ylh
literal 0
HcmV?d00001
diff --git a/src/Controls/samples/Controls.Sample.Sandbox/Resources/Styles/Colors.xaml b/src/Controls/samples/Controls.Sample.Sandbox/Resources/Styles/Colors.xaml
index ed47472ce314..f49ca80331e9 100644
--- a/src/Controls/samples/Controls.Sample.Sandbox/Resources/Styles/Colors.xaml
+++ b/src/Controls/samples/Controls.Sample.Sandbox/Resources/Styles/Colors.xaml
@@ -1,58 +1,59 @@
+ xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+ xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml">
-
+
- #512BD4
- #ac99ea
- #242424
- #DFD8F7
- #9880e5
- #2B0B98
- Red
+ #512BD4
+ #ac99ea
+ #242424
+ #DFD8F7
+ #9880e5
+ #2B0B98
+ Red
+ Green
- White
- Black
- #D600AA
- #190649
- #1f1f1f
+ White
+ Black
+ #D600AA
+ #190649
+ #1f1f1f
- #E1E1E1
- #C8C8C8
- #ACACAC
- #919191
- #6E6E6E
- #404040
- #212121
- #141414
+ #E1E1E1
+ #C8C8C8
+ #ACACAC
+ #919191
+ #6E6E6E
+ #404040
+ #212121
+ #141414
-
-
-
-
-
+
+
+
+
+
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/Controls/samples/Controls.Sample.Sandbox/Resources/Styles/Styles.xaml b/src/Controls/samples/Controls.Sample.Sandbox/Resources/Styles/Styles.xaml
index 0cc5833585bf..70561eb9faeb 100644
--- a/src/Controls/samples/Controls.Sample.Sandbox/Resources/Styles/Styles.xaml
+++ b/src/Controls/samples/Controls.Sample.Sandbox/Resources/Styles/Styles.xaml
@@ -1,510 +1,510 @@
+ xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+ xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml">
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
-
+
-
+
-
+
-
+
diff --git a/src/Controls/samples/Controls.Sample.Sandbox/SandboxShell.xaml b/src/Controls/samples/Controls.Sample.Sandbox/SandboxShell.xaml
index a617858a090c..f1d42a9d42f2 100644
--- a/src/Controls/samples/Controls.Sample.Sandbox/SandboxShell.xaml
+++ b/src/Controls/samples/Controls.Sample.Sandbox/SandboxShell.xaml
@@ -7,6 +7,11 @@
Shell.FlyoutBehavior="Flyout"
Title="Shell Handler Tests">
+
+
+
@@ -17,18 +22,19 @@
-
+
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/Controls/samples/Controls.Sample.Sandbox/ShellEventsTestPage.xaml.cs b/src/Controls/samples/Controls.Sample.Sandbox/ShellEventsTestPage.xaml.cs
new file mode 100644
index 000000000000..3b1409675a14
--- /dev/null
+++ b/src/Controls/samples/Controls.Sample.Sandbox/ShellEventsTestPage.xaml.cs
@@ -0,0 +1,157 @@
+using System.Text;
+
+namespace Maui.Controls.Sample;
+
+public partial class ShellEventsTestPage : ContentPage
+{
+ readonly StringBuilder _eventLog = new();
+ bool _isLogging;
+
+ public ShellEventsTestPage()
+ {
+ InitializeComponent();
+ }
+
+ protected override void OnAppearing()
+ {
+ base.OnAppearing();
+ if (_isLogging)
+ SubscribeToEvents();
+ }
+
+ protected override void OnDisappearing()
+ {
+ base.OnDisappearing();
+ UnsubscribeFromEvents();
+ }
+
+ // --- Event Logging ---
+
+ void OnStartEventLoggingClicked(object? sender, EventArgs e)
+ {
+ _isLogging = true;
+ SubscribeToEvents();
+ LogEvent("Event logging started");
+ StatusLabel.Text = "Status: Logging enabled";
+ }
+
+ void OnStopEventLoggingClicked(object? sender, EventArgs e)
+ {
+ _isLogging = false;
+ UnsubscribeFromEvents();
+ LogEvent("Event logging stopped");
+ StatusLabel.Text = "Status: Logging disabled";
+ }
+
+ void OnClearLogClicked(object? sender, EventArgs e)
+ {
+ _eventLog.Clear();
+ EventLogLabel.Text = "(no events logged yet)";
+ StatusLabel.Text = "Status: Log cleared";
+ }
+
+ void SubscribeToEvents()
+ {
+ if (Shell.Current is null)
+ return;
+ // Avoid duplicate subscriptions
+ UnsubscribeFromEvents();
+ Shell.Current.Navigating += OnShellNavigating;
+ Shell.Current.Navigated += OnShellNavigated;
+ }
+
+ void UnsubscribeFromEvents()
+ {
+ if (Shell.Current is null)
+ return;
+ Shell.Current.Navigating -= OnShellNavigating;
+ Shell.Current.Navigated -= OnShellNavigated;
+ }
+
+ void OnShellNavigating(object? sender, ShellNavigatingEventArgs e)
+ {
+ LogEvent($"NAVIGATING: {e.Source} → Current={e.Current?.Location} Target={e.Target?.Location}");
+ }
+
+ void OnShellNavigated(object? sender, ShellNavigatedEventArgs e)
+ {
+ LogEvent($"NAVIGATED: {e.Source} → Current={e.Current?.Location} Previous={e.Previous?.Location}");
+ }
+
+ void LogEvent(string message)
+ {
+ var timestamp = DateTime.Now.ToString("HH:mm:ss.fff");
+ _eventLog.AppendLine($"[{timestamp}] {message}");
+ EventLogLabel.Text = _eventLog.ToString();
+ }
+
+ // --- Trigger Navigation ---
+
+ async void OnPushPageClicked(object? sender, EventArgs e)
+ {
+ var page = new ContentPage
+ {
+ Title = "Pushed Page",
+ Content = new VerticalStackLayout
+ {
+ Spacing = 20,
+ Padding = new Thickness(30),
+ VerticalOptions = LayoutOptions.Center,
+ Children =
+ {
+ new Label
+ {
+ Text = "Pushed page — check event log after going back",
+ FontSize = 16,
+ HorizontalOptions = LayoutOptions.Center,
+ HorizontalTextAlignment = TextAlignment.Center
+ },
+ new Button
+ {
+ Text = "Go Back",
+ HorizontalOptions = LayoutOptions.Center,
+ Command = new Command(async () => await Shell.Current.GoToAsync(".."))
+ }
+ }
+ }
+ };
+
+ await Navigation.PushAsync(page);
+ }
+
+ async void OnGoToHomeClicked(object? sender, EventArgs e)
+ {
+ await Shell.Current.GoToAsync("//Home/MainPage");
+ }
+
+ async void OnGoToMultiTabClicked(object? sender, EventArgs e)
+ {
+ await Shell.Current.GoToAsync("//MultiTab/Content1");
+ }
+
+ // --- MenuItem Tests ---
+ // Shell MenuItems are added via XAML. The SandboxShell.xaml contains a