diff --git a/src/Controls/samples/Controls.Sample.Embedding/Platforms/Android/FirstFragment.cs b/src/Controls/samples/Controls.Sample.Embedding/Platforms/Android/FirstFragment.cs
index 33c949447ada..ad03de135b6a 100644
--- a/src/Controls/samples/Controls.Sample.Embedding/Platforms/Android/FirstFragment.cs
+++ b/src/Controls/samples/Controls.Sample.Embedding/Platforms/Android/FirstFragment.cs
@@ -11,6 +11,10 @@ namespace Maui.Controls.Sample.Droid;
 [Register("com.microsoft.maui.sample.emdedding." + nameof(FirstFragment))]
 public class FirstFragment : Fragment
 {
+	EmbeddingScenarios.IScenario? _scenario;
+	MyMauiContent? _mauiView;
+	Android.Views.View? _nativeView;
+
 	public override View? OnCreateView(LayoutInflater inflater, ViewGroup? container, Bundle? savedInstanceState) =>
 		inflater.Inflate(Resource.Layout.fragment_first, container, false);
 
@@ -26,14 +30,43 @@ public override void OnViewCreated(View view, Bundle? savedInstanceState)
 
 		var button3 = view.FindViewById<Button>(Resource.Id.button3)!;
 		button3.Click += OnMagicClicked;
+
+		// Uncomment the scenario to test:
+		//_scenario = new EmbeddingScenarios.Scenario1_Basic();
+		//_scenario = new EmbeddingScenarios.Scenario2_Scoped();
+		_scenario = new EmbeddingScenarios.Scenario3_Correct();
+
+		// Create the view and (maybe) the window
+		(_mauiView, _nativeView) = _scenario!.Embed(Activity!);
+
+		// Add the new view to the UI
+		var rootLayout = view.FindViewById<LinearLayout>(Resource.Id.layout_first)!;
+		rootLayout.AddView(_nativeView, 1, new LinearLayout.LayoutParams(MatchParent, WrapContent));
 	}
 
 	public override void OnDestroyView()
 	{
 		base.OnDestroyView();
+
+		// Remove the view from the UI
+		var rootLayout = View!.FindViewById<LinearLayout>(Resource.Id.layout_first)!;
+		rootLayout.RemoveView(_nativeView);
+
+		// If we used a window, then clean that up
+		if (_mauiView?.Window is IWindow window)
+			window.Destroying();
+
+		base.OnStop();
 	}
 
-	private void OnMagicClicked(object? sender, EventArgs e)
+	private async void OnMagicClicked(object? sender, EventArgs e)
 	{
+		if (_mauiView?.DotNetBot is not Image bot)
+			return;
+
+		await bot.RotateTo(360, 1000);
+		bot.Rotation = 0;
+
+		bot.HeightRequest = 90;
 	}
 }
diff --git a/src/Controls/samples/Controls.Sample.Embedding/Platforms/Android/SettingsFragment.cs b/src/Controls/samples/Controls.Sample.Embedding/Platforms/Android/SettingsFragment.cs
index 5360540cc53c..14caa5de1d61 100644
--- a/src/Controls/samples/Controls.Sample.Embedding/Platforms/Android/SettingsFragment.cs
+++ b/src/Controls/samples/Controls.Sample.Embedding/Platforms/Android/SettingsFragment.cs
@@ -11,6 +11,10 @@ namespace Maui.Controls.Sample.Droid;
 [Register("com.microsoft.maui.sample.emdedding." + nameof(SettingsFragment))]
 public class SettingsFragment : Fragment
 {
+	EmbeddingScenarios.IScenario? _scenario;
+	MyMauiContent? _mauiView;
+	Android.Views.View? _nativeView;
+
 	public override View? OnCreateView(LayoutInflater inflater, ViewGroup? container, Bundle? savedInstanceState) =>
 		inflater.Inflate(Resource.Layout.fragment_settings, container, false);
 
@@ -26,14 +30,43 @@ public override void OnViewCreated(View view, Bundle? savedInstanceState)
 
 		var button3 = view.FindViewById<Button>(Resource.Id.button3)!;
 		button3.Click += OnMagicClicked;
+
+		// Uncomment the scenario to test:
+		//_scenario = new EmbeddingScenarios.Scenario1_Basic();
+		//_scenario = new EmbeddingScenarios.Scenario2_Scoped();
+		_scenario = new EmbeddingScenarios.Scenario3_Correct();
+
+		// Create the view and (maybe) the window
+		(_mauiView, _nativeView) = _scenario!.Embed(Activity!);
+
+		// Add the new view to the UI
+		var rootLayout = view.FindViewById<LinearLayout>(Resource.Id.layout_settings)!;
+		rootLayout.AddView(_nativeView, 1, new LinearLayout.LayoutParams(MatchParent, WrapContent));
 	}
 
 	public override void OnDestroyView()
 	{
 		base.OnDestroyView();
+
+		// Remove the view from the UI
+		var rootLayout = View!.FindViewById<LinearLayout>(Resource.Id.layout_settings)!;
+		rootLayout.RemoveView(_nativeView);
+
+		// If we used a window, then clean that up
+		if (_mauiView?.Window is IWindow window)
+			window.Destroying();
+
+		base.OnStop();
 	}
 
-	private void OnMagicClicked(object? sender, EventArgs e)
+	private async void OnMagicClicked(object? sender, EventArgs e)
 	{
+		if (_mauiView?.DotNetBot is not Image bot)
+			return;
+
+		await bot.RotateTo(360, 1000);
+		bot.Rotation = 0;
+
+		bot.HeightRequest = 90;
 	}
 }
diff --git a/src/Controls/samples/Controls.Sample.Embedding/Platforms/MacCatalyst/MainViewController.cs b/src/Controls/samples/Controls.Sample.Embedding/Platforms/MacCatalyst/MainViewController.cs
index 559aaa840a01..fff7a9832eb9 100644
--- a/src/Controls/samples/Controls.Sample.Embedding/Platforms/MacCatalyst/MainViewController.cs
+++ b/src/Controls/samples/Controls.Sample.Embedding/Platforms/MacCatalyst/MainViewController.cs
@@ -2,6 +2,10 @@
 
 public class MainViewController : UIViewController
 {
+	EmbeddingScenarios.IScenario? _scenario;
+	MyMauiContent? _mauiView;
+	UIView? _nativeView;
+
 	public override void ViewDidLoad()
 	{
 		base.ViewDidLoad();
@@ -34,7 +38,16 @@ public override void ViewDidLoad()
 		firstButton.SetTitle("UIKit Button Above MAUI", UIControlState.Normal);
 		stackView.AddArrangedSubview(firstButton);
 
-		// TODO: The MAUI content will go here.
+		// Uncomment the scenario to test:
+		//_scenario = new EmbeddingScenarios.Scenario1_Basic();
+		//_scenario = new EmbeddingScenarios.Scenario2_Scoped();
+		_scenario = new EmbeddingScenarios.Scenario3_Correct();
+
+		// create the view and (maybe) the window
+		(_mauiView, _nativeView) = _scenario.Embed(ParentViewController!.View!.Window);
+
+		// add the new view to the UI
+		stackView.AddArrangedSubview(new ContainerView(_nativeView));
 
 		// Create UIKit button
 		var secondButton = new UIButton(UIButtonType.System);
@@ -44,11 +57,23 @@ public override void ViewDidLoad()
 		// Create UIKit button
 		var thirdButton = new UIButton(UIButtonType.System);
 		thirdButton.SetTitle("UIKit Button Magic", UIControlState.Normal);
+		thirdButton.TouchUpInside += OnMagicClicked;
 		stackView.AddArrangedSubview(thirdButton);
 
 		AddNavBarButtons();
 	}
 
+	private async void OnMagicClicked(object? sender, EventArgs e)
+	{
+		if (_mauiView?.DotNetBot is not Image bot)
+			return;
+
+		await bot.RotateTo(360, 1000);
+		bot.Rotation = 0;
+
+		bot.HeightRequest = 90;
+	}
+
 	private void AddNavBarButtons()
 	{
 		var addNewWindowButton = new UIBarButtonItem(
@@ -87,4 +112,33 @@ private void RequestSession(string? activityType = null)
 			});
 		}
 	}
+
+	// UIStackView uses IntrinsicContentSize instead of SizeThatFits
+	// so we need to create a container view to wrap the Maui view and
+	// redirect the IntrinsicContentSize to the Maui view's SizeThatFits.
+	class ContainerView : UIView
+	{
+		public ContainerView(UIView view)
+		{
+			AddSubview(view);
+		}
+
+		public override CGSize IntrinsicContentSize =>
+			SizeThatFits(new CGSize(nfloat.MaxValue, nfloat.MaxValue));
+
+		public override void LayoutSubviews()
+		{
+			if (Subviews?.FirstOrDefault() is {} view)
+				view.Frame = Bounds;
+		}
+
+		public override void SetNeedsLayout()
+		{
+			base.SetNeedsLayout();
+			InvalidateIntrinsicContentSize();
+		}
+
+		public override CGSize SizeThatFits(CGSize size) =>
+			Subviews?.FirstOrDefault()?.SizeThatFits(size) ?? CGSize.Empty;
+	}
 }
diff --git a/src/Controls/samples/Controls.Sample.Embedding/Platforms/Windows/MainWindow.xaml.cs b/src/Controls/samples/Controls.Sample.Embedding/Platforms/Windows/MainWindow.xaml.cs
index 626578938626..d1a297ef58f0 100644
--- a/src/Controls/samples/Controls.Sample.Embedding/Platforms/Windows/MainWindow.xaml.cs
+++ b/src/Controls/samples/Controls.Sample.Embedding/Platforms/Windows/MainWindow.xaml.cs
@@ -4,21 +4,54 @@ namespace Maui.Controls.Sample.WinUI;
 
 public sealed partial class MainWindow : Microsoft.UI.Xaml.Window
 {
+	EmbeddingScenarios.IScenario? _scenario;
+	MyMauiContent? _mauiView;
+	FrameworkElement? _nativeView;
+
 	public MainWindow()
 	{
 		InitializeComponent();
 	}
 
-	private void OnRootLayoutLoaded(object? sender, RoutedEventArgs e)
+	private async void OnRootLayoutLoaded(object? sender, RoutedEventArgs e)
 	{
+		// Sometimes Loaded fires twice...
+		if (_nativeView is not null)
+			return;
+
+		await Task.Yield();
+
+		// Uncomment the scenario to test:
+		//_scenario = new EmbeddingScenarios.Scenario1_Basic();
+		//_scenario = new EmbeddingScenarios.Scenario2_Scoped();
+		_scenario = new EmbeddingScenarios.Scenario3_Correct();
+
+		// create the view and (maybe) the window
+		(_mauiView, _nativeView) = _scenario.Embed(this);
+
+		// add the new view to the UI
+		RootLayout.Children.Insert(1, _nativeView);
 	}
 
 	private void OnWindowClosed(object? sender, WindowEventArgs args)
 	{
+		// Remove the view from the UI
+		RootLayout.Children.Remove(_nativeView);
+
+		// If we used a window, then clean that up
+		if (_mauiView?.Window is IWindow window)
+			window.Destroying();
 	}
 
-	private void OnMagicClicked(object? sender, RoutedEventArgs e)
+	private async void OnMagicClicked(object? sender, RoutedEventArgs e)
 	{
+		if (_mauiView?.DotNetBot is not Image bot)
+			return;
+
+		await bot.RotateTo(360, 1000);
+		bot.Rotation = 0;
+
+		bot.HeightRequest = 90;
 	}
 
 	private void OnNewWindowClicked(object? sender, RoutedEventArgs e)
diff --git a/src/Controls/samples/Controls.Sample.Embedding/Platforms/iOS/MainViewController.cs b/src/Controls/samples/Controls.Sample.Embedding/Platforms/iOS/MainViewController.cs
index 6ea74d6747b4..290a1263bfa2 100644
--- a/src/Controls/samples/Controls.Sample.Embedding/Platforms/iOS/MainViewController.cs
+++ b/src/Controls/samples/Controls.Sample.Embedding/Platforms/iOS/MainViewController.cs
@@ -2,6 +2,10 @@
 
 public class MainViewController : UIViewController
 {
+	EmbeddingScenarios.IScenario? _scenario;
+	MyMauiContent? _mauiView;
+	UIView? _nativeView;
+
 	public override void ViewDidLoad()
 	{
 		base.ViewDidLoad();
@@ -34,7 +38,16 @@ public override void ViewDidLoad()
 		firstButton.SetTitle("UIKit Button Above MAUI", UIControlState.Normal);
 		stackView.AddArrangedSubview(firstButton);
 
-		// TODO: The MAUI content will go here.
+		// Uncomment the scenario to test:
+		// _scenario = new EmbeddingScenarios.Scenario1_Basic();
+		//_scenario = new EmbeddingScenarios.Scenario2_Scoped();
+		_scenario = new EmbeddingScenarios.Scenario3_Correct();
+
+		// create the view and (maybe) the window
+		(_mauiView, _nativeView) = _scenario.Embed(ParentViewController!.View!.Window);
+
+		// add the new view to the UI
+		stackView.AddArrangedSubview(new ContainerView(_nativeView));
 
 		// Create UIKit button
 		var secondButton = new UIButton(UIButtonType.System);
@@ -44,12 +57,24 @@ public override void ViewDidLoad()
 		// Create UIKit button
 		var thirdButton = new UIButton(UIButtonType.System);
 		thirdButton.SetTitle("UIKit Button Magic", UIControlState.Normal);
+		thirdButton.TouchUpInside += OnMagicClicked;
 		stackView.AddArrangedSubview(thirdButton);
 
 		if (UIDevice.CurrentDevice.UserInterfaceIdiom == UIUserInterfaceIdiom.Pad)
 			AddNavBarButtons();
 	}
 
+	private async void OnMagicClicked(object? sender, EventArgs e)
+	{
+		if (_mauiView?.DotNetBot is not Image bot)
+			return;
+
+		await bot.RotateTo(360, 1000);
+		bot.Rotation = 0;
+
+		bot.HeightRequest = 90;
+	}
+
 	private void AddNavBarButtons()
 	{
 		var addNewWindowButton = new UIBarButtonItem(
@@ -88,4 +113,33 @@ private void RequestSession(string? activityType = null)
 			});
 		}
 	}
+
+	// UIStackView uses IntrinsicContentSize instead of SizeThatFits
+	// so we need to create a container view to wrap the Maui view and
+	// redirect the IntrinsicContentSize to the Maui view's SizeThatFits.
+	class ContainerView : UIView
+	{
+		public ContainerView(UIView view)
+		{
+			AddSubview(view);
+		}
+
+		public override CGSize IntrinsicContentSize =>
+			SizeThatFits(new CGSize(nfloat.MaxValue, nfloat.MaxValue));
+
+		public override void LayoutSubviews()
+		{
+			if (Subviews?.FirstOrDefault() is {} view)
+				view.Frame = Bounds;
+		}
+
+		public override void SetNeedsLayout()
+		{
+			base.SetNeedsLayout();
+			InvalidateIntrinsicContentSize();
+		}
+
+		public override CGSize SizeThatFits(CGSize size) =>
+			Subviews?.FirstOrDefault()?.SizeThatFits(size) ?? CGSize.Empty;
+	}
 }
diff --git a/src/Controls/samples/Controls.Sample.Embedding/Shared/EmbeddingScenarios.cs b/src/Controls/samples/Controls.Sample.Embedding/Shared/EmbeddingScenarios.cs
new file mode 100644
index 000000000000..247e071044c7
--- /dev/null
+++ b/src/Controls/samples/Controls.Sample.Embedding/Shared/EmbeddingScenarios.cs
@@ -0,0 +1,76 @@
+using Microsoft.Maui.Platform;
+using Microsoft.Maui.Controls.Embedding;
+
+#if ANDROID
+using PlatformView = Android.Views.View;
+using PlatformWindow = Android.App.Activity;
+#elif IOS || MACCATALYST
+using PlatformView = UIKit.UIView;
+using PlatformWindow = UIKit.UIWindow;
+#elif WINDOWS
+using PlatformView = Microsoft.UI.Xaml.FrameworkElement;
+using PlatformWindow = Microsoft.UI.Xaml.Window;
+#endif
+
+namespace Maui.Controls.Sample;
+
+class EmbeddingScenarios
+{
+	public interface IScenario
+	{
+		(MyMauiContent, PlatformView) Embed(PlatformWindow window);
+	}
+
+	public class Scenario1_Basic : IScenario
+	{
+		public (MyMauiContent, PlatformView) Embed(PlatformWindow window)
+		{
+			var mauiApp = MauiProgram.CreateMauiApp();
+#if ANDROID
+			var mauiContext = new MauiContext(mauiApp.Services, window);
+#else
+			var mauiContext = new MauiContext(mauiApp.Services);
+#endif
+			var mauiView = new MyMauiContent();
+			var nativeView = mauiView.ToPlatform(mauiContext);
+			return (mauiView, nativeView);
+		}
+	}
+
+	public class Scenario2_Scoped : IScenario
+	{
+		public (MyMauiContent, PlatformView) Embed(PlatformWindow window)
+		{
+			var mauiApp = MauiProgram.CreateMauiApp();
+			var mauiView = new MyMauiContent();
+			var nativeView = mauiView.ToPlatformEmbedded(mauiApp, window);
+			return (mauiView, nativeView);
+		}
+	}
+
+	public class Scenario3_Correct : IScenario
+	{
+		public static class MyEmbeddedMauiApp
+		{
+			static MauiApp? _shared;
+
+			public static MauiApp Shared => _shared ??= MauiProgram.CreateMauiApp();
+		}
+
+		PlatformWindow? _window;
+		IMauiContext? _windowContext;
+
+		public IMauiContext WindowContext =>
+			_windowContext ??= MyEmbeddedMauiApp.Shared.CreateEmbeddedWindowContext(_window ?? throw new InvalidOperationException());
+
+		public (MyMauiContent, PlatformView) Embed(PlatformWindow window)
+		{
+			_window ??= window;
+
+			var context = WindowContext;
+			var mauiView = new MyMauiContent();
+			var nativeView = mauiView.ToPlatformEmbedded(context);
+			return (mauiView, nativeView);
+		}
+	}
+}
diff --git a/src/Controls/samples/Controls.Sample.Embedding/Shared/MauiProgram.cs b/src/Controls/samples/Controls.Sample.Embedding/Shared/MauiProgram.cs
index 0d5c586f0080..100f5c7848eb 100644
--- a/src/Controls/samples/Controls.Sample.Embedding/Shared/MauiProgram.cs
+++ b/src/Controls/samples/Controls.Sample.Embedding/Shared/MauiProgram.cs
@@ -1,4 +1,5 @@
 using Microsoft.Extensions.Logging;
+using Microsoft.Maui.Controls.Embedding;
 
 namespace Maui.Controls.Sample;
 
@@ -10,6 +11,7 @@ public static MauiApp CreateMauiApp()
 
 		builder
 			.UseMauiApp<App>()
+			.UseMauiEmbedding()
 			.ConfigureFonts(fonts =>
 			{
 				fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
diff --git a/src/Controls/samples/Controls.Sample.Embedding/Shared/MyMauiContent.xaml b/src/Controls/samples/Controls.Sample.Embedding/Shared/MyMauiContent.xaml
new file mode 100644
index 000000000000..236348d3426f
--- /dev/null
+++ b/src/Controls/samples/Controls.Sample.Embedding/Shared/MyMauiContent.xaml
@@ -0,0 +1,67 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<ContentView
+  xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+  xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+  x:Class="Maui.Controls.Sample.MyMauiContent">
+
+  <VerticalStackLayout
+    Padding="30,0"
+    Spacing="25">
+
+    <Image
+      x:Name="image"
+      Source="dotnet_bot.png"
+      HeightRequest="185"
+      Aspect="AspectFit"
+      SemanticProperties.Description="dot net bot in a race car number eight">
+      <Image.GestureRecognizers>
+        <TapGestureRecognizer Tapped="OnCounterClicked" />
+      </Image.GestureRecognizers>
+    </Image>
+
+    <Label
+      Text="Hello, World!"
+      Style="{StaticResource Headline}"
+      SemanticProperties.HeadingLevel="Level1">
+
+      <VisualStateManager.VisualStateGroups>
+        <VisualStateGroupList>
+          <VisualStateGroup>
+            <VisualState x:Name="Narrow">
+              <VisualState.StateTriggers>
+                <AdaptiveTrigger MinWindowWidth="0" />
+              </VisualState.StateTriggers>
+              <VisualState.Setters>
+                <Setter Property="Text" Value="Hello, Nrw World!" />
+              </VisualState.Setters>
+            </VisualState>
+            <VisualState x:Name="Wide">
+              <VisualState.StateTriggers>
+                <AdaptiveTrigger MinWindowWidth="800" />
+              </VisualState.StateTriggers>
+              <VisualState.Setters>
+                <Setter Property="Text" Value="Hello, W i d e World!" />
+              </VisualState.Setters>
+            </VisualState>
+          </VisualStateGroup>
+        </VisualStateGroupList>
+      </VisualStateManager.VisualStateGroups>
+
+    </Label>
+
+    <Label
+      Text="Welcome to &#10;.NET Multi-platform App UI"
+      Style="{StaticResource SubHeadline}"
+      SemanticProperties.HeadingLevel="Level2"
+      SemanticProperties.Description="Welcome to dot net Multi platform App U I" />
+
+    <Button
+      x:Name="CounterBtn"
+      Text="Click me"
+      SemanticProperties.Hint="Counts the number of times you click"
+      Clicked="OnCounterClicked"
+      HorizontalOptions="Fill" />
+
+  </VerticalStackLayout>
+
+</ContentView>
diff --git a/src/Controls/samples/Controls.Sample.Embedding/Shared/MyMauiContent.xaml.cs b/src/Controls/samples/Controls.Sample.Embedding/Shared/MyMauiContent.xaml.cs
new file mode 100644
index 000000000000..a83eb2cbdc75
--- /dev/null
+++ b/src/Controls/samples/Controls.Sample.Embedding/Shared/MyMauiContent.xaml.cs
@@ -0,0 +1,31 @@
+using Microsoft.Maui.Controls.Embedding;
+using Microsoft.Maui.Platform;
+
+namespace Maui.Controls.Sample;
+
+public partial class MyMauiContent
+{
+	int count = 0;
+
+	public MyMauiContent()
+	{
+		InitializeComponent();
+	}
+
+	public Image DotNetBot => image;
+
+	private async void OnCounterClicked(object sender, EventArgs e)
+	{
+		count++;
+
+		if (count == 1)
+			CounterBtn.Text = $"Clicked {count} time";
+		else
+			CounterBtn.Text = $"Clicked {count} times";
+
+		SemanticScreenReader.Announce(CounterBtn.Text);
+
+		await image.ScaleTo(1.2, 60);
+		await image.ScaleTo(1, 60);
+	}
+}
diff --git a/src/Controls/src/Core/Application/Application.cs b/src/Controls/src/Core/Application/Application.cs
index 404ec6f21398..73db0faef7e5 100644
--- a/src/Controls/src/Core/Application/Application.cs
+++ b/src/Controls/src/Core/Application/Application.cs
@@ -524,7 +524,7 @@ protected virtual Window CreateWindow(IActivationState? activationState)
 			throw new NotImplementedException($"Either set {nameof(MainPage)} or override {nameof(Application.CreateWindow)}.");
 		}
 
-		void AddWindow(Window window)
+		internal void AddWindow(Window window)
 		{
 			_windows.Add(window);
 
diff --git a/src/Controls/src/Core/Embedding/EmbeddedWindow.cs b/src/Controls/src/Core/Embedding/EmbeddedWindow.cs
new file mode 100644
index 000000000000..b0881cef6258
--- /dev/null
+++ b/src/Controls/src/Core/Embedding/EmbeddedWindow.cs
@@ -0,0 +1,17 @@
+#if ANDROID || IOS || MACCATALYST || WINDOWS
+
+namespace Microsoft.Maui.Controls.Embedding;
+
+/// <summary>
+/// An embedded window that is never used directly, but instead forms a connection between
+/// the MAUI app and the embedded MAUI content.
+/// </summary>
+class EmbeddedWindow : Window, IWindow
+{
+	/// <summary>
+	/// Always returns null because this window will never have any direct content.
+	/// </summary>
+	IView IWindow.Content => null!;
+}
+
+#endif
diff --git a/src/Controls/src/Core/Embedding/EmbeddingExtensions.cs b/src/Controls/src/Core/Embedding/EmbeddingExtensions.cs
new file mode 100644
index 000000000000..a6dfff6e0d01
--- /dev/null
+++ b/src/Controls/src/Core/Embedding/EmbeddingExtensions.cs
@@ -0,0 +1,120 @@
+#if ANDROID || IOS || MACCATALYST || WINDOWS
+using System.Linq;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Maui.Embedding;
+using Microsoft.Maui.Hosting;
+
+#if ANDROID
+using PlatformView = Android.Views.View;
+using PlatformWindow = Android.App.Activity;
+#elif IOS || MACCATALYST
+using PlatformView = UIKit.UIView;
+using PlatformWindow = UIKit.UIWindow;
+#elif WINDOWS
+using PlatformView = Microsoft.UI.Xaml.FrameworkElement;
+using PlatformWindow = Microsoft.UI.Xaml.Window;
+#endif
+
+namespace Microsoft.Maui.Controls.Embedding;
+
+#pragma warning disable RS0016 // Add public types and members to the declared API
+
+/// <summary>
+/// A set of extension methods that allow for embedding a MAUI view within a native application.
+/// </summary>
+public static class EmbeddingExtensions
+{
+	/// <summary>
+	/// Enables MAUI to be embedded in native platform application by injecting embedded handlers into the service collection.
+	/// </summary>
+	/// <param name="builder">The <see cref="MauiAppBuilder"/> instance.</param>
+	/// <returns>The <see cref="MauiAppBuilder"/> instance.</returns>
+	public static MauiAppBuilder UseMauiEmbedding(this MauiAppBuilder builder)
+	{
+#if ANDROID
+		var platformApplication = (Android.App.Application)Android.App.Application.Context;
+#elif IOS || MACCATALYST
+		var platformApplication = UIKit.UIApplication.SharedApplication.Delegate;
+#elif WINDOWS
+		var platformApplication = Microsoft.UI.Xaml.Application.Current;
+#endif
+
+		// Enable Core embedded features.
+		builder.UseMauiEmbedding(platformApplication);
+
+		// Register the embedded window handler.
+		builder.ConfigureMauiHandlers(handlers =>
+		{
+			handlers.AddHandler<EmbeddedWindow, EmbeddedWindowHandler>();
+		});
+
+		return builder;
+	}
+
+	/// <summary>
+	/// Creates a window-scoped <see cref="IMauiContext"/> for the provided native platform window.
+	/// </summary>
+	/// <param name="mauiApp">The <see cref="MauiApp"/> instance.</param>
+	/// <param name="platformWindow">The native platform window instance to create the context for.</param>
+	/// <returns>The window-scoped <see cref="IMauiContext"/> instance.</returns>
+	/// <remarks>
+	/// In addition to the context being created, a new Window instance is created and attached to the app.
+	/// </remarks>
+	public static IMauiContext CreateEmbeddedWindowContext(this MauiApp mauiApp, PlatformWindow platformWindow)
+	{
+		var window = new EmbeddedWindow();
+
+		// Create the Core embedded window scope.
+		var windowContext = mauiApp.CreateEmbeddedWindowContext(platformWindow, window);
+
+		// If the app is an embedded app then we need to add the window to the app.
+		var embeddedApp = mauiApp.Services.GetRequiredService<EmbeddedPlatformApplication>();
+		if (embeddedApp.Application is Application app && !app.Windows.Contains(window))
+		{
+			app.AddWindow(window);
+		}
+
+		return windowContext;
+	}
+
+	/// <summary>
+	/// Similar to <see cref="ElementExtensions.ToPlatform(IElement, IMauiContext)"/>, but also adds the element as
+	/// a logical child to the embedded window.
+	/// </summary>
+	/// <param name="element">The element to use when creating the native platform view.</param>
+	/// <param name="context">The context to use when creating the native platform view.</param>
+	/// <returns>The native platform view that represents the element.</returns>
+	/// <remarks>
+	/// Only if the window is an embedded window and the element is a <see cref="VisualElement"/> will the element
+	/// be added as a logical child of that window.
+	/// </remarks>
+	public static PlatformView ToPlatformEmbedded(this IElement element, IMauiContext context)
+	{
+		// If the window is an embedded window, then we need to add the element as a logical child.
+		var wndProvider = context.Services.GetService<EmbeddedWindowProvider>();
+		if (wndProvider is not null && wndProvider.Window is EmbeddedWindow wnd && element is VisualElement visual)
+			wnd.AddLogicalChild(visual);
+
+		return element.ToPlatform(context);
+	}
+
+	/// <summary>
+	/// Similar to <see cref="ElementExtensions.ToPlatform(IElement, IMauiContext)"/>, but also adds the element as
+	/// a logical child to a new embedded window.
+	/// </summary>
+	/// <param name="element">The element to use when creating the native platform view.</param>
+	/// <param name="mauiApp">The <see cref="MauiApp"/> instance.</param>
+	/// <param name="platformWindow">The native platform window that will host this element.</param>
+	/// <returns>The native platform view that represents the element.</returns>
+	/// <remarks>
+	/// Only if the window is an embedded window and the element is a <see cref="VisualElement"/> will the element
+	/// be added as a logical child of that window.
+	/// </remarks>
+	public static PlatformView ToPlatformEmbedded(this IElement element, MauiApp mauiApp, PlatformWindow platformWindow)
+	{
+		var windowContext = mauiApp.CreateEmbeddedWindowContext(platformWindow);
+		return element.ToPlatformEmbedded(windowContext);
+	}
+}
+
+#endif
diff --git a/src/Core/src/Core/Extensions/VisualTreeElementExtensions.cs b/src/Core/src/Core/Extensions/VisualTreeElementExtensions.cs
index be8875d010d8..93bbce1b8afd 100644
--- a/src/Core/src/Core/Extensions/VisualTreeElementExtensions.cs
+++ b/src/Core/src/Core/Extensions/VisualTreeElementExtensions.cs
@@ -136,7 +136,7 @@ static List<IVisualTreeElement> GetVisualTreeElementsWindowsInternal(IVisualTree
 			var visualElements = new List<IVisualTreeElement>();
 			if (visualElement is IWindow window)
 			{
-				uiElement = window.Content.ToPlatform();
+				uiElement = window.Content?.ToPlatform();
 			}
 			else if (visualElement is IView view)
 			{
diff --git a/src/Core/src/Embedding/EmbeddedPlatformApplication.cs b/src/Core/src/Embedding/EmbeddedPlatformApplication.cs
new file mode 100644
index 000000000000..23154c10ce60
--- /dev/null
+++ b/src/Core/src/Embedding/EmbeddedPlatformApplication.cs
@@ -0,0 +1,60 @@
+#if ANDROID || IOS || MACCATALYST || WINDOWS
+using System;
+using Microsoft.Extensions.DependencyInjection;
+
+#if ANDROID
+using PlatformApplication = Android.App.Application;
+#elif IOS || MACCATALYST
+using PlatformApplication = UIKit.IUIApplicationDelegate;
+#elif WINDOWS
+using PlatformApplication = Microsoft.UI.Xaml.Application;
+#endif
+
+namespace Microsoft.Maui.Embedding;
+
+/// <summary>
+/// A <see cref="IPlatformApplication"/> that is used in embedding scenarios where the native platform application
+/// instance is either unknown at the time, or not controlled by MAUI.
+/// </summary>
+internal class EmbeddedPlatformApplication : IPlatformApplication
+{
+	private readonly MauiContext _rootContext;
+
+	public EmbeddedPlatformApplication(IServiceProvider services)
+	{
+		IPlatformApplication.Current = this;
+
+		PlatformApplication = services.GetRequiredService<PlatformApplication>();
+
+#if ANDROID
+		_rootContext = new MauiContext(services, PlatformApplication);
+#else
+		_rootContext = new MauiContext(services);
+#endif
+
+		Context = _rootContext.MakeApplicationScope(PlatformApplication);
+
+		Services = Context.Services;
+
+		Application = Services.GetRequiredService<IApplication>();
+
+		PlatformApplication.SetApplicationHandler(Application, Context);
+	}
+
+	/// <summary>
+	/// Gets the native platform application instance that is hosting this MAUI app.
+	/// </summary>
+	public PlatformApplication PlatformApplication { get; }
+
+	/// <summary>
+	/// Gets the application-scoped <see cref="IMauiContext"/>.
+	/// </summary>
+	public IMauiContext Context { get; }
+
+	/// Gets the application-scoped services.
+	public IServiceProvider Services { get; }
+
+	/// Gets the current MAUI application instance.
+	public IApplication Application { get; }
+}
+#endif
diff --git a/src/Core/src/Embedding/EmbeddedWindowHandler.Android.cs b/src/Core/src/Embedding/EmbeddedWindowHandler.Android.cs
new file mode 100644
index 000000000000..eceb21bda318
--- /dev/null
+++ b/src/Core/src/Embedding/EmbeddedWindowHandler.Android.cs
@@ -0,0 +1,24 @@
+using Android.App;
+
+namespace Microsoft.Maui.Embedding;
+
+internal partial class EmbeddedWindowHandler
+{
+	protected override void ConnectHandler(Activity platformView)
+	{
+		base.ConnectHandler(platformView);
+
+		UpdateVirtualViewFrame(platformView);
+	}
+
+	protected override void DisconnectHandler(Activity platformView)
+	{
+		base.DisconnectHandler(platformView);
+	}
+
+	void UpdateVirtualViewFrame(Activity activity)
+	{
+		var frame = activity.GetWindowFrame();
+		VirtualView.FrameChanged(frame);
+	}
+}
diff --git a/src/Core/src/Embedding/EmbeddedWindowHandler.Windows.cs b/src/Core/src/Embedding/EmbeddedWindowHandler.Windows.cs
new file mode 100644
index 000000000000..11d333133034
--- /dev/null
+++ b/src/Core/src/Embedding/EmbeddedWindowHandler.Windows.cs
@@ -0,0 +1,53 @@
+using Microsoft.Maui.Graphics;
+using Microsoft.UI.Windowing;
+
+using PlatformWindow = Microsoft.UI.Xaml.Window;
+
+namespace Microsoft.Maui.Embedding;
+
+internal partial class EmbeddedWindowHandler
+{
+	protected override void ConnectHandler(PlatformWindow platformView)
+	{
+		base.ConnectHandler(platformView);
+
+		var appWindow = platformView.GetAppWindow();
+		if (appWindow is not null)
+		{
+			// then pass the actual size back to the user
+			UpdateVirtualViewFrame(appWindow);
+
+			// THEN attach the event to reduce churn
+			appWindow.Changed += OnWindowChanged;
+		}
+	}
+
+	protected override void DisconnectHandler(PlatformWindow platformView)
+	{
+		var appWindow = platformView.GetAppWindow();
+		if (appWindow is not null)
+			appWindow.Changed -= OnWindowChanged;
+
+		base.DisconnectHandler(platformView);
+	}
+
+	void OnWindowChanged(AppWindow sender, AppWindowChangedEventArgs args)
+	{
+		if (!args.DidSizeChange && !args.DidPositionChange)
+			return;
+
+		UpdateVirtualViewFrame(sender);
+	}
+
+	void UpdateVirtualViewFrame(AppWindow appWindow)
+	{
+		var size = appWindow.Size;
+		var pos = appWindow.Position;
+
+		var density = PlatformView.GetDisplayDensity();
+
+		VirtualView.FrameChanged(new Rect(
+			pos.X / density, pos.Y / density,
+			size.Width / density, size.Height / density));
+	}
+}
diff --git a/src/Core/src/Embedding/EmbeddedWindowHandler.cs b/src/Core/src/Embedding/EmbeddedWindowHandler.cs
new file mode 100644
index 000000000000..f9955a706f34
--- /dev/null
+++ b/src/Core/src/Embedding/EmbeddedWindowHandler.cs
@@ -0,0 +1,56 @@
+#if ANDROID || IOS || MACCATALYST || WINDOWS
+using System;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Maui.Handlers;
+using Microsoft.Maui.Platform;
+
+#if ANDROID
+using PlatformWindow = Android.App.Activity;
+#elif IOS || MACCATALYST
+using PlatformWindow = UIKit.UIWindow;
+#elif WINDOWS
+using PlatformWindow = Microsoft.UI.Xaml.Window;
+#endif
+
+namespace Microsoft.Maui.Embedding;
+
+/// <summary>
+/// A reduced functionality <see cref="WindowHandler"/> for embedded scenarios.
+/// </summary>
+/// <remarks>
+/// The main purpose is to avoid adding mappers that affect the platform window since it is not meant to be
+/// modified arbitrarily from embedded MAUI views.
+/// </remarks>
+internal partial class EmbeddedWindowHandler : ElementHandler<IWindow, PlatformWindow>, IWindowHandler
+{
+	public static IPropertyMapper<IWindow, IWindowHandler> Mapper =
+		new PropertyMapper<IWindow, IWindowHandler>(ElementHandler.ElementMapper)
+		{
+		};
+
+	public static CommandMapper<IWindow, IWindowHandler> CommandMapper =
+		new(ElementCommandMapper)
+		{
+			[nameof(IWindow.RequestDisplayDensity)] = WindowHandler.MapRequestDisplayDensity,
+		};
+
+	public EmbeddedWindowHandler()
+		: base(Mapper, CommandMapper)
+	{
+	}
+
+	public EmbeddedWindowHandler(IPropertyMapper? mapper)
+		: base(mapper ?? Mapper, CommandMapper)
+	{
+	}
+
+	public EmbeddedWindowHandler(IPropertyMapper? mapper, CommandMapper? commandMapper)
+		: base(mapper ?? Mapper, commandMapper ?? CommandMapper)
+	{
+	}
+
+	protected override PlatformWindow CreatePlatformElement() =>
+		MauiContext!.Services.GetRequiredService<PlatformWindow>() ??
+		throw new InvalidOperationException("EmbeddedWindowHandler could not locate a platform window.");
+}
+#endif
diff --git a/src/Core/src/Embedding/EmbeddedWindowHandler.iOS.cs b/src/Core/src/Embedding/EmbeddedWindowHandler.iOS.cs
new file mode 100644
index 000000000000..87760c5aa06b
--- /dev/null
+++ b/src/Core/src/Embedding/EmbeddedWindowHandler.iOS.cs
@@ -0,0 +1,21 @@
+//using Microsoft.Maui.Graphics;
+//using Microsoft.UI.Windowing;
+
+//using PlatformWindow = Microsoft.UI.Xaml.Window;
+
+//namespace Microsoft.Maui.Embedding;
+
+//internal partial class EmbeddedWindowHandler
+//{
+//	protected override void ConnectHandler(PlatformWindow platformView)
+//	{
+//		base.ConnectHandler(platformView);
+
+//	}
+
+//	protected override void DisconnectHandler(PlatformWindow platformView)
+//	{
+
+//		base.DisconnectHandler(platformView);
+//	}
+//}
diff --git a/src/Core/src/Embedding/EmbeddedWindowProvider.cs b/src/Core/src/Embedding/EmbeddedWindowProvider.cs
new file mode 100644
index 000000000000..e4cb8ef0a2ef
--- /dev/null
+++ b/src/Core/src/Embedding/EmbeddedWindowProvider.cs
@@ -0,0 +1,36 @@
+#if ANDROID || IOS || MACCATALYST || WINDOWS
+using System;
+
+#if ANDROID
+using PlatformWindow = Android.App.Activity;
+#elif IOS || MACCATALYST
+using PlatformWindow = UIKit.UIWindow;
+#elif WINDOWS
+using PlatformWindow = Microsoft.UI.Xaml.Window;
+#endif
+
+namespace Microsoft.Maui.Embedding;
+
+/// <summary>
+/// A proxy service that provides access to the embedded window and its associated platform window.
+/// </summary>
+/// <remarks>
+/// This is used when embedding but also serves to allow the platform window to be added to the service collection
+/// before it is actually known or instantiated.
+/// </remarks>
+internal class EmbeddedWindowProvider
+{
+	WeakReference<PlatformWindow>? _platformWindow;
+	WeakReference<IWindow>? _window;
+
+	public void SetWindow(PlatformWindow? platformWindow, IWindow? window)
+	{
+		_platformWindow = platformWindow is null ? null : new WeakReference<PlatformWindow>(platformWindow);
+		_window = window is null ? null : new WeakReference<IWindow>(window);
+	}
+
+	public PlatformWindow? PlatformWindow => _platformWindow?.GetTargetOrDefault();
+
+	public IWindow? Window => _window?.GetTargetOrDefault();
+}
+#endif
diff --git a/src/Core/src/Embedding/EmbeddingExtensions.cs b/src/Core/src/Embedding/EmbeddingExtensions.cs
new file mode 100644
index 000000000000..aaf711132294
--- /dev/null
+++ b/src/Core/src/Embedding/EmbeddingExtensions.cs
@@ -0,0 +1,100 @@
+#if ANDROID || IOS || MACCATALYST || WINDOWS
+using System;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Maui.Hosting;
+
+#if ANDROID
+using PlatformWindow = Android.App.Activity;
+using PlatformApplication = Android.App.Application;
+#elif IOS || MACCATALYST
+using PlatformWindow = UIKit.UIWindow;
+using PlatformApplication = UIKit.IUIApplicationDelegate;
+#elif WINDOWS
+using PlatformWindow = Microsoft.UI.Xaml.Window;
+using PlatformApplication = Microsoft.UI.Xaml.Application;
+#endif
+
+namespace Microsoft.Maui.Embedding;
+
+/// <summary>
+/// A set of extension methods that allow for embedding a MAUI view within a native application.
+/// </summary>
+internal static class EmbeddingExtensions
+{
+	/// <summary>
+	/// Enables MAUI to be embedded in native application by injecting embedded handlers into the service collection.
+	/// </summary>
+	/// <param name="builder">The <see cref="MauiAppBuilder"/> instance.</param>
+	/// <param name="platformApplication">The native application instance.</param>
+	/// <returns>The <see cref="MauiAppBuilder"/> instance.</returns>
+	public static MauiAppBuilder UseMauiEmbedding(this MauiAppBuilder builder, PlatformApplication? platformApplication = null)
+	{
+#if ANDROID
+		platformApplication ??= (Android.App.Application)Android.App.Application.Context;
+#elif IOS || MACCATALYST
+		platformApplication ??= UIKit.UIApplication.SharedApplication.Delegate;
+#elif WINDOWS
+		platformApplication ??= Microsoft.UI.Xaml.Application.Current;
+#endif
+
+		if (platformApplication is null)
+		{
+			throw new InvalidOperationException("Platform application instance is required and was not able to be detected.");
+		}
+
+		// Register the current native application that is currently running.
+		builder.Services.AddSingleton(platformApplication);
+
+		// Register the IPlatformApplication for the embedded application.
+		builder.Services.AddSingleton<EmbeddedPlatformApplication>(svc => new EmbeddedPlatformApplication(svc));
+
+		builder.Services.AddScoped<EmbeddedWindowProvider>(svc => new EmbeddedWindowProvider());
+
+		// Returning null is acceptable here as the platform window is optional.
+		// However, we do not know for sure until we resolve it.
+		builder.Services.AddScoped<PlatformWindow>(svc => svc.GetRequiredService<EmbeddedWindowProvider>().PlatformWindow!);
+
+		// Register an initializer as we need a platform application to be
+		// instantiated as soon as possible. In a typical app, this would be
+		// done by the platform-specific bootstrapper.
+		builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton<IMauiInitializeService, EmbeddedInitializeService>(svc => new EmbeddedInitializeService()));
+
+		return builder;
+	}
+
+	/// <summary>
+	/// Creates a window-scoped <see cref="IMauiContext"/> for the provided platform window.
+	/// </summary>
+	/// <param name="mauiApp">The <see cref="MauiApp"/> instance.</param>
+	/// <param name="platformWindow">The native window instance to create the context for.</param>
+	/// <param name="window">The MAUI window instance to connect to the platform window.</param>
+	/// <returns>The window-scoped <see cref="IMauiContext"/> instance.</returns>
+	public static IMauiContext CreateEmbeddedWindowContext(this MauiApp mauiApp, PlatformWindow platformWindow, IWindow window)
+	{
+		// Get the embedded application instance.
+		var embeddedApp = mauiApp.Services.GetRequiredService<EmbeddedPlatformApplication>();
+
+		// Create a window context for the platform window that was provided.
+		var windowContext = embeddedApp.Context.MakeWindowScope(platformWindow, out var windowScope);
+
+		// Add the platform window to the service provider.
+		var wndProvider = windowContext.Services.GetRequiredService<EmbeddedWindowProvider>();
+		wndProvider.SetWindow(platformWindow, window);
+
+		// Connect the platform window to the MAUI window in order for lifecycle events to work.
+		window.ToHandler(windowContext);
+
+		return windowContext;
+	}
+
+	/// <summary>
+	/// An initializer to make sure the <see cref="IPlatformApplication.Current"/> is populated.
+	/// </summary>
+	private class EmbeddedInitializeService : IMauiInitializeService
+	{
+		public void Initialize(IServiceProvider services) =>
+			services.GetRequiredService<EmbeddedPlatformApplication>();
+	}
+}
+#endif