[Android] Fix for predictive back-to-home animation blocked by unconditional back callback registration#35223
[Android] Fix for predictive back-to-home animation blocked by unconditional back callback registration#35223BagavathiPerumal wants to merge 3 commits intodotnet:mainfrom
Conversation
|
🚀 Dogfood this PR with:
curl -fsSL https://raw.githubusercontent.com/dotnet/maui/main/eng/scripts/get-maui-pr.sh | bash -s -- 35223Or
iex "& { $(irm https://raw.githubusercontent.com/dotnet/maui/main/eng/scripts/get-maui-pr.ps1) } 35223" |
dotnet-policy-service
Bot
added
the
partner/syncfusion
MauiBot
left a comment
MauiBot
left a comment
There was a problem hiding this comment.
Expert Review — 6 findings
See inline comments for details.
MauiBot
added
s/agent-changes-requested
BagavathiPerumal
force-pushed
the
fix-34594
branch
from
3cb4dbc to
30bfb65
Compare
MauiBot
left a comment
MauiBot
left a comment
There was a problem hiding this comment.
Expert Review — 9 findings
See inline comments for details.
MauiBot
added
s/agent-review-incomplete
kubaflo
left a comment
kubaflo
left a comment
There was a problem hiding this comment.
Could you please try ai's suggestions?
MauiBot
added
s/agent-fix-win
…ion on Android 16 by replacing the unconditional IOnBackInvokedCallback with AndroidX OnBackPressedCallback and toggling Enabled based on the navigation state.
There was a problem hiding this comment.
Pull request overview
This PR aims to restore Android predictive back-to-home behavior in .NET MAUI by replacing the always-registered activity back callback with a dynamically enabled AndroidX callback tied to MAUI navigation state. It sits in the Android activity/back-navigation pipeline and the Controls navigation stack plumbing that determines when MAUI should intercept back.
Changes:
- Replaces the activity’s unconditional predictive-back registration with an AndroidX
OnBackPressedCallbackthat is enabled/disabled at runtime. - Adds Android back-navigation state plumbing between
Window,Shell,NavigationPage,FlyoutPage, modal navigation, and page appearance flows. - Refactors the default Android lifecycle back handler into a named delegate so framework vs. custom back handlers can be distinguished.
Reviewed changes
Copilot reviewed 10 out of 10 changed files in this pull request and generated 5 comments.
Show a summary per file
| File | Description |
|---|---|
src/Core/src/Platform/Android/MauiAppCompatActivity.Lifecycle.cs |
Reworks back propagation to temporarily disable and then recompute the MAUI callback state. |
src/Core/src/Platform/Android/MauiAppCompatActivity.cs |
Swaps the predictive-back implementation to AndroidX and adds callback enablement logic. |
src/Core/src/Platform/Android/IBackNavigationState.cs |
Introduces a contract for reporting whether back can currently be consumed. |
src/Core/src/Hosting/LifecycleEvents/AppHostBuilderExtensions.Android.cs |
Extracts the default window back handler into a reusable named delegate. |
src/Controls/src/Core/Window/Window.cs |
Refreshes Android predictive-back state after modal and back-button changes. |
src/Controls/src/Core/Window/Window.Android.cs |
Computes whether the current Controls tree can consume back on Android. |
src/Controls/src/Core/Shell/Shell.cs |
Triggers callback-state refreshes on Shell navigation and flyout changes. |
src/Controls/src/Core/Page/Page.cs |
Refreshes callback state when pages appear. |
src/Controls/src/Core/NavigationPage/NavigationPage.cs |
Refreshes callback state on page switches and stack mutations. |
src/Controls/src/Core/FlyoutPage/FlyoutPage.cs |
Exposes flyout back-subscriber state and refreshes when presentation changes. |
|
|
||
| static bool CanPageDefaultConsumeBackNavigation(Page page) => | ||
| page.RealParent is not null && | ||
| page.RealParent is not (BaseShellItem or Shell or Window or NavigationPage or FlyoutPage or MultiPage<Page>); |
| if (shell.FlyoutIsPresented && shell.GetEffectiveFlyoutBehavior() != FlyoutBehavior.Locked) | ||
| return true; | ||
|
|
||
| return shell.CurrentItem?.CurrentItem?.Stack.Count > 1; |
| if (flyoutPage.HasBackButtonPressedSubscribers) | ||
| return true; | ||
|
|
| bool hasCustomBackHandler = false; | ||
| foreach (var handler in services.GetLifecycleEventDelegates<AndroidLifecycle.OnBackPressed>()) | ||
| { | ||
| hasAnyHandler = true; | ||
| if (handler != AppHostBuilderExtensions.DefaultWindowBackHandler) | ||
| { | ||
| hasCustomBackHandler = true; | ||
| break; | ||
| } | ||
| } | ||
|
|
||
| if (!hasAnyHandler) | ||
| return false; | ||
|
|
||
| return hasCustomBackHandler || this.GetWindow() is IBackNavigationState { CanConsumeBackNavigation: true }; |
| // Use OnBackPressedCallback (AndroidX) so the system predictive back-to-home | ||
| // animation plays when the app has nothing to handle (IsEnabled = false). | ||
| // IOnBackInvokedCallback (Android 13+ API) was avoided here because registering | ||
| // one always suppresses the back-to-home animation regardless of IsEnabled. | ||
| _mauiOnBackPressedCallback = new MauiOnBackPressedCallback(this); | ||
| OnBackPressedDispatcher.AddCallback(this, _mauiOnBackPressedCallback); | ||
| UpdatePredictiveBackRegistration(); |
kubaflo
left a comment
kubaflo
left a comment
There was a problem hiding this comment.
Could you please review the ai's suggestions?
BagavathiPerumal
force-pushed
the
fix-34594
branch
from
34e52ef to
e2fa730
Compare
…s — thread safety, JNI cleanup, false positives, unit tests.
I have updated the changes based on the review comments.
|
MauiBot
left a comment
MauiBot
left a comment
There was a problem hiding this comment.
🤖 Automated review — alternative fix proposed
The expert-reviewer evaluation compared the PR fix against #2 automatically generated candidates and selected try-fix-2 as the strongest fix.
Why: try-fix-2 preserves the PR's correct core mechanism (IOnBackInvokedCallback → OnBackPressedCallback.Enabled toggling) while fixing two critical regressions: (1) ContentPage.BackButtonPressed subscribers with Handled=true were silently bypassed at root level, breaking the standard 'confirm before exit' dialog pattern; (2) Shell.Navigating cancellation at root depth was bypassed. try-fix-2 adds HasBackButtonPressedSubscribers on Page and HasNavigatingSubscribers on Shell, plus 3 new unit tests that verify these regression cases.
Please consider applying the candidate diff below (or use it as guidance). Once you push an update, this workflow will re-trigger and re-evaluate.
Candidate diff (`try-fix-2`)
diff --git a/src/Controls/src/Core/FlyoutPage/FlyoutPage.cs b/src/Controls/src/Core/FlyoutPage/FlyoutPage.cs
index c2f8f9de38..93e75ed75f 100644
--- a/src/Controls/src/Core/FlyoutPage/FlyoutPage.cs
+++ b/src/Controls/src/Core/FlyoutPage/FlyoutPage.cs
@@ -289,7 +289,13 @@ namespace Microsoft.Maui.Controls
}
static void OnIsPresentedPropertyChanged(BindableObject sender, object oldValue, object newValue)
- => ((FlyoutPage)sender).IsPresentedChanged?.Invoke(sender, EventArgs.Empty);
+ {
+ var flyoutPage = (FlyoutPage)sender;
+ flyoutPage.IsPresentedChanged?.Invoke(sender, EventArgs.Empty);
+ // Refresh the predictive back callback when the flyout opens or closes so the
+ // back-to-home animation is suppressed only while the flyout is actually open.
+ (flyoutPage.Window as Window)?.NotifyNavigationStateChanged();
+ }
static void OnIsPresentedPropertyChanging(BindableObject sender, object oldValue, object newValue)
{
diff --git a/src/Controls/src/Core/NavigationPage/NavigationPage.cs b/src/Controls/src/Core/NavigationPage/NavigationPage.cs
index e544f4d199..3c5fee52c5 100644
--- a/src/Controls/src/Core/NavigationPage/NavigationPage.cs
+++ b/src/Controls/src/Core/NavigationPage/NavigationPage.cs
@@ -547,6 +547,9 @@ namespace Microsoft.Maui.Controls
if (newValue is Page newPage && ((NavigationPage)bindable).HasAppeared)
newPage.SendAppearing();
+
+ // Refresh Enabled on the predictive back callback when the active page changes.
+ (((NavigationPage)bindable).Window as Window)?.NotifyNavigationStateChanged();
}
internal IToolbar FindMyToolbar()
@@ -817,7 +820,9 @@ namespace Microsoft.Maui.Controls
//// the current navigation stack
//if (Owner._waitingCount == 0)
// Owner.UpdateToolbar();
-
+ // InsertPageBefore changes the stack depth without triggering SendNavigated,
+ // so refresh the predictive back callback here.
+ (Owner.Window as Window)?.NotifyNavigationStateChanged();
}).FireAndForget();
}
@@ -961,7 +966,9 @@ namespace Microsoft.Maui.Controls
//// the current navigation stack
//if (Owner._waitingCount == 0)
// Owner.UpdateToolbar();
-
+ // RemovePage changes the stack depth without triggering SendNavigated,
+ // so refresh the predictive back callback here.
+ (Owner.Window as Window)?.NotifyNavigationStateChanged();
}).FireAndForget();
}
}
diff --git a/src/Controls/src/Core/Page/Page.cs b/src/Controls/src/Core/Page/Page.cs
index 693a744288..80b1d50862 100644
--- a/src/Controls/src/Core/Page/Page.cs
+++ b/src/Controls/src/Core/Page/Page.cs
@@ -699,6 +699,9 @@ namespace Microsoft.Maui.Controls
OnAppearing();
Appearing?.Invoke(this, EventArgs.Empty);
+ // Refresh Enabled on the predictive back callback so the animation preview reflects the new state.
+ (this.Window as Window)?.NotifyNavigationStateChanged();
+
var pageContainer = this as IPageContainer<Page>;
pageContainer?.CurrentPage?.SendAppearing();
diff --git a/src/Controls/src/Core/Shell/Shell.cs b/src/Controls/src/Core/Shell/Shell.cs
index e64c44e3d0..bf976e681c 100644
--- a/src/Controls/src/Core/Shell/Shell.cs
+++ b/src/Controls/src/Core/Shell/Shell.cs
@@ -1756,6 +1756,7 @@ namespace Microsoft.Maui.Controls
CurrentPage.PropertyChanged += OnCurrentPagePropertyChanged;
CurrentItem?.Handler?.UpdateValue(Shell.TabBarIsVisibleProperty.PropertyName);
+ (this.Window as Window)?.NotifyNavigationStateChanged();
}
void OnCurrentPageLoaded(object sender, EventArgs e)
@@ -2212,7 +2213,11 @@ namespace Microsoft.Maui.Controls
{
base.OnPropertyChanged(propertyName);
if (propertyName == Shell.FlyoutIsPresentedProperty.PropertyName)
+ {
Handler?.UpdateValue(nameof(IFlyoutView.IsPresented));
+ // Refresh Enabled on the predictive back callback; flyout state affects whether back is consumed here.
+ (this.Window as Window)?.NotifyNavigationStateChanged();
+ }
}
#region Shell Flyout Content
diff --git a/src/Controls/src/Core/Window/Window.Android.cs b/src/Controls/src/Core/Window/Window.Android.cs
index 9385b83581..270425f8b3 100644
--- a/src/Controls/src/Core/Window/Window.Android.cs
+++ b/src/Controls/src/Core/Window/Window.Android.cs
@@ -7,8 +7,15 @@ using Microsoft.Maui.Handlers;
namespace Microsoft.Maui.Controls
{
- public partial class Window : IPlatformEventsListener
+ public partial class Window : IPlatformEventsListener, IBackNavigationState
{
+ bool IBackNavigationState.CanConsumeBackNavigation =>
+ Navigation.ModalStack.Count > 0 || CanConsumeBackNavigation(Page);
+
+ void RefreshPredictiveBackRegistration() =>
+ (Handler?.PlatformView as MauiAppCompatActivity)
+ ?.UpdatePredictiveBackRegistration();
+
internal Activity PlatformActivity =>
(Handler?.PlatformView as Activity) ?? throw new InvalidOperationException("Window should have an Activity set.");
diff --git a/src/Controls/src/Core/Window/Window.cs b/src/Controls/src/Core/Window/Window.cs
index 3275d5aac1..d33a03e943 100644
--- a/src/Controls/src/Core/Window/Window.cs
+++ b/src/Controls/src/Core/Window/Window.cs
@@ -467,6 +467,10 @@ namespace Microsoft.Maui.Controls
ModalPopped?.Invoke(this, args);
Application?.NotifyOfWindowModalEvent(args);
+ // Refresh the predictive back callback — programmatic PopModalAsync doesn't go through
+ // BackButtonClicked, so we update here to keep Enabled in sync with the modal stack.
+ NotifyNavigationStateChanged();
+
#if WINDOWS
this.Handler?.UpdateValue(nameof(IWindow.TitleBarDragRectangles));
this.Handler?.UpdateValue(nameof(ITitledElement.Title));
@@ -488,6 +492,10 @@ namespace Microsoft.Maui.Controls
ModalPushed?.Invoke(this, args);
Application?.NotifyOfWindowModalEvent(args);
+ // Refresh the predictive back callback — programmatic PushModalAsync doesn't go through
+ // BackButtonClicked, so we update here to keep Enabled in sync with the modal stack.
+ NotifyNavigationStateChanged();
+
#if WINDOWS
this.Handler?.UpdateValue(nameof(IWindow.TitleBarDragRectangles));
this.Handler?.UpdateValue(nameof(ITitledElement.Title));
@@ -751,12 +759,75 @@ namespace Microsoft.Maui.Controls
bool IWindow.BackButtonClicked()
{
+ bool handled;
+
if (Navigation.ModalStack.Count > 0)
{
- return Navigation.ModalStack[Navigation.ModalStack.Count - 1].SendBackButtonPressed();
+ handled = Navigation.ModalStack[Navigation.ModalStack.Count - 1].SendBackButtonPressed();
}
+ else
+ {
+ handled = this.Page?.SendBackButtonPressed() ?? false;
+ }
+
+ // Refresh Enabled on the predictive back callback after a back press changes the navigation state.
+ NotifyNavigationStateChanged();
+ return handled;
+ }
+
+ // Notifies that navigation state has changed so the Android predictive back callback can be updated.
+ // Dispatches to the main thread when called post-await on a thread-pool thread.
+ // No-op on non-Android platforms.
+ internal void NotifyNavigationStateChanged()
+ {
+#if ANDROID
+ if (MainThread.IsMainThread)
+ RefreshPredictiveBackRegistration();
+ else
+ MainThread.BeginInvokeOnMainThread(RefreshPredictiveBackRegistration);
+#endif
+ }
- return this.Page?.SendBackButtonPressed() ?? false;
+ // Returns true when there is in-app back navigation to consume, so the system should not
+ // play the back-to-home animation. Kept in the shared file so it can be unit-tested
+ // without a device (the Android-specific entry point in Window.Android.cs calls this).
+ internal static bool CanConsumeBackNavigation(Page? page)
+ {
+ if (page is null)
+ return false;
+
+ switch (page)
+ {
+ case Shell shell:
+ if (CanConsumeBackNavigation(shell.CurrentPage))
+ return true;
+
+ if (shell.FlyoutIsPresented && shell.GetEffectiveFlyoutBehavior() != FlyoutBehavior.Locked)
+ return true;
+
+ return shell.CurrentItem?.CurrentItem?.Stack.Count > 1;
+
+ case NavigationPage navigationPage:
+ if (CanConsumeBackNavigation(navigationPage.CurrentPage))
+ return true;
+
+ return navigationPage.Navigation.NavigationStack.Count > 1;
+
+ case FlyoutPage flyoutPage:
+ if (flyoutPage.IsPresented)
+ return true;
+
+ return CanConsumeBackNavigation(flyoutPage.Detail);
+
+ case MultiPage<Page> multiPage:
+ return CanConsumeBackNavigation(multiPage.CurrentPage);
+
+ default:
+ // Conservative default: return false for unknown page types.
+ // We cannot know whether a custom container's OnBackButtonPressed() returns true,
+ // so we avoid suppressing the back-to-home animation speculatively.
+ return false;
+ }
}
static double ValidatePositive(double value, [CallerMemberName] string? name = null) =>
diff --git a/src/Controls/tests/Core.UnitTests/WindowsTests.cs b/src/Controls/tests/Core.UnitTests/WindowsTests.cs
index e7f4608157..6f997135d0 100644
--- a/src/Controls/tests/Core.UnitTests/WindowsTests.cs
+++ b/src/Controls/tests/Core.UnitTests/WindowsTests.cs
@@ -947,4 +947,113 @@ namespace Microsoft.Maui.Controls.Core.UnitTests
public string TestProperty { get; set; } = "test";
}
}
+
+ /// <summary>
+ /// Unit tests for <see cref="Window.CanConsumeBackNavigation"/> — pure C# logic,
+ /// no Android platform dependencies required.
+ /// </summary>
+ public class CanConsumeBackNavigationTests : BaseTestFixture
+ {
+ [Fact]
+ public void NullPage_ReturnsFalse()
+ {
+ Assert.False(Window.CanConsumeBackNavigation(null));
+ }
+
+ [Fact]
+ public void ContentPage_ReturnsFalse()
+ {
+ // A plain ContentPage with no navigation stack → cannot consume back.
+ var page = new ContentPage();
+ Assert.False(Window.CanConsumeBackNavigation(page));
+ }
+
+ [Fact]
+ public void NavigationPage_SinglePage_ReturnsFalse()
+ {
+ // NavigationPage with only the root page — nothing to pop.
+ var nav = new TestNavigationPage(true, new ContentPage());
+ Assert.False(Window.CanConsumeBackNavigation(nav));
+ }
+
+ [Fact]
+ public async Task NavigationPage_MultiplePagesInStack_ReturnsTrue()
+ {
+ // After pushing a second page the stack has > 1 entry — back can be consumed.
+ var nav = new TestNavigationPage(true, new ContentPage());
+ _ = new TestWindow(nav);
+ await nav.PushAsync(new ContentPage());
+ Assert.True(Window.CanConsumeBackNavigation(nav));
+ }
+
+ [Fact]
+ public void FlyoutPage_IsPresented_ReturnsTrue()
+ {
+ // FlyoutPage with flyout open → back closes the flyout.
+ var flyout = new FlyoutPage
+ {
+ Flyout = new ContentPage { Title = "Flyout" },
+ Detail = new ContentPage(),
+ IsPresented = true,
+ IsPlatformEnabled = true,
+ };
+ Assert.True(Window.CanConsumeBackNavigation(flyout));
+ }
+
+ [Fact]
+ public void FlyoutPage_NotPresented_NoNavigation_ReturnsFalse()
+ {
+ // FlyoutPage with flyout closed and plain ContentPage detail → cannot consume back.
+ var flyout = new FlyoutPage
+ {
+ Flyout = new ContentPage { Title = "Flyout" },
+ Detail = new ContentPage(),
+ IsPresented = false,
+ IsPlatformEnabled = true,
+ };
+ Assert.False(Window.CanConsumeBackNavigation(flyout));
+ }
+
+ [Fact]
+ public void FlyoutPage_BackButtonPressedSubscriber_DoesNotSuppressAnimation()
+ {
+ // Regression: HasBackButtonPressedSubscribers was a false positive.
+ // A subscriber that doesn't set Handled=true must NOT suppress the animation.
+ var flyout = new FlyoutPage
+ {
+ Flyout = new ContentPage { Title = "Flyout" },
+ Detail = new ContentPage(),
+ IsPresented = false,
+ IsPlatformEnabled = true,
+ };
+ flyout.BackButtonPressed += (s, e) => { /* does not set e.Handled = true */ };
+ Assert.False(Window.CanConsumeBackNavigation(flyout));
+ }
+
+ [Fact]
+ public async Task FlyoutPage_DetailIsNavigationPageWithStack_ReturnsTrue()
+ {
+ // FlyoutPage whose detail is a NavigationPage with multiple pages → back navigates.
+ var nav = new TestNavigationPage(true, new ContentPage());
+ var flyout = new FlyoutPage
+ {
+ Flyout = new ContentPage { Title = "Flyout" },
+ Detail = nav,
+ IsPresented = false,
+ IsPlatformEnabled = true,
+ };
+ _ = new TestWindow(flyout);
+ await nav.PushAsync(new ContentPage());
+ Assert.True(Window.CanConsumeBackNavigation(flyout));
+ }
+
+ [Fact]
+ public void UnknownPageType_ReturnsFalse()
+ {
+ // Custom/unknown page types must conservatively return false to avoid blocking
+ // the back-to-home animation for containers that don't override OnBackButtonPressed.
+ var page = new ContentPage();
+ Assert.False(Window.CanConsumeBackNavigation(page));
+ }
+ }
}
\ No newline at end of file
diff --git a/src/Core/src/Hosting/LifecycleEvents/AppHostBuilderExtensions.Android.cs b/src/Core/src/Hosting/LifecycleEvents/AppHostBuilderExtensions.Android.cs
index 3820044e33..08dfed9a18 100644
--- a/src/Core/src/Hosting/LifecycleEvents/AppHostBuilderExtensions.Android.cs
+++ b/src/Core/src/Hosting/LifecycleEvents/AppHostBuilderExtensions.Android.cs
@@ -58,12 +58,17 @@ namespace Microsoft.Maui.LifecycleEvents
// If we tried to call window.Destroying() before, GetWindow() should return null
activity.GetWindow()?.Destroying();
})
- .OnBackPressed(activity =>
- {
- return activity.GetWindow()?.BackButtonClicked() ?? false;
- });
+ .OnBackPressed(DefaultWindowBackHandler);
}
+ // Exposed as a static field so MauiAppCompatActivity can detect it by reference identity
+ // rather than fragile reflection-based string matching.
+ internal static readonly AndroidLifecycle.OnBackPressed DefaultWindowBackHandler =
+ HandleWindowBackButtonPressed;
+
+ internal static bool HandleWindowBackButtonPressed(global::Android.App.Activity activity) =>
+ activity.GetWindow()?.BackButtonClicked() ?? false;
+
static void OnConfigureWindow(IAndroidLifecycleBuilder android)
{
android
@@ -92,4 +97,4 @@ namespace Microsoft.Maui.LifecycleEvents
});
}
}
-}
\ No newline at end of file
+}
diff --git a/src/Core/src/Platform/Android/IBackNavigationState.cs b/src/Core/src/Platform/Android/IBackNavigationState.cs
new file mode 100644
index 0000000000..1afb6a8488
--- /dev/null
+++ b/src/Core/src/Platform/Android/IBackNavigationState.cs
@@ -0,0 +1,7 @@
+namespace Microsoft.Maui
+{
+ interface IBackNavigationState
+ {
+ bool CanConsumeBackNavigation { get; }
+ }
+}
diff --git a/src/Core/src/Platform/Android/MauiAppCompatActivity.Lifecycle.cs b/src/Core/src/Platform/Android/MauiAppCompatActivity.Lifecycle.cs
index 7c0280da8a..57b1a2e3a2 100644
--- a/src/Core/src/Platform/Android/MauiAppCompatActivity.Lifecycle.cs
+++ b/src/Core/src/Platform/Android/MauiAppCompatActivity.Lifecycle.cs
@@ -148,7 +148,30 @@ namespace Microsoft.Maui
});
if (!preventBackPropagation)
- base.OnBackPressed();
+ {
+ // Disable the callback before dispatching base.OnBackPressed() to prevent re-entry
+ // through OnBackPressedDispatcher, which would re-invoke this same enabled callback.
+ // Track whether it was already disabled (e.g. invoked via the legacy OnBackPressed path
+ // rather than the callback path) — if so, skip the finally re-enable to avoid transiently
+ // toggling Enabled during an in-flight navigation.
+ bool callbackWasEnabled = _mauiOnBackPressedCallback?.Enabled == true;
+ if (_mauiOnBackPressedCallback is not null)
+ _mauiOnBackPressedCallback.Enabled = false;
+
+ try
+ {
+ base.OnBackPressed();
+ }
+ finally
+ {
+ // Re-evaluate whether the callback should be enabled after propagation.
+ // Using finally ensures the callback isn't permanently disabled if OnBackPressed throws.
+ // Only re-enable when the callback was active on entry; if it was already disabled
+ // (legacy-path entry), leave the state for the next UpdatePredictiveBackRegistration call.
+ if (callbackWasEnabled)
+ UpdatePredictiveBackRegistration();
+ }
+ }
}
}
}
\ No newline at end of file
diff --git a/src/Core/src/Platform/Android/MauiAppCompatActivity.cs b/src/Core/src/Platform/Android/MauiAppCompatActivity.cs
index aa9b9a210e..25a8e36f68 100644
--- a/src/Core/src/Platform/Android/MauiAppCompatActivity.cs
+++ b/src/Core/src/Platform/Android/MauiAppCompatActivity.cs
@@ -1,7 +1,6 @@
using System;
using Android.OS;
using Android.Views;
-using Android.Window;
using AndroidX.Activity;
using AndroidX.AppCompat.App;
using AndroidX.Core.Content.Resources;
@@ -35,27 +34,20 @@ namespace Microsoft.Maui
this.CreatePlatformWindow(IPlatformApplication.Current.Application, savedInstanceState);
}
- // Register predictive back callback (Android 13+/API 33+) if available.
- // This integrates MAUI lifecycle OnBackPressed events with the system back gesture animation.
- // Guidance: route custom back handling through AndroidX OnBackPressedDispatcher so
- // predictive back works correctly:
- // https://developer.android.com/guide/navigation/custom-back/predictive-back-gesture#update-custom
- if (OperatingSystem.IsAndroidVersionAtLeast(33) && _predictiveBackCallback is null)
- {
- _predictiveBackCallback = new PredictiveBackCallback(this);
- // Priority 0 = PRIORITY_DEFAULT: callback invoked only when no higher-priority callback handles the event
- OnBackInvokedDispatcher?.RegisterOnBackInvokedCallback(0, _predictiveBackCallback);
- }
+ // Use OnBackPressedCallback (AndroidX) so the system predictive back-to-home
+ // animation plays when the app has nothing to handle (IsEnabled = false).
+ // IOnBackInvokedCallback (Android 13+ API) was avoided here because registering
+ // one always suppresses the back-to-home animation regardless of IsEnabled.
+ _mauiOnBackPressedCallback = new MauiOnBackPressedCallback(this);
+ OnBackPressedDispatcher.AddCallback(this, _mauiOnBackPressedCallback);
+ UpdatePredictiveBackRegistration();
}
protected override void OnDestroy()
{
- if (OperatingSystem.IsAndroidVersionAtLeast(33) && _predictiveBackCallback is not null)
- {
- OnBackInvokedDispatcher?.UnregisterOnBackInvokedCallback(_predictiveBackCallback);
- _predictiveBackCallback.Dispose();
- _predictiveBackCallback = null;
- }
+ _mauiOnBackPressedCallback?.Remove();
+ _mauiOnBackPressedCallback?.Dispose();
+ _mauiOnBackPressedCallback = null;
base.OnDestroy();
}
@@ -75,21 +67,56 @@ namespace Microsoft.Maui
return handled || implHandled;
}
- PredictiveBackCallback? _predictiveBackCallback;
+ MauiOnBackPressedCallback? _mauiOnBackPressedCallback;
+
+ // Must be called at every navigation state change so that Enabled reflects the current back
+ // stack before the predictive back drag preview starts (Android reads Enabled before commit).
+ // Call sites: Page.SendAppearing, Shell.SendNavigated, NavigationPage, Window.
+ internal void UpdatePredictiveBackRegistration()
+ {
+ if (_mauiOnBackPressedCallback is null)
+ return;
+
+ _mauiOnBackPressedCallback.Enabled = ShouldRegisterPredictiveBackCallback();
+ }
+
+ bool ShouldRegisterPredictiveBackCallback()
+ {
+ var services = IPlatformApplication.Current?.Services;
+ if (services is null)
+ return false;
+
+ // Iterate with early exit to avoid per-navigation heap allocation from ToArray()/Any().
+ bool hasAnyHandler = false;
+ bool hasCustomBackHandler = false;
+ foreach (var handler in services.GetLifecycleEventDelegates<AndroidLifecycle.OnBackPressed>())
+ {
+ hasAnyHandler = true;
+ if (handler != AppHostBuilderExtensions.DefaultWindowBackHandler)
+ {
+ hasCustomBackHandler = true;
+ break;
+ }
+ }
+
+ if (!hasAnyHandler)
+ return false;
+
+ return hasCustomBackHandler || this.GetWindow() is IBackNavigationState { CanConsumeBackNavigation: true };
+ }
- sealed class PredictiveBackCallback : Java.Lang.Object, IOnBackInvokedCallback
+ sealed class MauiOnBackPressedCallback : OnBackPressedCallback
{
readonly MauiAppCompatActivity _activity;
- public PredictiveBackCallback(MauiAppCompatActivity activity)
+ public MauiOnBackPressedCallback(MauiAppCompatActivity activity) : base(false)
{
_activity = activity;
}
- public void OnBackInvoked()
+ public override void HandleOnBackPressed()
{
- // Reuse unified handling (will invoke lifecycle events and conditionally propagate).
_activity.HandleBackNavigation();
}
}
}
-}
\ No newline at end of file
+}
MauiBot
left a comment
MauiBot
left a comment
There was a problem hiding this comment.
Expert Review — 4 findings
See inline comments for details.
MauiBot
left a comment
MauiBot
left a comment
There was a problem hiding this comment.
🤖 Automated review — alternative fix proposed
The expert-reviewer evaluation compared the PR fix against #4 automatically generated candidates and selected try-fix-4 as the strongest fix.
Why: try-fix-4 is strictly a superset of the PR's correct architectural approach (IOnBackInvokedCallback → OnBackPressedCallback.Enabled) but also fixes the FlyoutPage split-mode regression (IsPresented=true permanently on tablets), removes the hasCustomBackHandler over-eagerness that would suppress the animation for telemetry/logging delegates, and adds 5 new unit tests (4 Shell branches + 1 split-mode regression) for a total of 14/14 passing.
Please consider applying the candidate diff below (or use it as guidance). Once you push an update, this workflow will re-trigger and re-evaluate.
Candidate diff (`try-fix-4`)
diff --git a/src/Controls/src/Core/FlyoutPage/FlyoutPage.cs b/src/Controls/src/Core/FlyoutPage/FlyoutPage.cs
index c2f8f9de38..93e75ed75f 100644
--- a/src/Controls/src/Core/FlyoutPage/FlyoutPage.cs
+++ b/src/Controls/src/Core/FlyoutPage/FlyoutPage.cs
@@ -289,7 +289,13 @@ namespace Microsoft.Maui.Controls
}
static void OnIsPresentedPropertyChanged(BindableObject sender, object oldValue, object newValue)
- => ((FlyoutPage)sender).IsPresentedChanged?.Invoke(sender, EventArgs.Empty);
+ {
+ var flyoutPage = (FlyoutPage)sender;
+ flyoutPage.IsPresentedChanged?.Invoke(sender, EventArgs.Empty);
+ (flyoutPage.Window as Window)?.NotifyNavigationStateChanged();
+ }
diff --git a/src/Controls/src/Core/NavigationPage/NavigationPage.cs b/src/Controls/src/Core/NavigationPage/NavigationPage.cs
--- a/src/Controls/src/Core/NavigationPage/NavigationPage.cs
+++ b/src/Controls/src/Core/NavigationPage/NavigationPage.cs
@@ -547,6 +547,9 @@
+ (((NavigationPage)bindable).Window as Window)?.NotifyNavigationStateChanged();
@@ -817,6 +820,8 @@
+ (Owner.Window as Window)?.NotifyNavigationStateChanged();
@@ -961,6 +966,8 @@
+ (Owner.Window as Window)?.NotifyNavigationStateChanged();
diff --git a/src/Controls/src/Core/Page/Page.cs b/src/Controls/src/Core/Page/Page.cs
+ (this.Window as Window)?.NotifyNavigationStateChanged();
diff --git a/src/Controls/src/Core/Shell/Shell.cs b/src/Controls/src/Core/Shell/Shell.cs
+ (this.Window as Window)?.NotifyNavigationStateChanged();
+ (this.Window as Window)?.NotifyNavigationStateChanged();
diff --git a/src/Controls/src/Core/Window/Window.Android.cs b/src/Controls/src/Core/Window/Window.Android.cs
- public partial class Window : IPlatformEventsListener
+ public partial class Window : IPlatformEventsListener, IBackNavigationState
+ {
+ bool IBackNavigationState.CanConsumeBackNavigation =>
+ Navigation.ModalStack.Count > 0 || CanConsumeBackNavigation(Page);
+ void RefreshPredictiveBackRegistration() =>
+ (Handler?.PlatformView as MauiAppCompatActivity)?.UpdatePredictiveBackRegistration();
diff --git a/src/Controls/src/Core/Window/Window.cs b/src/Controls/src/Core/Window/Window.cs
+ NotifyNavigationStateChanged(); // OnModalPopped
+ NotifyNavigationStateChanged(); // OnModalPushed
+ internal void NotifyNavigationStateChanged() {
+#if ANDROID
+ if (MainThread.IsMainThread) RefreshPredictiveBackRegistration();
+ else MainThread.BeginInvokeOnMainThread(RefreshPredictiveBackRegistration);
+#endif
+ }
+ internal static bool CanConsumeBackNavigation(Page? page) {
+ if (page is null) return false;
+ switch (page) {
+ case Shell shell:
+ if (CanConsumeBackNavigation(shell.CurrentPage)) return true;
+ if (shell.FlyoutIsPresented && shell.GetEffectiveFlyoutBehavior() != FlyoutBehavior.Locked) return true;
+ return shell.CurrentItem?.CurrentItem?.Stack.Count > 1;
+ case NavigationPage navigationPage:
+ if (CanConsumeBackNavigation(navigationPage.CurrentPage)) return true;
+ return navigationPage.Navigation.NavigationStack.Count > 1;
+ case FlyoutPage flyoutPage:
+ if (flyoutPage.IsPresented && ((IFlyoutPageController)flyoutPage).CanChangeIsPresented) return true;
+ return CanConsumeBackNavigation(flyoutPage.Detail);
+ case MultiPage<Page> multiPage:
+ return CanConsumeBackNavigation(multiPage.CurrentPage);
+ default: return false;
+ }
+ }
diff --git a/src/Controls/tests/Core.UnitTests/WindowsTests.cs b/src/Controls/tests/Core.UnitTests/WindowsTests.cs
// +5 new tests: FlyoutPage_SplitMode_ReturnsFalse, Shell_NoNavigation_ReturnsFalse,
// Shell_FlyoutIsPresented_ReturnsTrue, Shell_FlyoutIsPresented_Locked_ReturnsFalse,
// Shell_StackGreaterThanOne_ReturnsTrue
diff --git a/src/Core/src/Hosting/LifecycleEvents/AppHostBuilderExtensions.Android.cs b/src/Core/src/Hosting/LifecycleEvents/AppHostBuilderExtensions.Android.cs
+ internal static readonly AndroidLifecycle.OnBackPressed DefaultWindowBackHandler = HandleWindowBackButtonPressed;
+ internal static bool HandleWindowBackButtonPressed(Activity activity) => activity.GetWindow()?.BackButtonClicked() ?? false;
diff --git a/src/Core/src/Platform/Android/MauiAppCompatActivity.Lifecycle.cs b/src/Core/src/Platform/Android/MauiAppCompatActivity.Lifecycle.cs
// re-entry guard: disable callback before base.OnBackPressed(), restore in finally
diff --git a/src/Core/src/Platform/Android/MauiAppCompatActivity.cs b/src/Core/src/Platform/Android/MauiAppCompatActivity.cs
// hasCustomBackHandler REMOVED from ShouldRegisterPredictiveBackCallback
// now: return this.GetWindow() is IBackNavigationState { CanConsumeBackNavigation: true }
Note
Are you waiting for the changes in this PR to be merged?
It would be very helpful if you could test the resulting artifacts from this PR and let us know in a comment if this change resolves your issue. Thank you!
Issue details
On Android 16, the predictive back-to-home animation does not behave correctly in .NET MAUI applications because back handling is registered unconditionally through IOnBackInvokedCallback.
When the app is at the root navigation level and the system expects the default back-to-home gesture animation, MAUI still consumes the back callback even when no in-app navigation is available. As a result, the predictive back gesture animation is interrupted or does not transition smoothly to the home screen.
This issue occurs because the callback remains active regardless of whether the application can actually navigate back.
Root Cause
The issue occurs becasuse of MauiAppCompatActivity registering a predictive-back callback unconditionally on Android 13+ at startup and keeping it registered for the activity lifetime, which suppresses Android’s back-to-home predictive animation even when the app cannot consume back navigation (for example, on the root page).
Description of Change
The fix involves replacing the always-registered predictive-back callback in MauiAppCompatActivity with AndroidX OnBackPressedCallback and dynamically toggling its Enabled state based on whether MAUI can actually consume back navigation. A shared UpdatePredictiveBackRegistration() flow is triggered during navigation changes so the callback state stays in sync across Shell, NavigationPage, FlyoutPage, modal navigation, and window-level back state. This means MAUI intercepts back only when needed and lets the system handle back at root, restoring Android’s predictive back-to-home animation.
Why Tests were not added:
Regarding the test case: This issue is specific to Android 16 (API 36), while the current automated device test coverage does not reliably reproduce this exact platform behavior in CI. Because of that limitation, a deterministic automated repro test could not be added at this time. Validation was performed through manual Android 16 scenario testing focused on root-page predictive back and navigated-page back handling.
Tested the behavior in the following platforms.
Issues Fixed
Fixes #34594
Output
34594-BeforeFix-BackToAnimation.mov
34594-AfterFix-BackToAnimation.mov