[iOS] Fix for ScrollView SafeAreaEdges="Container" Double Safe-Area Reservation Causing Phantom Scroll Range (#37765)

> [!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](https://github.com/dotnet/maui/wiki/Testing-PR-Builds) from
this PR and let us know in a comment if this change resolves your issue.
Thank you!

### Issue Description

On iOS, a ScrollView configured with SafeAreaEdges="Container"
incorrectly reserves the safe area twice, resulting in an additional
phantom scroll range. When the content is smaller than the viewport, the
ScrollView becomes unnecessarily scrollable. The extra scrollable area
corresponds exactly to the combined safe-area insets (for example, 82 pt
on an iPhone 11: 48 pt for the status bar and 34 pt for the home
indicator).

When the content is taller than the viewport, the same issue causes an
unnecessary dead over-scroll space at the end of the content.

### Root Cause

The issue occurs because MauiScrollView.CrossPlatformArrange always pads
the scroll content's measured size by the safe-area thickness when
ContentInsetAdjustmentBehavior is not Automatic, without checking
whether UIKit has already reserved the same space through
AdjustedContentInset.
 
As a result, when SafeAreaEdges="Container" is set and the native inset
is active, the safe area is accounted for twice—once by UIKit and once
by the manual padding. This inflates the content size beyond its actual
bounds and produces a phantom scrollable range, even when the content
should not be scrollable.

### Description of Change

The fix narrows the manual-padding condition so that it applies only
when the native inset is genuinely inactive—that is, when
SystemAdjustedContentInset is zero or ContentInsetAdjustmentBehavior is
Never. In all other cases, UIKit's own inset is trusted to reserve the
safe area, and the content size is left unchanged.
 
This removes the double reservation for SafeAreaEdges="Container" while
preserving the existing None and Automaticbehaviors.

Tested the behavior in the following platforms.
 
- [x] iOS
- [x] Android
- [ ] Mac
- [ ] Windows

### Issues Fixed

Fixes #36800

### Output

|Before Fix|After Fix|
|--|--|
<video
src="https://github.com/user-attachments/assets/19c064e4-4622-4d1d-992c-340a56fb948f">
|<video
src="https://github.com/user-attachments/assets/57fa7cae-6e95-4573-885d-8f2979750f38">|

---------
Co-authored-by: Jakub Florkowski <42434498+kubaflo@users.noreply.github.com>

Author: BagavathiPerumal

global.json

@@ -1,6 +1,6 @@
 {
   "tools": {
-    "dotnet": "10.0.108"
+    "dotnet": "10.0.111"
   },
   "sdk": {
     "paths": [

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

@@ -0,0 +1,73 @@
+#if IOS
+using UIKit;
+#endif
+
+namespace Maui.Controls.Sample.Issues;
+
+[Issue(IssueTracker.Github, 36800, "ScrollView with SafeAreaEdges=\"Container\" reserves the safe area twice, causing phantom scroll range", PlatformAffected.iOS)]
+public class Issue36800 : ContentPage
+{
+	ScrollView _scrollView;
+	Label _diagLabel;
+
+	public Issue36800()
+	{
+		SafeAreaEdges = SafeAreaEdges.None;
+
+		_diagLabel = new Label
+		{
+			Text = "Phantom=Unknown",
+			AutomationId = "DiagLabel"
+		};
+
+		var dumpButton = new Button
+		{
+			Text = "Dump native state",
+			AutomationId = "DumpButton"
+		};
+		dumpButton.Clicked += OnDumpClicked;
+
+		// Small content that comfortably fits within the viewport - the ScrollView
+		// should NOT be scrollable at all when the bug is fixed.
+		var content = new VerticalStackLayout
+		{
+			Padding = 16,
+			Spacing = 12,
+			Children =
+			{
+				new Label { Text = "Small content", FontSize = 22, AutomationId = "SmallContentLabel" },
+				dumpButton,
+				_diagLabel
+			}
+		};
+
+		_scrollView = new ScrollView
+		{
+			AutomationId = "TestScrollView",
+			SafeAreaEdges = new SafeAreaEdges(SafeAreaRegions.Container),
+			Content = content
+		};
+
+		Content = _scrollView;
+	}
+
+	void OnDumpClicked(object sender, EventArgs e)
+	{
+#if IOS
+		if (_scrollView.Handler?.PlatformView is UIScrollView native)
+		{
+			// Phantom scroll range: on a fixed (non-scrollable) content, the scrollable
+			// range should be zero. When the safe area is reserved twice, this value
+			// is positive and equals the safe-area thickness.
+			double phantom = (native.ContentSize.Height + native.AdjustedContentInset.Top + native.AdjustedContentInset.Bottom) - native.Bounds.Height;
+			_diagLabel.Text = $"Phantom={phantom}";
+		}
+		else
+		{
+			_diagLabel.Text = "Phantom=NoHandler";
+		}
+#else
+		_diagLabel.Text = "Phantom=0";
+#endif
+	}
+}

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

@@ -177,6 +177,7 @@ public void SafeAreaPerEdgeValidation()
 
 		// Open Soft Input test entry
 		App.Tap("SoftInputTestEntry");
+		Assert.That(App.WaitForKeyboardToShow(), Is.True, "Keyboard should be visible before validating the resized safe area");
 
 		// With AdjustNothing mode, the window doesn't resize or pan
 		// The MainGrid gets bottom padding from SoftInput, so ContentGrid should shrink
@@ -187,6 +188,7 @@ public void SafeAreaPerEdgeValidation()
 		});
 
 		App.DismissKeyboard();
+		Assert.That(App.WaitForKeyboardToHide(), Is.True, "Keyboard should be hidden before validating the restored safe area");
 
 		App.RetryAssert(() =>
 		{

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

@@ -141,6 +141,7 @@ public void SafeAreaNoWhiteSpaceAfterKeyboardDismissAndEdgeToggle()
 		var baselinePosition = App.WaitForElement("ContentGrid").GetRect();
 
 		App.Tap("SoftInputTestEntry");
+		Assert.That(App.WaitForKeyboardToShow(), Is.True, "Keyboard should be visible before validating the resized safe area");
 		App.RetryAssert(() =>
 		{
 			var withKeyboard = App.WaitForElement("ContentGrid").GetRect();
@@ -150,6 +151,7 @@ public void SafeAreaNoWhiteSpaceAfterKeyboardDismissAndEdgeToggle()
 
 		App.Tap("GridSetContainerButton");
 		App.DismissKeyboard();
+		Assert.That(App.WaitForKeyboardToHide(), Is.True, "Keyboard should be hidden before restoring all safe-area edges");
 		App.Tap("GridResetAllButton");
 
 		App.RetryAssert(() =>

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

@@ -0,0 +1,35 @@
+#if IOS // Fix is specific to iOS's ContentInsetAdjustmentBehavior/AdjustedContentInset handling; not applicable on Android/Catalyst/Windows
+using System.Globalization;
+using NUnit.Framework;
+using UITest.Appium;
+using UITest.Core;
+
+namespace Microsoft.Maui.TestCases.Tests.Issues;
+
+public class Issue36800 : _IssuesUITest
+{
+	public override string Issue => "ScrollView with SafeAreaEdges=\"Container\" reserves the safe area twice, causing phantom scroll range";
+
+	public Issue36800(TestDevice device) : base(device)
+	{
+	}
+
+	[Test]
+	[Category(UITestCategories.SafeAreaEdges)]
+	public void ScrollViewWithContainerSafeAreaDoesNotDoubleReserveSafeArea()
+	{
+		App.WaitForElement("TestScrollView");
+		App.Tap("DumpButton");
+
+		var diagText = App.WaitForElement("DiagLabel").GetText() ?? string.Empty;
+
+		Assert.That(diagText, Does.StartWith("Phantom="), $"Unexpected diagnostic text: {diagText}");
+
+		var phantomValueText = diagText.Substring("Phantom=".Length);
+		var phantom = double.Parse(phantomValueText, CultureInfo.InvariantCulture);
+
+		Assert.That(phantom, Is.LessThanOrEqualTo(1.0),
+			$"ScrollView with SafeAreaEdges=Container should not have a phantom scroll range, but measured {phantom}pt");
+	}
+}
+#endif

src/Core/src/Platform/iOS/MauiScrollView.cs

@@ -647,11 +647,23 @@ Size CrossPlatformArrange(CGRect bounds)
 					height = Bounds.Height + 1;
 				}
 			}
-			else if (ContentInsetAdjustmentBehavior != UIScrollViewContentInsetAdjustmentBehavior.Automatic)
+			else if (SystemAdjustedContentInset == UIEdgeInsets.Zero || ContentInsetAdjustmentBehavior == UIScrollViewContentInsetAdjustmentBehavior.Never)
 			{
+				// UIKit is not currently reserving any space for the safe area on
+				// this scroll view - either because the adjustment behavior is set
+				// to Never, or because it is set to Always but UIKit has not yet
+				// assigned a system inset for the current layout pass. In either
+				// case, the content size must be padded manually to keep the
+				// content clear of the safe area. Once UIKit assigns a non-zero
+				// inset, the safe area is reserved natively instead, as described
+				// below.
 				width += _safeArea.HorizontalThickness;
 				height += _safeArea.VerticalThickness;
 			}
+			// UIKit is already reserving the safe area natively via a non-zero
+			// AdjustedContentInset, so the content size is intentionally left
+			// unmodified here. Padding it again would reserve the same safe area
+			// twice, producing a scrollable range larger than the actual content.
 
 			contentSize = new Size(width, height);