From c9e55b9b26b8eb652017400b261e49962b588d98 Mon Sep 17 00:00:00 2001
From: Matthew Leibowitz <mattleibow@live.com>
Date: Wed, 6 Sep 2023 22:23:04 +0200
Subject: [PATCH] Implement touch interception on Android

---
 .../Concepts/InputTransparencyGalleryPage.cs  | 396 ++++++++++++++++--
 .../samples/Controls.Sample.UITests/Test.cs   |  36 +-
 .../Pages/Core/InputTransparentPage.xaml      |   5 +-
 .../Pages/Core/InputTransparentPage.xaml.cs   |   6 +
 .../Concepts/InputTransparencyGalleryTests.cs |  21 +-
 .../tests/UITests/Tests/_ViewUITests.cs       |  45 +-
 .../Handlers/Image/ImageHandler.Android.cs    |   3 +-
 .../Handlers/Layout/LayoutHandler.Android.cs  |   9 +-
 src/Core/src/Handlers/View/ViewHandler.cs     |  14 +-
 .../src/Platform/Android/LayoutViewGroup.cs   |  25 +-
 .../src/Platform/Android/MauiImageView.cs     |  19 +
 src/Core/src/Platform/Android/MauiTextView.cs |   9 +-
 .../Platform/Android/TouchEventInterceptor.cs | 208 +++++++++
 .../src/Platform/Android/ViewExtensions.cs    |   7 +
 src/Core/src/Platform/Android/WrapperView.cs  |  25 +-
 src/Core/src/Platform/Tizen/ViewExtensions.cs |   2 +-
 .../net-android/PublicAPI.Unshipped.txt       |   6 +
 src/Core/src/ViewExtensions.cs                |  12 +-
 .../HandlerTestBaseOfT.Android.cs             |   4 +-
 19 files changed, 747 insertions(+), 105 deletions(-)
 create mode 100644 src/Core/src/Platform/Android/MauiImageView.cs
 create mode 100644 src/Core/src/Platform/Android/TouchEventInterceptor.cs

diff --git a/src/Controls/samples/Controls.Sample.UITests/Concepts/InputTransparencyGalleryPage.cs b/src/Controls/samples/Controls.Sample.UITests/Concepts/InputTransparencyGalleryPage.cs
index 98be75b6debc..48bba4528372 100644
--- a/src/Controls/samples/Controls.Sample.UITests/Concepts/InputTransparencyGalleryPage.cs
+++ b/src/Controls/samples/Controls.Sample.UITests/Concepts/InputTransparencyGalleryPage.cs
@@ -1,5 +1,9 @@
 using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using Microsoft.Maui.Controls;
+using Microsoft.Maui.Graphics;
+using Microsoft.Maui.Layouts;
 
 namespace Maui.Controls.Sample
 {
@@ -7,20 +11,86 @@ internal class InputTransparencyGalleryPage : CoreGalleryBasePage
 	{
 		protected override void Build()
 		{
-			// Basic test with view defaults, should be clickable
-			Add(Test.InputTransparency.Default, new Button { Text = "Click Me!" })
+			// Single Control
+			AddButtonNotSet();
+			AddButton();
+			AddTransButtonInputBlocked();
+
+			// Button
+			AddButtonOverlay();
+			AddTransButtonOverlay();
+
+			// Image
+			AddOverlayTest<Image>(
+				Test.InputTransparency.ImageOverlayInputBlocked,
+				Test.InputTransparency.TransImageOverlay,
+				image => image.Source = ImageSource.FromFile("small_dotnet_bot.png"));
+			AddOverlayTest<Image>(
+				Test.InputTransparency.ImageBackOverlayInputBlocked,
+				Test.InputTransparency.TransImageBackOverlay,
+				image =>
+				{
+					image.Source = ImageSource.FromFile("small_dotnet_bot.png");
+					image.Background = Brush.Red;
+				});
+
+			// Label
+			AddOverlayTest<Label>(
+				Test.InputTransparency.LabelOverlayInputBlocked,
+				Test.InputTransparency.TransLabelOverlay,
+				label => label.Text = "Overlay Text");
+
+			// ActivityIndicator
+			AddOverlayTest<ActivityIndicator>(
+				Test.InputTransparency.ActivityIndicatorOverlayInputBlocked,
+				Test.InputTransparency.TransActivityIndicatorOverlay,
+				ai => ai.IsRunning = true);
+
+			// ProgressBar
+			AddOverlayTest<ProgressBar>(
+				Test.InputTransparency.ProgressBarOverlayInputBlocked,
+				Test.InputTransparency.TransProgressBarOverlay,
+				p => p.Progress = 0.75);
+
+			// Layout
+			AddOverlayTest<Grid>(
+				Test.InputTransparency.LayoutOverlayInputBlocked,
+				Test.InputTransparency.TransLayoutOverlay);
+			AddTransLayoutOverlayWithButton();
+			AddCascadeTransLayoutOverlay();
+			AddCascadeTransLayoutOverlayWithButton();
+
+			// ListView + CollectionView
+			AddItemsViewItemLayoutOverlay();
+			AddItemsViewItemTransLayoutOverlay();
+			AddItemsViewItemButtonOverlay();
+			AddItemsViewItemTransButtonOverlay();
+
+			// The full matrix
+			AddFullInputTransparencyMatrix();
+		}
+
+		// Basic test with view defaults, should be clickable
+		void AddButtonNotSet() =>
+			Add(Test.InputTransparency.ButtonNotSet, new Button { Text = "Click Me!" })
 				.With(t => t.View.Clicked += (s, e) => t.ReportSuccessEvent());
 
-			// Test when InputTransparent is explicitly set to False, should be clickable
-			Add(Test.InputTransparency.IsFalse, new Button { Text = "Click Me!", InputTransparent = false })
+		// Test when InputTransparent is explicitly set to False, should be clickable
+		void AddButton() =>
+			Add(Test.InputTransparency.Button, new Button { Text = "Click Me!", InputTransparent = false })
 				.With(t => t.View.Clicked += (s, e) => t.ReportSuccessEvent());
 
-			// Test when InputTransparent is explicitly set to True, should NOT be clickable
-			// and we emulate this by putting another button underneath that should be clickable
-			Add(Test.InputTransparency.IsTrue, () =>
+		// Test when InputTransparent is explicitly set to True, should NOT be clickable
+		void AddTransButtonInputBlocked() =>
+			Add(Test.InputTransparency.TransButtonInputBlocked, new Button { Text = "Click Me!", InputTransparent = true })
+				.With(t => t.View.Clicked += (s, e) => t.ReportFailEvent());
+
+		// Test when InputTransparent is explicitly set to False, should be clickable
+		void AddButtonOverlay() =>
+			Add(Test.InputTransparency.ButtonOverlay, () =>
 			{
 				var bottom = new Button { Text = "Bottom Button" };
-				var top = new Button { Text = "Click Me!", InputTransparent = true };
+				var top = new Button { Text = "Click Me!", InputTransparent = false };
 				var grid = new Grid { bottom, top };
 				return (grid, new { Bottom = bottom, Top = top });
 			})
@@ -29,35 +99,32 @@ protected override void Build()
 				var v = t.ViewContainer.View;
 				var bottom = t.Additional.Bottom;
 				var top = Annotate(t.Additional.Top, v);
-				bottom.Clicked += (s, e) => t.ViewContainer.ReportSuccessEvent();
-				top.Clicked += (s, e) => t.ViewContainer.ReportFailEvent();
+				bottom.Clicked += (s, e) => t.ViewContainer.ReportFailEvent();
+				top.Clicked += (s, e) => t.ViewContainer.ReportSuccessEvent();
 			});
 
-			// Test when there is an InputTransparent layout over the button, should be clickable
-			Add(Test.InputTransparency.TransLayoutOverlay, () =>
+		// Test when InputTransparent is explicitly set to True, should NOT be clickable
+		// and we emulate this by putting another button underneath that should be clickable
+		void AddTransButtonOverlay() =>
+			Add(Test.InputTransparency.TransButtonOverlay, () =>
 			{
-				var button = new Button { Text = "Click Me!" };
-				var grid = new Grid
-				{
-					new Grid { button },
-					new Grid
-					{
-						InputTransparent = true,
-						Background = Brush.Red,
-						Opacity = 0.5,
-					}
-				};
-				return (grid, new { Button = button });
+				var bottom = new Button { Text = "Bottom Button" };
+				var top = new Button { Text = "Click Me!", InputTransparent = true };
+				var grid = new Grid { bottom, top };
+				return (grid, new { Bottom = bottom, Top = top });
 			})
 			.With(t =>
 			{
 				var v = t.ViewContainer.View;
-				var button = Annotate(t.Additional.Button, v);
-				button.Clicked += (s, e) => t.ViewContainer.ReportSuccessEvent();
+				var bottom = t.Additional.Bottom;
+				var top = Annotate(t.Additional.Top, v);
+				bottom.Clicked += (s, e) => t.ViewContainer.ReportSuccessEvent();
+				top.Clicked += (s, e) => t.ViewContainer.ReportFailEvent();
 			});
 
-			// Test when there is an InputTransparent layout over the button, should NOT be clickable
-			// but the button IN the layout should be clickable because it is not cascading
+		// Test when there is an InputTransparent layout over the button, should NOT be clickable
+		// but the button IN the layout should be clickable because it is not cascading
+		void AddTransLayoutOverlayWithButton() =>
 			Add(Test.InputTransparency.TransLayoutOverlayWithButton, () =>
 			{
 				var bottom = new Button { Text = "Bottom Button" };
@@ -85,7 +152,8 @@ protected override void Build()
 				top.Clicked += (s, e) => t.ViewContainer.ReportSuccessEvent();
 			});
 
-			// Test when there is an InputTransparent layout over the button, should be clickable
+		// Test when there is an InputTransparent layout over the button, should be clickable
+		void AddCascadeTransLayoutOverlay() =>
 			Add(Test.InputTransparency.CascadeTransLayoutOverlay, () =>
 			{
 				var button = new Button { Text = "Click Me!" };
@@ -109,8 +177,9 @@ protected override void Build()
 				button.Clicked += (s, e) => t.ViewContainer.ReportSuccessEvent();
 			});
 
-			// Test when there is an InputTransparent layout over the button, should be clickable
-			// and the button IN the layout should NOT be clickable because it is cascading
+		// Test when there is an InputTransparent layout over the button, should be clickable
+		// and the button IN the layout should NOT be clickable because it is cascading
+		void AddCascadeTransLayoutOverlayWithButton() =>
 			Add(Test.InputTransparency.CascadeTransLayoutOverlayWithButton, () =>
 			{
 				var bottom = new Button { Text = "Bottom Button" };
@@ -138,8 +207,174 @@ protected override void Build()
 				top.Clicked += (s, e) => t.ViewContainer.ReportFailEvent();
 			});
 
-			// Tests for a nested layout (root grid, nested grid, button) with some variations to ensure
-			// that all combinations are correctly clickable
+		// CV test where a grid covers/blocks the button, so this causes the CV to select items
+		void AddItemsViewItemLayoutOverlay()
+		{
+			Button CreateBottom() => new Button { Text = "Click Me!" };
+			Grid CreateTop() => new Grid { };
+			void Setup(ExpectedEventViewContainer<View> vc, ObservableCollection<Button> bottoms, ObservableCollection<Grid> tops)
+			{
+				var v = vc.View;
+				if (v is CollectionView cv)
+					cv.SelectionChanged += (s, e) => vc.ReportSuccessEvent();
+				else if (v is ListView lv)
+					lv.ItemSelected += (s, e) => vc.ReportSuccessEvent();
+
+				bottoms.CollectionChanged += (s, e) =>
+				{
+					foreach (Button n in e.NewItems)
+					{
+						Annotate(n, v);
+						n.Clicked += (s, e) => vc.ReportFailEvent();
+					}
+				};
+			}
+
+			AddCollectionView(Test.InputTransparency.CollectionViewItemLayoutOverlay, CreateBottom, CreateTop)
+				.With(t => Setup(t.ViewContainer, t.Bottoms, t.Tops));
+
+			AddListView(Test.InputTransparency.ListViewItemLayoutOverlay, CreateBottom, CreateTop)
+				.With(t => Setup(t.ViewContainer, t.Bottoms, t.Tops));
+		}
+
+		// CV test where a transparent grid covers the button, so this allows button clicks
+		void AddItemsViewItemTransLayoutOverlay()
+		{
+			Button CreateBottom() => new Button { Text = "Click Me!" };
+			Grid CreateTop() => new Grid { InputTransparent = true };
+			void Setup(ExpectedEventViewContainer<View> vc, ObservableCollection<Button> bottoms, ObservableCollection<Grid> tops)
+			{
+				var v = vc.View;
+				if (v is CollectionView cv)
+					cv.SelectionChanged += (s, e) => vc.ReportFailEvent();
+				else if (v is ListView lv)
+					lv.ItemSelected += (s, e) => vc.ReportFailEvent();
+
+				bottoms.CollectionChanged += (s, e) =>
+				{
+					foreach (Button n in e.NewItems)
+					{
+						Annotate(n, v);
+						n.Clicked += (s, e) => vc.ReportSuccessEvent();
+					}
+				};
+			}
+
+			AddCollectionView(Test.InputTransparency.CollectionViewItemTransLayoutOverlay, CreateBottom, CreateTop)
+				.With(t => Setup(t.ViewContainer, t.Bottoms, t.Tops));
+
+			AddListView(Test.InputTransparency.ListViewItemTransLayoutOverlay, CreateBottom, CreateTop)
+				.With(t => Setup(t.ViewContainer, t.Bottoms, t.Tops));
+		}
+
+		// CV test where a button is the item so the CV is not selectable
+		void AddItemsViewItemButtonOverlay()
+		{
+			Grid CreateBottom() => new Grid { };
+			Button CreateTop() => new Button { Text = "Click Me!" };
+			void Setup(ExpectedEventViewContainer<View> vc, ObservableCollection<Grid> bottoms, ObservableCollection<Button> tops)
+			{
+				var v = vc.View;
+				if (v is CollectionView cv)
+					cv.SelectionChanged += (s, e) => vc.ReportFailEvent();
+				else if (v is ListView lv)
+					lv.ItemSelected += (s, e) => vc.ReportFailEvent();
+
+				tops.CollectionChanged += (s, e) =>
+				{
+					foreach (Button n in e.NewItems)
+					{
+						Annotate(n, v);
+						n.Clicked += (s, e) => vc.ReportSuccessEvent();
+					}
+				};
+			};
+
+			AddCollectionView(Test.InputTransparency.CollectionViewItemButtonOverlay, CreateBottom, CreateTop)
+				.With(t => Setup(t.ViewContainer, t.Bottoms, t.Tops));
+
+			AddListView(Test.InputTransparency.ListViewItemButtonOverlay, CreateBottom, CreateTop)
+				.With(t => Setup(t.ViewContainer, t.Bottoms, t.Tops));
+		}
+
+		// CV test where a transparent button is the item so the CV is selectable
+		void AddItemsViewItemTransButtonOverlay()
+		{
+			Grid CreateBottom() => new Grid { };
+			Button CreateTop() => new Button { Text = "Click Me!", InputTransparent = true };
+			void Setup(ExpectedEventViewContainer<View> vc, ObservableCollection<Grid> bottoms, ObservableCollection<Button> tops)
+			{
+				var v = vc.View;
+				if (v is CollectionView cv)
+					cv.SelectionChanged += (s, e) => vc.ReportSuccessEvent();
+				else if (v is ListView lv)
+					lv.ItemSelected += (s, e) => vc.ReportSuccessEvent();
+
+				tops.CollectionChanged += (s, e) =>
+				{
+					foreach (Button n in e.NewItems)
+					{
+						Annotate(n, v);
+						n.Clicked += (s, e) => vc.ReportFailEvent();
+					}
+				};
+			}
+
+			AddCollectionView(Test.InputTransparency.CollectionViewItemTransButtonOverlay, CreateBottom, CreateTop)
+				.With(t => Setup(t.ViewContainer, t.Bottoms, t.Tops));
+
+			AddListView(Test.InputTransparency.ListViewItemTransButtonOverlay, CreateBottom, CreateTop)
+				.With(t => Setup(t.ViewContainer, t.Bottoms, t.Tops));
+		}
+
+		void AddOverlayTest<T>(Test.InputTransparency test, Test.InputTransparency transTest, Action<T> setup = null)
+			where T : View, new()
+		{
+			// Test when there is an T over the button, should NOT be clickable
+			Add(test, () =>
+			{
+				var button = new Button { Text = "Click Me!" };
+				var view = new T { InputTransparent = false };
+				setup?.Invoke(view);
+				var grid = new Grid
+				{
+					new Grid { button },
+					view
+				};
+				return (grid, new { Button = button });
+			})
+			.With(t =>
+			{
+				var v = t.ViewContainer.View;
+				var button = Annotate(t.Additional.Button, v);
+				button.Clicked += (s, e) => t.ViewContainer.ReportFailEvent();
+			});
+
+			// Test when there is a transparent T over the button, should be clickable
+			Add(transTest, () =>
+			{
+				var button = new Button { Text = "Click Me!" };
+				var view = new T { InputTransparent = true };
+				setup?.Invoke(view);
+				var grid = new Grid
+				{
+					new Grid { button },
+					view
+				};
+				return (grid, new { Button = button });
+			})
+			.With(t =>
+			{
+				var v = t.ViewContainer.View;
+				var button = Annotate(t.Additional.Button, v);
+				button.Clicked += (s, e) => t.ViewContainer.ReportSuccessEvent();
+			});
+		}
+
+		// Tests for a nested layout (root grid, nested grid, button) with some variations to ensure
+		// that all combinations are correctly clickable
+		void AddFullInputTransparencyMatrix()
+		{
 			foreach (var state in Test.InputTransparencyMatrix.States)
 			{
 				var (rt, rc, nt, nc, t) = state.Key;
@@ -193,15 +428,8 @@ void AddNesting(bool rootTrans, bool rootCascade, bool nestedTrans, bool nestedC
 				{
 					// if one of the parent layouts are NOT transparent, then
 					// the tap should NOT go through to the bottom button
-#if ANDROID
-					// TODO: Android is broken with everything passing through
-					// https://github.com/dotnet/maui/issues/10252
-					bottom.Clicked += (s, e) => t.ViewContainer.ReportSuccessEvent();
-					top.Clicked += (s, e) => t.ViewContainer.ReportFailEvent();
-#else
 					bottom.Clicked += (s, e) => t.ViewContainer.ReportFailEvent();
 					top.Clicked += (s, e) => t.ViewContainer.ReportFailEvent();
-#endif
 				}
 				else
 				{
@@ -225,6 +453,94 @@ void AddNesting(bool rootTrans, bool rootCascade, bool nestedTrans, bool nestedC
 		ExpectedEventViewContainer<Button> Add(Test.InputTransparency test, Button button) =>
 			Add(new ExpectedEventViewContainer<Button>(test, button));
 
+		(ExpectedEventViewContainer<View> ViewContainer, ObservableCollection<TBottom> Bottoms, ObservableCollection<TTop> Tops)
+			AddCollectionView<TBottom, TTop>(Test.InputTransparency test, Func<TBottom> createBottom, Func<TTop> createTop)
+			where TBottom : View
+			where TTop : View
+		{
+			// NOTE: the CV height needs to be 3x the item height because some
+			// platforms tap the CV itself. This ensures the center of the CV is
+			// over the second item.
+			var added = Add(test.ToString(), () =>
+			{
+				var bottoms = new ObservableCollection<TBottom>();
+				var tops = new ObservableCollection<TTop>();
+				var cv = new CollectionView
+				{
+					SelectionMode = SelectionMode.Single,
+					HeightRequest = 150, // 3x the item height
+					ItemsSource = new[] { "First Item", "Second Item", "Third Item" },
+					ItemTemplate = new DataTemplate(() =>
+					{
+						var bottom = createBottom();
+						if (bottom is not null)
+							bottoms.Add(bottom);
+
+						var top = createTop();
+						if (top is not null)
+							tops.Add(top);
+
+						var grid = new Grid
+						{
+							HeightRequest = 50,
+							Children =
+							{
+								new Grid { bottom },
+								top
+							}
+						};
+						return grid;
+					})
+				};
+				return (cv, new { Bottoms = bottoms, Tops = tops });
+			});
+			return (added.ViewContainer, added.Additional.Bottoms, added.Additional.Tops);
+		}
+
+		(ExpectedEventViewContainer<View> ViewContainer, ObservableCollection<TBottom> Bottoms, ObservableCollection<TTop> Tops)
+			AddListView<TBottom, TTop>(Test.InputTransparency test, Func<TBottom> createBottom, Func<TTop> createTop)
+			where TBottom : View
+			where TTop : View
+		{
+			// NOTE: the LV height needs to be 3x the item height because some
+			// platforms tap the LV itself. This ensures the center of the LV is
+			// over the second item.
+			var added = Add(test.ToString(), () =>
+			{
+				var bottoms = new ObservableCollection<TBottom>();
+				var tops = new ObservableCollection<TTop>();
+				var lv = new ListView
+				{
+					SelectionMode = ListViewSelectionMode.Single,
+					HeightRequest = 150, // 3x the item height
+					ItemsSource = new[] { "First Item", "Second Item", "Third Item" },
+					ItemTemplate = new DataTemplate(() =>
+					{
+						var bottom = createBottom();
+						if (bottom is not null)
+							bottoms.Add(bottom);
+
+						var top = createTop();
+						if (top is not null)
+							tops.Add(top);
+
+						var grid = new Grid
+						{
+							HeightRequest = 50,
+							Children =
+							{
+								new Grid { bottom },
+								top
+							}
+						};
+						return new ViewCell { View = grid };
+					})
+				};
+				return (lv, new { Bottoms = bottoms, Tops = tops });
+			});
+			return (added.ViewContainer, added.Additional.Bottoms, added.Additional.Tops);
+		}
+
 		static T Annotate<T>(T view, View desired)
 			where T : View
 		{
diff --git a/src/Controls/samples/Controls.Sample.UITests/Test.cs b/src/Controls/samples/Controls.Sample.UITests/Test.cs
index 31ef4873d790..168f5b6e6671 100644
--- a/src/Controls/samples/Controls.Sample.UITests/Test.cs
+++ b/src/Controls/samples/Controls.Sample.UITests/Test.cs
@@ -713,13 +713,43 @@ public enum CarouselView
 
 		public enum InputTransparency
 		{
-			Default,
-			IsFalse,
-			IsTrue,
+			// Single Control
+			ButtonNotSet,
+			Button,
+			TransButtonInputBlocked,
+			// Button
+			ButtonOverlay,
+			TransButtonOverlay,
+			// Image
+			ImageOverlayInputBlocked,
+			TransImageOverlay,
+			ImageBackOverlayInputBlocked,
+			TransImageBackOverlay,
+			// Label
+			LabelOverlayInputBlocked,
+			TransLabelOverlay,
+			// ActivityIndicator
+			ActivityIndicatorOverlayInputBlocked,
+			TransActivityIndicatorOverlay,
+			// ProgressBar
+			ProgressBarOverlayInputBlocked,
+			TransProgressBarOverlay,
+			// Layout
+			LayoutOverlayInputBlocked,
 			TransLayoutOverlay,
 			TransLayoutOverlayWithButton,
 			CascadeTransLayoutOverlay,
 			CascadeTransLayoutOverlayWithButton,
+			// CollectionView
+			CollectionViewItemLayoutOverlay,
+			CollectionViewItemTransLayoutOverlay,
+			CollectionViewItemButtonOverlay,
+			CollectionViewItemTransButtonOverlay,
+			// ListView
+			ListViewItemLayoutOverlay,
+			ListViewItemTransLayoutOverlay,
+			ListViewItemButtonOverlay,
+			ListViewItemTransButtonOverlay,
 		}
 
 		public static class InputTransparencyMatrix
diff --git a/src/Controls/samples/Controls.Sample/Pages/Core/InputTransparentPage.xaml b/src/Controls/samples/Controls.Sample/Pages/Core/InputTransparentPage.xaml
index 9a6294e74917..95d11c562015 100644
--- a/src/Controls/samples/Controls.Sample/Pages/Core/InputTransparentPage.xaml
+++ b/src/Controls/samples/Controls.Sample/Pages/Core/InputTransparentPage.xaml
@@ -61,11 +61,10 @@
 
                 <Grid Margin="10" HeightRequest="100" BackgroundColor="LightBlue">
 
-                    <Button Text="Bottom Button" IsVisible="{Binding InputTransparent, Source={Reference testButton}}" Clicked="ClickSuccess" HorizontalOptions="Center" VerticalOptions="Center" />
-                    <Button Text="Bottom Button" IsVisible="{Binding InputTransparent, Source={Reference testButton}, Converter={StaticResource NegativeConverter}}" Clicked="ClickFail" HorizontalOptions="Center" VerticalOptions="Center" />
+                    <Button Text="Bottom Button" Clicked="ClickBottom" HorizontalOptions="Center" VerticalOptions="Center" Background="Red" />
 
                     <Grid x:Name="rootLayout">
-                        <Grid x:Name="nestedLayout">
+                        <Grid x:Name="nestedLayout" ColumnDefinitions="2*,1*">
                             <Button x:Name="testButton" Text="Test Button" Clicked="ClickSuccess" HorizontalOptions="Center" VerticalOptions="Center" />
                         </Grid>
                     </Grid>
diff --git a/src/Controls/samples/Controls.Sample/Pages/Core/InputTransparentPage.xaml.cs b/src/Controls/samples/Controls.Sample/Pages/Core/InputTransparentPage.xaml.cs
index 3f989d780843..31a62e5e4789 100644
--- a/src/Controls/samples/Controls.Sample/Pages/Core/InputTransparentPage.xaml.cs
+++ b/src/Controls/samples/Controls.Sample/Pages/Core/InputTransparentPage.xaml.cs
@@ -22,5 +22,11 @@ void ClickSuccess(object sender, EventArgs e)
 			Debug.WriteLine("Success; That should have worked, and it did!");
 			DisplayAlert("Success", "That should have worked, and it did!", "OK");
 		}
+
+		void ClickBottom(object sender, EventArgs e)
+		{
+			Debug.WriteLine("Click; You clicked a bottom button.");
+			DisplayAlert("Click", "You clicked a bottom button.", "OK");
+		}
 	}
 }
\ No newline at end of file
diff --git a/src/Controls/tests/UITests/Tests/Concepts/InputTransparencyGalleryTests.cs b/src/Controls/tests/UITests/Tests/Concepts/InputTransparencyGalleryTests.cs
index 48210dfdad95..533442d4b19e 100644
--- a/src/Controls/tests/UITests/Tests/Concepts/InputTransparencyGalleryTests.cs
+++ b/src/Controls/tests/UITests/Tests/Concepts/InputTransparencyGalleryTests.cs
@@ -20,7 +20,8 @@ protected override void NavigateToGallery()
 		}
 
 		[Test]
-		public void Simple([Values] Test.InputTransparency test) => RunTest(test.ToString());
+		public void Simple([Values] Test.InputTransparency test) =>
+			RunTest(test.ToString(), !test.ToString().EndsWith("InputBlocked"));
 
 		[Test]
 		[Combinatorial]
@@ -29,10 +30,10 @@ public void Matrix([Values] bool rootTrans, [Values] bool rootCascade, [Values]
 			var (clickable, passthru) = Test.InputTransparencyMatrix.States[(rootTrans, rootCascade, nestedTrans, nestedCascade, trans)];
 			var key = Test.InputTransparencyMatrix.GetKey(rootTrans, rootCascade, nestedTrans, nestedCascade, trans, clickable, passthru);
 
-			RunTest(key, clickable, passthru);
+			RunTest(key, clickable || passthru);
 		}
 
-		void RunTest(string test, bool? clickable = null, bool? passthru = null)
+		static void RunTest(string test, bool updatable)
 		{
 			var remote = new EventViewContainerRemote(UITestContext, test);
 			remote.GoTo(test.ToString());
@@ -44,23 +45,11 @@ void RunTest(string test, bool? clickable = null, bool? passthru = null)
 
 			var textAfterClick = remote.GetEventLabel().GetText();
 
-			if (clickable is null || passthru is null)
-			{
-				// some tests are really basic so have no need for fancy checks
-				Assert.AreEqual($"Event: {test} (SUCCESS 1)", textAfterClick);
-			}
-			else if (clickable == true || passthru == true)
+			if (updatable)
 			{
 				// if the button is clickable or taps pass through to the base button
 				Assert.AreEqual($"Event: {test} (SUCCESS 1)", textAfterClick);
 			}
-			else if (Device == TestDevice.Android)
-			{
-				// TODO: Android is broken with everything passing through so we just use that
-				// to test the bottom button was clickable
-				// https://github.com/dotnet/maui/issues/10252
-				Assert.AreEqual($"Event: {test} (SUCCESS 1)", textAfterClick);
-			}
 			else
 			{
 				// sometimes nothing can happen, so try test that
diff --git a/src/Controls/tests/UITests/Tests/_ViewUITests.cs b/src/Controls/tests/UITests/Tests/_ViewUITests.cs
index db7c7f8e3fbd..a8b87608b1c5 100644
--- a/src/Controls/tests/UITests/Tests/_ViewUITests.cs
+++ b/src/Controls/tests/UITests/Tests/_ViewUITests.cs
@@ -51,6 +51,49 @@ public virtual void _IsVisible()
 
 			Assert.AreEqual(0, viewPost.Count);
 		}
-	}
 
+		[Test]
+		public virtual void _InputTransparent()
+		{
+			var remote = new LayeredViewContainerRemote (UITestContext, Test.VisualElement.InputTransparent);
+			remote.GoTo ();
+
+			var hiddenButtonClickedLabelTextPre = remote.GetLayeredLabel ().Text;
+			Assert.AreEqual ("Hidden Button (Not Clicked)", hiddenButtonClickedLabelTextPre);
+
+			remote.TapHiddenButton ();
+
+			var hiddenButtonClickedLabelTextPost = remote.GetLayeredLabel ().Text;
+			var hiddenButtonClicked = hiddenButtonClickedLabelTextPost == "Hidden Button (Clicked)";
+
+			// // Allow tests to continue by dismissing DatePicker that should not show
+			// // Remove when InputTransparency works
+			// if (!hiddenButtonClicked && PlatformViewType == PlatformViews.DatePicker)
+			// 	remote.DismissPopOver ();
+
+			Assert.True (hiddenButtonClicked);
+		}
+
+		[Test]
+		public virtual void _NotInputTransparent()
+		{
+			var remote = new LayeredViewContainerRemote (UITestContext, Test.VisualElement.NotInputTransparent);
+			remote.GoTo ();
+
+			var hiddenButtonClickedLabelTextPre = remote.GetLayeredLabel ().Text;
+			Assert.AreEqual ("Hidden Button (Not Clicked)", hiddenButtonClickedLabelTextPre);
+
+			remote.TapHiddenButton ();
+
+			var hiddenButtonClickedLabelTextPost = remote.GetLayeredLabel ().Text;
+			var hiddenButtonClicked = hiddenButtonClickedLabelTextPost == "Hidden Button (Not Clicked)";
+
+			// // Allow tests to continue by dismissing DatePicker that should not show
+			// // Remove when InputTransparency works
+			// if (!hiddenButtonClicked && PlatformViewType == PlatformViews.DatePicker)
+			// 	remote.DismissPopOver ();
+
+			Assert.True (hiddenButtonClicked);
+		}
+	}
 }
diff --git a/src/Core/src/Handlers/Image/ImageHandler.Android.cs b/src/Core/src/Handlers/Image/ImageHandler.Android.cs
index bc0630ac8910..9a4e1f433ac4 100644
--- a/src/Core/src/Handlers/Image/ImageHandler.Android.cs
+++ b/src/Core/src/Handlers/Image/ImageHandler.Android.cs
@@ -1,5 +1,6 @@
 using System.Threading.Tasks;
 using Android.Graphics.Drawables;
+using Android.Views;
 using Android.Widget;
 using AndroidX.AppCompat.Widget;
 using Google.Android.Material.Button;
@@ -10,7 +11,7 @@ public partial class ImageHandler : ViewHandler<IImage, ImageView>
 	{
 		protected override ImageView CreatePlatformView()
 		{
-			var imageView = new AppCompatImageView(Context);
+			var imageView = new MauiImageView(Context);
 
 			// Enable view bounds adjustment on measure.
 			// This allows the ImageView's OnMeasure method to account for the image's intrinsic
diff --git a/src/Core/src/Handlers/Layout/LayoutHandler.Android.cs b/src/Core/src/Handlers/Layout/LayoutHandler.Android.cs
index 7a9e63b2e46e..4d63441a5a8b 100644
--- a/src/Core/src/Handlers/Layout/LayoutHandler.Android.cs
+++ b/src/Core/src/Handlers/Layout/LayoutHandler.Android.cs
@@ -153,12 +153,7 @@ public static partial void MapBackground(ILayoutHandler handler, ILayout layout)
 			handler.PlatformView?.UpdateBackground(layout);
 		}
 
-		public static partial void MapInputTransparent(ILayoutHandler handler, ILayout layout)
-		{
-			if (handler.PlatformView is LayoutViewGroup layoutViewGroup)
-			{
-				layoutViewGroup.InputTransparent = layout.InputTransparent;
-			}
-		}
+		public static partial void MapInputTransparent(ILayoutHandler handler, ILayout layout) =>
+			ViewHandler.MapInputTransparent(handler, layout);
 	}
 }
diff --git a/src/Core/src/Handlers/View/ViewHandler.cs b/src/Core/src/Handlers/View/ViewHandler.cs
index eb3ac9b6eaaf..194cd65785a6 100644
--- a/src/Core/src/Handlers/View/ViewHandler.cs
+++ b/src/Core/src/Handlers/View/ViewHandler.cs
@@ -127,7 +127,7 @@ public bool HasContainer
 		/// </summary>
 		public virtual bool NeedsContainer
 		{
-			get => VirtualView.NeedsContainer();
+			get => VirtualView.NeedsContainer(this);
 		}
 
 		/// <summary>
@@ -416,7 +416,7 @@ public static void MapContainerView(IViewHandler handler, IView view)
 			if (handler is ViewHandler viewHandler)
 				handler.HasContainer = viewHandler.NeedsContainer;
 			else
-				handler.HasContainer = view.NeedsContainer();
+				handler.HasContainer = view.NeedsContainer(handler);
 		}
 
 		/// <summary>
@@ -481,20 +481,14 @@ public static void MapInputTransparent(IViewHandler handler, IView view)
 		{
 #if ANDROID
 			handler.UpdateValue(nameof(IViewHandler.ContainerView));
+#endif
 
-			if (handler.ContainerView is WrapperView wrapper)
-				wrapper.InputTransparent = view.InputTransparent;
-#else
-
-#if IOS || MACCATALYST
-			// Containers on iOS/Mac Catalyst may be hit testable, so we need to
+			// Containers may also need to be hit testable, so we need to
 			// propagate the the view's values to its container view.
 			if (handler.ContainerView is WrapperView wrapper)
 				wrapper.UpdateInputTransparent(handler, view);
-#endif
 
 			((PlatformView?)handler.PlatformView)?.UpdateInputTransparent(handler, view);
-#endif
 		}
 
 		/// <summary>
diff --git a/src/Core/src/Platform/Android/LayoutViewGroup.cs b/src/Core/src/Platform/Android/LayoutViewGroup.cs
index 6b4f40dad1d2..2fef53e5eb08 100644
--- a/src/Core/src/Platform/Android/LayoutViewGroup.cs
+++ b/src/Core/src/Platform/Android/LayoutViewGroup.cs
@@ -11,7 +11,7 @@
 
 namespace Microsoft.Maui.Platform
 {
-	public class LayoutViewGroup : ViewGroup, ICrossPlatformLayoutBacking, IVisualTreeElementProvidable
+	public class LayoutViewGroup : ViewGroup, ICrossPlatformLayoutBacking, IVisualTreeElementProvidable, ITouchInterceptingView, IInputTransparentCapable
 	{
 		readonly ARect _clipRect = new();
 		readonly Context _context;
@@ -122,16 +122,25 @@ protected override void OnLayout(bool changed, int l, int t, int r, int b)
 			}
 		}
 
-		public override bool OnTouchEvent(MotionEvent? e)
-		{
-			if (InputTransparent)
-			{
-				return false;
-			}
+		WeakReference<IOnTouchListener>? _touchListener;
 
-			return base.OnTouchEvent(e);
+		public override void SetOnTouchListener(IOnTouchListener? l)
+		{
+			_touchListener = l is null ? null : new(l);
+			base.SetOnTouchListener(l);
 		}
 
+		bool ITouchInterceptingView.TouchEventNotReallyHandled { get; set; }
+
+		public override bool OnTouchEvent(MotionEvent? e) =>
+			base.OnTouchEvent(e) ||
+			TouchEventInterceptor.OnTouchEvent(this, e);
+
+		public override bool DispatchTouchEvent(MotionEvent? e) =>
+			TouchEventInterceptor.DispatchingTouchEvent(this, e) &&
+			base.DispatchTouchEvent(e) &&
+			TouchEventInterceptor.DispatchedTouchEvent(this, e, _touchListener?.GetTargetOrDefault());
+
 		IVisualTreeElement? IVisualTreeElementProvidable.GetElement()
 		{
 			if (CrossPlatformLayout is IVisualTreeElement layoutElement &&
diff --git a/src/Core/src/Platform/Android/MauiImageView.cs b/src/Core/src/Platform/Android/MauiImageView.cs
new file mode 100644
index 000000000000..45e0a08264e5
--- /dev/null
+++ b/src/Core/src/Platform/Android/MauiImageView.cs
@@ -0,0 +1,19 @@
+using Android.Content;
+using Android.Views;
+using AndroidX.AppCompat.Widget;
+
+namespace Microsoft.Maui.Platform
+{
+	class MauiImageView : AppCompatImageView, IInputTransparentCapable
+	{
+		public MauiImageView(Context context) : base(context)
+		{
+		}
+
+		bool IInputTransparentCapable.InputTransparent { get; set; }
+
+		public override bool OnTouchEvent(MotionEvent? e) =>
+			base.OnTouchEvent(e) ||
+			TouchEventInterceptor.OnTouchEvent(this, e);
+	}
+}
diff --git a/src/Core/src/Platform/Android/MauiTextView.cs b/src/Core/src/Platform/Android/MauiTextView.cs
index d23830f3eb1b..a70cefde4389 100644
--- a/src/Core/src/Platform/Android/MauiTextView.cs
+++ b/src/Core/src/Platform/Android/MauiTextView.cs
@@ -1,15 +1,18 @@
 using System;
 using Android.Content;
+using Android.Views;
 using AndroidX.AppCompat.Widget;
 
 namespace Microsoft.Maui.Platform
 {
-	public class MauiTextView : AppCompatTextView
+	public class MauiTextView : AppCompatTextView, IInputTransparentCapable
 	{
 		public MauiTextView(Context context) : base(context)
 		{
 		}
 
+		bool IInputTransparentCapable.InputTransparent { get; set; }
+
 		internal event EventHandler<LayoutChangedEventArgs>? LayoutChanged;
 
 		protected override void OnLayout(bool changed, int l, int t, int r, int b)
@@ -18,6 +21,10 @@ protected override void OnLayout(bool changed, int l, int t, int r, int b)
 
 			LayoutChanged?.Invoke(this, new LayoutChangedEventArgs(l, t, r, b));
 		}
+
+		public override bool OnTouchEvent(MotionEvent? e) =>
+			base.OnTouchEvent(e) ||
+			TouchEventInterceptor.OnTouchEvent(this, e);
 	}
 
 	public class LayoutChangedEventArgs : EventArgs
diff --git a/src/Core/src/Platform/Android/TouchEventInterceptor.cs b/src/Core/src/Platform/Android/TouchEventInterceptor.cs
new file mode 100644
index 000000000000..394a2aba76d5
--- /dev/null
+++ b/src/Core/src/Platform/Android/TouchEventInterceptor.cs
@@ -0,0 +1,208 @@
+using System;
+using Android.Views;
+
+namespace Microsoft.Maui.Platform
+{
+	/// <summary>
+	/// A helper class to correctly intercept touches if a view is overlapping another view.
+	/// </summary>
+	/// 
+	/// <remarks>
+	/// Normally dispatchTouchEvent feeds the touch events to its children one at a time, top child
+	/// first, (and only to the children in the hit-test area of the event) stopping as soon as one
+	/// of them has handled the event.
+	/// 
+	/// But to be consistent across the platforms, we don't want this behavior; if an element is not
+	/// input transparent we don't want an event to "pass through it" and be handled by an element
+	/// "behind/under" it. We just want the processing to end after the first non-transparent child,
+	/// regardless of whether the event has been handled.
+	///
+	/// This is only an issue for a couple of controls; the interactive controls (switch, button,
+	/// slider, etc) already "handle" their touches and the events don't propagate to other child
+	/// controls. But for image, label, and box that doesn't happen. We can't have those controls lie
+	/// about their events being handled because then the events won't propagate to *parent* controls
+	/// (e.g., a frame with a label in it would never get a tap gesture from the label). In other
+	/// words, we *want* parent propagation, but *do not want* sibling propagation. So we need to
+	/// short-circuit base.DispatchTouchEvent here, but still return "false".
+	///
+	/// Duplicating the logic of ViewGroup.dispatchTouchEvent and modifying it slightly for our
+	/// purposes is a non-starter; the method is too complex and does a lot of micro-optimization.
+	/// Instead, we provide a signalling mechanism for the controls which don't already "handle" touch
+	/// events to tell us that they will be lying about handling their event; they then return "true"
+	/// to short-circuit base.DispatchTouchEvent.
+	///
+	/// The container gets this message and after it gets the "handled" result from dispatchTouchEvent, 
+	/// it then knows to ignore that result and return false/unhandled. This allows the event to
+	/// propagate up the tree.
+	/// </remarks>
+	static class TouchEventInterceptor
+	{
+		/// <summary>
+		/// Determine if the view needs to be wrapped in order to correctly handle
+		/// touch interception for input transparency.
+		/// </summary>
+		/// <param name="view">The cross-platform view that is being processed.</param>
+		/// <param name="handler">The view handler of the view.</param>
+		/// <returns>
+		/// Returns true if the view needs to be wrapped, false if the view
+		/// already supports input transparency to9uch interception.
+		/// </returns>
+		public static bool NeedsContainer(IView view, IViewHandler handler)
+		{
+			// layouts already handle input transparency correctly
+			if (view is ILayout)
+				return false;
+
+			// INTERACTIVE views (eg: buttons and entries) that are input
+			// transparent need to be wrapped so we can intercept touches and
+			// do a pass-through to the control below it.
+			// 
+			// However, for views that indicate that they can do this themselves,
+			// we can skip the wrapper.
+			// 
+			// Most views are interactive, so this code works for most cases,
+			// but we do need to have special cases for NON-interactive views.
+			// Some examples are: labels and images. For these cases we have two
+			// options:
+			//  1. Wrap
+			//      - Return true in the ViewHandler.NeedsContainer property for
+			//        that particular handler.
+			//      - This will add another level of nesting in the UI which is
+			//        bad for perf, but may be simplest.
+			//  2. Inherit and Implement
+			//      - Create a MauiXxx type and inherit from the platform type.
+			//      - Implement IInputTransparentCapable interface.
+			//      - Override the OnTouchEvent method and ensure at least:
+			//          public override bool OnTouchEvent(MotionEvent? e) =>
+			//            base.OnTouchEvent(e) ||
+			//            TouchEventInterceptor.OnTouchEvent(this, e);
+			//      - This reduces UI nesting, but potentially adds new types to
+			//        maintain.
+			if (view.InputTransparent && handler.PlatformView is not IInputTransparentCapable)
+				return true;
+
+			return false;
+		}
+		/// <summary>
+		/// This method should be called by any view that will "intercept" the touches.
+		/// </summary>
+		/// <param name="platformView">The view that is receiving the touch event.</param>
+		/// <param name="e">The touch event.</param>
+		/// <returns>Returns true if the touch was "handled", false if the view does not want to do anything.</returns>
+		public static bool OnTouchEvent(View? platformView, MotionEvent? e)
+		{
+			if (platformView is null || !platformView.IsAlive())
+				return false;
+
+			if (e is null || e.Action == MotionEventActions.Cancel)
+				return false;
+
+			var touchIntercepting = platformView.Parent as ITouchInterceptingView;
+			if (touchIntercepting is null || ShouldPassThroughElement(platformView))
+				return false;
+
+			// Let the container know that we are "fake" handling this event.
+			touchIntercepting.TouchEventNotReallyHandled = true;
+			return true;
+		}
+
+		/// <summary>
+		/// This method should only be called before base.DispatchTouchEvent()
+		/// and by the view that handles the interception logic.
+		/// </summary>
+		/// <param name="platformView">The view that is receiving the touch event.</param>
+		/// <param name="e">The touch event.</param>
+		public static bool DispatchingTouchEvent<T>(T platformView, MotionEvent? e)
+			where T : View, ITouchInterceptingView
+		{
+			if (platformView is null || !platformView.IsAlive())
+				return false;
+
+			// If the view is NOT a layout but IS input transparent, then the event SHOULD pass through it
+			if (platformView is not LayoutViewGroup && platformView is WrapperView w && w.InputTransparent)
+				return false;
+
+			platformView.TouchEventNotReallyHandled = false;
+
+			// Always return true because this always happens.
+			return true;
+		}
+
+		/// <summary>
+		/// This method should only be called after base.DispatchTouchEvent()
+		/// and by the view that handles the interception logic.
+		/// </summary>
+		public static bool DispatchedTouchEvent<T>(T platformView, MotionEvent? e, View.IOnTouchListener? touchListener)
+			where T : View, ITouchInterceptingView
+		{
+			if (platformView is null || !platformView.IsAlive())
+				return false;
+
+			if (platformView.TouchEventNotReallyHandled)
+			{
+				// If the child control returned true from its touch event handler but signalled that it was a fake "true", then we
+				// don't consider the event truly "handled" yet.
+				//
+				// Since a child control short-circuited the normal dispatchTouchEvent stuff, this layout never got the chance for
+				// IOnTouchListener.OnTouch and the OnTouchEvent override to try handling the touches; we'll do that now.
+				//
+				// Any associated Touch Listeners are called from DispatchTouchEvents if all children of this view return false
+				// So here we are simulating both calls that would have typically been called from inside DispatchTouchEvent
+				// but were not called due to the fake "true".
+
+				var result = touchListener?.OnTouch(platformView, e) ?? false;
+				return result || platformView.OnTouchEvent(e);
+			}
+
+			return true;
+		}
+
+		static bool ShouldPassThroughElement(View platformView)
+		{
+			// Check if the view is a layout
+			if (platformView is LayoutViewGroup lvg)
+			{
+				// If the layout is NOT input transparent, then the event should NOT pass through it
+				if (!lvg.InputTransparent)
+					return false;
+
+				// If the event is being bubbled up from a child which is NOT input transparent,
+				// we do NOT want it to be passed through (just up the tree)
+				if (platformView is ITouchInterceptingView tiv && tiv.TouchEventNotReallyHandled)
+					return false;
+
+				// This event is NOT being bubbled up by a child layout that is NOT InputTransparent
+				return true;
+			}
+
+			// Check if the view is a control/wrapper of a control
+			if (platformView is IInputTransparentCapable itc)
+			{
+				// If the view is NOT a layout but IS input transparent, then the event SHOULD pass through it
+				if (itc.InputTransparent)
+					return true;
+			}
+
+			return false;
+		}
+	}
+
+	/// <summary>
+	/// This interface is implemented by various container views that are
+	/// listening for taps on their children.
+	/// </summary>
+	interface ITouchInterceptingView
+	{
+		bool TouchEventNotReallyHandled { get; set; }
+	}
+
+	/// <summary>
+	/// This interface is implemented by various views that with to indicate
+	/// that they can correctly handle input transparency touch input and do not
+	/// need to be wrapped.
+	/// </summary>
+	interface IInputTransparentCapable
+	{
+		bool InputTransparent { get; set; }
+	}
+}
diff --git a/src/Core/src/Platform/Android/ViewExtensions.cs b/src/Core/src/Platform/Android/ViewExtensions.cs
index da702477f4d8..50b6be4e7734 100644
--- a/src/Core/src/Platform/Android/ViewExtensions.cs
+++ b/src/Core/src/Platform/Android/ViewExtensions.cs
@@ -118,12 +118,19 @@ public static void UpdateShadow(this AView platformView, IView view)
 			if (platformView is WrapperView wrapper)
 				wrapper.Shadow = view.Shadow;
 		}
+
 		public static void UpdateBorder(this AView platformView, IView view)
 		{
 			if (platformView is WrapperView wrapper)
 				wrapper.Border = (view as IBorder)?.Border;
 		}
 
+		public static void UpdateInputTransparent(this AView platformView, IViewHandler handler, IView view)
+		{
+			if (platformView is IInputTransparentCapable itc)
+				itc.InputTransparent = view.InputTransparent;
+		}
+
 		public static ViewStates ToPlatformVisibility(this Visibility visibility)
 		{
 			return visibility switch
diff --git a/src/Core/src/Platform/Android/WrapperView.cs b/src/Core/src/Platform/Android/WrapperView.cs
index c15495bef315..be47b8a24c2e 100644
--- a/src/Core/src/Platform/Android/WrapperView.cs
+++ b/src/Core/src/Platform/Android/WrapperView.cs
@@ -10,7 +10,7 @@
 
 namespace Microsoft.Maui.Platform
 {
-	public partial class WrapperView : PlatformWrapperView
+	public partial class WrapperView : PlatformWrapperView, ITouchInterceptingView, IInputTransparentCapable
 	{
 		const int MaximumRadius = 100;
 
@@ -25,6 +25,10 @@ public partial class WrapperView : PlatformWrapperView
 
 		AView _borderView;
 
+		IOnTouchListener _touchListener;
+
+		bool ITouchInterceptingView.TouchEventNotReallyHandled { get; set; }
+
 		public bool InputTransparent { get; set; }
 
 		public WrapperView(Context context)
@@ -68,14 +72,19 @@ public override void RequestLayout()
 			base.RequestLayout();
 		}
 
-		public override bool DispatchTouchEvent(MotionEvent e)
-		{
-			if (InputTransparent)
-			{
-				return false;
-			}
+		public override bool OnTouchEvent(MotionEvent e) =>
+			base.OnTouchEvent(e) ||
+			TouchEventInterceptor.OnTouchEvent(this, e);
+
+		public override bool DispatchTouchEvent(MotionEvent e) =>
+			TouchEventInterceptor.DispatchingTouchEvent(this, e) &&
+			base.DispatchTouchEvent(e) &&
+			TouchEventInterceptor.DispatchedTouchEvent(this, e, _touchListener);
 
-			return base.DispatchTouchEvent(e);
+		public override void SetOnTouchListener(IOnTouchListener l)
+		{
+			_touchListener = l;
+			base.SetOnTouchListener(l);
 		}
 
 		partial void ClipChanged()
diff --git a/src/Core/src/Platform/Tizen/ViewExtensions.cs b/src/Core/src/Platform/Tizen/ViewExtensions.cs
index 83e917292318..c2c63ca3f912 100644
--- a/src/Core/src/Platform/Tizen/ViewExtensions.cs
+++ b/src/Core/src/Platform/Tizen/ViewExtensions.cs
@@ -333,7 +333,7 @@ internal static IDisposable OnUnloaded(this NView view, Action action)
 			return disposable;
 		}
 
-		internal static bool NeedsContainer(this IView? view)
+		internal static bool NeedsContainer(this IView? view, IViewHandler handler)
 		{
 			if (view is IBorderView border)
 				return border?.Shape != null || border?.Stroke != null;
diff --git a/src/Core/src/PublicAPI/net-android/PublicAPI.Unshipped.txt b/src/Core/src/PublicAPI/net-android/PublicAPI.Unshipped.txt
index e8b26bb171ca..cb165960c3a6 100644
--- a/src/Core/src/PublicAPI/net-android/PublicAPI.Unshipped.txt
+++ b/src/Core/src/PublicAPI/net-android/PublicAPI.Unshipped.txt
@@ -63,8 +63,11 @@ override Microsoft.Maui.Handlers.RadioButtonHandler.PlatformArrange(Microsoft.Ma
 override Microsoft.Maui.Handlers.ShapeViewHandler.GetDesiredSize(double widthConstraint, double heightConstraint) -> Microsoft.Maui.Graphics.Size
 override Microsoft.Maui.Layouts.FlexBasis.Equals(object? obj) -> bool
 override Microsoft.Maui.Layouts.FlexBasis.GetHashCode() -> int
+override Microsoft.Maui.Platform.LayoutViewGroup.DispatchTouchEvent(Android.Views.MotionEvent? e) -> bool
+override Microsoft.Maui.Platform.LayoutViewGroup.SetOnTouchListener(Android.Views.View.IOnTouchListener? l) -> void
 override Microsoft.Maui.MauiAppCompatActivity.DispatchTouchEvent(Android.Views.MotionEvent? e) -> bool
 override Microsoft.Maui.Platform.ContentViewGroup.GetClipPath(int width, int height) -> Android.Graphics.Path?
+override Microsoft.Maui.Platform.MauiTextView.OnTouchEvent(Android.Views.MotionEvent? e) -> bool
 override Microsoft.Maui.Platform.NavigationViewFragment.OnDestroy() -> void
 override Microsoft.Maui.PlatformContentViewGroup.JniPeerMembers.get -> Java.Interop.JniPeerMembers!
 override Microsoft.Maui.PlatformContentViewGroup.ThresholdClass.get -> nint
@@ -108,6 +111,7 @@ Microsoft.Maui.IWebView.UserAgent.set -> void
 static Microsoft.Maui.Handlers.WebViewHandler.MapUserAgent(Microsoft.Maui.Handlers.IWebViewHandler! handler, Microsoft.Maui.IWebView! webView) -> void
 static Microsoft.Maui.Platform.ApplicationExtensions.UpdateNightMode(this Microsoft.Maui.IApplication! application) -> void
 static Microsoft.Maui.Platform.ShapeExtensions.ToPlatform(this Microsoft.Maui.Graphics.IShape! shape, Microsoft.Maui.Graphics.Rect bounds, float strokeThickness, float density, bool innerPath = false) -> Android.Graphics.Path!
+static Microsoft.Maui.Platform.ViewExtensions.UpdateInputTransparent(this Android.Views.View! platformView, Microsoft.Maui.IViewHandler! handler, Microsoft.Maui.IView! view) -> void
 static Microsoft.Maui.Platform.ViewGroupExtensions.TryGetFirstChildOfType<T>(this Android.Views.ViewGroup! viewGroup, out T? result) -> bool
 static Microsoft.Maui.Platform.WebViewExtensions.UpdateUserAgent(this Android.Webkit.WebView! platformWebView, Microsoft.Maui.IWebView! webView) -> void
 *REMOVED*Microsoft.Maui.WeakEventManager.HandleEvent(object! sender, object! args, string! eventName) -> void
@@ -118,6 +122,8 @@ static Microsoft.Maui.PropertyMapperExtensions.PrependToMapping<TVirtualView, TV
 static Microsoft.Maui.PropertyMapperExtensions.ReplaceMapping<TVirtualView, TViewHandler>(this Microsoft.Maui.IPropertyMapper<Microsoft.Maui.IElement!, Microsoft.Maui.IElementHandler!>! propertyMapper, string! key, System.Action<TViewHandler, TVirtualView>! method) -> void
 static Microsoft.Maui.SizeRequest.operator !=(Microsoft.Maui.SizeRequest left, Microsoft.Maui.SizeRequest right) -> bool
 static Microsoft.Maui.SizeRequest.operator ==(Microsoft.Maui.SizeRequest left, Microsoft.Maui.SizeRequest right) -> bool
+~override Microsoft.Maui.Platform.WrapperView.OnTouchEvent(Android.Views.MotionEvent e) -> bool
+~override Microsoft.Maui.Platform.WrapperView.SetOnTouchListener(Android.Views.View.IOnTouchListener l) -> void
 *REMOVED*override Microsoft.Maui.Handlers.ViewHandler.SetVirtualView(Microsoft.Maui.IElement! element) -> void
 override Microsoft.Maui.Platform.WrapperView.Visibility.get -> Android.Views.ViewStates
 override Microsoft.Maui.Platform.WrapperView.Visibility.set -> void
diff --git a/src/Core/src/ViewExtensions.cs b/src/Core/src/ViewExtensions.cs
index 75cc700f25f7..9d1b288374c3 100644
--- a/src/Core/src/ViewExtensions.cs
+++ b/src/Core/src/ViewExtensions.cs
@@ -49,13 +49,16 @@ public static partial class ViewExtensions
 #endif
 
 #if !TIZEN
-		internal static bool NeedsContainer(this IView? view)
+		internal static bool NeedsContainer(this IView? view, IViewHandler handler)
 		{
-			if (view?.Clip != null || view?.Shadow != null)
+			if (view is null)
+				return false;
+
+			if (view.Clip is not null || view.Shadow is not null)
 				return true;
 
 #if ANDROID
-			if (view?.InputTransparent == true)
+			if (TouchEventInterceptor.NeedsContainer(view, handler))
 				return true;
 #endif
 
@@ -64,11 +67,10 @@ internal static bool NeedsContainer(this IView? view)
 				return true;
 #elif WINDOWS
 			if (view is IBorderView border)
-				return border?.Shape != null || border?.Stroke != null;
+				return border.Shape is not null || border.Stroke is not null;
 #endif
 			return false;
 		}
 #endif
-
 	}
 }
diff --git a/src/Core/tests/DeviceTests.Shared/HandlerTests/HandlerTestBaseOfT.Android.cs b/src/Core/tests/DeviceTests.Shared/HandlerTests/HandlerTestBaseOfT.Android.cs
index 952ec19ac0de..3d9465006c3a 100644
--- a/src/Core/tests/DeviceTests.Shared/HandlerTests/HandlerTestBaseOfT.Android.cs
+++ b/src/Core/tests/DeviceTests.Shared/HandlerTests/HandlerTestBaseOfT.Android.cs
@@ -164,7 +164,9 @@ public async Task NeedsContainerWhenInputTransparent()
 
 			var handler = await CreateHandlerAsync(view);
 
-			if (handler is ViewHandler vh)
+			if (handler is LayoutHandler lh)
+				Assert.False(lh.NeedsContainer);
+			else if (handler is ViewHandler vh)
 				Assert.True(vh.NeedsContainer);
 		}
 	}