[Android] Fix AppBar flicker on CheckBox/Switch toggle with Material 3

[Dhivya-SF4094]

Issue detail:

When Material 3 is enabled on Android, toggling a CheckBox or Switch that is inside a ScrollView causes the AppBarLayout surface color to flicker.

Root Cause

AppBarLayout.liftOnScroll auto-detects FragmentContainerView as the scrolling target. Its canScrollVertically() always returns 0, so every layout pass triggered by CheckBox/Switch animations causes shouldLift() to flip — producing a visible flicker between lifted and non-lifted surface colors.

Description of Change

Explicitly set AppBarLayout.LiftOnScrollTargetViewId to the actual scrollable view (MauiScrollView or MauiRecyclerView), bypassing the broken auto-detection. The fix is gated behind RuntimeFeature.IsMaterial3Enabled - zero behavioral change when M3 is disabled.

New file:

AppbarLayoutExtensions.cs — Shared helper that manages the lift-on-scroll target for both MauiScrollView and MauiRecyclerView. Handles:

• Claiming/releasing the lift target on attach/detach/visibility changes
• Ancestor MauiScrollView detection (outermost ScrollView takes priority in nested scenarios)
• Walking the view tree to find any sibling AppBarLayout (supports both NavigationPage and Shell)
• CarouselView support via ViewTreeObserver.OnScrollChangedListener to detect page swipes and transfer the lift target to the currently visible page
• Syncing SetLifted() with the view's actual scroll position after carousel swipes or visibility toggles

Modified files:

MauiScrollView.cs — Delegates lift-target logic to AppbarLayoutExtensions in OnAttachedToWindow, OnDetachedFromWindow, and OnVisibilityChanged (all M3-gated)
MauiRecyclerView.cs — Same pattern for CollectionView/CarouselView pages without a wrapping ScrollView.

Fixes

Fixes #35180

Validated the behaviour in the following platforms

• Android
• Windows
• iOS
• Mac

Screenshots

Before	After
35180_BeforeFix.mov	35180_AfterFix.mov

[github-actions]

🚀 Dogfood this PR with:

⚠️ WARNING: Do not do this without first carefully reviewing the code of this PR to satisfy yourself it is safe.

curl -fsSL https://raw.githubusercontent.com/dotnet/maui/main/eng/scripts/get-maui-pr.sh | bash -s -- 35181

Or

• Run remotely in PowerShell:

iex "& { $(irm https://raw.githubusercontent.com/dotnet/maui/main/eng/scripts/get-maui-pr.ps1) } 35181"

[MauiBot]

🤖 Automated review — alternative fix proposed

The expert-reviewer evaluation compared the PR fix against #1 automatically generated candidates and selected try-fix-1 as the strongest fix.

Why: try-fix-1 wins by fixing the two most critical correctness bugs in the original PR: (1) a ViewTreeObserver memory leak caused by removing the scroll listener from the wrong (post-detach) observer instance, and (2) a SetLifted(false) call in ClearAppBarLiftTarget that would itself cause a visible un-lift flash during navigation transitions — the very flicker symptom being fixed. All other PR functionality (M3 gate, carousel support, nested scroll view priority) is preserved unchanged.

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-1`)

diff --git a/src/Controls/src/Core/Handlers/Items/Android/MauiRecyclerView.cs b/src/Controls/src/Core/Handlers/Items/Android/MauiRecyclerView.cs
index 2cacd2f34d..91b8077571 100644
--- a/src/Controls/src/Core/Handlers/Items/Android/MauiRecyclerView.cs
+++ b/src/Controls/src/Core/Handlers/Items/Android/MauiRecyclerView.cs
@@ -8,8 +8,10 @@ using Android.Views;
 using AndroidX.RecyclerView.Widget;
 using Microsoft.Maui.Controls.Internals;
 using Microsoft.Maui.Controls.Platform;
+using Microsoft.Maui.Platform;
 using Microsoft.Maui.Graphics;
 using ARect = Android.Graphics.Rect;
+using AView = Android.Views.View;
 using AViewCompat = AndroidX.Core.View.ViewCompat;
 
 namespace Microsoft.Maui.Controls.Handlers.Items
@@ -45,6 +49,7 @@ namespace Microsoft.Maui.Controls.Handlers.Items
 		SimpleItemTouchHelperCallback _itemTouchHelperCallback;
 		WeakNotifyPropertyChangedProxy _layoutPropertyChangedProxy;
 		PropertyChangedEventHandler _layoutPropertyChanged;
+		AppBarLiftTargetHelper? _appBarLiftTargetHelper;
 
 		~MauiRecyclerView() => _layoutPropertyChangedProxy?.Unsubscribe();
 
@@ -57,6 +62,47 @@ namespace Microsoft.Maui.Controls.Handlers.Items
 			_itemsUpdateScrollObserver = new DataChangeObserver(AdjustScrollForItemUpdate);
 		}
 
+		protected override void OnAttachedToWindow()
+		{
+			base.OnAttachedToWindow();
+
+			if (RuntimeFeature.IsMaterial3Enabled)
+			{
+				_appBarLiftTargetHelper ??= new AppBarLiftTargetHelper(this);
+				Post(_appBarLiftTargetHelper.TrySetIfOnScreen);
+			}
+		}
+
+		protected override void OnDetachedFromWindow()
+		{
+			base.OnDetachedFromWindow();
+
+			if (RuntimeFeature.IsMaterial3Enabled)
+			{
+				_appBarLiftTargetHelper?.Clear();
+			}
+		}
+
+		protected override void OnVisibilityChanged(AView changedView, ViewStates visibility)
+		{
+			base.OnVisibilityChanged(changedView, visibility);
+
+			if (!RuntimeFeature.IsMaterial3Enabled)
+			{
+				return;
+			}
+
+			if (visibility == ViewStates.Visible)
+			{
+				_appBarLiftTargetHelper ??= new AppBarLiftTargetHelper(this);
+				Post(_appBarLiftTargetHelper.TrySetIfOnScreen);
+			}
+			else
+			{
+				_appBarLiftTargetHelper?.Clear();
+			}
+		}
+
 		public virtual void TearDownOldElement(TItemsView oldElement)
diff --git a/src/Controls/src/Core/PublicAPI/net-android/PublicAPI.Unshipped.txt b/src/Controls/src/Core/PublicAPI/net-android/PublicAPI.Unshipped.txt
--- a/src/Controls/src/Core/PublicAPI/net-android/PublicAPI.Unshipped.txt
+++ b/src/Controls/src/Core/PublicAPI/net-android/PublicAPI.Unshipped.txt
+override Microsoft.Maui.Controls.Handlers.Items.MauiRecyclerView<TItemsView, TAdapter, TItemsViewSource>.OnAttachedToWindow() -> void
+override Microsoft.Maui.Controls.Handlers.Items.MauiRecyclerView<TItemsView, TAdapter, TItemsViewSource>.OnDetachedFromWindow() -> void
+override Microsoft.Maui.Controls.Handlers.Items.MauiRecyclerView<TItemsView, TAdapter, TItemsViewSource>.OnVisibilityChanged(Android.Views.View changedView, Android.Views.ViewStates visibility) -> void
diff --git a/src/Core/src/Platform/Android/AppBarLiftTargetHelper.cs b/src/Core/src/Platform/Android/AppBarLiftTargetHelper.cs
new file mode 100644
index 0000000000..0af2cc2130
--- /dev/null
+++ b/src/Core/src/Platform/Android/AppBarLiftTargetHelper.cs
@@ -0,0 +1,249 @@
+using Android.Graphics;
+using Android.Views;
+using Google.Android.Material.AppBar;
+
+namespace Microsoft.Maui.Platform
+{
+    // Manages pinning the lift-on-scroll target of a MAUI navigation AppBarLayout
+    // to a specific scrollable view (e.g. MauiScrollView or RecyclerView).
+    // Shared between MauiScrollView and MauiRecyclerView to avoid duplicating
+    // the same ancestor-walk / attach / detach logic.
+    //
+    // When the scrollable view is inside a CarouselView/ViewPager2, adjacent
+    // off-screen pages are pre-cached and their views stay attached without
+    // receiving visibility callbacks during page swipes.  A ViewTreeObserver
+    // scroll-changed listener detects these transitions and transfers the
+    // lift target to whichever page's scrollable view is currently on-screen.
+    internal class AppBarLiftTargetHelper
+    {
+        readonly View _view;
+        readonly Rect _visibleRect = new Rect();
+        AppBarLayout? _liftOnScrollAppBar;
+        ScrollChangedListener? _scrollChangedListener;
+        // Track the exact ViewTreeObserver instance the listener was registered on.
+        // After a view detach/re-attach cycle, _view.ViewTreeObserver returns a brand-new
+        // instance, so calling RemoveOnScrollChangedListener on the current observer would
+        // silently fail and leak the old listener.  We must remove from the same instance
+        // we added to.
+        ViewTreeObserver? _registeredObserver;
+
+        internal AppBarLiftTargetHelper(View view)
+        {
+            _view = view;
+        }
+
+        internal void TrySetIfOnScreen()
+        {
+            // Guard: the view may have detached or been hidden between Post() and execution.
+            if (!_view.IsAttachedToWindow || _view.Visibility != ViewStates.Visible)
+            {
+                return;
+            }
+
+            // When inside a CarouselView, ViewPager2 pre-loads adjacent off-screen pages,
+            // so their ScrollViews also attach. Only the on-screen page's ScrollView should
+            // claim the lift target. GetGlobalVisibleRect returns false if the view is
+            // entirely outside the clipped viewport (e.g. a pre-loaded carousel page).
+            if (!_view.GetGlobalVisibleRect(_visibleRect))
+            {
+                // Off-screen — start listening for parent scroll changes so we
+                // can claim the lift target when the page scrolls into view.
+                StartListeningForParentScrollChanges();
+                return;
+            }
+
+            TrySetAppBarLiftTarget();
+
+            // Listen for parent scroll changes to detect when we go off-screen
+            // (e.g. user swipes to another carousel page).
+            StartListeningForParentScrollChanges();
+        }
+
+        internal void Clear()
+        {
+            StopListeningForParentScrollChanges();
+            ClearAppBarLiftTarget();
+        }
+
+        void ClearAppBarLiftTarget()
+        {
+            if (_liftOnScrollAppBar is null)
+            {
+                return;
+            }
+
+            // Only clear if we're still the current target; avoid stomping on another scroll view
+            // that may have been set as the target after us.
+            if (_liftOnScrollAppBar.LiftOnScrollTargetViewId == _view.Id)
+            {
+                _liftOnScrollAppBar.LiftOnScrollTargetViewId = View.NoId;
+                // Do NOT call SetLifted(false) here.  Doing so would cause a brief un-lift
+                // flash when the view is merely detaching or going invisible (e.g. navigation
+                // transition, CheckBox animation).  The AppBarLayout will re-evaluate its
+                // lifted state naturally once the next valid scroll view registers itself.
+            }
+
+            _liftOnScrollAppBar = null;
+        }
+
+        void TrySetAppBarLiftTarget()
+        {
+            // If a MauiScrollView ancestor exists, it should own the lift target instead.
+            // The outermost scroll view in the page is the one whose scroll offset should
+            // drive the AppBar's lifted state.
+            if (HasAncestorMauiScrollView())
+            {
+                return;
+            }
+
+            var appBar = FindAppBarLayout();
+            if (appBar is null)
+            {
+                return;
+            }
+
+            if (_view.Id == View.NoId)
+            {
+                _view.Id = View.GenerateViewId();
+            }
+
+            _liftOnScrollAppBar = appBar;
+            appBar.LiftOnScrollTargetViewId = _view.Id;
+
+            // Force the AppBar to reflect this view's current scroll position.
+            // After a carousel swipe or visibility toggle the AppBar may be stuck
+            // in the wrong state; CanScrollVertically(-1) is true when the view
+            // has been scrolled down from the top.
+            appBar.SetLifted(_view.CanScrollVertically(-1));
+        }
+
+        void OnParentScrollChanged()
+        {
+            if (!_view.IsAttachedToWindow || _view.Visibility != ViewStates.Visible)
+            {
+                return;
+            }
+
+            bool isOnScreen = _view.GetGlobalVisibleRect(_visibleRect);
+            bool ownsTarget = _liftOnScrollAppBar is not null;
+
+            if (isOnScreen && !ownsTarget)
+            {
+                TrySetAppBarLiftTarget();
+            }
+            else if (!isOnScreen && ownsTarget)
+            {
+                // Release without stopping the listener — we still need to
+                // detect when the carousel swipes back to this page.
+                ClearAppBarLiftTarget();
+            }
+        }
+
+        void StartListeningForParentScrollChanges()
+        {
+            if (_scrollChangedListener is not null)
+            {
+                return;
+            }
+
+            var observer = _view.ViewTreeObserver;
+            if (observer is null || !observer.IsAlive)
+            {
+                return;
+            }
+
+            _scrollChangedListener = new ScrollChangedListener(this);
+            observer.AddOnScrollChangedListener(_scrollChangedListener);
+            // Cache the observer we registered on.  After a detach/re-attach the view
+            // returns a different ViewTreeObserver instance; we must deregister from this
+            // specific instance or the listener will leak.
+            _registeredObserver = observer;
+        }
+
+        void StopListeningForParentScrollChanges()
+        {
+            if (_scrollChangedListener is null)
+            {
+                return;
+            }
+
+            // Use the cached observer we originally registered on, not _view.ViewTreeObserver,
+            // which may point to a different (post-detach) instance.
+            var observer = _registeredObserver;
+            if (observer is not null && observer.IsAlive)
+            {
+                observer.RemoveOnScrollChangedListener(_scrollChangedListener);
+            }
+
+            _scrollChangedListener.Dispose();
+            _scrollChangedListener = null;
+            _registeredObserver = null;
+        }
+
+        bool HasAncestorMauiScrollView()
+        {
+            var parent = _view.Parent;
+            while (parent is View parentView)
+            {
+                if (parentView is MauiScrollView)
+                {
+                    return true;
+                }
+
+                // Stop once we reach the AppBarLayout level — anything above that isn't "inside the page".
+                if (parentView is AppBarLayout ||
+                    (parentView.Id != View.NoId && parentView.Id == Resource.Id.navigationlayout_appbar))
+                {
+                    return false;
+                }
+
+                parent = parentView.Parent;
+            }
+
+            return false;
+        }
+
+        AppBarLayout? FindAppBarLayout()
+        {
+            // Walk up the ancestry looking for an AppBarLayout that is a sibling
+            // of the content view hosting this scroll view.
+            // NavigationPage uses Resource.Id.navigationlayout_appbar, but Shell creates
+            // its AppBarLayout programmatically without an ID, so we match any AppBarLayout.
+            var parent = _view.Parent;
+            while (parent is View parentView)
+            {
+                if (parentView is ViewGroup group)
+                {
+                    for (int i = 0; i < group.ChildCount; i++)
+                    {
+                        if (group.GetChildAt(i) is AppBarLayout appBar)
+                        {
+                            return appBar;
+                        }
+                    }
+                }
+
+                parent = parentView.Parent;
+            }
+
+            return null;
+        }
+
+        // Lightweight Java-side listener that forwards ViewTreeObserver scroll
+        // changes back to the managed helper for carousel page-change detection.
+        sealed class ScrollChangedListener : Java.Lang.Object, ViewTreeObserver.IOnScrollChangedListener
+        {
+            readonly AppBarLiftTargetHelper _helper;
+
+            public ScrollChangedListener(AppBarLiftTargetHelper helper)
+            {
+                _helper = helper;
+            }
+
+            public void OnScrollChanged()
+            {
+                _helper.OnParentScrollChanged();
+            }
+        }
+    }
+}
diff --git a/src/Core/src/Platform/Android/MauiScrollView.cs b/src/Core/src/Platform/Android/MauiScrollView.cs
index bc92251800..44b9bb13cb 100644
--- a/src/Core/src/Platform/Android/MauiScrollView.cs
+++ b/src/Core/src/Platform/Android/MauiScrollView.cs
@@ -25,6 +25,7 @@ namespace Microsoft.Maui.Platform
 		ScrollBarVisibility _horizontalScrollVisibility;
 		bool _didSafeAreaEdgeConfigurationChange = true;
 		bool _isInsetListenerSet;
+		AppBarLiftTargetHelper? _appBarLiftTargetHelper;
 
 		internal float LastX { get; set; }
 		internal float LastY { get; set; }
@@ -62,6 +63,21 @@ namespace Microsoft.Maui.Platform
 		{
 			base.OnAttachedToWindow();
 			_isInsetListenerSet = MauiWindowInsetListenerExtensions.TrySetMauiWindowInsetListener(this, _context);
+
+			if (RuntimeFeature.IsMaterial3Enabled)
+			{
+				// Pin the MAUI navigation AppBarLayout's lift-on-scroll target to this NestedScrollView.
+				// Otherwise AppBarLayout auto-detects the outer FragmentContainerView as the scrolling target,
+				// and its ViewTreeObserver-driven shouldLift() check evaluates canScrollVertically() on the
+				// container (which is always 0), causing the lifted state to flip on every layout pass
+				// triggered by sibling views (e.g. CheckBox/Switch state animations) and producing a
+				// visible scrolledContainerColor flicker.
+				// Use Post() to defer until layout is complete — when this ScrollView is inside
+				// a CarouselView, adjacent off-screen pages also attach and we need to verify
+				// the view is actually on-screen before claiming the lift target.
+				_appBarLiftTargetHelper ??= new AppBarLiftTargetHelper(this);
+				Post(_appBarLiftTargetHelper.TrySetIfOnScreen);
+			}
 		}
 
 		protected override void OnDetachedFromWindow()
@@ -72,6 +88,30 @@ namespace Microsoft.Maui.Platform
 
 			_isInsetListenerSet = false;
 			_didSafeAreaEdgeConfigurationChange = true;
+			if (RuntimeFeature.IsMaterial3Enabled)
+			{
+				_appBarLiftTargetHelper?.Clear();
+			}
+		}
+
+		protected override void OnVisibilityChanged(View changedView, ViewStates visibility)
+		{
+			base.OnVisibilityChanged(changedView, visibility);
+
+			if (!RuntimeFeature.IsMaterial3Enabled)
+			{
+				return;
+			}
+
+			if (visibility == ViewStates.Visible)
+			{
+				_appBarLiftTargetHelper ??= new AppBarLiftTargetHelper(this);
+				Post(_appBarLiftTargetHelper.TrySetIfOnScreen);
+			}
+			else
+			{
+				_appBarLiftTargetHelper?.Clear();
+			}
 		}
 
 		#region IHandleWindowInsets Implementation
diff --git a/src/Core/src/PublicAPI/net-android/PublicAPI.Unshipped.txt b/src/Core/src/PublicAPI/net-android/PublicAPI.Unshipped.txt
--- a/src/Core/src/PublicAPI/net-android/PublicAPI.Unshipped.txt
+++ b/src/Core/src/PublicAPI/net-android/PublicAPI.Unshipped.txt
+override Microsoft.Maui.Platform.MauiScrollView.OnVisibilityChanged(Android.Views.View! changedView, Android.Views.ViewStates visibility) -> void

[kubaflo]

Could you please try ai's suggestions?

[MauiBot]

Expert Review — 6 findings

See inline comments for details.

[kubaflo]

/review -b feature/regression-check

[MauiBot]

🤖 Automated review — alternative fix proposed

The expert-reviewer evaluation compared the PR fix against #1 automatically generated candidates and selected try-fix-1 as the strongest fix.

Why: try-fix-1 fixes the bug at its root by making the navigation content host (MauiNavigationContentContainer : FragmentContainerView) return a correct CanScrollVertically answer, so AppBarLayout.findFirstScrollingChild() becomes deterministic. This removes ~270 lines of per-scrollable plumbing, the ViewTreeObserver listener, the view-id mutation, and the M3 feature gating that the PR currently carries — while preserving Material 3 fidelity and dissolving every concern raised on the PR review thread.

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-1`)

diff --git a/src/Core/src/Platform/Android/MauiNavigationContentContainer.cs b/src/Core/src/Platform/Android/MauiNavigationContentContainer.cs
new file mode 100644
index 0000000000..9f7913d422
--- /dev/null
+++ b/src/Core/src/Platform/Android/MauiNavigationContentContainer.cs
@@ -0,0 +1,62 @@
+using System;
+using Android.Content;
+using Android.Runtime;
+using Android.Util;
+using Android.Views;
+using AndroidX.Fragment.App;
+
+namespace Microsoft.Maui.Platform
+{
+	// Registered with an explicit Java FQN so LayoutInflater can resolve the
+	// axml tag in Debug, Release, AOT and trimmed builds.
+	[Register("microsoft/maui/platform/MauiNavigationContentContainer")]
+	public class MauiNavigationContentContainer : FragmentContainerView
+	{
+		public MauiNavigationContentContainer(Context context, IAttributeSet attrs)
+			: base(context, attrs)
+		{
+		}
+
+		protected MauiNavigationContentContainer(IntPtr javaReference, JniHandleOwnership transfer)
+			: base(javaReference, transfer)
+		{
+		}
+
+		// AppBarLayout.liftOnScroll auto-detection calls canScrollVertically(-1)
+		// on the view annotated with appbar_scrolling_view_behavior to decide
+		// whether to enter the lifted state. The default FragmentContainerView
+		// always returns 0 because it isn't a scrolling container itself; the
+		// real scrolling happens in a descendant (MauiScrollView / MauiRecyclerView /
+		// WebView / third-party). Delegate to descendants so the answer is correct
+		// and stable across layout passes — eliminates the lift/unlift flicker
+		// observed when sibling animations (CheckBox / Switch state changes)
+		// trigger layout passes (issue #35180).
+		public override bool CanScrollVertically(int direction)
+			=> base.CanScrollVertically(direction)
+				|| DescendantCanScrollVertically(this, direction);
+
+		static bool DescendantCanScrollVertically(ViewGroup group, int direction)
+		{
+			for (int i = 0, n = group.ChildCount; i < n; i++)
+			{
+				var child = group.GetChildAt(i);
+				if (child is null || child.Visibility != ViewStates.Visible)
+				{
+					continue;
+				}
+
+				if (child.CanScrollVertically(direction))
+				{
+					return true;
+				}
+
+				if (child is ViewGroup vg && DescendantCanScrollVertically(vg, direction))
+				{
+					return true;
+				}
+			}
+
+			return false;
+		}
+	}
+}
diff --git a/src/Core/src/Platform/Android/Resources/Layout/navigationlayout.axml b/src/Core/src/Platform/Android/Resources/Layout/navigationlayout.axml
index 2bac91007b..751125cddb 100644
--- a/src/Core/src/Platform/Android/Resources/Layout/navigationlayout.axml
+++ b/src/Core/src/Platform/Android/Resources/Layout/navigationlayout.axml
@@ -22,7 +22,7 @@
 
     </com.google.android.material.appbar.AppBarLayout>
 
-    <androidx.fragment.app.FragmentContainerView
+    <microsoft.maui.platform.MauiNavigationContentContainer
             android:id="@+id/navigationlayout_content"
             android:layout_width="match_parent"
             android:layout_height="match_parent"
diff --git a/src/Core/src/PublicAPI/net-android/PublicAPI.Unshipped.txt b/src/Core/src/PublicAPI/net-android/PublicAPI.Unshipped.txt
index 59fed41b6d..6128c56668 100644
--- a/src/Core/src/PublicAPI/net-android/PublicAPI.Unshipped.txt
+++ b/src/Core/src/PublicAPI/net-android/PublicAPI.Unshipped.txt
@@ -9,6 +9,9 @@ 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
+Microsoft.Maui.Platform.MauiNavigationContentContainer
+Microsoft.Maui.Platform.MauiNavigationContentContainer.MauiNavigationContentContainer(Android.Content.Context! context, Android.Util.IAttributeSet! attrs) -> void
+override Microsoft.Maui.Platform.MauiNavigationContentContainer.CanScrollVertically(int direction) -> bool
 override Microsoft.Maui.Platform.ContentViewGroup.HasOverlappingRendering.get -> bool
 override Microsoft.Maui.Platform.LayoutViewGroup.HasOverlappingRendering.get -> bool
 override Microsoft.Maui.Platform.WrapperView.HasOverlappingRendering.get -> bool

[kubaflo]

/review -b feature/regression-check

[MauiBot]

Expert Review — 7 findings

See inline comments for details.

[MauiBot]

🤖 AI Summary

👋 @Dhivya-SF4094 — new AI review results are available. Please review the latest session below.

📊 Review Session — 5585cda · Updated fix in MauiScrollView and MauiRecyclerView · 2026-05-21 20:38 UTC

🚦 Gate — Test Before & After Fix

Gate Result: ⚠️ SKIPPED

No tests were detected in this PR.

Recommendation: Add tests to verify the fix using the write-tests-agent.

---

🧪 UI Tests — CollectionView,ViewBaseTests

Detected UI test categories: CollectionView,ViewBaseTests

🧪 UI Test Execution Results

❌ FAILED — 0 passed, 2 failed, 0 skipped (platform: android)

Category	Result	Tests	Duration	Notes
CollectionView	❌ FAILED	0/1 — build/deploy failed before per-test results	474.6s	exit code 1
ViewBaseTests	❌ FAILED	0/1 — build/deploy failed before per-test results	366.6s	exit code 1

Failed test details

❌ CollectionView — build/deploy failed (no per-test results)

Last 30 lines of build/test stdout:

Build FAILED.

/home/vsts/work/1/s/src/Controls/src/Core/Handlers/Items/Android/MauiRecyclerView.cs(86,27): error RS0036: Symbol 'override Microsoft.Maui.Controls.Handlers.Items.MauiRecyclerView<TItemsView, TAdapter, TItemsViewSource>.OnVisibilityChanged(Android.Views.View changedView, Android.Views.ViewStates visibility) -> void' is missing nullability annotations in the declared API (https://github.com/dotnet/roslyn/blob/main/src/RoslynAnalyzers/PublicApiAnalyzers/PublicApiAnalyzers.Help.md) [/home/vsts/work/1/s/src/Controls/src/Core/Controls.Core.csproj::TargetFramework=net10.0-android36.0]
    0 Warning(s)
    1 Error(s)

Time Elapsed 00:01:03.40
* daemon not running; starting now at tcp:5037
* daemon started successfully
  Determining projects to restore...
  All projects are up-to-date for restore.
  ##vso[build.updatebuildnumber]10.0.80-ci+azdo.14162401
  Graphics -> /home/vsts/work/1/s/artifacts/bin/Graphics/Debug/net10.0-android36.0/Microsoft.Maui.Graphics.dll
  ##vso[build.updatebuildnumber]10.0.80-ci+azdo.14162401
  Essentials -> /home/vsts/work/1/s/artifacts/bin/Essentials/Debug/net10.0-android36.0/Microsoft.Maui.Essentials.dll
  ##vso[build.updatebuildnumber]10.0.80-ci+azdo.14162401
  Core -> /home/vsts/work/1/s/artifacts/bin/Core/Debug/net10.0-android36.0/Microsoft.Maui.dll
  Controls.BindingSourceGen -> /home/vsts/work/1/s/artifacts/bin/Controls.BindingSourceGen/Debug/netstandard2.0/Microsoft.Maui.Controls.BindingSourceGen.dll
  ##vso[build.updatebuildnumber]10.0.80-ci+azdo.14162401
  ##vso[build.updatebuildnumber]10.0.80-ci+azdo.14162401
/home/vsts/work/1/s/src/Controls/src/Core/Handlers/Items/Android/MauiRecyclerView.cs(86,27): error RS0036: Symbol 'override Microsoft.Maui.Controls.Handlers.Items.MauiRecyclerView<TItemsView, TAdapter, TItemsViewSource>.OnVisibilityChanged(Android.Views.View changedView, Android.Views.ViewStates visibility) -> void' is missing nullability annotations in the declared API (https://github.com/dotnet/roslyn/blob/main/src/RoslynAnalyzers/PublicApiAnalyzers/PublicApiAnalyzers.Help.md) [/home/vsts/work/1/s/src/Controls/src/Core/Controls.Core.csproj::TargetFramework=net10.0-android36.0]
  Maps -> /home/vsts/work/1/s/artifacts/bin/Maps/Debug/net10.0-android36.0/Microsoft.Maui.Maps.dll

Build FAILED.

/home/vsts/work/1/s/src/Controls/src/Core/Handlers/Items/Android/MauiRecyclerView.cs(86,27): error RS0036: Symbol 'override Microsoft.Maui.Controls.Handlers.Items.MauiRecyclerView<TItemsView, TAdapter, TItemsViewSource>.OnVisibilityChanged(Android.Views.View changedView, Android.Views.ViewStates visibility) -> void' is missing nullability annotations in the declared API (https://github.com/dotnet/roslyn/blob/main/src/RoslynAnalyzers/PublicApiAnalyzers/PublicApiAnalyzers.Help.md) [/home/vsts/work/1/s/src/Controls/src/Core/Controls.Core.csproj::TargetFramework=net10.0-android36.0]
    0 Warning(s)
    1 Error(s)

Time Elapsed 00:01:01.65

❌ ViewBaseTests — build/deploy failed (no per-test results)

Last 30 lines of build/test stdout:

Build FAILED.

/home/vsts/work/1/s/src/Controls/src/Core/Handlers/Items/Android/MauiRecyclerView.cs(86,27): error RS0036: Symbol 'override Microsoft.Maui.Controls.Handlers.Items.MauiRecyclerView<TItemsView, TAdapter, TItemsViewSource>.OnVisibilityChanged(Android.Views.View changedView, Android.Views.ViewStates visibility) -> void' is missing nullability annotations in the declared API (https://github.com/dotnet/roslyn/blob/main/src/RoslynAnalyzers/PublicApiAnalyzers/PublicApiAnalyzers.Help.md) [/home/vsts/work/1/s/src/Controls/src/Core/Controls.Core.csproj::TargetFramework=net10.0-android36.0]
    0 Warning(s)
    1 Error(s)

Time Elapsed 00:01:37.51
* daemon not running; starting now at tcp:5037
* daemon started successfully
  Determining projects to restore...
  All projects are up-to-date for restore.
  ##vso[build.updatebuildnumber]10.0.80-ci+azdo.14162401
  Graphics -> /home/vsts/work/1/s/artifacts/bin/Graphics/Debug/net10.0-android36.0/Microsoft.Maui.Graphics.dll
  ##vso[build.updatebuildnumber]10.0.80-ci+azdo.14162401
  Essentials -> /home/vsts/work/1/s/artifacts/bin/Essentials/Debug/net10.0-android36.0/Microsoft.Maui.Essentials.dll
  ##vso[build.updatebuildnumber]10.0.80-ci+azdo.14162401
  Core -> /home/vsts/work/1/s/artifacts/bin/Core/Debug/net10.0-android36.0/Microsoft.Maui.dll
  ##vso[build.updatebuildnumber]10.0.80-ci+azdo.14162401
  Controls.BindingSourceGen -> /home/vsts/work/1/s/artifacts/bin/Controls.BindingSourceGen/Debug/netstandard2.0/Microsoft.Maui.Controls.BindingSourceGen.dll
  Maps -> /home/vsts/work/1/s/artifacts/bin/Maps/Debug/net10.0-android36.0/Microsoft.Maui.Maps.dll
  ##vso[build.updatebuildnumber]10.0.80-ci+azdo.14162401
/home/vsts/work/1/s/src/Controls/src/Core/Handlers/Items/Android/MauiRecyclerView.cs(86,27): error RS0036: Symbol 'override Microsoft.Maui.Controls.Handlers.Items.MauiRecyclerView<TItemsView, TAdapter, TItemsViewSource>.OnVisibilityChanged(Android.Views.View changedView, Android.Views.ViewStates visibility) -> void' is missing nullability annotations in the declared API (https://github.com/dotnet/roslyn/blob/main/src/RoslynAnalyzers/PublicApiAnalyzers/PublicApiAnalyzers.Help.md) [/home/vsts/work/1/s/src/Controls/src/Core/Controls.Core.csproj::TargetFramework=net10.0-android36.0]

Build FAILED.

/home/vsts/work/1/s/src/Controls/src/Core/Handlers/Items/Android/MauiRecyclerView.cs(86,27): error RS0036: Symbol 'override Microsoft.Maui.Controls.Handlers.Items.MauiRecyclerView<TItemsView, TAdapter, TItemsViewSource>.OnVisibilityChanged(Android.Views.View changedView, Android.Views.ViewStates visibility) -> void' is missing nullability annotations in the declared API (https://github.com/dotnet/roslyn/blob/main/src/RoslynAnalyzers/PublicApiAnalyzers/PublicApiAnalyzers.Help.md) [/home/vsts/work/1/s/src/Controls/src/Core/Controls.Core.csproj::TargetFramework=net10.0-android36.0]
    0 Warning(s)
    1 Error(s)

Time Elapsed 00:01:39.12

Failures here are informational only — they do not block the gate or affect try-fix candidate scoring.

---

🔍 Regression Cross-Reference

🔍 Regression Cross-Reference

🟢 No regression risks detected. No labeled bug-fix PRs in the last 6 months touched the modified files.

---

🔍 Pre-Flight — Context & Validation

Pre-Flight Summary — PR #35181

Title: [Android] Fix AppBar flicker on CheckBox/Switch toggle with Material 3
Author: Dhivya-SF4094 (Syncfusion partner)
Branch: appbar_flicker → main
Issue: #35180
Labels: platform/android, partner/syncfusion, material3, s/agent-reviewed, s/agent-review-incomplete, s/agent-fix-pr-picked
State: OPEN, no milestone
Diff size: +365 / -0 (5 files; 1 new)

Problem

When Material 3 is enabled on Android, toggling a CheckBox/Switch inside a ScrollView (within a NavigationPage or Shell) causes the AppBarLayout surface color to flicker between its lifted and non-lifted states on every toggle, especially after the page has been scrolled.

Root cause

AppBarLayout.liftOnScroll auto-detects the first scroll-flagged sibling as its scroll target. With MAUI's nav hosting, that target is the outer FragmentContainerView (not the inner MauiScrollView). FragmentContainerView.canScrollVertically() always returns 0, so on every layout pass shouldLift() evaluates inconsistently — every CheckBox/Switch state-change animation triggers a layout pass that flips lifted state, producing a visible flash of scrolledContainerColor.

PR's Fix

Set AppBarLayout.LiftOnScrollTargetViewId explicitly to the actual scrollable view's id (the MauiScrollView or MauiRecyclerView), bypassing the auto-detection. Gated behind RuntimeFeature.IsMaterial3Enabled.

Files

File	Change
src/Core/src/Platform/Android/AppbarLayoutExtensions.cs	NEW — 242-line shared helper that walks ancestors to find sibling AppBarLayout, claims/releases target on attach/detach/visibility, handles CarouselView (off-screen pre-cached pages) via ViewTreeObserver.IOnScrollChangedListener, syncs SetLifted() to actual scroll position. State stored per-view in ConditionalWeakTable.
src/Core/src/Platform/Android/MauiScrollView.cs	+59 — overrides OnAttachedToWindow/OnDetachedFromWindow/OnVisibilityChanged (all M3-gated), posts a runnable that calls TrySetAppBarLiftTargetIfOnScreen().
src/Controls/src/Core/Handlers/Items/Android/MauiRecyclerView.cs	+60 — same pattern for CollectionView/CarouselView pages without a wrapping ScrollView.
src/Core/src/PublicAPI/net-android/PublicAPI.Unshipped.txt	+1 (OnVisibilityChanged override).
src/Controls/src/Core/PublicAPI/net-android/PublicAPI.Unshipped.txt	+3 overrides on MauiRecyclerView.

Strengths

• Gated behind M3 feature flag → no risk to M2 path.
• Carousel/ViewPager2 pre-cache case is explicitly handled (off-screen pages don't steal the target).
• Outer-MauiScrollView precedence prevents nested-scroll wrong-target.
• Shared helper avoids logic duplication between scroll and recycler view.
• State stored in ConditionalWeakTable → no leak risk.

Risks / Concerns

• Adds two state-management surfaces (MauiScrollView, MauiRecyclerView) and a 242-line extensions module. Surface area increases.
• Sets a View.GenerateViewId() permanently on the scroll view if it had NoId — could in principle collide with any other consumer querying by id (low risk, but not zero).
• Adds public overrides to MauiRecyclerView<TItemsView, TAdapter, TItemsViewSource> which is generic and a derivation point for third parties — breaks sealed override patterns downstream (low risk).
• The fix is push-based (each scroll view claims the AppBar). Alternative pull-based design (AppBar finds its target once) is not explored.
• The OnScrollChangedListener fires on every parent scroll — measured very lightweight, but it's installed on every MAUI scroll/recycler view on every M3 page even when not inside a CarouselView.
• No unit/UI test added — gate skipped.

Gate Result

⚠️ SKIPPED — no tests detected in this PR. Author should be asked to add a repro test (likely a UI test with a scrolled CheckBox toggle screenshot/state assertion).

Prior Agent Status

PR already carries s/agent-fix-pr-picked from a previous review pass, indicating an earlier agent run preferred the PR's fix over its candidates. This run will re-examine with different alternative axes.

---

🔧 Fix — Analysis & Comparison

try-fix Summary — PR #35181

Environment limitation

This phase ran inside a CI step without an Android emulator, the full Android workload pre-built, or device-test infrastructure available. Empirically running the #35180 repro (CheckBox toggle in a scrolled ScrollView with M3 enabled) would require either Helix device-test queues or a local Android emulator. The PR itself ships no automated test (gate phase was skipped for this reason), so even running the existing suite would not validate the repro.

Candidates below are therefore documented as analytical alternatives — concrete implementation sketches with predicted behavior and trade-offs — rather than empirically verified passes/failures. This is the honest result the autonomous workflow can produce here; see notes in pre-flight/content.md.

The PR already carries the s/agent-fix-pr-picked label from an earlier review pass, signalling that a prior agent run concluded the PR's fix beat its candidates. This pass corroborates that conclusion along three additional axes.

Candidates explored

#	Approach	Axis vs PR	Predicted outcome	Verdict
1	Centralize fix in NavigationRootManager + ShellContentFragment via OnHierarchyChangeListener (pull-based)	Locality / API surface	Fixes Nav/Shell repro; regresses CarouselView page swipes without extra plumbing	Smaller surface, but loses Carousel coverage the PR has
2	Set appBar.LiftOnScroll = false when M3 enabled	Feature removal	Flicker gone, but scrolledContainerColor affordance lost framework-wide	Removes a designed M3 feature — unacceptable
3	Clear AppBar stateListAnimator to suppress the lifted/non-lifted transition	Symptom-masking at animation layer	Visible flicker likely gone; internal state still oscillates; M3 elevation animation lost	Treats symptom, not cause

Detailed candidates

See:

• try-fix-1/content.md — Centralized pull-based AppBar resolver
• try-fix-2/content.md — Disable LiftOnScroll on M3
• try-fix-3/content.md — Suppress lifted-state animator

Final recommendation

Keep the PR's fix. Each alternative is meaningfully different along a real axis (locality, scope, layer) and each surfaces a genuine trade-off, but none is demonstrably better than the PR overall:

• Candidate 1 is the most architecturally appealing alternative (no public API churn, no per-scroll-view state, single resolver location). However the PR's per-scroll-view design is what gives it correct CarouselView page-swipe behavior without an additional ViewPager2.OnPageChangeCallback hook. Reaching parity would re-add roughly the listener machinery the PR has, eliminating the locality advantage.
• Candidates 2 and 3 both fix the literal repro at the cost of a Material 3 visual affordance the framework deliberately added — they are feature regressions disguised as bug fixes.

Suggestions back to the author (do not block the PR)

1. Add a UI test for [Android] AppBar flicker while changing the CheckBox or Switch state after scrolling in Material 3 #35180. A simple TestCases.HostApp page with a NavigationPage containing a scrolled ScrollView + CheckBox, plus a screenshot/state assertion before and after toggle, would let CI guard against regression. The PR's diff is precisely the kind of platform-specific change that benefits from a repro test.
2. Consider whether the three new MauiRecyclerView overrides need to be public. They are added to a generic class derived by third parties; if they were internal (or the methods routed through internal virtual helpers) the API surface bump would shrink. Worth a follow-up if compatible.
3. Consider whether assigning View.GenerateViewId() on a previously-NoId MauiRecyclerView could clash with any test code that queries by id. Sweep of the repo suggests no, but a comment guarding that invariant would help future readers.

None of these are blockers — the PR's approach is structurally sound and the additions are appropriately gated behind RuntimeFeature.IsMaterial3Enabled.

---

📋 Report — Final Recommendation

Comparative Analysis — PR #35181

Candidates evaluated

Candidate	Source	Verified pass?	Verified regression?
pr	PR as submitted (5 files, +365 / −0)	Not empirically tested (no Android emulator/Helix in this run)	None observed
pr-plus-reviewer	pr + VTO-caching reviewer fix (~10 lines in AppbarLayoutExtensions.cs)	Not empirically tested	None observed
try-fix-1	Centralised pull-based resolver in NavigationRootManager + ShellContentFragment	Not empirically tested	Predicted CarouselView regression (no per-page resolution)
try-fix-2	appBar.LiftOnScroll = false on M3	Not empirically tested	Designed M3 affordance removed framework-wide
try-fix-3	Clear AppBar stateListAnimator	Not empirically tested	Same M3 affordance removed; underlying state still oscillates (symptom-mask)

Per the rule "candidates that failed regression tests rank lower than candidates that passed": none have empirical test runs (no test exists yet; gate skipped). Where regressions are predicted by static analysis (try-fix-1/2/3), those candidates rank below the PR-family ones.

Pairwise comparison

pr vs pr-plus-reviewer

Same architecture; pr-plus-reviewer adds a localised VTO caching fix that closes a real but rare listener-leak path during detach. No public-API delta, no behavioural change on the happy path. Reviewer's other notes are non-blocking suggestions to the author. pr-plus-reviewer strictly dominates pr.

pr-plus-reviewer vs try-fix-1

try-fix-1 has the more attractive architecture (single resolver, no public-API additions). But its sketch loses CarouselView page-swipe correctness without re-introducing roughly the listener machinery the PR has. The PR's CarouselView coverage is a real feature, not incidental complexity. pr-plus-reviewer wins on completeness.

pr-plus-reviewer vs try-fix-2

try-fix-2 disables liftOnScroll, removing a deliberately-designed M3 visual feature (scrolledContainerColor + elevation animation) framework-wide for all M3 apps. Trades a bug for a regression. pr-plus-reviewer wins clearly.

pr-plus-reviewer vs try-fix-3

try-fix-3 masks the symptom by killing the stateListAnimator — the same M3 affordance is lost, and the underlying flicker (in appBar.IsLifted state and any observer thereof) persists. Symptom-only. pr-plus-reviewer wins clearly.

Ranking

1. pr-plus-reviewer ⭐ — winner. Strictly improves pr with a one-file VTO-caching correctness fix.
2. pr — sound architecture, correct M3 gating, CarouselView covered; only the listener-leak detail keeps it behind pr-plus-reviewer.
3. try-fix-1 — best alternative architecture but loses CarouselView coverage; would need extra plumbing to reach parity.
4. try-fix-3 — symptom-mask, M3 affordance lost.
5. try-fix-2 — feature removal disguised as a fix.

Winner

pr-plus-reviewer — apply the reviewer's VTO-caching change to AppbarLayoutExtensions.cs, keep everything else from the PR as submitted. Post the remaining reviewer notes (nits #2, #5, #6 and follow-up #7 — add a UI test) as non-blocking comments to the author.

Suggestions to the author (non-blocking)

1. Add a UI test for [Android] AppBar flicker while changing the CheckBox or Switch state after scrolling in Material 3 #35180 in TestCases.HostApp — a NavigationPage page with a scrolled ScrollView + CheckBox and a UI assertion that the AppBar background does not flicker on toggle.
2. Consider routing the new M3 logic in MauiRecyclerView through an internal virtual helper rather than three new protected overrides on a generic, third-party-derivable class.
3. Add a brief comment in ClearAppBarLiftTargetCore noting that releasing the target on visibility-loss briefly reverts to the buggy auto-detect — acceptable in practice because the next page claims quickly.

---

[Dhivya-SF4094]

Validated AI summary and addressed the concern.

[kubaflo]

/review -b feature/regression-check