From 1fce082912c56b5195635090e3b213de3c7add75 Mon Sep 17 00:00:00 2001
From: Brandon Minnick <13558917+brminnick@users.noreply.github.com>
Date: Fri, 10 Nov 2023 15:38:49 -0800
Subject: [PATCH] Add `CancellationToken` Parameter to Methods Returning `Task`
 and `ValueTask` (#1503)

* Update .editorconfig

* Update DrawingViewService.windows.cs

* Add `CancellationToken` to IDrawingView, IAlert, AnimationBehavior

* Update AvatarViewGesturesPage

* Update SpeechToTextImplementation.windows.cs

* Update SpeechToTextImplementation.windows.cs

* Add CancellationToken

* Update Unit Tests

* Fix Failing Unit Tests

* Remove Duplicative `ThrowIfCancellationRequested()`

* Remove Duplicate `ThrowIfCancellationRequested()`

* Add Timeout to `async Task` Unit Tests

* Fix Unit Test Timeouts

* Update `AnimateCommand` (`ICommand` -> `Command<CancellationToken> `)

* `dotnet format`

* Fix typo

* Fix compiler bug

* Update DrawingViewService.tizen.cs

* Fix Unit Test Timeout

* Fix BaseTest Inheritance

* Refactor using TaskCompletionSource

* Add CancellationToken

* Increase `TestDuration.Short`

* Increase to TestDuration.Long

* Increase to TestDuration.Medium

* Revert to `ICommand ForceValidateCommand`

* Update ValidationBehavior.shared.cs

* Update `void SeekTo(TimeSpan)`  -> `Task SeekTo(TimeSpan, CancellationToken)`

* Implement `IDisposable` pattern

* Update `PlatformSeek()`

* Promote PlatformSeek to `Task`

* Fix Floating Point Comparison Bug

* Update Windows + Tizen MediaElement

* Update MauiMediaElement.windows.cs

* Refactor + Optimize Code

* Add CancellationToken Unit Tests for `Alerts`, `Animations` and `Behaviors`

* Add CancellationToken Unit Tests for Converters

* Ad Unit Tests for Extensions

* Add Unit Tests for Layouts

* Add CancellationToken for PopupService

* Add Views CancellationToken Unit Tests

* Add Default Value to CancellationToken Parameter on Public APIs

* Update CONTRIBUTING.md

* `dotnet format`

* `dotnet format`

* Update src/CommunityToolkit.Maui/Behaviors/AnimationBehavior.shared.cs

* Update src/CommunityToolkit.Maui/Behaviors/AnimationBehavior.shared.cs
---
 .editorconfig                                 |   5 +-
 CONTRIBUTING.md                               |   6 +
 .../Pages/Alerts/SnackbarPage.xaml.cs         |   9 +-
 .../Pages/Alerts/ToastPage.xaml.cs            |  10 +-
 .../Behaviors/AnimationBehaviorPage.xaml      |   2 +-
 .../Behaviors/AnimationBehaviorPage.xaml.cs   |   9 +-
 .../NumericValidationBehaviorPage.xaml.cs     |   4 +-
 .../AvatarView/AvatarViewGesturesPage.xaml.cs |  34 ++-
 .../Pages/Views/DrawingViewPage.xaml.cs       |  19 +-
 .../Pages/Views/LazyView/CustomLazyView.cs    |   4 +-
 .../Pages/Views/LazyView/LazyViewPage.xaml    |   2 +-
 .../Pages/Views/LazyView/LazyViewPage.xaml.cs |   7 +-
 .../Pages/Views/LazyView/MyLazyView.cs        |  11 -
 .../Pages/Views/LazyView/MyViewLazyView.cs    |  11 +
 .../Views/MediaElement/MediaElementPage.xaml  |  26 +--
 .../MediaElement/MediaElementPage.xaml.cs     |  73 +++----
 .../Views/Popup/MultiplePopupPage.xaml.cs     |  20 +-
 .../Popup/ShowPopupInOnAppearingPage.xaml.cs  |   4 +-
 .../Behaviors/AnimationBehaviorViewModel.cs   |   2 +-
 ...yteArrayToImageSourceConverterViewModel.cs |   8 +-
 .../ItemTappedEventArgsConverterViewModel.cs  |   4 +-
 .../Essentials/SpeechToTextViewModel.cs       |  10 +-
 .../Extensions/KeyboardExtensionsViewModel.cs |   2 +-
 .../Layouts/StateContainerViewModel.cs        |   8 +-
 .../ViewModels/Views/DrawingViewViewModel.cs  |   2 +-
 .../CustomSizeAndPositionPopupViewModel.cs    |   6 +-
 .../Views/Popup/MultiplePopupViewModel.cs     |  10 +-
 .../Views/Popups/ButtonPopup.xaml.cs          |   6 +-
 .../Views/Popups/MultipleButtonPopup.xaml.cs  |  12 +-
 .../Popups/NoOutsideTapDismissPopup.xaml.cs   |   6 +-
 .../Views/Popups/ReturnResultPopup.xaml.cs    |   6 +-
 .../Views/Popups/TransparentPopup.xaml.cs     |   3 +-
 .../Essentials/FileSaver/FileSaver.shared.cs  |   4 +-
 .../FileSaverImplementation.shared.cs         |   4 +-
 .../Essentials/FileSaver/IFileSaver.shared.cs |   4 +-
 .../FolderPicker/FolderPicker.shared.cs       |   2 +-
 .../FolderPickerImplementation.shared.cs      |   4 +-
 .../FolderPicker/IFolderPicker.shared.cs      |   4 +-
 .../SpeechToText/ISpeechToText.shared.cs      |   8 +-
 ...SharedSpeechToTextImplementation.macios.cs |   2 +-
 .../SpeechToText/SpeechToText.shared.cs       |   8 +-
 .../SpeechToTextImplementation.shared.cs      |   8 +-
 .../SpeechToTextImplementation.tizen.cs       |   6 +-
 .../SpeechToTextImplementation.windows.cs     |  11 +-
 .../IPopupService.cs                          |   9 +-
 .../Interfaces/IDrawingLine.shared.cs         |   3 +-
 .../Interfaces/IDrawingView.shared.cs         |   3 +-
 .../KeyboardExtensions.shared.cs              |   4 +-
 .../Views/DrawingView/DrawingLine.shared.cs   |  13 +-
 .../Service/DrawingViewService.android.cs     |  17 +-
 .../Service/DrawingViewService.macios.cs      |  20 +-
 .../Service/DrawingViewService.net.cs         |  16 +-
 .../Service/DrawingViewService.tizen.cs       |  26 ++-
 .../Service/DrawingViewService.windows.cs     |  21 +-
 .../Handlers/MediaElementHandler.shared.cs    |  52 ++---
 .../IAsynchronousMediaElementHandler.cs       |  12 ++
 .../Interfaces/IMediaElement.cs               |   5 +-
 .../MediaElement.shared.cs                    |  84 ++++++--
 .../Views/MauiMediaElement.windows.cs         |  26 ++-
 .../Views/MediaManager.android.cs             |  79 ++++---
 .../Views/MediaManager.macios.cs              |  86 ++++----
 .../Views/MediaManager.shared.cs              |  20 +-
 .../Views/MediaManager.tizen.cs               |  27 +--
 .../Views/MediaManager.windows.cs             | 103 ++++-----
 .../Generators/TextColorToGenerator.cs        |   6 +-
 .../Alerts/SnackbarTests.cs                   |  88 ++++++--
 .../Alerts/ToastTests.cs                      |  58 +++++-
 .../Animations/FadeAnimationTests.cs          |  44 +++-
 .../BaseTest.cs                               |   7 +
 .../Behaviors/AnimationBehaviorTests.cs       |  96 ++++++++-
 .../CharactersValidationBehaviorTests.cs      |  50 ++++-
 .../Behaviors/EmailValidationBehaviorTests.cs |  47 ++++-
 .../Behaviors/IconTintColorBehaviorTests.cs   |   2 -
 .../Behaviors/MultiValidationBehaviorTests.cs |  58 +++++-
 .../NumericValidationBehaviorTests.cs         |  58 +++++-
 .../Behaviors/TextValidationBehaviorTests.cs  |  50 ++++-
 .../Behaviors/UriValidationBehaviorTests.cs   |  50 ++++-
 .../UserStoppedTypingBehaviorTests.cs         | 197 +++++++++++++-----
 .../Behaviors/ValidationBehaviorTests.cs      |  68 +++++-
 .../CommunityToolkit.Maui.UnitTests.csproj    |   1 +
 .../ByteArrayToImageSourceConverterTests.cs   |   2 +-
 .../Converters/ImageResourceConverterTests.cs |  38 +++-
 .../Essentials/BadgeTests.cs                  |   2 +-
 .../Essentials/FileSaverTests.cs              |   6 +-
 .../Essentials/FolderPickerTests.cs           |   6 +-
 .../Essentials/SpeechToTextTests.cs           |  23 +-
 .../Extensions/BackgroundColorToTests.cs      |  36 +++-
 .../ColorConversionExtensionsTests.cs         |   2 +-
 .../Extensions/TextColorToTests.cs            |  28 +++
 .../GravatarImageSourceTests.cs               |   6 +-
 .../Layouts/StateContainerTests.cs            |  80 +++++--
 .../Mocks/MockDrawingViewHandler.cs           |   3 +-
 .../PopupServiceTests.cs                      | 138 ++++++++++--
 .../Views/DrawingView/DrawingLineTests.cs     |  30 ++-
 .../Views/DrawingView/DrawingViewTests.cs     |  30 ++-
 .../Views/LazyView/LazyViewTests.cs           |  36 +++-
 .../MediaElement/MediaSourceConverterTests.cs |   2 +-
 .../Views/MediaElement/MediaSourceTests.cs    |   2 +-
 .../Views/Popup/PopupTests.cs                 | 160 ++++++++++++--
 .../Alerts/Snackbar/Snackbar.android.cs       |   2 +-
 .../Alerts/Snackbar/Snackbar.macios.cs        |   3 +-
 .../Alerts/Snackbar/Snackbar.tizen.cs         |   1 +
 .../Animations/BaseAnimation.shared.cs        |   3 +-
 .../Animations/FadeAnimation.shared.cs        |   6 +-
 .../Behaviors/AnimationBehavior.shared.cs     |  35 +++-
 .../Behaviors/MaskedBehavior.shared.cs        |  10 +-
 .../ProgressBarAnimationBehavior.shared.cs    |   8 +-
 .../Validators/ValidationBehavior.shared.cs   |  29 +--
 .../ColorAnimationExtensions.shared.cs        |   9 +-
 .../GravatarImageSource.shared.cs             |  43 ++--
 .../StateContainer/StateContainer.shared.cs   |  10 +-
 src/CommunityToolkit.Maui/PopupService.cs     |  18 +-
 .../Views/DrawingView/DrawingView.shared.cs   |  12 +-
 .../Views/LazyView/LazyView.shared.cs         |   6 +-
 .../Views/Popup/Popup.shared.cs               |  36 ++--
 .../Views/Popup/PopupExtensions.shared.cs     |  35 ++--
 .../Views/Popup/PopupExtensions.windows.cs    |   4 +-
 117 files changed, 2077 insertions(+), 735 deletions(-)
 delete mode 100644 samples/CommunityToolkit.Maui.Sample/Pages/Views/LazyView/MyLazyView.cs
 create mode 100644 samples/CommunityToolkit.Maui.Sample/Pages/Views/LazyView/MyViewLazyView.cs
 create mode 100644 src/CommunityToolkit.Maui.MediaElement/Interfaces/IAsynchronousMediaElementHandler.cs

diff --git a/.editorconfig b/.editorconfig
index 6e5bd260ec..8a894f0871 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -71,7 +71,7 @@ csharp_style_pattern_matching_over_is_with_cast_check = true:suggestion
 csharp_style_pattern_matching_over_as_with_null_check = true:suggestion
 csharp_style_inlined_variable_declaration = true:suggestion
 csharp_style_throw_expression = true:suggestion
-csharp_style_conditional_delegate_call = true:suggestions
+csharp_style_conditional_delegate_call = true:suggestion
 
 # Naming rules
 
@@ -122,6 +122,9 @@ dotnet_diagnostic.CA1050.severity = error
 # CA2016: Forward the 'cancellationToken' parameter methods that take one
 dotnet_diagnostic.CA2016.severity = error
 
+# CA1068: CancellationToken parameters must come last
+dotnet_diagnostic.CA1068.severity = error
+
 # CA2208: Method passes parameter as the paramName argument to a ArgumentNullException constructor. Replace this argument with one of the method's parameter names. Note that the provided parameter name should have the exact casing as declared on the method.
 dotnet_diagnostic.CA2208.severity = error
 
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index eae3db0332..92ab2b83bd 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -125,6 +125,12 @@ Here we will have some:
 ### Debug Logging
 * Always use `Trace.WriteLine()` instead of `Debug.WriteLine` for debug logging because `Debug.WriteLine` is removed by the compiler in Release builds
 
+### Methods Returning Task and ValueTask
+* Always include a `CancellationToken` as a parameter to every method returning `Task` or `ValueTask`
+* If the method is public, provide a the default value for the `CancellationToken` (eg `CancellationToken token = default`)
+  * If the method is not publc, do not provide a default value for the `CancellationToken`
+* Use `CancellationToken.ThrowIfCancellationRequested()` to verify the `CancellationToken`
+
 ### Enums
 * Always use `Unknown` at index 0 for return types that may have a value that is not known
 * Always use `Default` at index 0 for option types that can use the system default option
diff --git a/samples/CommunityToolkit.Maui.Sample/Pages/Alerts/SnackbarPage.xaml.cs b/samples/CommunityToolkit.Maui.Sample/Pages/Alerts/SnackbarPage.xaml.cs
index afddaa2b35..a304c4cb54 100644
--- a/samples/CommunityToolkit.Maui.Sample/Pages/Alerts/SnackbarPage.xaml.cs
+++ b/samples/CommunityToolkit.Maui.Sample/Pages/Alerts/SnackbarPage.xaml.cs
@@ -60,7 +60,8 @@ async void DisplayCustomSnackbarButtonClicked(object? sender, EventArgs args)
 				options,
 				DisplayCustomSnackbarButton);
 
-			await customSnackbar.Show();
+			var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+			await customSnackbar.Show(cts.Token);
 
 			DisplayCustomSnackbarButton.Text = dismissCustomSnackbarText;
 		}
@@ -68,7 +69,9 @@ async void DisplayCustomSnackbarButtonClicked(object? sender, EventArgs args)
 		{
 			if (customSnackbar is not null)
 			{
-				await customSnackbar.Dismiss();
+				var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+				await customSnackbar.Dismiss(cts.Token);
+
 				customSnackbar.Dispose();
 			}
 
@@ -102,7 +105,7 @@ await Application.Current.MainPage.Navigation.PushModalAsync(new ContentPage
 
 					Children =
 					{
-						new Button { Command = new AsyncRelayCommand(() => Snackbar.Make("Snackbar in a Modal Page").Show()) }
+						new Button { Command = new AsyncRelayCommand(token => Snackbar.Make("Snackbar in a Modal Page").Show(token)) }
 							.Top().CenterHorizontal()
 							.Text("Display Snackbar"),
 
diff --git a/samples/CommunityToolkit.Maui.Sample/Pages/Alerts/ToastPage.xaml.cs b/samples/CommunityToolkit.Maui.Sample/Pages/Alerts/ToastPage.xaml.cs
index 875801d27c..4ee35c83af 100644
--- a/samples/CommunityToolkit.Maui.Sample/Pages/Alerts/ToastPage.xaml.cs
+++ b/samples/CommunityToolkit.Maui.Sample/Pages/Alerts/ToastPage.xaml.cs
@@ -16,13 +16,17 @@ public ToastPage(ToastViewModel toastViewModel) : base(toastViewModel)
 	async void ShowToastButtonClicked(object? sender, EventArgs args)
 	{
 		var toast = Toast.Make("This is a default Toast.");
-		await toast.Show();
+
+		var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+		await toast.Show(cts.Token);
 	}
 
 	async void ShowCustomToastButtonClicked(object? sender, EventArgs args)
 	{
 		var toast = Toast.Make("This is a big Toast.", ToastDuration.Long, 30d);
-		await toast.Show();
+
+		var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+		await toast.Show(cts.Token);
 	}
 
 	async void DisplayToastInModalButtonClicked(object? sender, EventArgs e)
@@ -37,7 +41,7 @@ await Application.Current.MainPage.Navigation.PushModalAsync(new ContentPage
 
 					Children =
 					{
-						new Button { Command = new AsyncRelayCommand(() => Toast.Make("Toast in a Modal Page").Show()) }
+						new Button { Command = new AsyncRelayCommand(token => Toast.Make("Toast in a Modal Page").Show(token)) }
 							.Top().CenterHorizontal()
 							.Text("Display Toast"),
 
diff --git a/samples/CommunityToolkit.Maui.Sample/Pages/Behaviors/AnimationBehaviorPage.xaml b/samples/CommunityToolkit.Maui.Sample/Pages/Behaviors/AnimationBehaviorPage.xaml
index a835ed6827..5b180cefc5 100644
--- a/samples/CommunityToolkit.Maui.Sample/Pages/Behaviors/AnimationBehaviorPage.xaml
+++ b/samples/CommunityToolkit.Maui.Sample/Pages/Behaviors/AnimationBehaviorPage.xaml
@@ -16,7 +16,7 @@
             <Label.FormattedText>
                 <FormattedString>
                     <FormattedString.Spans>
-                        <Span Text="AnimationBehavor is a Behavior that can be attached to any VisualElement, allowing developers to: trigger animations via: ICommand AnimateCommand." />
+                        <Span Text="AnimationBehavior is a Behavior that can be attached to any VisualElement, allowing developers to: trigger animations via: ICommand AnimateCommand." />
                         <Span Text="{x:Static system:Environment.NewLine}" />
                         <Span Text="* use the default of a TapGestureRecognizer being added to the attached VisualElement" />
                         <Span Text="{x:Static system:Environment.NewLine}" />
diff --git a/samples/CommunityToolkit.Maui.Sample/Pages/Behaviors/AnimationBehaviorPage.xaml.cs b/samples/CommunityToolkit.Maui.Sample/Pages/Behaviors/AnimationBehaviorPage.xaml.cs
index 785aad33cd..2152a8e920 100644
--- a/samples/CommunityToolkit.Maui.Sample/Pages/Behaviors/AnimationBehaviorPage.xaml.cs
+++ b/samples/CommunityToolkit.Maui.Sample/Pages/Behaviors/AnimationBehaviorPage.xaml.cs
@@ -13,10 +13,10 @@ public AnimationBehaviorPage(AnimationBehaviorViewModel animationBehaviorViewMod
 
 class SampleScaleAnimation : BaseAnimation
 {
-	public override async Task Animate(VisualElement view)
+	public override async Task Animate(VisualElement view, CancellationToken token)
 	{
-		await view.ScaleTo(1.2, Length, Easing);
-		await view.ScaleTo(1, Length, Easing);
+		await view.ScaleTo(1.2, Length, Easing).WaitAsync(token);
+		await view.ScaleTo(1, Length, Easing).WaitAsync(token);
 	}
 }
 
@@ -24,5 +24,6 @@ class SampleScaleToAnimation : BaseAnimation
 {
 	public double Scale { get; set; }
 
-	public override Task Animate(VisualElement view) => view.ScaleTo(Scale, Length, Easing);
+	public override Task Animate(VisualElement view, CancellationToken token)
+		=> view.ScaleTo(Scale, Length, Easing).WaitAsync(token);
 }
\ No newline at end of file
diff --git a/samples/CommunityToolkit.Maui.Sample/Pages/Behaviors/NumericValidationBehaviorPage.xaml.cs b/samples/CommunityToolkit.Maui.Sample/Pages/Behaviors/NumericValidationBehaviorPage.xaml.cs
index 03aa561cde..6bcf292b81 100644
--- a/samples/CommunityToolkit.Maui.Sample/Pages/Behaviors/NumericValidationBehaviorPage.xaml.cs
+++ b/samples/CommunityToolkit.Maui.Sample/Pages/Behaviors/NumericValidationBehaviorPage.xaml.cs
@@ -16,11 +16,11 @@ async void SetEntryValue(object? sender, EventArgs e)
 	{
 		var toastVisibilityTimeSpan = TimeSpan.FromSeconds(5);
 		var cts = new CancellationTokenSource(toastVisibilityTimeSpan);
-		
+
 		await Toast.Make($"The app will crash because `null` is an invalid value for {nameof(NumericValidationBehavior)}.\nOptionally, {nameof(Options)}.{nameof(Options.SetShouldSuppressExceptionsInBehaviors)} can be set to true", Core.ToastDuration.Long).Show(cts.Token);
 
 		await Task.Delay(toastVisibilityTimeSpan, cts.Token);
-		
+
 		SafeEntry.Text = null;
 	}
 }
\ No newline at end of file
diff --git a/samples/CommunityToolkit.Maui.Sample/Pages/Views/AvatarView/AvatarViewGesturesPage.xaml.cs b/samples/CommunityToolkit.Maui.Sample/Pages/Views/AvatarView/AvatarViewGesturesPage.xaml.cs
index 2148a525cb..f610d8584f 100644
--- a/samples/CommunityToolkit.Maui.Sample/Pages/Views/AvatarView/AvatarViewGesturesPage.xaml.cs
+++ b/samples/CommunityToolkit.Maui.Sample/Pages/Views/AvatarView/AvatarViewGesturesPage.xaml.cs
@@ -7,19 +7,39 @@ public partial class AvatarViewGesturesPage : BasePage<AvatarViewGesturesViewMod
 {
 	public AvatarViewGesturesPage(AvatarViewGesturesViewModel avatarViewGesturesViewModel) : base(avatarViewGesturesViewModel) => InitializeComponent();
 
-	async void DragGestureRecognizer_DragStarting(object sender, DragStartingEventArgs e) => await ShowToastGestureMessage("AvatarView drag gesture recognizer, drag starting.");
+	async void DragGestureRecognizer_DragStarting(object sender, DragStartingEventArgs e)
+	{
+		var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+		await ShowToastGestureMessage("AvatarView drag gesture recognizer, drag starting.", cts.Token);
+	}
 
-	async void PanGestureRecognizer_PanUpdated(object sender, PanUpdatedEventArgs e) => await ShowToastGestureMessage("AvatarView pan gesture recognizer, pan updated.");
+	async void PanGestureRecognizer_PanUpdated(object sender, PanUpdatedEventArgs e)
+	{
+		var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+		await ShowToastGestureMessage("AvatarView pan gesture recognizer, pan updated.", cts.Token);
+	}
 
-	async void PinchGestureRecognizer_PinchUpdated(object sender, PinchGestureUpdatedEventArgs e) => await ShowToastGestureMessage("AvatarView pinch gesture recognizer, pinch updated.");
+	async void PinchGestureRecognizer_PinchUpdated(object sender, PinchGestureUpdatedEventArgs e)
+	{
+		var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+		await ShowToastGestureMessage("AvatarView pinch gesture recognizer, pinch updated.", cts.Token);
+	}
 
-	async void SwipeGestureRecognizer_Swiped(object sender, SwipedEventArgs e) => await ShowToastGestureMessage("AvatarView swipe gesture recognizer, swiped.");
+	async void SwipeGestureRecognizer_Swiped(object sender, SwipedEventArgs e)
+	{
+		var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+		await ShowToastGestureMessage("AvatarView swipe gesture recognizer, swiped.", cts.Token);
+	}
 
-	async void TapGestureRecognizer_Tapped(object sender, EventArgs e) => await ShowToastGestureMessage("AvatarView Tap Gesture Recognizer, tapped.");
+	async void TapGestureRecognizer_Tapped(object sender, EventArgs e)
+	{
+		var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+		await ShowToastGestureMessage("AvatarView Tap Gesture Recognizer, tapped.", cts.Token);
+	}
 
-	static async Task ShowToastGestureMessage(string message)
+	static Task ShowToastGestureMessage(string message, CancellationToken token)
 	{
 		Core.IToast toast = Toast.Make(message, Core.ToastDuration.Short);
-		await toast.Show();
+		return toast.Show(token);
 	}
 }
\ No newline at end of file
diff --git a/samples/CommunityToolkit.Maui.Sample/Pages/Views/DrawingViewPage.xaml.cs b/samples/CommunityToolkit.Maui.Sample/Pages/Views/DrawingViewPage.xaml.cs
index 1421e92598..1dfdf1d52e 100644
--- a/samples/CommunityToolkit.Maui.Sample/Pages/Views/DrawingViewPage.xaml.cs
+++ b/samples/CommunityToolkit.Maui.Sample/Pages/Views/DrawingViewPage.xaml.cs
@@ -30,23 +30,29 @@ void LoadPointsButtonClicked(object sender, EventArgs e)
 
 	async void GetCurrentDrawingViewImageClicked(object sender, EventArgs e)
 	{
-		var stream = await DrawingViewControl.GetImageStream(GestureImage.Width, GestureImage.Height);
+		var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+		var stream = await DrawingViewControl.GetImageStream(GestureImage.Width, GestureImage.Height, cts.Token);
+
 		GestureImage.Source = ImageSource.FromStream(() => stream);
 	}
 
 	async void GenerateImageButtonClicked(object sender, EventArgs e)
 	{
 		var lines = GenerateLines(2);
-		await DrawImage(lines);
+
+		var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+		await DrawImage(lines, cts.Token);
 	}
 
-	async Task DrawImage(IEnumerable<DrawingLine> lines)
+	async Task DrawImage(IEnumerable<DrawingLine> lines, CancellationToken token)
 	{
 		var drawingLines = lines.ToList();
 		var points = drawingLines.SelectMany(x => x.Points).ToList();
 		var stream = await DrawingView.GetImageStream(drawingLines,
 			new Size(points.Max(x => x.X) - points.Min(x => x.X), points.Max(x => x.Y) - points.Min(x => x.Y)),
-			Colors.Gray);
+			Colors.Gray,
+			token);
+
 		GestureImage.Source = ImageSource.FromStream(() => stream);
 	}
 
@@ -71,7 +77,10 @@ async void OnDrawingLineCompleted(object sender, DrawingLineCompletedEventArgs e
 	{
 		var width = GetSide(GestureImage.Width);
 		var height = GetSide(GestureImage.Height);
-		var stream = await e.LastDrawingLine.GetImageStream(width, height, Colors.Gray.AsPaint());
+
+		var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+		var stream = await e.LastDrawingLine.GetImageStream(width, height, Colors.Gray.AsPaint(), cts.Token);
+
 		GestureImage.Source = ImageSource.FromStream(() => stream);
 	}
 }
\ No newline at end of file
diff --git a/samples/CommunityToolkit.Maui.Sample/Pages/Views/LazyView/CustomLazyView.cs b/samples/CommunityToolkit.Maui.Sample/Pages/Views/LazyView/CustomLazyView.cs
index fb995626aa..2a2fa8c2bb 100644
--- a/samples/CommunityToolkit.Maui.Sample/Pages/Views/LazyView/CustomLazyView.cs
+++ b/samples/CommunityToolkit.Maui.Sample/Pages/Views/LazyView/CustomLazyView.cs
@@ -4,13 +4,13 @@ namespace CommunityToolkit.Maui.Sample.Pages.Views.LazyView;
 
 public class CustomLazyView<TView> : Maui.Views.LazyView where TView : View, new()
 {
-	public override async ValueTask LoadViewAsync()
+	public override async ValueTask LoadViewAsync(CancellationToken token)
 	{
 		// display a loading indicator
 		Content = new ActivityIndicator { IsRunning = true }.Center();
 
 		// simulate a long running task
-		await Task.Delay(3000);
+		await Task.Delay(3000, token);
 
 		// load the view
 		Content = new TView { BindingContext = BindingContext };
diff --git a/samples/CommunityToolkit.Maui.Sample/Pages/Views/LazyView/LazyViewPage.xaml b/samples/CommunityToolkit.Maui.Sample/Pages/Views/LazyView/LazyViewPage.xaml
index 1d1987bffa..4a1060b548 100644
--- a/samples/CommunityToolkit.Maui.Sample/Pages/Views/LazyView/LazyViewPage.xaml
+++ b/samples/CommunityToolkit.Maui.Sample/Pages/Views/LazyView/LazyViewPage.xaml
@@ -54,7 +54,7 @@
             <Label Text="Lazy Loading Based On User Action" Style="{StaticResource Heading}"/>
             <Label Text="{Binding Source={x:Reference LazyUserAction}, Path=HasLazyViewLoaded, StringFormat='HasLazyViewLoaded = {0}'}" Style="{StaticResource Heading}"/>
             <Button Text="Load View Now" Clicked="LoadLazyView_Clicked" WidthRequest="200" IsVisible="{Binding Source={x:Reference LazyUserAction}, Path=HasLazyViewLoaded, Converter={mct:InvertedBoolConverter}}" />
-            <local:MyLazyView x:Name="LazyUserAction" Style="{StaticResource MyViewStyle}"/>
+            <local:MyViewLazyView x:Name="LazyUserAction" Style="{StaticResource MyViewStyle}"/>
         </VerticalStackLayout>
     </ScrollView>
 </pages:BasePage>
diff --git a/samples/CommunityToolkit.Maui.Sample/Pages/Views/LazyView/LazyViewPage.xaml.cs b/samples/CommunityToolkit.Maui.Sample/Pages/Views/LazyView/LazyViewPage.xaml.cs
index 4aab35b826..5c65fe055d 100644
--- a/samples/CommunityToolkit.Maui.Sample/Pages/Views/LazyView/LazyViewPage.xaml.cs
+++ b/samples/CommunityToolkit.Maui.Sample/Pages/Views/LazyView/LazyViewPage.xaml.cs
@@ -12,11 +12,14 @@ public LazyViewPage(LazyViewViewModel viewModel) : base(viewModel)
 	protected override async void OnAppearing()
 	{
 		base.OnAppearing();
-		await LazyActiviation.LoadViewAsync();
+
+		var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+		await LazyActiviation.LoadViewAsync(cts.Token);
 	}
 
 	async void LoadLazyView_Clicked(object sender, EventArgs e)
 	{
-		await LazyUserAction.LoadViewAsync();
+		var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+		await LazyUserAction.LoadViewAsync(cts.Token);
 	}
 }
\ No newline at end of file
diff --git a/samples/CommunityToolkit.Maui.Sample/Pages/Views/LazyView/MyLazyView.cs b/samples/CommunityToolkit.Maui.Sample/Pages/Views/LazyView/MyLazyView.cs
deleted file mode 100644
index 074e031361..0000000000
--- a/samples/CommunityToolkit.Maui.Sample/Pages/Views/LazyView/MyLazyView.cs
+++ /dev/null
@@ -1,11 +0,0 @@
-using CommunityToolkit.Maui.Views;
-
-namespace CommunityToolkit.Maui.Sample.Pages.Views.LazyView;
-
-public class MyLazyView : LazyView<MyView>
-{
-	public override async ValueTask LoadViewAsync()
-	{
-		await base.LoadViewAsync();
-	}
-}
\ No newline at end of file
diff --git a/samples/CommunityToolkit.Maui.Sample/Pages/Views/LazyView/MyViewLazyView.cs b/samples/CommunityToolkit.Maui.Sample/Pages/Views/LazyView/MyViewLazyView.cs
new file mode 100644
index 0000000000..e8d274ba83
--- /dev/null
+++ b/samples/CommunityToolkit.Maui.Sample/Pages/Views/LazyView/MyViewLazyView.cs
@@ -0,0 +1,11 @@
+using CommunityToolkit.Maui.Views;
+
+namespace CommunityToolkit.Maui.Sample.Pages.Views.LazyView;
+
+class MyViewLazyView : LazyView<MyView>
+{
+	public override async ValueTask LoadViewAsync(CancellationToken token)
+	{
+		await base.LoadViewAsync(token);
+	}
+}
\ No newline at end of file
diff --git a/samples/CommunityToolkit.Maui.Sample/Pages/Views/MediaElement/MediaElementPage.xaml b/samples/CommunityToolkit.Maui.Sample/Pages/Views/MediaElement/MediaElementPage.xaml
index 6931f2be34..44866bb166 100644
--- a/samples/CommunityToolkit.Maui.Sample/Pages/Views/MediaElement/MediaElementPage.xaml
+++ b/samples/CommunityToolkit.Maui.Sample/Pages/Views/MediaElement/MediaElementPage.xaml
@@ -29,7 +29,7 @@
                 <RowDefinition Height="Auto" />
             </Grid.RowDefinitions>
             <toolkit:MediaElement
-                x:Name="mediaElement"
+                x:Name="MediaElement"
                 ShouldAutoPlay="True"
                 Source="https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4"
                 MediaEnded="OnMediaEnded"
@@ -43,9 +43,9 @@
                 <Label HorizontalOptions="Center">
                     <Label.Text>
                         <MultiBinding StringFormat="{}Position: {0}/{1} - Current State: {2}">
-                            <Binding Path="Position" Source="{x:Reference mediaElement}" Converter="{StaticResource SecondsToStringConverter}" />
-                            <Binding Path="Duration" Source="{x:Reference mediaElement}" Converter="{StaticResource SecondsToStringConverter}" />
-                            <Binding Path="CurrentState" Source="{x:Reference mediaElement}" />
+                            <Binding Path="Position" Source="{x:Reference MediaElement}" Converter="{StaticResource SecondsToStringConverter}" />
+                            <Binding Path="Duration" Source="{x:Reference MediaElement}" Converter="{StaticResource SecondsToStringConverter}" />
+                            <Binding Path="CurrentState" Source="{x:Reference MediaElement}" />
                         </MultiBinding>
                     </Label.Text>
                 </Label>
@@ -59,12 +59,12 @@
                 <Button Grid.Column="3" Text="Mute" Clicked="OnMuteClicked">
                     <Button.Triggers>
                         <DataTrigger TargetType="Button"
-                                     Binding="{Binding ShouldMute, Source={x:Reference mediaElement}}"
+                                     Binding="{Binding ShouldMute, Source={x:Reference MediaElement}}"
                                      Value="True">
                             <Setter Property="Text" Value="Unmute" />
                         </DataTrigger>
                         <DataTrigger TargetType="Button"
-                                     Binding="{Binding ShouldMute, Source={x:Reference mediaElement}}"
+                                     Binding="{Binding ShouldMute, Source={x:Reference MediaElement}}"
                                      Value="False">
                             <Setter Property="Text" Value="Mute" />
                         </DataTrigger>
@@ -73,7 +73,7 @@
             </Grid>
 
             <Slider
-                x:Name="positionSlider"
+                x:Name="PositionSlider"
                 Grid.Row="3"
                 MinimumTrackColor="Gray"
                 DragStarted="Slider_DragStarted"
@@ -83,7 +83,7 @@
                 <Button Text="Change Source" Clicked="ChangeSourceClicked" />
 
                 <Grid ColumnDefinitions="*, 100" ColumnSpacing="5">
-                    <Entry x:Name="customSourceEntry" Placeholder="Enter URL" HorizontalOptions="FillAndExpand" />
+                    <Entry x:Name="CustomSourceEntry" Placeholder="Enter URL" HorizontalOptions="FillAndExpand" />
                     <Button Grid.Column="1" Clicked="Button_Clicked" Text="Load" />
                 </Grid>
 
@@ -95,7 +95,7 @@
                     <Label.FormattedText>
                         <FormattedString>
                             <Span Text="Speed:" />
-                            <Span Text="{Binding Source={x:Reference mediaElement}, Path=Speed}" />
+                            <Span Text="{Binding Source={x:Reference MediaElement}, Path=Speed}" />
                         </FormattedString>
                     </Label.FormattedText>
                 </Label>
@@ -109,7 +109,7 @@
                     <Label.FormattedText>
                         <FormattedString>
                             <Span Text="Volume:" />
-                            <Span Text="{Binding Source={x:Reference mediaElement}, Path=Volume, StringFormat='{}{0:P0}'}" />
+                            <Span Text="{Binding Source={x:Reference MediaElement}, Path=Volume, StringFormat='{}{0:P0}'}" />
                         </FormattedString>
                     </Label.FormattedText>
                 </Label>
@@ -124,7 +124,7 @@
                         Margin="0,0,5,0"
                         ThumbColor="White"
                         OnColor="LimeGreen"
-                        IsToggled="{Binding Source={x:Reference mediaElement}, Path=ShouldShowPlaybackControls}" />
+                        IsToggled="{Binding Source={x:Reference MediaElement}, Path=ShouldShowPlaybackControls}" />
                     <Label
                         VerticalOptions="Center"
                         Text="Show playback controls" />
@@ -134,7 +134,7 @@
                         Margin="0,0,5,0"
                         ThumbColor="White"
                         OnColor="LimeGreen"
-                        IsToggled="{Binding Source={x:Reference mediaElement}, Path=ShouldLoopPlayback}" />
+                        IsToggled="{Binding Source={x:Reference MediaElement}, Path=ShouldLoopPlayback}" />
                     <Label
                         VerticalOptions="Center"
                         Text="Loop media" />
@@ -144,7 +144,7 @@
                         Margin="0,0,5,0"
                         ThumbColor="White"
                         OnColor="LimeGreen"
-                        IsToggled="{Binding Source={x:Reference mediaElement}, Path=ShouldKeepScreenOn}" />
+                        IsToggled="{Binding Source={x:Reference MediaElement}, Path=ShouldKeepScreenOn}" />
                     <Label
                         VerticalOptions="Center"
                         Text="Keep screen on" />
diff --git a/samples/CommunityToolkit.Maui.Sample/Pages/Views/MediaElement/MediaElementPage.xaml.cs b/samples/CommunityToolkit.Maui.Sample/Pages/Views/MediaElement/MediaElementPage.xaml.cs
index 442b6b7436..c92a272e33 100644
--- a/samples/CommunityToolkit.Maui.Sample/Pages/Views/MediaElement/MediaElementPage.xaml.cs
+++ b/samples/CommunityToolkit.Maui.Sample/Pages/Views/MediaElement/MediaElementPage.xaml.cs
@@ -19,15 +19,15 @@ public MediaElementPage(MediaElementViewModel viewModel, ILogger<MediaElementPag
 		InitializeComponent();
 
 		this.logger = logger;
-		mediaElement.PropertyChanged += MediaElement_PropertyChanged;
+		MediaElement.PropertyChanged += MediaElement_PropertyChanged;
 	}
 
 	void MediaElement_PropertyChanged(object? sender, PropertyChangedEventArgs e)
 	{
 		if (e.PropertyName == MediaElement.DurationProperty.PropertyName)
 		{
-			logger.LogInformation("Duration: {newDuration}", mediaElement.Duration);
-			positionSlider.Maximum = mediaElement.Duration.TotalSeconds;
+			logger.LogInformation("Duration: {newDuration}", MediaElement.Duration);
+			PositionSlider.Maximum = MediaElement.Duration.TotalSeconds;
 		}
 	}
 
@@ -43,100 +43,101 @@ void OnStateChanged(object? sender, MediaStateChangedEventArgs e) =>
 	void OnPositionChanged(object? sender, MediaPositionChangedEventArgs e)
 	{
 		logger.LogInformation("Position changed to {position}", e.Position);
-		positionSlider.Value = e.Position.TotalSeconds;
+		PositionSlider.Value = e.Position.TotalSeconds;
 	}
 
 	void OnSeekCompleted(object? sender, EventArgs e) => logger.LogInformation("Seek completed.");
 
 	void OnSpeedMinusClicked(object? sender, EventArgs e)
 	{
-		if (mediaElement.Speed >= 1)
+		if (MediaElement.Speed >= 1)
 		{
-			mediaElement.Speed -= 1;
+			MediaElement.Speed -= 1;
 		}
 	}
 
 	void OnSpeedPlusClicked(object? sender, EventArgs e)
 	{
-		if (mediaElement.Speed < 10)
+		if (MediaElement.Speed < 10)
 		{
-			mediaElement.Speed += 1;
+			MediaElement.Speed += 1;
 		}
 	}
 
 	void OnVolumeMinusClicked(object? sender, EventArgs e)
 	{
-		if (mediaElement.Volume >= 0)
+		if (MediaElement.Volume >= 0)
 		{
-			if (mediaElement.Volume < .1)
+			if (MediaElement.Volume < .1)
 			{
-				mediaElement.Volume = 0;
+				MediaElement.Volume = 0;
 
 				return;
 			}
 
-			mediaElement.Volume -= .1;
+			MediaElement.Volume -= .1;
 		}
 	}
 
 	void OnVolumePlusClicked(object? sender, EventArgs e)
 	{
-		if (mediaElement.Volume < 1)
+		if (MediaElement.Volume < 1)
 		{
-			if (mediaElement.Volume > .9)
+			if (MediaElement.Volume > .9)
 			{
-				mediaElement.Volume = 1;
+				MediaElement.Volume = 1;
 
 				return;
 			}
 
-			mediaElement.Volume += .1;
+			MediaElement.Volume += .1;
 		}
 	}
 
 	void OnPlayClicked(object? sender, EventArgs e)
 	{
-		mediaElement.Play();
+		MediaElement.Play();
 	}
 
 	void OnPauseClicked(object? sender, EventArgs e)
 	{
-		mediaElement.Pause();
+		MediaElement.Pause();
 	}
 
 	void OnStopClicked(object? sender, EventArgs e)
 	{
-		mediaElement.Stop();
+		MediaElement.Stop();
 	}
 
 	void OnMuteClicked(object? sender, EventArgs e)
 	{
-		mediaElement.ShouldMute = !mediaElement.ShouldMute;
+		MediaElement.ShouldMute = !MediaElement.ShouldMute;
 	}
 
 	void BasePage_Unloaded(object? sender, EventArgs e)
 	{
 		// Stop and cleanup MediaElement when we navigate away
-		mediaElement.Handler?.DisconnectHandler();
+		MediaElement.Handler?.DisconnectHandler();
 	}
 
-	void Slider_DragCompleted(object? sender, EventArgs e)
+	async void Slider_DragCompleted(object? sender, EventArgs e)
 	{
 		ArgumentNullException.ThrowIfNull(sender);
 
 		var newValue = ((Slider)sender).Value;
-		mediaElement.SeekTo(TimeSpan.FromSeconds(newValue));
-		mediaElement.Play();
+		await MediaElement.SeekTo(TimeSpan.FromSeconds(newValue), CancellationToken.None);
+
+		MediaElement.Play();
 	}
 
 	void Slider_DragStarted(object sender, EventArgs e)
 	{
-		mediaElement.Pause();
+		MediaElement.Pause();
 	}
 
 	void Button_Clicked(object? sender, EventArgs e)
 	{
-		if (string.IsNullOrWhiteSpace(customSourceEntry.Text))
+		if (string.IsNullOrWhiteSpace(CustomSourceEntry.Text))
 		{
 			DisplayAlert("Error Loading URL Source", "No value was found to load as a media source. " +
 				"When you do enter a value, make sure it's a valid URL. No additional validation is done.",
@@ -145,10 +146,10 @@ void Button_Clicked(object? sender, EventArgs e)
 			return;
 		}
 
-		mediaElement.Source = MediaSource.FromUri(customSourceEntry.Text);
+		MediaElement.Source = MediaSource.FromUri(CustomSourceEntry.Text);
 	}
 
-	async void ChangeSourceClicked(System.Object sender, System.EventArgs e)
+	async void ChangeSourceClicked(Object sender, EventArgs e)
 	{
 		var result = await DisplayActionSheet("Choose a source", "Cancel", null,
 			loadOnlineMp4, loadHls, loadLocalResource, resetSource);
@@ -156,40 +157,40 @@ async void ChangeSourceClicked(System.Object sender, System.EventArgs e)
 		switch (result)
 		{
 			case loadOnlineMp4:
-				mediaElement.Source =
+				MediaElement.Source =
 					MediaSource.FromUri(
 						"https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4");
 				return;
 
 			case loadHls:
-				mediaElement.Source
+				MediaElement.Source
 					= MediaSource.FromUri(
 						"https://wowza.peer5.com/live/smil:bbb_abr.smil/playlist.m3u8");
 				return;
 
 			case resetSource:
-				mediaElement.Source = null;
+				MediaElement.Source = null;
 				return;
 
 			case loadLocalResource:
 				if (DeviceInfo.Platform == DevicePlatform.MacCatalyst
 					|| DeviceInfo.Platform == DevicePlatform.iOS)
 				{
-					mediaElement.Source = MediaSource.FromResource("AppleVideo.mp4");
+					MediaElement.Source = MediaSource.FromResource("AppleVideo.mp4");
 				}
 				else if (DeviceInfo.Platform == DevicePlatform.Android)
 				{
-					mediaElement.Source = MediaSource.FromResource("AndroidVideo.mp4");
+					MediaElement.Source = MediaSource.FromResource("AndroidVideo.mp4");
 				}
 				else if (DeviceInfo.Platform == DevicePlatform.WinUI)
 				{
-					mediaElement.Source = MediaSource.FromResource("WindowsVideo.mp4");
+					MediaElement.Source = MediaSource.FromResource("WindowsVideo.mp4");
 				}
 				return;
 		}
 	}
 
-	async void ChangeAspectClicked(System.Object sender, System.EventArgs e)
+	async void ChangeAspectClicked(Object sender, EventArgs e)
 	{
 		var resultAspect = await DisplayActionSheet("Choose aspect ratio",
 			"Cancel", null, Aspect.AspectFit.ToString(),
@@ -209,6 +210,6 @@ await DisplayAlert("Error", "There was an error determining the selected aspect"
 			return;
 		}
 
-		mediaElement.Aspect = (Aspect)aspectEnum;
+		MediaElement.Aspect = (Aspect)aspectEnum;
 	}
 }
\ No newline at end of file
diff --git a/samples/CommunityToolkit.Maui.Sample/Pages/Views/Popup/MultiplePopupPage.xaml.cs b/samples/CommunityToolkit.Maui.Sample/Pages/Views/Popup/MultiplePopupPage.xaml.cs
index b8d4e7300d..03e8e4b1fd 100644
--- a/samples/CommunityToolkit.Maui.Sample/Pages/Views/Popup/MultiplePopupPage.xaml.cs
+++ b/samples/CommunityToolkit.Maui.Sample/Pages/Views/Popup/MultiplePopupPage.xaml.cs
@@ -24,49 +24,49 @@ public MultiplePopupPage(PopupSizeConstants popupSizeConstants,
 	async void HandleSimplePopupButtonClicked(object sender, EventArgs e)
 	{
 		var simplePopup = new SimplePopup(popupSizeConstants);
-		await this.ShowPopupAsync(simplePopup);
+		await this.ShowPopupAsync(simplePopup, CancellationToken.None);
 	}
 
 	async void HandleButtonPopupButtonClicked(object sender, EventArgs e)
 	{
 		var buttonPopup = new ButtonPopup(popupSizeConstants);
-		await this.ShowPopupAsync(buttonPopup);
+		await this.ShowPopupAsync(buttonPopup, CancellationToken.None);
 	}
 
 	async void HandleMultipleButtonPopupButtonClicked(object sender, EventArgs e)
 	{
 		var multipleButtonPopup = new MultipleButtonPopup(popupSizeConstants);
-		await this.ShowPopupAsync(multipleButtonPopup);
+		await this.ShowPopupAsync(multipleButtonPopup, CancellationToken.None);
 	}
 
 	async void HandleNoOutsideTapDismissPopupClicked(object sender, EventArgs e)
 	{
 		var noOutsideTapDismissPopup = new NoOutsideTapDismissPopup(popupSizeConstants);
-		await this.ShowPopupAsync(noOutsideTapDismissPopup);
+		await this.ShowPopupAsync(noOutsideTapDismissPopup, CancellationToken.None);
 	}
 
 	async void HandleToggleSizePopupButtonClicked(object sender, EventArgs e)
 	{
 		var toggleSizePopup = new ToggleSizePopup(popupSizeConstants);
-		await this.ShowPopupAsync(toggleSizePopup);
+		await this.ShowPopupAsync(toggleSizePopup, CancellationToken.None);
 	}
 
 	async void HandleTransparentPopupButtonClicked(object sender, EventArgs e)
 	{
 		var transparentPopup = new TransparentPopup();
-		await this.ShowPopupAsync(transparentPopup);
+		await this.ShowPopupAsync(transparentPopup, CancellationToken.None);
 	}
 
 	async void HandleOpenedEventSimplePopupButtonClicked(object sender, EventArgs e)
 	{
 		var openedEventSimplePopup = new OpenedEventSimplePopup(popupSizeConstants);
-		await this.ShowPopupAsync(openedEventSimplePopup);
+		await this.ShowPopupAsync(openedEventSimplePopup, CancellationToken.None);
 	}
 
 	async void HandleReturnResultPopupButtonClicked(object sender, EventArgs e)
 	{
 		var returnResultPopup = new ReturnResultPopup(popupSizeConstants);
-		var result = await this.ShowPopupAsync(returnResultPopup);
+		var result = await this.ShowPopupAsync(returnResultPopup, CancellationToken.None);
 
 		await DisplayAlert("Pop Result Returned", $"Result: {result}", "OK");
 	}
@@ -74,12 +74,12 @@ async void HandleReturnResultPopupButtonClicked(object sender, EventArgs e)
 	async void HandleXamlBindingPopupPopupButtonClicked(object sender, EventArgs e)
 	{
 		var xamlBindingPopup = new XamlBindingPopup(popupSizeConstants);
-		await this.ShowPopupAsync(xamlBindingPopup);
+		await this.ShowPopupAsync(xamlBindingPopup, CancellationToken.None);
 	}
 
 	async void HandleCsharpBindingPopupButtonClicked(object sender, EventArgs e)
 	{
 		var csharpBindingPopup = new CsharpBindingPopup(popupSizeConstants, csharpBindingPopupViewModel);
-		await this.ShowPopupAsync(csharpBindingPopup);
+		await this.ShowPopupAsync(csharpBindingPopup, CancellationToken.None);
 	}
 }
\ No newline at end of file
diff --git a/samples/CommunityToolkit.Maui.Sample/Pages/Views/Popup/ShowPopupInOnAppearingPage.xaml.cs b/samples/CommunityToolkit.Maui.Sample/Pages/Views/Popup/ShowPopupInOnAppearingPage.xaml.cs
index 347cb069f8..423a943196 100644
--- a/samples/CommunityToolkit.Maui.Sample/Pages/Views/Popup/ShowPopupInOnAppearingPage.xaml.cs
+++ b/samples/CommunityToolkit.Maui.Sample/Pages/Views/Popup/ShowPopupInOnAppearingPage.xaml.cs
@@ -20,7 +20,9 @@ public ShowPopupInOnAppearingPage(
 
 	protected override async void OnAppearing()
 	{
+		var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+
 		// Proves that we now support showing a popup before the platform is even ready.
-		await this.ShowPopupAsync(new ReturnResultPopup(popupSizeConstants));
+		await this.ShowPopupAsync(new ReturnResultPopup(popupSizeConstants), cts.Token);
 	}
 }
\ No newline at end of file
diff --git a/samples/CommunityToolkit.Maui.Sample/ViewModels/Behaviors/AnimationBehaviorViewModel.cs b/samples/CommunityToolkit.Maui.Sample/ViewModels/Behaviors/AnimationBehaviorViewModel.cs
index b41e54e3d1..7d2f8ad748 100644
--- a/samples/CommunityToolkit.Maui.Sample/ViewModels/Behaviors/AnimationBehaviorViewModel.cs
+++ b/samples/CommunityToolkit.Maui.Sample/ViewModels/Behaviors/AnimationBehaviorViewModel.cs
@@ -7,5 +7,5 @@ namespace CommunityToolkit.Maui.Sample.ViewModels.Behaviors;
 public partial class AnimationBehaviorViewModel : BaseViewModel
 {
 	[RelayCommand]
-	Task OnAnimation() => Snackbar.Make($"{nameof(AnimationCommand)} is triggered.").Show();
+	Task OnAnimation(CancellationToken token) => Snackbar.Make($"{nameof(AnimationCommand)} is triggered.").Show(token);
 }
\ No newline at end of file
diff --git a/samples/CommunityToolkit.Maui.Sample/ViewModels/Converters/ByteArrayToImageSourceConverterViewModel.cs b/samples/CommunityToolkit.Maui.Sample/ViewModels/Converters/ByteArrayToImageSourceConverterViewModel.cs
index 2b00481a45..83b4b90529 100644
--- a/samples/CommunityToolkit.Maui.Sample/ViewModels/Converters/ByteArrayToImageSourceConverterViewModel.cs
+++ b/samples/CommunityToolkit.Maui.Sample/ViewModels/Converters/ByteArrayToImageSourceConverterViewModel.cs
@@ -37,20 +37,20 @@ public void Dispose()
 	bool CanDownloadDotNetBotImageComandExecute => !IsDownloadingImage && DotNetBotImageByteArray is null;
 
 	[RelayCommand(CanExecute = nameof(CanDownloadDotNetBotImageComandExecute))]
-	async Task DownloadDotNetBotImage()
+	async Task DownloadDotNetBotImage(CancellationToken token)
 	{
 		IsDownloadingImage = true;
 
 		var maximumDownloadTime = TimeSpan.FromSeconds(5);
-		var cancellationTokenSource = new CancellationTokenSource(maximumDownloadTime);
+		var maximumDownloadTimeCTS = new CancellationTokenSource(maximumDownloadTime);
 
 		// Ensure Activity Indicator appears on screen for a minumum of 1.5 seconds when the user taps the Download Button
 		var minimumDownloadTime = TimeSpan.FromSeconds(1.5);
-		var minimumDownloadTimeTask = Task.Delay(minimumDownloadTime, cancellationTokenSource.Token);
+		var minimumDownloadTimeTask = Task.Delay(minimumDownloadTime, maximumDownloadTimeCTS.Token).WaitAsync(token);
 
 		try
 		{
-			DotNetBotImageByteArray = await client.GetByteArrayAsync("https://user-images.githubusercontent.com/13558917/137551073-ac8958bf-83e3-4ae3-8623-4db6dce49d02.png", cancellationTokenSource.Token).ConfigureAwait(false);
+			DotNetBotImageByteArray = await client.GetByteArrayAsync("https://user-images.githubusercontent.com/13558917/137551073-ac8958bf-83e3-4ae3-8623-4db6dce49d02.png", maximumDownloadTimeCTS.Token).WaitAsync(token).ConfigureAwait(false);
 
 			await minimumDownloadTimeTask.ConfigureAwait(false);
 
diff --git a/samples/CommunityToolkit.Maui.Sample/ViewModels/Converters/ItemTappedEventArgsConverterViewModel.cs b/samples/CommunityToolkit.Maui.Sample/ViewModels/Converters/ItemTappedEventArgsConverterViewModel.cs
index e12009b2cb..a7a4d3ce2b 100644
--- a/samples/CommunityToolkit.Maui.Sample/ViewModels/Converters/ItemTappedEventArgsConverterViewModel.cs
+++ b/samples/CommunityToolkit.Maui.Sample/ViewModels/Converters/ItemTappedEventArgsConverterViewModel.cs
@@ -18,13 +18,13 @@ public partial class ItemTappedEventArgsConverterViewModel : BaseViewModel
 	};
 
 	[RelayCommand]
-	Task ItemTapped(Person? person)
+	Task ItemTapped(Person? person, CancellationToken token)
 	{
 		ArgumentNullException.ThrowIfNull(person);
 
 		ItemSelected = null;
 
-		return Application.Current?.MainPage?.DisplayAlert("Item Tapped", person.Name, "Ok") ?? Task.CompletedTask;
+		return Application.Current?.MainPage?.DisplayAlert("Item Tapped", person.Name, "Ok").WaitAsync(token) ?? Task.CompletedTask;
 	}
 
 }
diff --git a/samples/CommunityToolkit.Maui.Sample/ViewModels/Essentials/SpeechToTextViewModel.cs b/samples/CommunityToolkit.Maui.Sample/ViewModels/Essentials/SpeechToTextViewModel.cs
index 9b10561ac0..c7de96e7ec 100644
--- a/samples/CommunityToolkit.Maui.Sample/ViewModels/Essentials/SpeechToTextViewModel.cs
+++ b/samples/CommunityToolkit.Maui.Sample/ViewModels/Essentials/SpeechToTextViewModel.cs
@@ -45,11 +45,11 @@ public SpeechToTextViewModel(ITextToSpeech textToSpeech, ISpeechToText speechToT
 	public ObservableCollection<Locale> Locales { get; } = new();
 
 	[RelayCommand]
-	async Task SetLocales()
+	async Task SetLocales(CancellationToken token)
 	{
 		Locales.Clear();
 
-		var locales = await textToSpeech.GetLocalesAsync();
+		var locales = await textToSpeech.GetLocalesAsync().WaitAsync(token);
 
 		foreach (var locale in locales.OrderBy(x => x.Language).ThenBy(x => x.Name))
 		{
@@ -80,7 +80,7 @@ async Task Listen(CancellationToken cancellationToken)
 			var isGranted = await speechToText.RequestPermissions(cancellationToken);
 			if (!isGranted)
 			{
-				await Toast.Make("Permission not granted").Show(CancellationToken.None);
+				await Toast.Make("Permission not granted").Show(cancellationToken);
 				return;
 			}
 
@@ -106,7 +106,7 @@ async Task Listen(CancellationToken cancellationToken)
 			}
 			else
 			{
-				await Toast.Make(recognitionResult.Exception?.Message ?? "Unable to recognize speech").Show(CancellationToken.None);
+				await Toast.Make(recognitionResult.Exception?.Message ?? "Unable to recognize speech").Show(cancellationToken);
 			}
 
 			if (RecognitionText is beginSpeakingPrompt)
@@ -130,7 +130,7 @@ async Task StartListen(CancellationToken cancellationToken)
 		var isGranted = await speechToText.RequestPermissions(cancellationToken);
 		if (!isGranted)
 		{
-			await Toast.Make("Permission not granted").Show(CancellationToken.None);
+			await Toast.Make("Permission not granted").Show(cancellationToken);
 			return;
 		}
 
diff --git a/samples/CommunityToolkit.Maui.Sample/ViewModels/Extensions/KeyboardExtensionsViewModel.cs b/samples/CommunityToolkit.Maui.Sample/ViewModels/Extensions/KeyboardExtensionsViewModel.cs
index 880e95a58a..a15aa989d4 100644
--- a/samples/CommunityToolkit.Maui.Sample/ViewModels/Extensions/KeyboardExtensionsViewModel.cs
+++ b/samples/CommunityToolkit.Maui.Sample/ViewModels/Extensions/KeyboardExtensionsViewModel.cs
@@ -49,7 +49,7 @@ async Task OnShowKeyboard(ITextInput view, CancellationToken token)
 	{
 		try
 		{
-			bool isSuccessful = await view.ShowKeyboardAsync(CancellationToken.None);
+			bool isSuccessful = await view.ShowKeyboardAsync(token);
 
 			if (isSuccessful)
 			{
diff --git a/samples/CommunityToolkit.Maui.Sample/ViewModels/Layouts/StateContainerViewModel.cs b/samples/CommunityToolkit.Maui.Sample/ViewModels/Layouts/StateContainerViewModel.cs
index 075184085c..8c5cdd52ef 100644
--- a/samples/CommunityToolkit.Maui.Sample/ViewModels/Layouts/StateContainerViewModel.cs
+++ b/samples/CommunityToolkit.Maui.Sample/ViewModels/Layouts/StateContainerViewModel.cs
@@ -21,16 +21,16 @@ public partial class StateContainerViewModel : BaseViewModel
 	bool canAnimationStateChange = true;
 
 	[RelayCommand(CanExecute = nameof(CanCycleStateChange))]
-	async Task CycleStates()
+	async Task CycleStates(CancellationToken token)
 	{
 		CurrentState = StateKey.Loading;
-		await Task.Delay(2000).ConfigureAwait(false);
+		await Task.Delay(2000, token).ConfigureAwait(false);
 
 		CurrentState = StateKey.Success;
-		await Task.Delay(2000).ConfigureAwait(false);
+		await Task.Delay(2000, token).ConfigureAwait(false);
 
 		CurrentState = StateKey.Anything;
-		await Task.Delay(2000).ConfigureAwait(false);
+		await Task.Delay(2000, token).ConfigureAwait(false);
 
 		// Setting state to empty string or null returns to the default content
 		CurrentState = string.Empty;
diff --git a/samples/CommunityToolkit.Maui.Sample/ViewModels/Views/DrawingViewViewModel.cs b/samples/CommunityToolkit.Maui.Sample/ViewModels/Views/DrawingViewViewModel.cs
index d87c80fc5e..9db40ddcd7 100644
--- a/samples/CommunityToolkit.Maui.Sample/ViewModels/Views/DrawingViewViewModel.cs
+++ b/samples/CommunityToolkit.Maui.Sample/ViewModels/Views/DrawingViewViewModel.cs
@@ -72,7 +72,7 @@ async Task Save(CancellationToken cancellationToken)
 	{
 		try
 		{
-			await using var stream = await DrawingView.GetImageStream(Lines, new Size(1920, 1080), Brush.Blue);
+			await using var stream = await DrawingView.GetImageStream(Lines, new Size(1920, 1080), Brush.Blue, cancellationToken);
 
 			await Permissions.RequestAsync<Permissions.StorageRead>().WaitAsync(cancellationToken);
 			await Permissions.RequestAsync<Permissions.StorageWrite>().WaitAsync(cancellationToken);
diff --git a/samples/CommunityToolkit.Maui.Sample/ViewModels/Views/Popup/CustomSizeAndPositionPopupViewModel.cs b/samples/CommunityToolkit.Maui.Sample/ViewModels/Views/Popup/CustomSizeAndPositionPopupViewModel.cs
index 0255419443..380c50004b 100644
--- a/samples/CommunityToolkit.Maui.Sample/ViewModels/Views/Popup/CustomSizeAndPositionPopupViewModel.cs
+++ b/samples/CommunityToolkit.Maui.Sample/ViewModels/Views/Popup/CustomSizeAndPositionPopupViewModel.cs
@@ -22,11 +22,11 @@ public partial class CustomSizeAndPositionPopupViewModel : BaseViewModel
 	public IReadOnlyList<string> FlowDirectionOptions { get; } = Enum.GetNames(typeof(FlowDirection)).ToList();
 
 	[RelayCommand(CanExecute = nameof(CanShowButtonExecute))]
-	public Task ExecuteShowButton()
+	public Task ExecuteShowButton(CancellationToken token)
 	{
 		if (!IsFlowDirectionSelectionValid(FlowDirectionSelectedIndex, FlowDirectionOptions.Count))
 		{
-			throw new ArgumentOutOfRangeException(nameof(FlowDirectionSelectedIndex), FlowDirectionSelectedIndex, "Invalid FlowDirection Selected");
+			throw new IndexOutOfRangeException("Invalid FlowDirection Selected");
 		}
 
 		Microsoft.Maui.Primitives.LayoutAlignment? verticalOptions = null, horizontalOptions = null;
@@ -76,7 +76,7 @@ public Task ExecuteShowButton()
 			HorizontalOptions = horizontalOptions.Value
 		};
 
-		return Shell.Current.ShowPopupAsync(popup);
+		return Shell.Current.ShowPopupAsync(popup, token);
 	}
 
 	static bool IsFlowDirectionSelectionValid(int flowDirectionSelection, int flowDirectionOptionsCount)
diff --git a/samples/CommunityToolkit.Maui.Sample/ViewModels/Views/Popup/MultiplePopupViewModel.cs b/samples/CommunityToolkit.Maui.Sample/ViewModels/Views/Popup/MultiplePopupViewModel.cs
index 5f08474732..5be9493b27 100644
--- a/samples/CommunityToolkit.Maui.Sample/ViewModels/Views/Popup/MultiplePopupViewModel.cs
+++ b/samples/CommunityToolkit.Maui.Sample/ViewModels/Views/Popup/MultiplePopupViewModel.cs
@@ -13,16 +13,18 @@ public MultiplePopupViewModel(IPopupService popupService)
 	}
 
 	[RelayCommand]
-	Task OnCsharpBindingPopup()
+	Task OnCsharpBindingPopup(CancellationToken token)
 	{
 		return popupService.ShowPopupAsync<CsharpBindingPopupViewModel>(
-			onPresenting: viewModel => viewModel.Load("This is a platform specific popup with a .NET MAUI View being rendered. The behaviors of the popup will confirm to 100% this platform look and feel, but still allows you to use your .NET MAUI Controls."));
+			onPresenting: viewModel => viewModel.Load("This is a platform specific popup with a .NET MAUI View being rendered. The behaviors of the popup will confirm to 100% this platform look and feel, but still allows you to use your .NET MAUI Controls."),
+			token);
 	}
 
 	[RelayCommand]
-	Task OnUpdatingPopup()
+	Task OnUpdatingPopup(CancellationToken token)
 	{
 		return popupService.ShowPopupAsync<UpdatingPopupViewModel>(
-			onPresenting: viewModel => viewModel.PerformUpdates(10));
+			onPresenting: viewModel => viewModel.PerformUpdates(10),
+			token);
 	}
 }
\ No newline at end of file
diff --git a/samples/CommunityToolkit.Maui.Sample/Views/Popups/ButtonPopup.xaml.cs b/samples/CommunityToolkit.Maui.Sample/Views/Popups/ButtonPopup.xaml.cs
index a2e29e4a47..878318b840 100644
--- a/samples/CommunityToolkit.Maui.Sample/Views/Popups/ButtonPopup.xaml.cs
+++ b/samples/CommunityToolkit.Maui.Sample/Views/Popups/ButtonPopup.xaml.cs
@@ -11,5 +11,9 @@ public ButtonPopup(PopupSizeConstants popupSizeConstants)
 		Size = popupSizeConstants.Medium;
 	}
 
-	async void Button_Clicked(object? sender, EventArgs e) => await CloseAsync();
+	async void Button_Clicked(object? sender, EventArgs e)
+	{
+		var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+		await CloseAsync(cts.Token);
+	}
 }
\ No newline at end of file
diff --git a/samples/CommunityToolkit.Maui.Sample/Views/Popups/MultipleButtonPopup.xaml.cs b/samples/CommunityToolkit.Maui.Sample/Views/Popups/MultipleButtonPopup.xaml.cs
index cfa3e3e7a4..527aa6e02e 100644
--- a/samples/CommunityToolkit.Maui.Sample/Views/Popups/MultipleButtonPopup.xaml.cs
+++ b/samples/CommunityToolkit.Maui.Sample/Views/Popups/MultipleButtonPopup.xaml.cs
@@ -12,7 +12,15 @@ public MultipleButtonPopup(PopupSizeConstants popupSizeConstants)
 		Size = popupSizeConstants.Medium;
 	}
 
-	async void Cancel_Clicked(object? sender, EventArgs e) => await CloseAsync(false);
+	async void Cancel_Clicked(object? sender, EventArgs e)
+	{
+		var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+		await CloseAsync(false, cts.Token);
+	}
 
-	async void Okay_Clicked(object? sender, EventArgs e) => await CloseAsync(true);
+	async void Okay_Clicked(object? sender, EventArgs e)
+	{
+		var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+		await CloseAsync(true, cts.Token);
+	}
 }
\ No newline at end of file
diff --git a/samples/CommunityToolkit.Maui.Sample/Views/Popups/NoOutsideTapDismissPopup.xaml.cs b/samples/CommunityToolkit.Maui.Sample/Views/Popups/NoOutsideTapDismissPopup.xaml.cs
index 9528630665..8ad89fe2a0 100644
--- a/samples/CommunityToolkit.Maui.Sample/Views/Popups/NoOutsideTapDismissPopup.xaml.cs
+++ b/samples/CommunityToolkit.Maui.Sample/Views/Popups/NoOutsideTapDismissPopup.xaml.cs
@@ -15,7 +15,9 @@ public NoOutsideTapDismissPopup(PopupSizeConstants popupSizeConstants)
 
 	async void Button_Clicked(object? sender, EventArgs e)
 	{
-		await CloseAsync();
-		await Toast.Make("Popup Dismissed By Button").Show();
+		var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+
+		await CloseAsync(cts.Token);
+		await Toast.Make("Popup Dismissed By Button").Show(cts.Token);
 	}
 }
\ No newline at end of file
diff --git a/samples/CommunityToolkit.Maui.Sample/Views/Popups/ReturnResultPopup.xaml.cs b/samples/CommunityToolkit.Maui.Sample/Views/Popups/ReturnResultPopup.xaml.cs
index 45a03d8dc2..47bfa3f471 100644
--- a/samples/CommunityToolkit.Maui.Sample/Views/Popups/ReturnResultPopup.xaml.cs
+++ b/samples/CommunityToolkit.Maui.Sample/Views/Popups/ReturnResultPopup.xaml.cs
@@ -13,5 +13,9 @@ public ReturnResultPopup(PopupSizeConstants popupSizeConstants)
 		ResultWhenUserTapsOutsideOfPopup = "User Tapped Outside of Popup";
 	}
 
-	async void Button_Clicked(object? sender, EventArgs e) => await CloseAsync("Close button tapped");
+	async void Button_Clicked(object? sender, EventArgs e)
+	{
+		var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+		await CloseAsync("Close button tapped", cts.Token);
+	}
 }
\ No newline at end of file
diff --git a/samples/CommunityToolkit.Maui.Sample/Views/Popups/TransparentPopup.xaml.cs b/samples/CommunityToolkit.Maui.Sample/Views/Popups/TransparentPopup.xaml.cs
index afe0e2cfbc..7c4445045e 100644
--- a/samples/CommunityToolkit.Maui.Sample/Views/Popups/TransparentPopup.xaml.cs
+++ b/samples/CommunityToolkit.Maui.Sample/Views/Popups/TransparentPopup.xaml.cs
@@ -8,6 +8,7 @@ public partial class TransparentPopup : Popup
 
 	public async void CloseButtonClicked(object? sender, EventArgs args)
 	{
-		await CloseAsync();
+		var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+		await CloseAsync(cts.Token);
 	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/FileSaver/FileSaver.shared.cs b/src/CommunityToolkit.Maui.Core/Essentials/FileSaver/FileSaver.shared.cs
index c0c747e629..aad2d2ca42 100644
--- a/src/CommunityToolkit.Maui.Core/Essentials/FileSaver/FileSaver.shared.cs
+++ b/src/CommunityToolkit.Maui.Core/Essentials/FileSaver/FileSaver.shared.cs
@@ -18,7 +18,7 @@ public static class FileSaver
 	[SupportedOSPlatform("MacCatalyst14.0")]
 	[SupportedOSPlatform("Tizen")]
 	[SupportedOSPlatform("Windows")]
-	public static Task<FileSaverResult> SaveAsync(string initialPath, string fileName, Stream stream, CancellationToken cancellationToken) =>
+	public static Task<FileSaverResult> SaveAsync(string initialPath, string fileName, Stream stream, CancellationToken cancellationToken = default) =>
 		Default.SaveAsync(initialPath, fileName, stream, cancellationToken);
 
 	/// <inheritdoc cref="IFileSaver.SaveAsync(string, Stream, CancellationToken)"/>
@@ -27,7 +27,7 @@ public static Task<FileSaverResult> SaveAsync(string initialPath, string fileNam
 	[SupportedOSPlatform("MacCatalyst14.0")]
 	[SupportedOSPlatform("Tizen")]
 	[SupportedOSPlatform("Windows")]
-	public static Task<FileSaverResult> SaveAsync(string fileName, Stream stream, CancellationToken cancellationToken) =>
+	public static Task<FileSaverResult> SaveAsync(string fileName, Stream stream, CancellationToken cancellationToken = default) =>
 		Default.SaveAsync(fileName, stream, cancellationToken);
 
 	internal static void SetDefault(IFileSaver implementation) =>
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/FileSaver/FileSaverImplementation.shared.cs b/src/CommunityToolkit.Maui.Core/Essentials/FileSaver/FileSaverImplementation.shared.cs
index 9bc7f2fe07..6fdf9ab6ee 100644
--- a/src/CommunityToolkit.Maui.Core/Essentials/FileSaver/FileSaverImplementation.shared.cs
+++ b/src/CommunityToolkit.Maui.Core/Essentials/FileSaver/FileSaverImplementation.shared.cs
@@ -3,7 +3,7 @@ namespace CommunityToolkit.Maui.Storage;
 public sealed partial class FileSaverImplementation
 {
 	/// <inheritdoc/>
-	public async Task<FileSaverResult> SaveAsync(string initialPath, string fileName, Stream stream, CancellationToken cancellationToken)
+	public async Task<FileSaverResult> SaveAsync(string initialPath, string fileName, Stream stream, CancellationToken cancellationToken = default)
 	{
 		try
 		{
@@ -18,7 +18,7 @@ public async Task<FileSaverResult> SaveAsync(string initialPath, string fileName
 	}
 
 	/// <inheritdoc/>
-	public async Task<FileSaverResult> SaveAsync(string fileName, Stream stream, CancellationToken cancellationToken)
+	public async Task<FileSaverResult> SaveAsync(string fileName, Stream stream, CancellationToken cancellationToken = default)
 	{
 		try
 		{
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/FileSaver/IFileSaver.shared.cs b/src/CommunityToolkit.Maui.Core/Essentials/FileSaver/IFileSaver.shared.cs
index 01d33d1f99..f8248115b8 100644
--- a/src/CommunityToolkit.Maui.Core/Essentials/FileSaver/IFileSaver.shared.cs
+++ b/src/CommunityToolkit.Maui.Core/Essentials/FileSaver/IFileSaver.shared.cs
@@ -19,7 +19,7 @@ public interface IFileSaver
 	[SupportedOSPlatform("MacCatalyst14.0")]
 	[SupportedOSPlatform("Tizen")]
 	[SupportedOSPlatform("Windows")]
-	Task<FileSaverResult> SaveAsync(string initialPath, string fileName, Stream stream, CancellationToken cancellationToken);
+	Task<FileSaverResult> SaveAsync(string initialPath, string fileName, Stream stream, CancellationToken cancellationToken = default);
 
 	/// <summary>
 	/// Saves a file to the default folder on the file system
@@ -32,5 +32,5 @@ public interface IFileSaver
 	[SupportedOSPlatform("MacCatalyst14.0")]
 	[SupportedOSPlatform("Tizen")]
 	[SupportedOSPlatform("Windows")]
-	Task<FileSaverResult> SaveAsync(string fileName, Stream stream, CancellationToken cancellationToken);
+	Task<FileSaverResult> SaveAsync(string fileName, Stream stream, CancellationToken cancellationToken = default);
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/FolderPicker/FolderPicker.shared.cs b/src/CommunityToolkit.Maui.Core/Essentials/FolderPicker/FolderPicker.shared.cs
index 890912263b..4ff09fa6fd 100644
--- a/src/CommunityToolkit.Maui.Core/Essentials/FolderPicker/FolderPicker.shared.cs
+++ b/src/CommunityToolkit.Maui.Core/Essentials/FolderPicker/FolderPicker.shared.cs
@@ -18,7 +18,7 @@ public static class FolderPicker
 	[SupportedOSPlatform("MacCatalyst14.0")]
 	[SupportedOSPlatform("Tizen")]
 	[SupportedOSPlatform("Windows")]
-	public static Task<FolderPickerResult> PickAsync(string initialPath, CancellationToken cancellationToken) =>
+	public static Task<FolderPickerResult> PickAsync(string initialPath, CancellationToken cancellationToken = default) =>
 		Default.PickAsync(initialPath, cancellationToken);
 
 	/// <inheritdoc cref="IFolderPicker.PickAsync(CancellationToken)"/>
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/FolderPicker/FolderPickerImplementation.shared.cs b/src/CommunityToolkit.Maui.Core/Essentials/FolderPicker/FolderPickerImplementation.shared.cs
index fc9387e122..15346c70a7 100644
--- a/src/CommunityToolkit.Maui.Core/Essentials/FolderPicker/FolderPickerImplementation.shared.cs
+++ b/src/CommunityToolkit.Maui.Core/Essentials/FolderPicker/FolderPickerImplementation.shared.cs
@@ -3,7 +3,7 @@ namespace CommunityToolkit.Maui.Storage;
 public sealed partial class FolderPickerImplementation
 {
 	/// <inheritdoc/>
-	public async Task<FolderPickerResult> PickAsync(string initialPath, CancellationToken cancellationToken)
+	public async Task<FolderPickerResult> PickAsync(string initialPath, CancellationToken cancellationToken = default)
 	{
 		try
 		{
@@ -18,7 +18,7 @@ public async Task<FolderPickerResult> PickAsync(string initialPath, Cancellation
 	}
 
 	/// <inheritdoc/>
-	public async Task<FolderPickerResult> PickAsync(CancellationToken cancellationToken)
+	public async Task<FolderPickerResult> PickAsync(CancellationToken cancellationToken = default)
 	{
 		try
 		{
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/FolderPicker/IFolderPicker.shared.cs b/src/CommunityToolkit.Maui.Core/Essentials/FolderPicker/IFolderPicker.shared.cs
index 7f7cb23dce..4e699c4a88 100644
--- a/src/CommunityToolkit.Maui.Core/Essentials/FolderPicker/IFolderPicker.shared.cs
+++ b/src/CommunityToolkit.Maui.Core/Essentials/FolderPicker/IFolderPicker.shared.cs
@@ -18,7 +18,7 @@ public interface IFolderPicker
 	[SupportedOSPlatform("MacCatalyst14.0")]
 	[SupportedOSPlatform("Tizen")]
 	[SupportedOSPlatform("Windows")]
-	Task<FolderPickerResult> PickAsync(string initialPath, CancellationToken cancellationToken);
+	Task<FolderPickerResult> PickAsync(string initialPath, CancellationToken cancellationToken = default);
 
 	/// <summary>
 	/// Allows the user to pick a folder from the file system
@@ -30,5 +30,5 @@ public interface IFolderPicker
 	[SupportedOSPlatform("MacCatalyst14.0")]
 	[SupportedOSPlatform("Tizen")]
 	[SupportedOSPlatform("Windows")]
-	Task<FolderPickerResult> PickAsync(CancellationToken cancellationToken);
+	Task<FolderPickerResult> PickAsync(CancellationToken cancellationToken = default);
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/ISpeechToText.shared.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/ISpeechToText.shared.cs
index e6b3d82d29..c9e6964905 100644
--- a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/ISpeechToText.shared.cs
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/ISpeechToText.shared.cs
@@ -34,7 +34,7 @@ public interface ISpeechToText : IAsyncDisposable
 	/// <param name="recognitionResult">Intermediate recognition result.</param>
 	/// <param name="cancellationToken"><see cref="CancellationToken"/></param>
 	/// <returns>Final recognition result</returns>
-	Task<SpeechToTextResult> ListenAsync(CultureInfo culture, IProgress<string>? recognitionResult, CancellationToken cancellationToken);
+	Task<SpeechToTextResult> ListenAsync(CultureInfo culture, IProgress<string>? recognitionResult, CancellationToken cancellationToken = default);
 
 	/// <summary>
 	/// Starts the SpeechToText service
@@ -44,7 +44,7 @@ public interface ISpeechToText : IAsyncDisposable
 	/// </remarks>
 	/// <param name="culture">Speak language</param>
 	/// <param name="cancellationToken"><see cref="CancellationToken"/></param>
-	Task StartListenAsync(CultureInfo culture, CancellationToken cancellationToken);
+	Task StartListenAsync(CultureInfo culture, CancellationToken cancellationToken = default);
 
 	/// <summary>
 	/// Stops the SpeechToText service
@@ -53,12 +53,12 @@ public interface ISpeechToText : IAsyncDisposable
 	/// Speech recognition results will be surfaced via <see cref="RecognitionResultCompleted"/>
 	/// </remarks>
 	/// <param name="cancellationToken"><see cref="CancellationToken"/></param>
-	Task StopListenAsync(CancellationToken cancellationToken);
+	Task StopListenAsync(CancellationToken cancellationToken = default);
 
 	/// <summary>
 	/// Request permissions for speech to text.
 	/// </summary>
 	/// <param name="cancellationToken"><see cref="CancellationToken"/></param>
 	/// <returns>True if permissions granted</returns>
-	Task<bool> RequestPermissions(CancellationToken cancellationToken);
+	Task<bool> RequestPermissions(CancellationToken cancellationToken = default);
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SharedSpeechToTextImplementation.macios.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SharedSpeechToTextImplementation.macios.cs
index 346e7ca92d..2624973064 100644
--- a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SharedSpeechToTextImplementation.macios.cs
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SharedSpeechToTextImplementation.macios.cs
@@ -42,7 +42,7 @@ public async ValueTask DisposeAsync()
 	}
 
 	/// <inheritdoc />
-	public Task<bool> RequestPermissions(CancellationToken cancellationToken)
+	public Task<bool> RequestPermissions(CancellationToken cancellationToken = default)
 	{
 		var taskResult = new TaskCompletionSource<bool>();
 
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToText.shared.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToText.shared.cs
index 230366a5fc..9a85ccd572 100644
--- a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToText.shared.cs
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToText.shared.cs
@@ -13,19 +13,19 @@ public static class SpeechToText
 	public static ISpeechToText Default => defaultImplementation.Value;
 
 	/// <inheritdoc cref="ISpeechToText.ListenAsync"/>
-	public static Task<SpeechToTextResult> ListenAsync(CultureInfo culture, IProgress<string>? recognitionResult, CancellationToken cancellationToken) =>
+	public static Task<SpeechToTextResult> ListenAsync(CultureInfo culture, IProgress<string>? recognitionResult, CancellationToken cancellationToken = default) =>
 		Default.ListenAsync(culture, recognitionResult, cancellationToken);
 
 	/// <inheritdoc cref="ISpeechToText.StartListenAsync"/>
-	public static Task StartListenAsync(CultureInfo culture, CancellationToken cancellationToken) =>
+	public static Task StartListenAsync(CultureInfo culture, CancellationToken cancellationToken = default) =>
 		Default.StartListenAsync(culture, cancellationToken);
 
 	/// <inheritdoc cref="ISpeechToText.StopListenAsync"/>
-	public static Task StopListenAsync(CancellationToken cancellationToken) =>
+	public static Task StopListenAsync(CancellationToken cancellationToken = default) =>
 		Default.StopListenAsync(cancellationToken);
 
 	/// <inheritdoc cref="ISpeechToText.RequestPermissions"/>
-	public static Task<bool> RequestPermissions(CancellationToken cancellationToken) =>
+	public static Task<bool> RequestPermissions(CancellationToken cancellationToken = default) =>
 		Default.RequestPermissions(cancellationToken);
 
 	internal static void SetDefault(ISpeechToText implementation) =>
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.shared.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.shared.cs
index 6f12285cb7..b4f52faa85 100644
--- a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.shared.cs
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.shared.cs
@@ -33,7 +33,7 @@ public event EventHandler<SpeechToTextStateChangedEventArgs> StateChanged
 
 
 	/// <inheritdoc/>
-	public async Task<SpeechToTextResult> ListenAsync(CultureInfo culture, IProgress<string>? recognitionResult, CancellationToken cancellationToken)
+	public async Task<SpeechToTextResult> ListenAsync(CultureInfo culture, IProgress<string>? recognitionResult, CancellationToken cancellationToken = default)
 	{
 		try
 		{
@@ -54,7 +54,7 @@ public async Task<SpeechToTextResult> ListenAsync(CultureInfo culture, IProgress
 	}
 
 	/// <inheritdoc/>
-	public async Task StartListenAsync(CultureInfo culture, CancellationToken cancellationToken)
+	public async Task StartListenAsync(CultureInfo culture, CancellationToken cancellationToken = default)
 	{
 		cancellationToken.ThrowIfCancellationRequested();
 
@@ -68,7 +68,7 @@ public async Task StartListenAsync(CultureInfo culture, CancellationToken cancel
 	}
 
 	/// <inheritdoc/>
-	public Task StopListenAsync(CancellationToken cancellationToken) => InternalStopListeningAsync(cancellationToken);
+	public Task StopListenAsync(CancellationToken cancellationToken = default) => InternalStopListeningAsync(cancellationToken);
 
 	void OnRecognitionResultUpdated(string recognitionResult)
 	{
@@ -87,7 +87,7 @@ void OnSpeechToTextStateChanged(SpeechToTextState speechToTextState)
 
 #if !MACCATALYST && !IOS
 	/// <inheritdoc/>
-	public async Task<bool> RequestPermissions(CancellationToken cancellationToken)
+	public async Task<bool> RequestPermissions(CancellationToken cancellationToken = default)
 	{
 		var status = await Permissions.RequestAsync<Permissions.Microphone>().WaitAsync(cancellationToken).ConfigureAwait(false);
 		return status is PermissionStatus.Granted;
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.tizen.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.tizen.cs
index dda14e9c02..a112f959e0 100644
--- a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.tizen.cs
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.tizen.cs
@@ -133,7 +133,7 @@ Task<bool> Initialize(CancellationToken cancellationToken)
 			return tcsInitialize.Task.WaitAsync(cancellationToken);
 		}
 
-		tcsInitialize = new TaskCompletionSource<bool>(cancellationToken);
+		tcsInitialize = new TaskCompletionSource<bool>();
 		sttClient = new SttClient();
 
 		sttClient.StateChanged += (s, e) =>
@@ -169,12 +169,12 @@ async Task InternalStartListeningAsync(CultureInfo culture, CancellationToken ca
 			: RecognitionType.Free;
 
 		sttClient.Start(defaultSttEngineLocale, recognitionType);
-
-		cancellationToken.ThrowIfCancellationRequested();
 	}
 
 	Task InternalStopListeningAsync(CancellationToken cancellationToken)
 	{
+		cancellationToken.ThrowIfCancellationRequested();
+
 		if (sttClient is not null)
 		{
 			StopRecording(sttClient);
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.windows.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.windows.cs
index 7ac6fed7c6..6a0c6639b3 100644
--- a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.windows.cs
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.windows.cs
@@ -44,7 +44,7 @@ async Task InternalStartListeningAsync(CultureInfo culture, CancellationToken ca
 		speechRecognizer.ContinuousRecognitionSession.Completed += OnCompleted;
 		try
 		{
-			await speechRecognizer.ContinuousRecognitionSession.StartAsync();
+			await speechRecognizer.ContinuousRecognitionSession.StartAsync().AsTask(cancellationToken);
 		}
 		catch (Exception ex) when ((uint)ex.HResult is privacyStatementDeclinedCode)
 		{
@@ -77,10 +77,7 @@ void ResultGenerated(SpeechContinuousRecognitionSession sender, SpeechContinuous
 		OnRecognitionResultUpdated(args.Result.Text);
 	}
 
-	async Task InternalStopListeningAsync(CancellationToken cancellationToken)
-	{
-		await StopRecording(cancellationToken);
-	}
+	Task InternalStopListeningAsync(CancellationToken cancellationToken) =>  StopRecording(cancellationToken);
 
 	async Task<string> InternalListenAsync(CultureInfo culture, IProgress<string>? recognitionResult, CancellationToken cancellationToken)
 	{
@@ -103,7 +100,7 @@ async Task StopRecording(CancellationToken cancellationToken)
 				speechRecognizer.ContinuousRecognitionSession.Completed -= OnCompleted;
 
 				cancellationToken.ThrowIfCancellationRequested();
-				await speechRecognizer.ContinuousRecognitionSession.StopAsync();
+				await speechRecognizer.ContinuousRecognitionSession.StopAsync().AsTask(cancellationToken);
 			}
 		}
 		catch
@@ -133,7 +130,7 @@ async Task Initialize(CultureInfo culture, CancellationToken cancellationToken)
 		speechRecognizer = new SpeechRecognizer(new Language(culture.IetfLanguageTag));
 		speechRecognizer.StateChanged += SpeechRecognizer_StateChanged;
 		cancellationToken.ThrowIfCancellationRequested();
-		await speechRecognizer.CompileConstraintsAsync();
+		await speechRecognizer.CompileConstraintsAsync().AsTask(cancellationToken);
 	}
 
 	void SpeechRecognizer_StateChanged(SpeechRecognizer sender, SpeechRecognizerStateChangedEventArgs args)
diff --git a/src/CommunityToolkit.Maui.Core/IPopupService.cs b/src/CommunityToolkit.Maui.Core/IPopupService.cs
index 3d57530215..f549dbfa2d 100644
--- a/src/CommunityToolkit.Maui.Core/IPopupService.cs
+++ b/src/CommunityToolkit.Maui.Core/IPopupService.cs
@@ -32,8 +32,9 @@ public interface IPopupService
 	/// Resolves and displays a <see cref="CommunityToolkit.Maui.Core.IPopup"/> and <typeparamref name="TViewModel"/> pair that was registered with <c>AddTransientPopup</c>.
 	/// </summary>
 	/// <typeparam name="TViewModel">The type of the view model registered with the <see cref="CommunityToolkit.Maui.Core.IPopup"/>.</typeparam>
+	/// <param name="token"><see cref="CancellationToken"/> </param>
 	/// <returns>A <see cref="Task"/> that can be awaited to return the result of the <see cref="CommunityToolkit.Maui.Core.IPopup"/> once it has been dismissed.</returns>
-	Task<object?> ShowPopupAsync<TViewModel>() where TViewModel : INotifyPropertyChanged;
+	Task<object?> ShowPopupAsync<TViewModel>(CancellationToken token = default) where TViewModel : INotifyPropertyChanged;
 
 	/// <summary>
 	/// Resolves and displays a <see cref="CommunityToolkit.Maui.Core.IPopup"/> and <typeparamref name="TViewModel"/> pair that was registered with <c>AddTransientPopup</c>.
@@ -42,13 +43,15 @@ public interface IPopupService
 	/// <typeparam name="TViewModel">The type of the view model registered with the <see cref="CommunityToolkit.Maui.Core.IPopup"/>.</typeparam>
 	/// <returns>A <see cref="Task"/> that can be awaited to return the result of the <see cref="CommunityToolkit.Maui.Core.IPopup"/> once it has been dismissed.</returns>
 	/// <param name="onPresenting">An <see cref="Action{TViewModel}"/> that will be performed before the popup is presented.</param>
-	Task<object?> ShowPopupAsync<TViewModel>(Action<TViewModel> onPresenting) where TViewModel : INotifyPropertyChanged;
+	/// <param name="token"><see cref="CancellationToken"/> </param>
+	Task<object?> ShowPopupAsync<TViewModel>(Action<TViewModel> onPresenting, CancellationToken token = default) where TViewModel : INotifyPropertyChanged;
 
 	/// <summary>
 	/// Resolves and displays a <see cref="CommunityToolkit.Maui.Core.IPopup"/> and <typeparamref name="TViewModel"/> pair that was registered with <c>AddTransientPopup</c>.
 	/// </summary>
 	/// <typeparam name="TViewModel">The type of the view model registered with the <see cref="CommunityToolkit.Maui.Core.IPopup"/>.</typeparam>
 	/// <param name="viewModel">The view model to use as the <c>BindingContext</c> for the <see cref="CommunityToolkit.Maui.Core.IPopup"/>.</param>
+	/// <param name="token"><see cref="CancellationToken"/> </param>
 	/// <returns>A <see cref="Task"/> that can be awaited to return the result of the <see cref="CommunityToolkit.Maui.Core.IPopup"/> once it has been dismissed.</returns>
-	Task<object?> ShowPopupAsync<TViewModel>(TViewModel viewModel) where TViewModel : INotifyPropertyChanged;
+	Task<object?> ShowPopupAsync<TViewModel>(TViewModel viewModel, CancellationToken token = default) where TViewModel : INotifyPropertyChanged;
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.Core/Interfaces/IDrawingLine.shared.cs b/src/CommunityToolkit.Maui.Core/Interfaces/IDrawingLine.shared.cs
index 54c4ec442b..6fde7f4d38 100644
--- a/src/CommunityToolkit.Maui.Core/Interfaces/IDrawingLine.shared.cs
+++ b/src/CommunityToolkit.Maui.Core/Interfaces/IDrawingLine.shared.cs
@@ -39,5 +39,6 @@ public interface IDrawingLine
 	/// <param name="imageSizeHeight">Desired height of the image that is returned.</param>
 	/// <param name="background">Background of the generated image.</param>
 	/// <returns><see cref="ValueTask{Stream}"/> containing the data of the requested image with data that's currently on the <see cref="IDrawingLine"/>.</returns>
-	ValueTask<Stream> GetImageStream(double imageSizeWidth, double imageSizeHeight, Paint background);
+	/// <param name="token"> <see cref="CancellationToken"/>.</param>
+	ValueTask<Stream> GetImageStream(double imageSizeWidth, double imageSizeHeight, Paint background, CancellationToken token = default);
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.Core/Interfaces/IDrawingView.shared.cs b/src/CommunityToolkit.Maui.Core/Interfaces/IDrawingView.shared.cs
index 857777c5d9..bef0059b4b 100644
--- a/src/CommunityToolkit.Maui.Core/Interfaces/IDrawingView.shared.cs
+++ b/src/CommunityToolkit.Maui.Core/Interfaces/IDrawingView.shared.cs
@@ -45,8 +45,9 @@ public interface IDrawingView : IView
 	/// </summary>
 	/// <param name="imageSizeWidth">Desired width of the image that is returned. The image will be resized proportionally.</param>
 	/// <param name="imageSizeHeight">Desired height of the image that is returned. The image will be resized proportionally.</param>
+	/// <param name="token"> <see cref="CancellationToken"/>.</param>
 	/// <returns><see cref="Task{Stream}"/> containing the data of the requested image with data that's currently on the <see cref="IDrawingView"/>.</returns>
-	ValueTask<Stream> GetImageStream(double imageSizeWidth, double imageSizeHeight);
+	ValueTask<Stream> GetImageStream(double imageSizeWidth, double imageSizeHeight, CancellationToken token = default);
 
 	/// <summary>
 	/// Clears the <see cref="Lines"/> that are currently drawn on the <see cref="IDrawingView"/>.
diff --git a/src/CommunityToolkit.Maui.Core/Platform/KeyboardExtensions/KeyboardExtensions.shared.cs b/src/CommunityToolkit.Maui.Core/Platform/KeyboardExtensions/KeyboardExtensions.shared.cs
index 40428ad9ad..14c58799f3 100644
--- a/src/CommunityToolkit.Maui.Core/Platform/KeyboardExtensions/KeyboardExtensions.shared.cs
+++ b/src/CommunityToolkit.Maui.Core/Platform/KeyboardExtensions/KeyboardExtensions.shared.cs
@@ -28,7 +28,7 @@ public static partial class KeyboardExtensions
 	/// <param name="token">Cancellation token</param>
 	/// <returns>
 	/// Returns <c>true</c> if the platform was able to hide the soft input device.</returns>
-	public static ValueTask<bool> HideKeyboardAsync(this ITextInput targetView, CancellationToken token)
+	public static ValueTask<bool> HideKeyboardAsync(this ITextInput targetView, CancellationToken token = default)
 	{
 		token.ThrowIfCancellationRequested();
 		if (!targetView.TryGetPlatformView(out var platformView, out _, out _))
@@ -46,7 +46,7 @@ public static ValueTask<bool> HideKeyboardAsync(this ITextInput targetView, Canc
 	/// <param name="token">Cancellation token</param>
 	/// <returns>
 	/// Returns <c>true</c> if the platform was able to show the soft input device.</returns>
-	public static Task<bool> ShowKeyboardAsync(this ITextInput targetView, CancellationToken token)
+	public static Task<bool> ShowKeyboardAsync(this ITextInput targetView, CancellationToken token = default)
 	{
 		token.ThrowIfCancellationRequested();
 
diff --git a/src/CommunityToolkit.Maui.Core/Views/DrawingView/DrawingLine.shared.cs b/src/CommunityToolkit.Maui.Core/Views/DrawingView/DrawingLine.shared.cs
index 391c84a35a..38fb5a236b 100644
--- a/src/CommunityToolkit.Maui.Core/Views/DrawingView/DrawingLine.shared.cs
+++ b/src/CommunityToolkit.Maui.Core/Views/DrawingView/DrawingLine.shared.cs
@@ -46,14 +46,16 @@ public int Granularity
 	/// <param name="lineWidth">The desired line width to be used in the generated image.</param>
 	/// <param name="strokeColor">The desired color of the line to be used in the generated image.</param>
 	/// <param name="background">Background of the generated image.</param>
+	/// <param name="token"><see cref="CancellationToken"/> </param>
 	/// <returns><see cref="ValueTask{Stream}"/> containing the data of the requested image with data that's provided through the <paramref name="points"/> parameter.</returns>
 	public static ValueTask<Stream> GetImageStream(IEnumerable<PointF> points,
 										Size imageSize,
 										float lineWidth,
 										Color strokeColor,
-										Paint background)
+										Paint background,
+										CancellationToken token = default)
 	{
-		return DrawingViewService.GetImageStream(points.ToList(), imageSize, lineWidth, strokeColor, background);
+		return DrawingViewService.GetImageStream(points.ToList(), imageSize, lineWidth, strokeColor, background, token);
 	}
 
 	/// <summary>
@@ -62,7 +64,10 @@ public static ValueTask<Stream> GetImageStream(IEnumerable<PointF> points,
 	/// <param name="imageSizeWidth">Desired width of the image that is returned.</param>
 	/// <param name="imageSizeHeight">Desired height of the image that is returned.</param>
 	/// <param name="background">Background of the generated image.</param>
+	/// <param name="token"><see cref="CancellationToken"/> </param>
 	/// <returns><see cref="ValueTask{Stream}"/> containing the data of the requested image with data that's currently on the <see cref="IDrawingView"/>.</returns>
-	public ValueTask<Stream> GetImageStream(double imageSizeWidth, double imageSizeHeight, Paint background) =>
-		DrawingViewService.GetImageStream(Points.ToList(), new Size(imageSizeWidth, imageSizeHeight), LineWidth, LineColor, background);
+	public ValueTask<Stream> GetImageStream(double imageSizeWidth, double imageSizeHeight, Paint background, CancellationToken token = default)
+	{
+		return DrawingViewService.GetImageStream(Points.ToList(), new Size(imageSizeWidth, imageSizeHeight), LineWidth, LineColor, background, token);
+	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.Core/Views/DrawingView/Service/DrawingViewService.android.cs b/src/CommunityToolkit.Maui.Core/Views/DrawingView/Service/DrawingViewService.android.cs
index c7c3f45a17..80357f4a7e 100644
--- a/src/CommunityToolkit.Maui.Core/Views/DrawingView/Service/DrawingViewService.android.cs
+++ b/src/CommunityToolkit.Maui.Core/Views/DrawingView/Service/DrawingViewService.android.cs
@@ -19,13 +19,14 @@ public static class DrawingViewService
 	/// <param name="lines">Drawing lines</param>
 	/// <param name="imageSize">Maximum image size. The image will be resized proportionally.</param>
 	/// <param name="background">Image background</param>
+	/// <param name="token"><see cref="CancellationToken"/></param>
 	/// <returns>Image stream</returns>
-	public static ValueTask<Stream> GetImageStream(in IList<IDrawingLine> lines,
-												   in Size imageSize,
-												   in Paint? background)
+	public static ValueTask<Stream> GetImageStream(IList<IDrawingLine> lines, Size imageSize, Paint? background, CancellationToken token = default)
 	{
+		token.ThrowIfCancellationRequested();
 
 		var image = GetBitmapForLines(lines, background);
+
 		return ValueTask.FromResult(GetBitmapStream(image, imageSize));
 	}
 
@@ -37,14 +38,14 @@ public static ValueTask<Stream> GetImageStream(in IList<IDrawingLine> lines,
 	/// <param name="lineWidth">Line Width</param>
 	/// <param name="strokeColor">Line color</param>
 	/// <param name="background">Image background</param>
+	/// <param name="token"><see cref="CancellationToken"/></param>
 	/// <returns>Image stream</returns>
-	public static ValueTask<Stream> GetImageStream(in IList<PointF> points,
-										in Size imageSize,
-										in float lineWidth,
-										in Color strokeColor,
-										in Paint? background)
+	public static ValueTask<Stream> GetImageStream(IList<PointF> points, Size imageSize, float lineWidth, Color strokeColor, Paint? background, CancellationToken token = default)
 	{
+		token.ThrowIfCancellationRequested();
+
 		var image = GetBitmapForPoints(points, lineWidth, strokeColor, background);
+
 		return ValueTask.FromResult(GetBitmapStream(image, imageSize));
 	}
 
diff --git a/src/CommunityToolkit.Maui.Core/Views/DrawingView/Service/DrawingViewService.macios.cs b/src/CommunityToolkit.Maui.Core/Views/DrawingView/Service/DrawingViewService.macios.cs
index 2a19461a24..32fa2b7b4d 100644
--- a/src/CommunityToolkit.Maui.Core/Views/DrawingView/Service/DrawingViewService.macios.cs
+++ b/src/CommunityToolkit.Maui.Core/Views/DrawingView/Service/DrawingViewService.macios.cs
@@ -15,15 +15,20 @@ public static class DrawingViewService
 	/// <param name="lines">Drawing lines</param>
 	/// <param name="imageSize">Maximum image size. The image will be resized proportionally.</param>
 	/// <param name="background">Image background</param>
+	/// <param name="token"><see cref="CancellationToken"/></param>
 	/// <returns>Image stream</returns>
-	public static ValueTask<Stream> GetImageStream(in IList<IDrawingLine> lines, in Size imageSize, in Paint? background)
+	public static ValueTask<Stream> GetImageStream(IList<IDrawingLine> lines, Size imageSize, Paint? background, CancellationToken token = default)
 	{
+		token.ThrowIfCancellationRequested();
+
 		var image = GetUIImageForLines(lines, background);
 		if (image is null)
 		{
 			return ValueTask.FromResult(Stream.Null);
 		}
-		
+
+		token.ThrowIfCancellationRequested();
+
 		var imageAsPng = GetMaximumUIImage(image, imageSize.Width, imageSize.Height)
 							.AsPNG() ?? throw new InvalidOperationException("Unable to convert image to PNG");
 
@@ -38,19 +43,20 @@ public static ValueTask<Stream> GetImageStream(in IList<IDrawingLine> lines, in
 	/// <param name="lineWidth">Line Width</param>
 	/// <param name="strokeColor">Line color</param>
 	/// <param name="background">Image background</param>
+	/// <param name="token"><see cref="CancellationToken"/></param>
 	/// <returns>Image stream</returns>
-	public static ValueTask<Stream> GetImageStream(in IList<PointF> points,
-										in Size imageSize,
-										in float lineWidth,
-										in Color strokeColor,
-										in Paint? background)
+	public static ValueTask<Stream> GetImageStream(IList<PointF> points, Size imageSize, float lineWidth, Color strokeColor, Paint? background, CancellationToken token = default)
 	{
+		token.ThrowIfCancellationRequested();
+
 		var image = GetUIImageForPoints(points, lineWidth, strokeColor, background);
 		if (image is null)
 		{
 			return ValueTask.FromResult(Stream.Null);
 		}
 
+		token.ThrowIfCancellationRequested();
+
 		var imageAsPng = GetMaximumUIImage(image, imageSize.Width, imageSize.Height)
 							.AsPNG() ?? throw new InvalidOperationException("Unable to convert image to PNG");
 
diff --git a/src/CommunityToolkit.Maui.Core/Views/DrawingView/Service/DrawingViewService.net.cs b/src/CommunityToolkit.Maui.Core/Views/DrawingView/Service/DrawingViewService.net.cs
index b07e5f2fb3..2ef5b849f3 100644
--- a/src/CommunityToolkit.Maui.Core/Views/DrawingView/Service/DrawingViewService.net.cs
+++ b/src/CommunityToolkit.Maui.Core/Views/DrawingView/Service/DrawingViewService.net.cs
@@ -13,9 +13,13 @@ public static class DrawingViewService
 	/// <param name="lineWidth">Line Width</param>
 	/// <param name="strokeColor">Line color</param>
 	/// <param name="background">Image background</param>
+	/// <param name="token"><see cref="CancellationToken"/></param>
 	/// <returns>Image stream</returns>
-	public static ValueTask<Stream> GetImageStream(IList<PointF> points, Size imageSize, float lineWidth, Color strokeColor, Paint? background)
-		=> ValueTask.FromResult(Stream.Null);
+	public static ValueTask<Stream> GetImageStream(IList<PointF> points, Size imageSize, float lineWidth, Color strokeColor, Paint? background, CancellationToken token = default)
+	{
+		token.ThrowIfCancellationRequested();
+		return ValueTask.FromResult(Stream.Null);
+	}
 
 	/// <summary>
 	/// Get image stream from lines
@@ -23,7 +27,11 @@ public static ValueTask<Stream> GetImageStream(IList<PointF> points, Size imageS
 	/// <param name="lines">Drawing lines</param>
 	/// <param name="imageSize">Maximum image size. The image will be resized proportionally.</param>
 	/// <param name="background">Image background</param>
+	/// <param name="token"><see cref="CancellationToken"/></param>
 	/// <returns>Image stream</returns>
-	public static ValueTask<Stream> GetImageStream(IList<IDrawingLine> lines, Size imageSize, Paint? background)
-		=> ValueTask.FromResult(Stream.Null);
+	public static ValueTask<Stream> GetImageStream(IList<IDrawingLine> lines, Size imageSize, Paint? background, CancellationToken token = default)
+	{
+		token.ThrowIfCancellationRequested();
+		return ValueTask.FromResult(Stream.Null);
+	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.Core/Views/DrawingView/Service/DrawingViewService.tizen.cs b/src/CommunityToolkit.Maui.Core/Views/DrawingView/Service/DrawingViewService.tizen.cs
index a8573eb279..2835f4754f 100644
--- a/src/CommunityToolkit.Maui.Core/Views/DrawingView/Service/DrawingViewService.tizen.cs
+++ b/src/CommunityToolkit.Maui.Core/Views/DrawingView/Service/DrawingViewService.tizen.cs
@@ -16,18 +16,21 @@ public static class DrawingViewService
 	/// <param name="lineWidth">Line Width</param>
 	/// <param name="strokeColor">Line color</param>
 	/// <param name="background">Image background</param>
+	/// <param name="token"><see cref="CancellationToken"/></param>
 	/// <returns>Image stream</returns>
-	public static ValueTask<Stream> GetImageStream(IList<PointF> points, Size imageSize, float lineWidth, Color strokeColor, Paint? background)
+	public static async ValueTask<Stream> GetImageStream(IList<PointF> points, Size imageSize, float lineWidth, Color strokeColor, Paint? background, CancellationToken token = default)
 	{
+		token.ThrowIfCancellationRequested();
+
 		var image = GetBitmapForPoints(points, lineWidth, strokeColor, background);
 
 		if (image is null)
 		{
-			return ValueTask.FromResult(Stream.Null);
+			return Stream.Null;
 		}
 
 		// Defer to thread pool thread https://github.com/CommunityToolkit/Maui/pull/692#pullrequestreview-1150202727
-		return new ValueTask<Stream>(Task.Run<Stream>(() =>
+		var stream = await Task.Run<Stream>(() =>
 		{
 			var resized = image.Resize(new SKImageInfo((int)imageSize.Width, (int)imageSize.Height, SKColorType.Bgra8888, SKAlphaType.Opaque), SKFilterQuality.High);
 			var data = resized.Encode(SKEncodedImageFormat.Png, 100);
@@ -37,7 +40,9 @@ public static ValueTask<Stream> GetImageStream(IList<PointF> points, Size imageS
 			stream.Seek(0, SeekOrigin.Begin);
 
 			return stream;
-		}));
+		}, token);
+
+		return stream;
 	}
 
 	/// <summary>
@@ -46,18 +51,21 @@ public static ValueTask<Stream> GetImageStream(IList<PointF> points, Size imageS
 	/// <param name="lines">Drawing lines</param>
 	/// <param name="imageSize">Maximum image size. The image will be resized proportionally.</param>
 	/// <param name="background">Image background</param>
+	/// <param name="token"><see cref="CancellationToken"/></param>
 	/// <returns>Image stream</returns>
-	public static ValueTask<Stream> GetImageStream(IList<IDrawingLine> lines, Size imageSize, Paint? background)
+	public static async ValueTask<Stream> GetImageStream(IList<IDrawingLine> lines, Size imageSize, Paint? background, CancellationToken token = default)
 	{
+		token.ThrowIfCancellationRequested();
+
 		var image = GetBitmapForLines(lines, background);
 
 		if (image is null)
 		{
-			return ValueTask.FromResult(Stream.Null);
+			return Stream.Null;
 		}
 
 		// Defer to thread pool thread https://github.com/CommunityToolkit/Maui/pull/692#pullrequestreview-1150202727
-		return new ValueTask<Stream>(Task.Run<Stream>(() =>
+		var stream = await Task.Run<Stream>(() =>
 		{
 			var resized = image.Resize(new SKImageInfo((int)imageSize.Width, (int)imageSize.Height, SKColorType.Bgra8888, SKAlphaType.Opaque), SKFilterQuality.High);
 			var data = resized.Encode(SKEncodedImageFormat.Png, 100);
@@ -67,7 +75,9 @@ public static ValueTask<Stream> GetImageStream(IList<IDrawingLine> lines, Size i
 			stream.Seek(0, SeekOrigin.Begin);
 
 			return stream;
-		}));
+		}, token);
+
+		return stream;
 	}
 
 	static (SKBitmap?, SizeF offset) GetBitmap(in ICollection<PointF> points, float maxLineWidth)
diff --git a/src/CommunityToolkit.Maui.Core/Views/DrawingView/Service/DrawingViewService.windows.cs b/src/CommunityToolkit.Maui.Core/Views/DrawingView/Service/DrawingViewService.windows.cs
index 87105c6e9f..7ca15dfea6 100644
--- a/src/CommunityToolkit.Maui.Core/Views/DrawingView/Service/DrawingViewService.windows.cs
+++ b/src/CommunityToolkit.Maui.Core/Views/DrawingView/Service/DrawingViewService.windows.cs
@@ -21,11 +21,13 @@ public static class DrawingViewService
 	/// <param name="lines">Drawing lines</param>
 	/// <param name="imageSize">Maximum image size. The image will be resized proportionally.</param>
 	/// <param name="background">Image background</param>
+	/// <param name="token"><see cref="CancellationToken"/></param>
 	/// <returns>Image stream</returns>
-	public static ValueTask<Stream> GetImageStream(IList<IDrawingLine> lines, Size imageSize, Paint? background)
+	public static ValueTask<Stream> GetImageStream(IList<IDrawingLine> lines, Size imageSize, Paint? background, CancellationToken token = default)
 	{
 		var canvas = GetImageInternal(lines, imageSize, background);
-		return GetCanvasRenderTargetStream(canvas);
+
+		return GetCanvasRenderTargetStream(canvas, token);
 	}
 
 	/// <summary>
@@ -36,19 +38,16 @@ public static ValueTask<Stream> GetImageStream(IList<IDrawingLine> lines, Size i
 	/// <param name="lineWidth">Line Width</param>
 	/// <param name="strokeColor">Line color</param>
 	/// <param name="background">Image background</param>
+	/// <param name="token"><see cref="CancellationToken"/></param>
 	/// <returns>Image stream</returns>
-	public static ValueTask<Stream> GetImageStream(
-		IList<PointF> points,
-		Size imageSize,
-		float lineWidth,
-		Color strokeColor,
-		Paint? background)
+	public static ValueTask<Stream> GetImageStream(IList<PointF> points, Size imageSize, float lineWidth, Color strokeColor, Paint? background, CancellationToken token = default)
 	{
 		var canvas = GetImageInternal(points, imageSize, lineWidth, strokeColor, background);
-		return GetCanvasRenderTargetStream(canvas);
+
+		return GetCanvasRenderTargetStream(canvas, token);
 	}
 
-	static async ValueTask<Stream> GetCanvasRenderTargetStream(CanvasRenderTarget? canvas)
+	static async ValueTask<Stream> GetCanvasRenderTargetStream(CanvasRenderTarget? canvas, CancellationToken token)
 	{
 		if (canvas is null)
 		{
@@ -58,7 +57,7 @@ static async ValueTask<Stream> GetCanvasRenderTargetStream(CanvasRenderTarget? c
 		using (canvas)
 		{
 			var fileStream = new InMemoryRandomAccessStream();
-			await canvas.SaveAsync(fileStream, CanvasBitmapFileFormat.Png);
+			await canvas.SaveAsync(fileStream, CanvasBitmapFileFormat.Png).AsTask(token);
 
 			var stream = fileStream.AsStream();
 			stream.Position = 0;
diff --git a/src/CommunityToolkit.Maui.MediaElement/Handlers/MediaElementHandler.shared.cs b/src/CommunityToolkit.Maui.MediaElement/Handlers/MediaElementHandler.shared.cs
index 7c2841e617..a952bd00d2 100644
--- a/src/CommunityToolkit.Maui.MediaElement/Handlers/MediaElementHandler.shared.cs
+++ b/src/CommunityToolkit.Maui.MediaElement/Handlers/MediaElementHandler.shared.cs
@@ -70,8 +70,8 @@ public MediaElementHandler(IPropertyMapper? mapper, CommandMapper? commandMapper
 	/// <see cref="MediaElement"/> and platform counterpart.
 	/// </summary>
 	/// <param name="handler">The associated handler.</param>
-	/// <param name="MediaElement">The associated <see cref="MediaElement"/> instance.</param>
-	public static void MapAspect(MediaElementHandler handler, MediaElement MediaElement)
+	/// <param name="mediaElement">The associated <see cref="MediaElement"/> instance.</param>
+	public static void MapAspect(MediaElementHandler handler, MediaElement mediaElement)
 	{
 		handler.mediaManager?.UpdateAspect();
 	}
@@ -81,8 +81,8 @@ public static void MapAspect(MediaElementHandler handler, MediaElement MediaElem
 	/// <see cref="MediaElement"/> and platform counterpart.
 	/// </summary>
 	/// <param name="handler">The associated handler.</param>
-	/// <param name="MediaElement">The associated <see cref="MediaElement"/> instance.</param>
-	public static void MapShouldShowPlaybackControls(MediaElementHandler handler, MediaElement MediaElement)
+	/// <param name="mediaElement">The associated <see cref="MediaElement"/> instance.</param>
+	public static void MapShouldShowPlaybackControls(MediaElementHandler handler, MediaElement mediaElement)
 	{
 		handler.mediaManager?.UpdateShouldShowPlaybackControls();
 	}
@@ -92,8 +92,8 @@ public static void MapShouldShowPlaybackControls(MediaElementHandler handler, Me
 	/// <see cref="MediaElement"/> and platform counterpart.
 	/// </summary>
 	/// <param name="handler">The associated handler.</param>
-	/// <param name="MediaElement">The associated <see cref="MediaElement"/> instance.</param>
-	public static void MapSource(MediaElementHandler handler, MediaElement MediaElement)
+	/// <param name="mediaElement">The associated <see cref="MediaElement"/> instance.</param>
+	public static void MapSource(MediaElementHandler handler, MediaElement mediaElement)
 	{
 		handler.mediaManager?.UpdateSource();
 	}
@@ -103,8 +103,8 @@ public static void MapSource(MediaElementHandler handler, MediaElement MediaElem
 	/// <see cref="MediaElement"/> and platform counterpart.
 	/// </summary>
 	/// <param name="handler">The associated handler.</param>
-	/// <param name="MediaElement">The associated <see cref="MediaElement"/> instance.</param>
-	public static void MapSpeed(MediaElementHandler handler, MediaElement MediaElement)
+	/// <param name="mediaElement">The associated <see cref="MediaElement"/> instance.</param>
+	public static void MapSpeed(MediaElementHandler handler, MediaElement mediaElement)
 	{
 		handler.mediaManager?.UpdateSpeed();
 	}
@@ -113,10 +113,10 @@ public static void MapSpeed(MediaElementHandler handler, MediaElement MediaEleme
 	/// Maps the status update between the abstract <see cref="MediaElement"/> and platform counterpart.
 	/// </summary>
 	/// <param name="handler">The associated handler.</param>
-	/// <param name="MediaElement">The associated <see cref="MediaElement"/> instance.</param>
+	/// <param name="mediaElement">The associated <see cref="MediaElement"/> instance.</param>
 	/// <param name="args">The associated event arguments for this request.</param>
 	/// <remarks><paramref name="args"/> is not used.</remarks>
-	public static void MapStatusUpdated(MediaElementHandler handler, MediaElement MediaElement, object? args)
+	public static void MapStatusUpdated(MediaElementHandler handler, MediaElement mediaElement, object? args)
 	{
 		handler.mediaManager?.UpdateStatus();
 	}
@@ -126,8 +126,8 @@ public static void MapStatusUpdated(MediaElementHandler handler, MediaElement Me
 	/// <see cref="MediaElement"/> and platform counterpart.
 	/// </summary>
 	/// <param name="handler">The associated handler.</param>
-	/// <param name="MediaElement">The associated <see cref="MediaElement"/> instance.</param>
-	public static void MapVolume(MediaElementHandler handler, MediaElement MediaElement)
+	/// <param name="mediaElement">The associated <see cref="MediaElement"/> instance.</param>
+	public static void MapVolume(MediaElementHandler handler, MediaElement mediaElement)
 	{
 		handler.mediaManager?.UpdateVolume();
 	}
@@ -137,8 +137,8 @@ public static void MapVolume(MediaElementHandler handler, MediaElement MediaElem
 	/// <see cref="MediaElement"/> and platform counterpart.
 	/// </summary>
 	/// <param name="handler">The associated handler.</param>
-	/// <param name="MediaElement">The associated <see cref="MediaElement"/> instance.</param>
-	public static void MapShouldKeepScreenOn(MediaElementHandler handler, MediaElement MediaElement)
+	/// <param name="mediaElement">The associated <see cref="MediaElement"/> instance.</param>
+	public static void MapShouldKeepScreenOn(MediaElementHandler handler, MediaElement mediaElement)
 	{
 		handler.mediaManager?.UpdateShouldKeepScreenOn();
 	}
@@ -148,8 +148,8 @@ public static void MapShouldKeepScreenOn(MediaElementHandler handler, MediaEleme
 	/// <see cref="MediaElement"/> and platform counterpart.
 	/// </summary>
 	/// <param name="handler">The associated handler.</param>
-	/// <param name="MediaElement">The associated <see cref="MediaElement"/> instance.</param>
-	public static void MapShouldMute(MediaElementHandler handler, MediaElement MediaElement)
+	/// <param name="mediaElement">The associated <see cref="MediaElement"/> instance.</param>
+	public static void MapShouldMute(MediaElementHandler handler, MediaElement mediaElement)
 	{
 		handler.mediaManager?.UpdateShouldMute();
 	}
@@ -158,10 +158,10 @@ public static void MapShouldMute(MediaElementHandler handler, MediaElement Media
 	/// Maps the play operation request between the abstract <see cref="MediaElement"/> and platform counterpart.
 	/// </summary>
 	/// <param name="handler">The associated handler.</param>
-	/// <param name="MediaElement">The associated <see cref="MediaElement"/> instance.</param>
+	/// <param name="mediaElement">The associated <see cref="MediaElement"/> instance.</param>
 	/// <param name="args">The associated event arguments for this request.</param>
 	/// <remarks><paramref name="args"/> is not used.</remarks>
-	public static void MapPlayRequested(MediaElementHandler handler, MediaElement MediaElement, object? args)
+	public static void MapPlayRequested(MediaElementHandler handler, MediaElement mediaElement, object? args)
 	{
 		handler.mediaManager?.Play();
 	}
@@ -170,10 +170,10 @@ public static void MapPlayRequested(MediaElementHandler handler, MediaElement Me
 	/// Maps the pause operation request between the abstract <see cref="MediaElement"/> and platform counterpart.
 	/// </summary>
 	/// <param name="handler">The associated handler.</param>
-	/// <param name="MediaElement">The associated <see cref="MediaElement"/> instance.</param>
+	/// <param name="mediaElement">The associated <see cref="MediaElement"/> instance.</param>
 	/// <param name="args">The associated event arguments for this request.</param>
 	/// <remarks><paramref name="args"/> is not used.</remarks>
-	public static void MapPauseRequested(MediaElementHandler handler, MediaElement MediaElement, object? args)
+	public static void MapPauseRequested(MediaElementHandler handler, MediaElement mediaElement, object? args)
 	{
 		handler.mediaManager?.Pause();
 	}
@@ -182,25 +182,27 @@ public static void MapPauseRequested(MediaElementHandler handler, MediaElement M
 	/// Maps the seek operation request between the abstract <see cref="MediaElement"/> and platform counterpart.
 	/// </summary>
 	/// <param name="handler">The associated handler.</param>
-	/// <param name="MediaElement">The associated <see cref="MediaElement"/> instance.</param>
+	/// <param name="mediaElement">The associated <see cref="MediaElement"/> instance.</param>
 	/// <param name="args">The associated event arguments for this request.</param>
 	/// <remarks><paramref name="args"/> should be of type <see cref="MediaSeekRequestedEventArgs"/>, otherwise nothing happens.</remarks>
-	public static void MapSeekRequested(MediaElementHandler handler, MediaElement MediaElement, object? args)
+	public static async void MapSeekRequested(MediaElementHandler handler, MediaElement mediaElement, object? args)
 	{
 		ArgumentNullException.ThrowIfNull(args);
 
 		var positionArgs = (MediaSeekRequestedEventArgs)args;
-		handler.mediaManager?.Seek(positionArgs.RequestedPosition);
+		await (handler.mediaManager?.Seek(positionArgs.RequestedPosition, CancellationToken.None) ?? Task.CompletedTask);
+
+		((IMediaElement)mediaElement).SeekCompletedTCS.TrySetResult();
 	}
 
 	/// <summary>
 	/// Maps the stop operation request between the abstract <see cref="MediaElement"/> and platform counterpart.
 	/// </summary>
 	/// <param name="handler">The associated handler.</param>
-	/// <param name="MediaElement">The associated <see cref="MediaElement"/> instance.</param>
+	/// <param name="mediaElement">The associated <see cref="MediaElement"/> instance.</param>
 	/// <param name="args">The associated event arguments for this request.</param>
 	/// <remarks><paramref name="args"/> is not used.</remarks>
-	public static void MapStopRequested(MediaElementHandler handler, MediaElement MediaElement, object? args)
+	public static void MapStopRequested(MediaElementHandler handler, MediaElement mediaElement, object? args)
 	{
 		handler.mediaManager?.Stop();
 	}
diff --git a/src/CommunityToolkit.Maui.MediaElement/Interfaces/IAsynchronousMediaElementHandler.cs b/src/CommunityToolkit.Maui.MediaElement/Interfaces/IAsynchronousMediaElementHandler.cs
new file mode 100644
index 0000000000..151e408c17
--- /dev/null
+++ b/src/CommunityToolkit.Maui.MediaElement/Interfaces/IAsynchronousMediaElementHandler.cs
@@ -0,0 +1,12 @@
+namespace CommunityToolkit.Maui.Core;
+
+/// <summary>
+/// Interface that allows asynchronous completion of .NET MAUI Handlers
+/// </summary>
+public interface IAsynchronousMediaElementHandler
+{
+	/// <summary>
+	/// A <see cref="TaskCompletionSource"/> to provide Handlers an asynchronous way to complete
+	/// </summary>
+	TaskCompletionSource SeekCompletedTCS { get; }
+}
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.MediaElement/Interfaces/IMediaElement.cs b/src/CommunityToolkit.Maui.MediaElement/Interfaces/IMediaElement.cs
index 97c9dbfcf2..fc621bc902 100644
--- a/src/CommunityToolkit.Maui.MediaElement/Interfaces/IMediaElement.cs
+++ b/src/CommunityToolkit.Maui.MediaElement/Interfaces/IMediaElement.cs
@@ -6,7 +6,7 @@ namespace CommunityToolkit.Maui.Core;
 /// <summary>
 /// With MediaElement you can play multimedia inside of your app.
 /// </summary>
-public interface IMediaElement : IView
+public interface IMediaElement : IView, IAsynchronousMediaElementHandler
 {
 	/// <summary>
 	/// Gets the media aspect ratio.
@@ -127,8 +127,9 @@ public interface IMediaElement : IView
 	/// Seek to a specific position in the currently playing media.
 	/// </summary>
 	/// <param name="position">The requested position to seek to.</param>
+	/// <param name="token"><see cref="CancellationToken"/>.</param>
 	/// <remarks>If <paramref name="position"/> is outside of the range of the current media item, nothing will happen.</remarks>
-	void SeekTo(TimeSpan position);
+	Task SeekTo(TimeSpan position, CancellationToken token = default);
 
 	/// <summary>
 	/// Stops playing the currently playing media and resets the <see cref="Position"/>.
diff --git a/src/CommunityToolkit.Maui.MediaElement/MediaElement.shared.cs b/src/CommunityToolkit.Maui.MediaElement/MediaElement.shared.cs
index a6ba0bec2f..1ba62c3097 100644
--- a/src/CommunityToolkit.Maui.MediaElement/MediaElement.shared.cs
+++ b/src/CommunityToolkit.Maui.MediaElement/MediaElement.shared.cs
@@ -8,25 +8,23 @@ namespace CommunityToolkit.Maui.Views;
 /// <summary>
 /// Represents an object that is used to render audio and video to the display.
 /// </summary>
-public class MediaElement : View, IMediaElement
+public class MediaElement : View, IMediaElement, IDisposable
 {
 	/// <summary>
 	/// Backing store for the <see cref="Aspect"/> property.
 	/// </summary>
 	public static readonly BindableProperty AspectProperty =
-		  BindableProperty.Create(nameof(Aspect), typeof(Aspect), typeof(MediaElement), Aspect.AspectFit);
+		BindableProperty.Create(nameof(Aspect), typeof(Aspect), typeof(MediaElement), Aspect.AspectFit);
 
 	static readonly BindablePropertyKey durationPropertyKey =
-	  BindableProperty.CreateReadOnly(nameof(Duration), typeof(TimeSpan), typeof(MediaElement), TimeSpan.Zero);
-
-	readonly WeakEventManager eventManager = new();
+		BindableProperty.CreateReadOnly(nameof(Duration), typeof(TimeSpan), typeof(MediaElement), TimeSpan.Zero);
 
 	/// <summary>
 	/// Backing store for the <see cref="CurrentState"/> property.
 	/// </summary>
 	public static readonly BindableProperty CurrentStateProperty =
-		  BindableProperty.Create(nameof(CurrentState), typeof(MediaElementState), typeof(MediaElement),
-			  MediaElementState.None, propertyChanged: OnCurrentStatePropertyChanged);
+		BindableProperty.Create(nameof(CurrentState), typeof(MediaElementState), typeof(MediaElement),
+			MediaElementState.None, propertyChanged: OnCurrentStatePropertyChanged);
 
 	/// <summary>
 	/// Backing store for the <see cref="Duration"/> property.
@@ -43,31 +41,31 @@ public class MediaElement : View, IMediaElement
 	/// Backing store for the <see cref="ShouldLoopPlayback"/> property.
 	/// </summary>
 	public static readonly BindableProperty ShouldLoopPlaybackProperty =
-		  BindableProperty.Create(nameof(ShouldLoopPlayback), typeof(bool), typeof(MediaElement), false);
+		BindableProperty.Create(nameof(ShouldLoopPlayback), typeof(bool), typeof(MediaElement), false);
 
 	/// <summary>
 	/// Backing store for the <see cref="ShouldKeepScreenOn"/> property.
 	/// </summary>
 	public static readonly BindableProperty ShouldKeepScreenOnProperty =
-		  BindableProperty.Create(nameof(ShouldKeepScreenOn), typeof(bool), typeof(MediaElement), false);
+		BindableProperty.Create(nameof(ShouldKeepScreenOn), typeof(bool), typeof(MediaElement), false);
 
 	/// <summary>
 	/// Backing store for the <see cref="ShouldMute"/> property.
 	/// </summary>
 	public static readonly BindableProperty ShouldMuteProperty =
-		  BindableProperty.Create(nameof(ShouldMute), typeof(bool), typeof(MediaElement), false);
+		BindableProperty.Create(nameof(ShouldMute), typeof(bool), typeof(MediaElement), false);
 
 	/// <summary>
 	/// Backing store for the <see cref="Position"/> property.
 	/// </summary>
 	public static readonly BindableProperty PositionProperty =
-		  BindableProperty.Create(nameof(Position), typeof(TimeSpan), typeof(MediaElement), TimeSpan.Zero);
+		BindableProperty.Create(nameof(Position), typeof(TimeSpan), typeof(MediaElement), TimeSpan.Zero);
 
 	/// <summary>
 	/// Backing store for the <see cref="ShouldShowPlaybackControls"/> property.
 	/// </summary>
 	public static readonly BindableProperty ShowsPlaybackControlsProperty =
-		  BindableProperty.Create(nameof(ShouldShowPlaybackControls), typeof(bool), typeof(MediaElement), true);
+		BindableProperty.Create(nameof(ShouldShowPlaybackControls), typeof(bool), typeof(MediaElement), true);
 
 	/// <summary>
 	/// Backing store for the <see cref="Source"/> property.
@@ -80,7 +78,7 @@ public class MediaElement : View, IMediaElement
 	/// Backing store for the <see cref="Speed"/> property.
 	/// </summary>
 	public static readonly BindableProperty SpeedProperty =
-		  BindableProperty.Create(nameof(Speed), typeof(double), typeof(MediaElement), 1.0);
+		BindableProperty.Create(nameof(Speed), typeof(double), typeof(MediaElement), 1.0);
 
 	/// <summary>
 	/// Backing store for the <see cref="MediaHeight"/> property.
@@ -98,10 +96,15 @@ public class MediaElement : View, IMediaElement
 	/// Backing store for the <see cref="Volume"/> property.
 	/// </summary>
 	public static readonly BindableProperty VolumeProperty =
-		  BindableProperty.Create(nameof(Volume), typeof(double), typeof(MediaElement), 1.0,
-			  BindingMode.TwoWay, propertyChanging: ValidateVolume);
+		BindableProperty.Create(nameof(Volume), typeof(double), typeof(MediaElement), 1.0,
+			BindingMode.TwoWay, propertyChanging: ValidateVolume);
+
+	readonly WeakEventManager eventManager = new();
+	readonly SemaphoreSlim seekToSemaphoreSlim = new(1, 1);
 
+	bool isDisposed;
 	IDispatcherTimer? timer;
+	TaskCompletionSource seekCompletedTaskCompletionSource = new();
 
 	/// <inheritdoc cref="IMediaElement.MediaEnded"/>
 	public event EventHandler MediaEnded
@@ -181,6 +184,11 @@ internal event EventHandler StopRequested
 		remove => eventManager.RemoveEventHandler(value);
 	}
 
+	/// <summary>
+	/// Finalizer
+	/// </summary>
+	~MediaElement() => Dispose(false);
+
 	/// <summary>
 	/// The current position of the playing media. This is a bindable property.
 	/// </summary>
@@ -347,6 +355,16 @@ TimeSpan IMediaElement.Duration
 		set => SetValue(durationPropertyKey, value);
 	}
 
+	/// <inheritdoc/>
+	TaskCompletionSource IAsynchronousMediaElementHandler.SeekCompletedTCS => seekCompletedTaskCompletionSource;
+
+	/// <inheritdoc/>
+	public void Dispose()
+	{
+		Dispose(true);
+		GC.SuppressFinalize(this);
+	}
+
 	/// <inheritdoc cref="IMediaElement.Pause"/>
 	public void Pause()
 	{
@@ -361,11 +379,23 @@ public void Play()
 		Handler?.Invoke(nameof(PlayRequested));
 	}
 
-	/// <inheritdoc cref="IMediaElement.SeekTo(TimeSpan)"/>
-	public void SeekTo(TimeSpan position)
+	/// <inheritdoc cref="IMediaElement.SeekTo(TimeSpan, CancellationToken)"/>
+	public async Task SeekTo(TimeSpan position, CancellationToken token = default)
 	{
-		MediaSeekRequestedEventArgs args = new(position);
-		Handler?.Invoke(nameof(SeekRequested), args);
+		await seekToSemaphoreSlim.WaitAsync(token);
+
+		try
+		{
+			MediaSeekRequestedEventArgs args = new(position);
+			Handler?.Invoke(nameof(SeekRequested), args);
+
+			await seekCompletedTaskCompletionSource.Task.WaitAsync(token);
+		}
+		finally
+		{
+			seekCompletedTaskCompletionSource = new();
+			seekToSemaphoreSlim.Release();
+		}
 	}
 
 	/// <inheritdoc cref="IMediaElement.Stop"/>
@@ -406,6 +436,22 @@ protected override void OnBindingContextChanged()
 		base.OnBindingContextChanged();
 	}
 
+	/// <inheritdoc/>
+	protected virtual void Dispose(bool disposing)
+	{
+		if (isDisposed)
+		{
+			return;
+		}
+
+		if (disposing)
+		{
+			seekToSemaphoreSlim.Dispose();
+		}
+
+		isDisposed = true;
+	}
+
 	static void OnSourcePropertyChanged(BindableObject bindable, object oldValue, object newValue) =>
 		((MediaElement)bindable).OnSourcePropertyChanged((MediaSource?)newValue);
 
diff --git a/src/CommunityToolkit.Maui.MediaElement/Views/MauiMediaElement.windows.cs b/src/CommunityToolkit.Maui.MediaElement/Views/MauiMediaElement.windows.cs
index fce89e213d..f2b1fce00f 100644
--- a/src/CommunityToolkit.Maui.MediaElement/Views/MauiMediaElement.windows.cs
+++ b/src/CommunityToolkit.Maui.MediaElement/Views/MauiMediaElement.windows.cs
@@ -9,18 +9,25 @@ namespace CommunityToolkit.Maui.Core.Views;
 /// </summary>
 public class MauiMediaElement : Grid, IDisposable
 {
-	readonly MediaPlayerElement mediaElement;
+	readonly MediaPlayerElement mediaPlayerElement;
+
+	bool isDisposed;
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="MauiMediaElement"/> class.
 	/// </summary>
-	/// <param name="mediaElementElement"></param>
-	public MauiMediaElement(MediaPlayerElement mediaElementElement)
+	/// <param name="mediaPlayerElement"></param>
+	public MauiMediaElement(MediaPlayerElement mediaPlayerElement)
 	{
-		this.mediaElement = mediaElementElement;
-		Children.Add(this.mediaElement);
+		this.mediaPlayerElement = mediaPlayerElement;
+		Children.Add(this.mediaPlayerElement);
 	}
 
+	/// <summary>
+	/// Finalizer
+	/// </summary>
+	~MauiMediaElement() => Dispose(false);
+
 	/// <summary>
 	/// Releases the managed and unmanaged resources used by the <see cref="MauiMediaElement"/>.
 	/// </summary>
@@ -35,9 +42,16 @@ public void Dispose()
 	/// </summary>
 	protected virtual void Dispose(bool disposing)
 	{
+		if(isDisposed)
+		{
+			return;
+		}
+
 		if (disposing)
 		{
-			mediaElement.MediaPlayer.Dispose();
+			mediaPlayerElement.MediaPlayer.Dispose();
 		}
+
+		isDisposed = true;
 	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.android.cs b/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.android.cs
index cd5e711cf0..6a80f27156 100644
--- a/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.android.cs
+++ b/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.android.cs
@@ -15,8 +15,12 @@ namespace CommunityToolkit.Maui.Core.Views;
 
 public partial class MediaManager : Java.Lang.Object, IPlayer.IListener
 {
-	double previousSpeed = -1;
+	readonly SemaphoreSlim seekToSemaphoreSlim = new(1, 1);
+
+	double? previousSpeed;
 	float volumeBeforeMute = 1;
+	TaskCompletionSource? seekToTaskCompletionSource;
+
 
 	/// <summary>
 	/// The platform native counterpart of <see cref="MediaElement"/>.
@@ -54,14 +58,14 @@ public partial class MediaManager : Java.Lang.Object, IPlayer.IListener
 	/// </remarks>
 	public void OnPlaybackParametersChanged(PlaybackParameters? playbackParameters)
 	{
-		if (playbackParameters is null || MediaElement is null)
+		if (playbackParameters is null)
 		{
 			return;
 		}
 
-		if ((double)playbackParameters.Speed != MediaElement.Speed)
+		if (!AreFloatingPointNumbersEqual(playbackParameters.Speed, MediaElement.Speed, 0.01))
 		{
-			MediaElement.Speed = (double)playbackParameters.Speed;
+			MediaElement.Speed = playbackParameters.Speed;
 		}
 	}
 
@@ -140,6 +144,9 @@ public void OnPlaybackStateChanged(int playbackState)
 				newState = MediaElementState.Stopped;
 				MediaElement.MediaEnded();
 				break;
+			case IPlayer.StateReady:
+				seekToTaskCompletionSource?.TrySetResult();
+				break;
 		}
 
 		MediaElement.CurrentStateChanged(newState);
@@ -155,11 +162,6 @@ public void OnPlaybackStateChanged(int playbackState)
 	/// </remarks>
 	public void OnPlayerError(PlaybackException? error)
 	{
-		if (MediaElement is null)
-		{
-			return;
-		}
-
 		var errorMessage = string.Empty;
 		var errorCode = string.Empty;
 		var errorCodeName = string.Empty;
@@ -179,7 +181,12 @@ public void OnPlayerError(PlaybackException? error)
 			errorCode = $"Error codename: {error?.ErrorCodeName}";
 		}
 
-		var message = string.Join(", ", new[] { errorCodeName, errorCode, errorMessage }.Where(s => !string.IsNullOrEmpty(s)));
+		var message = string.Join(", ", new[]
+		{
+			errorCodeName,
+			errorCode,
+			errorMessage
+		}.Where(s => !string.IsNullOrEmpty(s)));
 
 		MediaElement.MediaFailed(new MediaFailedEventArgs(message));
 
@@ -195,7 +202,8 @@ public void OnPlayerError(PlaybackException? error)
 	/// </remarks>
 	public void OnSeekProcessed()
 	{
-		MediaElement?.SeekCompleted();
+		// Deprecated in ExoPlayer v2.12.0
+		// Use OnPlaybackStateChanged with STATE_READY instead: https://stackoverflow.com/a/65745607/5953643
 	}
 
 	/// <summary>
@@ -243,11 +251,29 @@ protected virtual partial void PlatformPause()
 		Player.Pause();
 	}
 
-	protected virtual partial ValueTask PlatformSeek(TimeSpan position)
+	protected virtual async partial Task PlatformSeek(TimeSpan position, CancellationToken token)
 	{
-		Player?.SeekTo((long)position.TotalMilliseconds);
+		if (Player is null)
+		{
+			throw new InvalidOperationException($"{nameof(IExoPlayer)} is not yet initialized");
+		}
+
+		await seekToSemaphoreSlim.WaitAsync(token);
+
+		seekToTaskCompletionSource = new();
+
+		try
+		{
+			Player.SeekTo((long)position.TotalMilliseconds);
+
+			await seekToTaskCompletionSource.Task.WaitAsync(token);
 
-		return ValueTask.CompletedTask;
+			MediaElement.SeekCompleted();
+		}
+		finally
+		{
+			seekToSemaphoreSlim.Release();
+		}
 	}
 
 	protected virtual partial void PlatformStop()
@@ -340,23 +366,20 @@ protected virtual partial void PlatformUpdateAspect()
 		{
 			Aspect.AspectFill => AspectRatioFrameLayout.ResizeModeZoom,
 			Aspect.Fill => AspectRatioFrameLayout.ResizeModeFill,
-			_ => AspectRatioFrameLayout.ResizeModeFit,
-
+			Aspect.Center or Aspect.AspectFit => AspectRatioFrameLayout.ResizeModeFit,
+			_ => throw new NotSupportedException($"{nameof(Aspect)}: {MediaElement.Aspect} is not yet supported")
 		};
 	}
 
 	protected virtual partial void PlatformUpdateSpeed()
 	{
-		if (MediaElement is null || Player is null)
+		if (Player is null)
 		{
 			return;
 		}
 
 		// First time we're getting a playback speed, set initial value
-		if (previousSpeed == -1)
-		{
-			previousSpeed = MediaElement.Speed;
-		}
+		previousSpeed ??= MediaElement.Speed;
 
 		if (MediaElement.Speed > 0)
 		{
@@ -378,7 +401,7 @@ protected virtual partial void PlatformUpdateSpeed()
 
 	protected virtual partial void PlatformUpdateShouldShowPlaybackControls()
 	{
-		if (MediaElement is null || PlayerView is null)
+		if (PlayerView is null)
 		{
 			return;
 		}
@@ -388,7 +411,7 @@ protected virtual partial void PlatformUpdateShouldShowPlaybackControls()
 
 	protected virtual partial void PlatformUpdatePosition()
 	{
-		if (MediaElement is null || Player is null)
+		if (Player is null)
 		{
 			return;
 		}
@@ -401,7 +424,7 @@ protected virtual partial void PlatformUpdatePosition()
 
 	protected virtual partial void PlatformUpdateVolume()
 	{
-		if (MediaElement is null || Player is null)
+		if (Player is null)
 		{
 			return;
 		}
@@ -429,7 +452,7 @@ protected virtual partial void PlatformUpdateShouldKeepScreenOn()
 
 	protected virtual partial void PlatformUpdateShouldMute()
 	{
-		if (Player is null || MediaElement is null)
+		if (Player is null)
 		{
 			return;
 		}
@@ -440,7 +463,7 @@ protected virtual partial void PlatformUpdateShouldMute()
 		{
 			volumeBeforeMute = Player.Volume;
 		}
-		else if (volumeBeforeMute != Player.Volume && Player.Volume > 0)
+		else if (!AreFloatingPointNumbersEqual(volumeBeforeMute, Player.Volume) && Player.Volume > 0)
 		{
 			volumeBeforeMute = Player.Volume;
 		}
@@ -450,7 +473,7 @@ protected virtual partial void PlatformUpdateShouldMute()
 
 	protected virtual partial void PlatformUpdateShouldLoopPlayback()
 	{
-		if (MediaElement is null || Player is null)
+		if (Player is null)
 		{
 			return;
 		}
@@ -459,6 +482,7 @@ protected virtual partial void PlatformUpdateShouldLoopPlayback()
 	}
 
 	#region IPlayer.IListener implementation method stubs
+
 	public void OnAudioAttributesChanged(AudioAttributes? audioAttributes) { }
 	public void OnAudioSessionIdChanged(int audioSessionId) { }
 	public void OnAvailableCommandsChanged(IPlayer.Commands? availableCommands) { }
@@ -491,5 +515,6 @@ public void OnTimelineChanged(Timeline? timeline, int reason) { }
 	public void OnTracksChanged(Tracks? tracks) { }
 	public void OnTrackSelectionParametersChanged(TrackSelectionParameters? trackSelectionParameters) { }
 	public void OnVideoSizeChanged(VideoSize? videoSize) { }
+
 	#endregion
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.macios.cs b/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.macios.cs
index 8719fe4bea..20c34fa971 100644
--- a/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.macios.cs
+++ b/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.macios.cs
@@ -132,33 +132,46 @@ protected virtual partial void PlatformPause()
 		Player?.Pause();
 	}
 
-	protected virtual partial ValueTask PlatformSeek(TimeSpan position)
+	protected virtual async partial Task PlatformSeek(TimeSpan position, CancellationToken token)
 	{
-		if (PlayerItem is null || Player?.CurrentItem is null
-			|| Player?.Status != AVPlayerStatus.ReadyToPlay)
+		token.ThrowIfCancellationRequested();
+
+		var seekTaskCompletionSource = new TaskCompletionSource();
+
+		if (Player?.CurrentItem is null)
+		{
+			throw new InvalidOperationException($"{nameof(AVPlayer)}.{nameof(AVPlayer.CurrentItem)} is not yet initialized");
+		}
+
+		if (Player?.Status is not AVPlayerStatus.ReadyToPlay)
 		{
-			return ValueTask.CompletedTask;
+			throw new InvalidOperationException($"{nameof(AVPlayer)}.{nameof(AVPlayer.Status)} must first be set to {AVPlayerStatus.ReadyToPlay}");
 		}
 
 		var ranges = Player.CurrentItem.SeekableTimeRanges;
-		var seekTo = new CMTime(Convert.ToInt64(position.TotalMilliseconds), 1000);
+		var seekToTime = new CMTime(Convert.ToInt64(position.TotalMilliseconds), 1000);
+
 		foreach (var v in ranges)
 		{
-			if (seekTo >= (seekTo - v.CMTimeRangeValue.Start)
-				&& seekTo < (v.CMTimeRangeValue.Start + v.CMTimeRangeValue.Duration))
+			if (seekToTime >= (seekToTime - v.CMTimeRangeValue.Start)
+				&& seekToTime < (v.CMTimeRangeValue.Start + v.CMTimeRangeValue.Duration))
 			{
-				Player.Seek(seekTo + v.CMTimeRangeValue.Start, (complete) =>
+				Player.Seek(seekToTime + v.CMTimeRangeValue.Start, complete =>
 				{
-					if (complete)
+					if (!complete)
 					{
-						MediaElement?.SeekCompleted();
+						throw new InvalidOperationException("Seek Failed");
 					}
+
+					seekTaskCompletionSource.SetResult();
 				});
 				break;
 			}
 		}
 
-		return ValueTask.CompletedTask;
+		await seekTaskCompletionSource.Task.WaitAsync(token);
+
+		MediaElement.SeekCompleted();
 	}
 
 	protected virtual partial void PlatformStop()
@@ -206,7 +219,7 @@ protected virtual partial void PlatformUpdateSource()
 
 			if (!string.IsNullOrWhiteSpace(uri))
 			{
-				asset = AVAsset.FromUrl(NSUrl.CreateFileUrl(new[] { uri }));
+				asset = AVAsset.FromUrl(NSUrl.CreateFileUrl(uri));
 			}
 		}
 		else if (MediaElement.Source is ResourceMediaSource resourceMediaSource)
@@ -240,20 +253,20 @@ protected virtual partial void PlatformUpdateSource()
 
 		CurrentItemErrorObserver = PlayerItem?.AddObserver("error",
 			valueObserverOptions, (NSObservedChange change) =>
-		{
-			if (Player?.CurrentItem?.Error is null)
 			{
-				return;
-			}
+				if (Player?.CurrentItem?.Error is null)
+				{
+					return;
+				}
 
-			var message = $"{Player?.CurrentItem?.Error?.LocalizedDescription} - " +
-			$"{Player?.CurrentItem?.Error?.LocalizedFailureReason}";
+				var message = $"{Player?.CurrentItem?.Error?.LocalizedDescription} - " +
+					$"{Player?.CurrentItem?.Error?.LocalizedFailureReason}";
 
-			MediaElement.MediaFailed(
-				new MediaFailedEventArgs(message));
+				MediaElement.MediaFailed(
+					new MediaFailedEventArgs(message));
 
-			Logger?.LogError("{logMessage}", message);
-		});
+				Logger.LogError("{logMessage}", message);
+			});
 
 		if (PlayerItem is not null && PlayerItem.Error is null)
 		{
@@ -272,7 +285,7 @@ protected virtual partial void PlatformUpdateSource()
 
 	protected virtual partial void PlatformUpdateSpeed()
 	{
-		if (PlayerViewController?.Player is null || MediaElement is null)
+		if (PlayerViewController?.Player is null)
 		{
 			return;
 		}
@@ -285,7 +298,6 @@ protected virtual partial void PlatformUpdateSpeed()
 		}
 
 		PlayerViewController.Player.Rate = (float)MediaElement.Speed;
-
 	}
 
 	protected virtual partial void PlatformUpdateShouldShowPlaybackControls()
@@ -347,7 +359,7 @@ protected virtual partial void PlatformUpdateVolume()
 
 	protected virtual partial void PlatformUpdateShouldKeepScreenOn()
 	{
-		if (Player is null || MediaElement is null)
+		if (Player is null)
 		{
 			return;
 		}
@@ -357,7 +369,7 @@ protected virtual partial void PlatformUpdateShouldKeepScreenOn()
 
 	protected virtual partial void PlatformUpdateShouldMute()
 	{
-		if (Player is null || MediaElement is null)
+		if (Player is null)
 		{
 			return;
 		}
@@ -407,19 +419,16 @@ void AddStatusObservers()
 			return;
 		}
 
-		MutedObserver = Player.AddObserver("muted", valueObserverOptions,
-					MutedChanged);
-		VolumeObserver = Player.AddObserver("volume", valueObserverOptions,
-					VolumeChanged);
+		MutedObserver = Player.AddObserver("muted", valueObserverOptions, MutedChanged);
+		VolumeObserver = Player.AddObserver("volume", valueObserverOptions, VolumeChanged);
 		StatusObserver = Player.AddObserver("status", valueObserverOptions, StatusChanged);
-		TimeControlStatusObserver = Player.AddObserver("timeControlStatus",
-			valueObserverOptions, TimeControlStatusChanged);
+		TimeControlStatusObserver = Player.AddObserver("timeControlStatus", valueObserverOptions, TimeControlStatusChanged);
 		RateObserver = AVPlayer.Notifications.ObserveRateDidChange(RateChanged);
 	}
 
 	void VolumeChanged(NSObservedChange e)
 	{
-		if (MediaElement is null || Player is null)
+		if (Player is null)
 		{
 			return;
 		}
@@ -427,13 +436,13 @@ void VolumeChanged(NSObservedChange e)
 		var volumeDiff = Math.Abs(Player.Volume - MediaElement.Volume);
 		if (volumeDiff > 0.01)
 		{
-			MediaElement.Volume = (double)Player.Volume;
+			MediaElement.Volume = Player.Volume;
 		}
 	}
 
 	void MutedChanged(NSObservedChange e)
 	{
-		if (MediaElement is null || Player is null)
+		if (Player is null)
 		{
 			return;
 		}
@@ -562,20 +571,19 @@ void PlayedToEnd(object? sender, NSNotificationEventArgs args)
 			}
 			catch (Exception e)
 			{
-				Logger?.LogWarning(e, "{logMessage}",
-					$"Failed to play media to end.");
+				Logger.LogWarning(e, "{logMessage}", $"Failed to play media to end.");
 			}
 		}
 	}
 
 	void RateChanged(object? sender, NSNotificationEventArgs args)
 	{
-		if (MediaElement is null || Player is null)
+		if (Player is null)
 		{
 			return;
 		}
 
-		if (MediaElement.Speed != Player.Rate)
+		if (!AreFloatingPointNumbersEqual(MediaElement.Speed, Player.Rate))
 		{
 			MediaElement.Speed = Player.Rate;
 		}
diff --git a/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.shared.cs b/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.shared.cs
index ec9f9aa8bf..253f5beaa8 100644
--- a/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.shared.cs
+++ b/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.shared.cs
@@ -27,6 +27,10 @@ public partial class MediaManager
 	/// <param name="dispatcher">The <see cref="IDispatcher"/> instance that allows propagation to the main thread.</param>
 	public MediaManager(IMauiContext context, IMediaElement mediaElement, IDispatcher dispatcher)
 	{
+		ArgumentNullException.ThrowIfNull(context);
+		ArgumentNullException.ThrowIfNull(mediaElement);
+		ArgumentNullException.ThrowIfNull(dispatcher);
+
 		MauiContext = context;
 		Dispatcher = dispatcher;
 		MediaElement = mediaElement;
@@ -82,9 +86,10 @@ public void Pause()
 	/// Invokes the seek operation on the platform element.
 	/// </summary>
 	/// <param name="position">The position to seek to.</param>
-	public ValueTask Seek(TimeSpan position)
+	/// <param name="token"><see cref="CancellationToken"/> ></param>
+	public Task Seek(TimeSpan position, CancellationToken token = default)
 	{
-		return PlatformSeek(position);
+		return PlatformSeek(position, token);
 	}
 
 	/// <summary>
@@ -182,7 +187,8 @@ public void UpdateVolume()
 	/// Invokes the platform seek functionality and seeks to a specific position.
 	/// </summary>
 	/// <param name="position">The position to seek to.</param>
-	protected virtual partial ValueTask PlatformSeek(TimeSpan position);
+	/// <param name="token"><see cref="CancellationToken"/></param>
+	protected virtual partial Task PlatformSeek(TimeSpan position, CancellationToken token);
 
 	/// <summary>
 	/// Invokes the platform stop functionality and stops media playback.
@@ -234,12 +240,18 @@ public void UpdateVolume()
 	/// Invokes the platform functionality to update the media playback volume.
 	/// </summary>
 	protected virtual partial void PlatformUpdateVolume();
+
+	static bool AreFloatingPointNumbersEqual(in double number1, in double number2, double tolerance = 0.01) => Math.Abs(number1 - number2) > tolerance;
 }
 
 #if !(WINDOWS || ANDROID || IOS || MACCATALYST || TIZEN)
 partial class MediaManager
 {
-	protected virtual partial ValueTask PlatformSeek(TimeSpan position) => ValueTask.CompletedTask;
+	protected virtual partial Task PlatformSeek(TimeSpan position, CancellationToken token)
+	{
+		token.ThrowIfCancellationRequested();
+		return Task.CompletedTask;
+	}
 	protected virtual partial void PlatformPlay() { }
 	protected virtual partial void PlatformPause() { }
 	protected virtual partial void PlatformStop() { }
diff --git a/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.tizen.cs b/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.tizen.cs
index 8d72921e29..9a40bddc6f 100644
--- a/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.tizen.cs
+++ b/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.tizen.cs
@@ -83,20 +83,21 @@ protected virtual partial void PlatformPause()
 		}
 	}
 
-	protected virtual partial ValueTask PlatformSeek(TimeSpan position)
+	protected virtual async partial Task PlatformSeek(TimeSpan position, CancellationToken token)
 	{
 		if (Player is null)
 		{
-			return ValueTask.CompletedTask;
+			throw new InvalidOperationException($"{nameof(CommunityToolkit.Maui.Core.Views.TizenPlayer)} is not yet initialized");
 		}
 
-		if (Player.State is PlayerState.Ready or PlayerState.Playing or PlayerState.Paused)
+		if (Player.State is not (PlayerState.Ready or PlayerState.Playing or PlayerState.Paused))
 		{
-			Player.SetPlayPositionAsync((int)position.TotalMilliseconds, false);
-			MediaElement.SeekCompleted();
+			throw new InvalidOperationException($"{nameof(CommunityToolkit.Maui.Core.Views.TizenPlayer)}.{nameof(CommunityToolkit.Maui.Core.Views.TizenPlayer.State)} must first be set to {PlayerState.Ready}, {PlayerState.Playing} or {PlayerState.Paused}");
 		}
 
-		return ValueTask.CompletedTask;
+		await Player.SetPlayPositionAsync((int)position.TotalMilliseconds, false).WaitAsync(token);
+
+		MediaElement.SeekCompleted();
 	}
 
 	protected virtual partial void PlatformStop()
@@ -118,7 +119,7 @@ protected virtual partial void PlatformStop()
 
 	protected virtual partial void PlatformUpdateAspect()
 	{
-		if (Player is null || MediaElement is null)
+		if (Player is null)
 		{
 			return;
 		}
@@ -191,7 +192,7 @@ protected virtual partial void PlatformUpdateSource()
 
 	protected virtual partial void PlatformUpdateSpeed()
 	{
-		if (MediaElement is null || Player is null)
+		if (Player is null)
 		{
 			return;
 		}
@@ -207,7 +208,7 @@ protected virtual partial void PlatformUpdateSpeed()
 
 	protected virtual partial void PlatformUpdateShouldShowPlaybackControls()
 	{
-		if (MediaElement is null || VideoView is null)
+		if (VideoView is null)
 		{
 			return;
 		}
@@ -215,7 +216,7 @@ protected virtual partial void PlatformUpdateShouldShowPlaybackControls()
 
 	protected virtual partial void PlatformUpdatePosition()
 	{
-		if (MediaElement is null || Player is null)
+		if (Player is null)
 		{
 			return;
 		}
@@ -233,7 +234,7 @@ protected virtual partial void PlatformUpdatePosition()
 
 	protected virtual partial void PlatformUpdateVolume()
 	{
-		if (MediaElement is null || Player is null)
+		if (Player is null)
 		{
 			return;
 		}
@@ -267,7 +268,7 @@ protected virtual partial void PlatformUpdateShouldKeepScreenOn()
 
 	protected virtual partial void PlatformUpdateShouldMute()
 	{
-		if (Player is null || MediaElement is null)
+		if (Player is null)
 		{
 			return;
 		}
@@ -277,7 +278,7 @@ protected virtual partial void PlatformUpdateShouldMute()
 
 	protected virtual partial void PlatformUpdateShouldLoopPlayback()
 	{
-		if (MediaElement is null || Player is null || VideoView is null)
+		if (Player is null || VideoView is null)
 		{
 			return;
 		}
diff --git a/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.windows.cs b/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.windows.cs
index 21f840f1ba..f2e24b8997 100644
--- a/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.windows.cs
+++ b/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.windows.cs
@@ -1,6 +1,8 @@
-using CommunityToolkit.Maui.Core.Primitives;
+using System.Collections.Frozen;
+using CommunityToolkit.Maui.Core.Primitives;
 using CommunityToolkit.Maui.Views;
 using Microsoft.Extensions.Logging;
+using Microsoft.UI.Xaml.Controls;
 using Windows.Media.Playback;
 using Windows.Storage;
 using Windows.System.Display;
@@ -11,16 +13,16 @@ namespace CommunityToolkit.Maui.Core.Views;
 
 partial class MediaManager : IDisposable
 {
-	// The requests to keep display active are cumulative, this bool makes sure it only gets requested once
-	bool displayActiveRequested;
-
 	// States that allow changing position
-	MediaElementState[] allowUpdatePositionStates = new[]
+	readonly FrozenSet<MediaElementState> allowUpdatePositionStates = new[]
 	{
 		MediaElementState.Playing,
 		MediaElementState.Paused,
 		MediaElementState.Stopped,
-	};
+	}.ToFrozenSet();
+
+	// The requests to keep display active are cumulative, this bool makes sure it only gets requested once
+	bool displayActiveRequested;
 
 	/// <summary>
 	/// The <see cref="DisplayRequest"/> is used to enable the <see cref="MediaElement.ShouldKeepScreenOn"/> functionality.
@@ -86,19 +88,22 @@ protected virtual partial void PlatformPause()
 		}
 	}
 
-	protected virtual async partial ValueTask PlatformSeek(TimeSpan position)
+	protected virtual async partial Task PlatformSeek(TimeSpan position, CancellationToken token)
 	{
-		if (Player?.MediaPlayer.CanSeek ?? false)
+		if (Player?.MediaPlayer.CanSeek is true)
 		{
 			if (Dispatcher.IsDispatchRequired)
 			{
-				await Dispatcher.DispatchAsync(() => Player.MediaPlayer.Position = position);
+				await Dispatcher.DispatchAsync(() => UpdatePosition(Player, position)).WaitAsync(token);
 			}
 			else
 			{
-				Player.MediaPlayer.Position = position;
+				token.ThrowIfCancellationRequested();
+				UpdatePosition(Player, position);
 			}
 		}
+
+		static void UpdatePosition(in MediaPlayerElement mediaPlayerElement, in TimeSpan position) => mediaPlayerElement.MediaPlayer.Position = position;
 	}
 
 	protected virtual partial void PlatformStop()
@@ -123,7 +128,7 @@ protected virtual partial void PlatformStop()
 
 	protected virtual partial void PlatformUpdateAspect()
 	{
-		if (Player is null || MediaElement is null)
+		if (Player is null)
 		{
 			return;
 		}
@@ -171,8 +176,7 @@ protected virtual partial void PlatformUpdateShouldShowPlaybackControls()
 
 	protected virtual partial void PlatformUpdatePosition()
 	{
-		if (MediaElement is not null
-			&& Player is not null
+		if (Player is not null
 			&& allowUpdatePositionStates.Contains(MediaElement.CurrentState))
 		{
 			MediaElement.Position = Player.MediaPlayer.Position;
@@ -181,7 +185,7 @@ protected virtual partial void PlatformUpdatePosition()
 
 	protected virtual partial void PlatformUpdateVolume()
 	{
-		if (Player is null || MediaElement is null)
+		if (Player is null)
 		{
 			return;
 		}
@@ -192,19 +196,20 @@ protected virtual partial void PlatformUpdateVolume()
 			return;
 		}
 
-		MainThread.BeginInvokeOnMainThread(() =>
+		if (Dispatcher.IsDispatchRequired)
+		{
+			Dispatcher.Dispatch(() => UpdateVolume(Player, MediaElement.Volume));
+		}
+		else
 		{
-			Player.MediaPlayer.Volume = MediaElement.Volume;
-		});
+			UpdateVolume(Player, MediaElement.Volume);
+		}
+
+		static void UpdateVolume(in MediaPlayerElement mediaPlayerElement, in double volume) => mediaPlayerElement.MediaPlayer.Volume = volume;
 	}
 
 	protected virtual partial void PlatformUpdateShouldKeepScreenOn()
 	{
-		if (MediaElement is null)
-		{
-			return;
-		}
-
 		if (MediaElement.ShouldKeepScreenOn)
 		{
 			if (MediaElement != null
@@ -227,7 +232,7 @@ protected virtual partial void PlatformUpdateShouldKeepScreenOn()
 
 	protected virtual partial void PlatformUpdateShouldMute()
 	{
-		if (MediaElement is null || Player?.MediaPlayer is null)
+		if (Player?.MediaPlayer is null)
 		{
 			return;
 		}
@@ -237,7 +242,7 @@ protected virtual partial void PlatformUpdateShouldMute()
 
 	protected virtual async partial void PlatformUpdateSource()
 	{
-		if (MediaElement is null || Player is null)
+		if (Player is null)
 		{
 			return;
 		}
@@ -281,7 +286,7 @@ protected virtual async partial void PlatformUpdateSource()
 
 	protected virtual partial void PlatformUpdateShouldLoopPlayback()
 	{
-		if (MediaElement is null || Player is null)
+		if (Player is null)
 		{
 			return;
 		}
@@ -323,19 +328,24 @@ protected virtual void Dispose(bool disposing)
 
 	void OnMediaElementMediaOpened(WindowsMediaElement sender, object args)
 	{
-		if (MediaElement is null || Player is null)
+		if (Player is null)
 		{
 			return;
 		}
 
-		MainThread.BeginInvokeOnMainThread(() =>
+		if (Dispatcher.IsDispatchRequired)
 		{
-			MediaElement.Duration = Player.MediaPlayer.NaturalDuration == TimeSpan.MaxValue ?
-				TimeSpan.Zero
-				: Player.MediaPlayer.NaturalDuration;
+			Dispatcher.Dispatch(() => SetDuration(MediaElement, Player));
+		}
+		else
+		{
+			SetDuration(MediaElement, Player);
+		}
+		MediaElement.MediaOpened();
 
-			MediaElement.MediaOpened();
-		});
+		static void SetDuration(in IMediaElement mediaElement, in MediaPlayerElement mediaPlayerElement) => mediaElement.Duration = mediaPlayerElement.MediaPlayer.NaturalDuration == TimeSpan.MaxValue
+																																		? TimeSpan.Zero
+																																		: mediaPlayerElement.MediaPlayer.NaturalDuration;
 	}
 
 	void OnMediaElementMediaEnded(WindowsMediaElement sender, object args)
@@ -370,34 +380,29 @@ void OnMediaElementMediaFailed(WindowsMediaElement sender, MediaPlayerFailedEven
 
 	void OnMediaElementIsMutedChanged(WindowsMediaElement sender, object args)
 	{
-		if (MediaElement is not null)
-		{
-			MediaElement.ShouldMute = sender.IsMuted;
-		}
+		MediaElement.ShouldMute = sender.IsMuted;
 	}
 
 	void OnMediaElementVolumeChanged(WindowsMediaElement sender, object args)
 	{
-		if (MediaElement is not null)
-		{
-			MediaElement.Volume = sender.Volume;
-		}
+		MediaElement.Volume = sender.Volume;
 	}
 
 	void OnPlaybackSessionPlaybackRateChanged(MediaPlaybackSession sender, object args)
 	{
-		if (MediaElement is null)
-		{
-			return;
-		}
-
 		if (MediaElement.Speed != sender.PlaybackRate)
 		{
-			MainThread.BeginInvokeOnMainThread(() =>
+			if (Dispatcher.IsDispatchRequired)
 			{
-				MediaElement.Speed = sender.PlaybackRate;
-			});
+				Dispatcher.Dispatch(() => UpdateSpeed(MediaElement, sender.PlaybackRate));
+			}
+			else
+			{
+				UpdateSpeed(MediaElement, sender.PlaybackRate);
+			}
 		}
+
+		static void UpdateSpeed(in IMediaElement mediaElement, in double playbackRate) => mediaElement.Speed = playbackRate;
 	}
 
 	void OnPlaybackSessionPlaybackStateChanged(MediaPlaybackSession sender, object args)
@@ -415,7 +420,7 @@ void OnPlaybackSessionPlaybackStateChanged(MediaPlaybackSession sender, object a
 
 		if (sender.PlaybackState == MediaPlaybackState.Playing && sender.PlaybackRate == 0)
 		{
-			MainThread.BeginInvokeOnMainThread(() =>
+			Dispatcher.Dispatch(() =>
 			{
 				sender.PlaybackRate = 1;
 			});
diff --git a/src/CommunityToolkit.Maui.SourceGenerators/Generators/TextColorToGenerator.cs b/src/CommunityToolkit.Maui.SourceGenerators/Generators/TextColorToGenerator.cs
index da4d39acac..7bdaf8213b 100644
--- a/src/CommunityToolkit.Maui.SourceGenerators/Generators/TextColorToGenerator.cs
+++ b/src/CommunityToolkit.Maui.SourceGenerators/Generators/TextColorToGenerator.cs
@@ -118,6 +118,7 @@ static void Execution(SourceProductionContext context, TextStyleClassMetadata te
 #nullable enable
 
 using System;
+using System.Threading;
 using System.Threading.Tasks;
 using CommunityToolkit.Maui.Core.Extensions;
 using Microsoft.Maui;
@@ -138,8 +139,9 @@ namespace {{textStyleClassMetadata.Namespace}};
 	/// <param name="rate">The time, in milliseconds, between the frames of the animation</param>
 	/// <param name="length">The duration, in milliseconds, of the animation</param>
 	/// <param name="easing">The easing function to be used in the animation</param>
+	/// <param name="token"><see cref="CancellationToken"/></param>
 	/// <returns>Value indicating if the animation completed successfully or not</returns>
-	public static Task<bool> TextColorTo{{textStyleClassMetadata.GenericArguments}}(this global::{{textStyleClassMetadata.Namespace}}.{{textStyleClassMetadata.ClassName}}{{textStyleClassMetadata.GenericArguments}} element, {{mauiColorFullName}} color, uint rate = 16u, uint length = 250u, Easing? easing = null)
+	public static Task<bool> TextColorTo{{textStyleClassMetadata.GenericArguments}}(this global::{{textStyleClassMetadata.Namespace}}.{{textStyleClassMetadata.ClassName}}{{textStyleClassMetadata.GenericArguments}} element, {{mauiColorFullName}} color, uint rate = 16u, uint length = 250u, Easing? easing = null, CancellationToken token = default)
 {{textStyleClassMetadata.GenericConstraints}}
 	{
 		ArgumentNullException.ThrowIfNull(element);
@@ -173,7 +175,7 @@ namespace {{textStyleClassMetadata.Namespace}};
 			animationCompletionSource.SetResult(false);
 		}
 
-		return animationCompletionSource.Task;
+		return animationCompletionSource.Task.WaitAsync(token);
 
 
 		static Animation GetRedTransformAnimation({{textStyleClassMetadata.Namespace}}.{{textStyleClassMetadata.ClassName}}{{textStyleClassMetadata.GenericArguments}} element, float targetRed) =>
diff --git a/src/CommunityToolkit.Maui.UnitTests/Alerts/SnackbarTests.cs b/src/CommunityToolkit.Maui.UnitTests/Alerts/SnackbarTests.cs
index 7e6bc48516..68e82fa8b2 100644
--- a/src/CommunityToolkit.Maui.UnitTests/Alerts/SnackbarTests.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/Alerts/SnackbarTests.cs
@@ -16,7 +16,7 @@ public SnackbarTests()
 	}
 
 	[Fact]
-	public void SnackbarDefautValues()
+	public void SnackbarDefaultValues()
 	{
 		Assert.Null(snackbar.Action);
 		Assert.Equal(AlertDefaults.ActionButtonText, snackbar.ActionButtonText);
@@ -32,21 +32,67 @@ public void SnackbarDefautValues()
 		Assert.Equal(AlertDefaults.TextColor, snackbar.VisualOptions.TextColor);
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task SnackbarShow_CancellationTokenExpires()
+	{
+		var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
+
+		// Ensure CancellationToken expires
+		await Task.Delay(100, CancellationToken.None);
+
+		await Assert.ThrowsAsync<OperationCanceledException>(() => snackbar.Show(cts.Token));
+	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task SnackbarShow_CancellationTokenCanceled()
+	{
+		var cts = new CancellationTokenSource();
+
+		await Assert.ThrowsAsync<OperationCanceledException>(() =>
+		{
+			cts.Cancel();
+			return snackbar.Show(cts.Token);
+		});
+	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task SnackbarDismiss_CancellationTokenExpires()
+	{
+		var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
+
+		// Ensure CancellationToken expires
+		await Task.Delay(100, CancellationToken.None);
+
+		await Assert.ThrowsAsync<OperationCanceledException>(() => snackbar.Dismiss(cts.Token));
+	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task SnackbarDismiss_CancellationTokenCanceled()
+	{
+		var cts = new CancellationTokenSource();
+
+		await Assert.ThrowsAsync<OperationCanceledException>(() =>
+		{
+			cts.Cancel();
+			return snackbar.Dismiss(cts.Token);
+		});
+	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task SnackbarShow_IsShownTrue()
 	{
-		await snackbar.Show();
+		await snackbar.Show(CancellationToken.None);
 		Assert.True(Snackbar.IsShown);
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task SnackbarDismissed_IsShownFalse()
 	{
-		await snackbar.Dismiss();
+		await snackbar.Dismiss(CancellationToken.None);
 		Assert.False(Snackbar.IsShown);
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task SnackbarShow_ShownEventRaised()
 	{
 		var receivedEvents = new List<EventArgs>();
@@ -54,11 +100,11 @@ public async Task SnackbarShow_ShownEventRaised()
 		{
 			receivedEvents.Add(e);
 		};
-		await snackbar.Show();
+		await snackbar.Show(CancellationToken.None);
 		Assert.Single(receivedEvents);
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task SnackbarDismiss_DismissedEventRaised()
 	{
 		var receivedEvents = new List<EventArgs>();
@@ -66,11 +112,11 @@ public async Task SnackbarDismiss_DismissedEventRaised()
 		{
 			receivedEvents.Add(e);
 		};
-		await snackbar.Dismiss();
+		await snackbar.Dismiss(CancellationToken.None);
 		Assert.Single(receivedEvents);
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task VisualElement_DisplaySnackbar_ShownEventReceived()
 	{
 		var receivedEvents = new List<EventArgs>();
@@ -127,7 +173,7 @@ public void SnackbarMake_NewSnackbarCreatedWithValidProperties()
 		currentSnackbar.Should().BeEquivalentTo(expectedSnackbar);
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task SnackbarShow_CancellationTokenCancelled_ReceiveException()
 	{
 		using var cancellationTokenSource = new CancellationTokenSource();
@@ -137,7 +183,7 @@ public async Task SnackbarShow_CancellationTokenCancelled_ReceiveException()
 		await snackbar.Invoking(x => x.Show(cancellationTokenSource.Token)).Should().ThrowExactlyAsync<OperationCanceledException>();
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task SnackbarDismiss_CancellationTokenCancelled_ReceiveException()
 	{
 		using var cancellationTokenSource = new CancellationTokenSource();
@@ -147,27 +193,27 @@ public async Task SnackbarDismiss_CancellationTokenCancelled_ReceiveException()
 		await snackbar.Invoking(x => x.Dismiss(cancellationTokenSource.Token)).Should().ThrowExactlyAsync<OperationCanceledException>();
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task SnackbarShow_CancellationTokenNotCancelled_NotReceiveException()
 	{
 		using var cancellationTokenSource = new CancellationTokenSource();
 		await snackbar.Invoking(x => x.Show(cancellationTokenSource.Token)).Should().NotThrowAsync<OperationCanceledException>();
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task SnackbarDismiss_CancellationTokenNotCancelled_NotReceiveException()
 	{
 		using var cancellationTokenSource = new CancellationTokenSource();
 		await snackbar.Invoking(x => x.Dismiss(cancellationTokenSource.Token)).Should().NotThrowAsync<OperationCanceledException>();
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task SnackbarShow_CancellationTokenNone_NotReceiveException()
 	{
 		await snackbar.Invoking(x => x.Show(CancellationToken.None)).Should().NotThrowAsync<OperationCanceledException>();
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task SnackbarDismiss_CancellationTokenNone_NotReceiveException()
 	{
 		await snackbar.Invoking(x => x.Dismiss(CancellationToken.None)).Should().NotThrowAsync<OperationCanceledException>();
@@ -177,8 +223,14 @@ public async Task SnackbarDismiss_CancellationTokenNone_NotReceiveException()
 	public void SnackbarNullValuesThrowArgumentNullException()
 	{
 #pragma warning disable CS8625 // Cannot convert null literal to non-nullable reference type.
-		Assert.Throws<ArgumentNullException>(() => new Snackbar { Text = null });
-		Assert.Throws<ArgumentNullException>(() => new Snackbar { ActionButtonText = null });
+		Assert.Throws<ArgumentNullException>(() => new Snackbar
+		{
+			Text = null
+		});
+		Assert.Throws<ArgumentNullException>(() => new Snackbar
+		{
+			ActionButtonText = null
+		});
 		Assert.Throws<ArgumentNullException>(() => Snackbar.Make(null));
 		Assert.Throws<ArgumentNullException>(() => Snackbar.Make(string.Empty, actionButtonText: null));
 		Assert.ThrowsAsync<ArgumentNullException>(() => new Button().DisplaySnackbar(null));
diff --git a/src/CommunityToolkit.Maui.UnitTests/Alerts/ToastTests.cs b/src/CommunityToolkit.Maui.UnitTests/Alerts/ToastTests.cs
index d4907dc4b0..267bc6d07a 100644
--- a/src/CommunityToolkit.Maui.UnitTests/Alerts/ToastTests.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/Alerts/ToastTests.cs
@@ -15,6 +15,52 @@ public ToastTests()
 		Assert.IsAssignableFrom<IAlert>(toast);
 	}
 
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task ToastShow_CancellationTokenExpires()
+	{
+		var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
+
+		// Ensure CancellationToken expires
+		await Task.Delay(100, CancellationToken.None);
+
+		await Assert.ThrowsAsync<OperationCanceledException>(() => toast.Show(cts.Token));
+	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task ToastShow_CancellationTokenCanceled()
+	{
+		var cts = new CancellationTokenSource();
+
+		await Assert.ThrowsAsync<OperationCanceledException>(() =>
+		{
+			cts.Cancel();
+			return toast.Show(cts.Token);
+		});
+	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task ToastDismiss_CancellationTokenExpires()
+	{
+		var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
+
+		// Ensure CancellationToken expires
+		await Task.Delay(100, CancellationToken.None);
+
+		await Assert.ThrowsAsync<OperationCanceledException>(() => toast.Dismiss(cts.Token));
+	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task ToastDismiss_CancellationTokenCanceled()
+	{
+		var cts = new CancellationTokenSource();
+
+		await Assert.ThrowsAsync<OperationCanceledException>(() =>
+		{
+			cts.Cancel();
+			return toast.Dismiss(cts.Token);
+		});
+	}
+
 	[Fact]
 	public void ToastMake_NewToastCreatedWithValidProperties()
 	{
@@ -33,7 +79,7 @@ public void ToastMake_NewToastCreatedWithValidProperties()
 		currentToast.Should().BeEquivalentTo(expectedToast);
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task ToastShow_CancellationTokenCancelled_ReceiveException()
 	{
 		var cancellationTokenSource = new CancellationTokenSource();
@@ -42,7 +88,7 @@ public async Task ToastShow_CancellationTokenCancelled_ReceiveException()
 		cancellationTokenSource.Dispose();
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task ToastDismiss_CancellationTokenCancelled_ReceiveException()
 	{
 		var cancellationTokenSource = new CancellationTokenSource();
@@ -51,7 +97,7 @@ public async Task ToastDismiss_CancellationTokenCancelled_ReceiveException()
 		cancellationTokenSource.Dispose();
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task ToastShow_CancellationTokenNotCancelled_NotReceiveException()
 	{
 		var cancellationTokenSource = new CancellationTokenSource();
@@ -59,7 +105,7 @@ public async Task ToastShow_CancellationTokenNotCancelled_NotReceiveException()
 		cancellationTokenSource.Dispose();
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task ToastDismiss_CancellationTokenNotCancelled_NotReceiveException()
 	{
 		var cancellationTokenSource = new CancellationTokenSource();
@@ -67,13 +113,13 @@ public async Task ToastDismiss_CancellationTokenNotCancelled_NotReceiveException
 		cancellationTokenSource.Dispose();
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task ToastShow_CancellationTokenNone_NotReceiveException()
 	{
 		await toast.Invoking(x => x.Show(CancellationToken.None)).Should().NotThrowAsync<OperationCanceledException>();
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task ToastDismiss_CancellationTokenNone_NotReceiveException()
 	{
 		await toast.Invoking(x => x.Dismiss(CancellationToken.None)).Should().NotThrowAsync<OperationCanceledException>();
diff --git a/src/CommunityToolkit.Maui.UnitTests/Animations/FadeAnimationTests.cs b/src/CommunityToolkit.Maui.UnitTests/Animations/FadeAnimationTests.cs
index 6c9ce25374..92091ad858 100644
--- a/src/CommunityToolkit.Maui.UnitTests/Animations/FadeAnimationTests.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/Animations/FadeAnimationTests.cs
@@ -7,17 +7,51 @@ namespace CommunityToolkit.Maui.UnitTests.Animations;
 
 public class FadeAnimationTests : BaseTest
 {
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task AnimateShouldThrowWithNullView()
 	{
 		FadeAnimation animation = new();
 
-		var performAnimation = () => animation.Animate(null!);
+#pragma warning disable CS8625 // Cannot convert null literal to non-nullable reference type.
+		await Assert.ThrowsAsync<ArgumentNullException>(() => animation.Animate(null, CancellationToken.None));
+#pragma warning restore CS8625 // Cannot convert null literal to non-nullable reference type.
+	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task CancellationTokenCanceled()
+	{
+		FadeAnimation animation = new();
+		var cts = new CancellationTokenSource();
+
+		var label = new Label
+		{
+			Opacity = 0.9
+		};
+		label.EnableAnimations();
+
+		await Assert.ThrowsAsync<TaskCanceledException>(() =>
+		{
+			cts.Cancel();
+			return animation.Animate(label, cts.Token);
+		});
+	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task CancellationTokenExpired()
+	{
+		FadeAnimation animation = new();
+		var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
+
+		var label = new Label
+		{
+			Opacity = 0.9
+		};
+		label.EnableAnimations();
 
-		await performAnimation.Should().ThrowAsync<ArgumentNullException>();
+		await Assert.ThrowsAsync<TaskCanceledException>(() => animation.Animate(label, cts.Token));
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Medium)]
 	public async Task AnimateShouldReturnToOriginalOpacity()
 	{
 		FadeAnimation animation = new();
@@ -28,7 +62,7 @@ public async Task AnimateShouldReturnToOriginalOpacity()
 		};
 		label.EnableAnimations();
 
-		await animation.Animate(label);
+		await animation.Animate(label, CancellationToken.None);
 
 		label.Opacity.Should().Be(0.9);
 	}
diff --git a/src/CommunityToolkit.Maui.UnitTests/BaseTest.cs b/src/CommunityToolkit.Maui.UnitTests/BaseTest.cs
index 5d7a01ed89..af9ddcfd6b 100644
--- a/src/CommunityToolkit.Maui.UnitTests/BaseTest.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/BaseTest.cs
@@ -9,6 +9,13 @@ public abstract class BaseTest : IDisposable
 
 	bool isDisposed;
 
+	protected enum TestDuration
+	{
+		Short = 2000,
+		Medium = 5000,
+		Long = 10000
+	}
+
 	protected BaseTest()
 	{
 		defaultCulture = Thread.CurrentThread.CurrentCulture;
diff --git a/src/CommunityToolkit.Maui.UnitTests/Behaviors/AnimationBehaviorTests.cs b/src/CommunityToolkit.Maui.UnitTests/Behaviors/AnimationBehaviorTests.cs
index 5f19aeabc8..16ebb86e35 100644
--- a/src/CommunityToolkit.Maui.UnitTests/Behaviors/AnimationBehaviorTests.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/Behaviors/AnimationBehaviorTests.cs
@@ -2,6 +2,7 @@
 using CommunityToolkit.Maui.Behaviors;
 using CommunityToolkit.Maui.UnitTests.Mocks;
 using FluentAssertions;
+using Nito.AsyncEx;
 using Xunit;
 
 namespace CommunityToolkit.Maui.UnitTests.Behaviors;
@@ -49,7 +50,7 @@ public void TapGestureRecognizerNotAttachedWhenViewIsInputView()
 		addBehavior.Should().Throw<InvalidOperationException>();
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task AnimateCommandStartsAnimation()
 	{
 		bool animationStarted = false, animationEnded = false;
@@ -71,7 +72,7 @@ public async Task AnimateCommandStartsAnimation()
 			Behaviors = { behavior }
 		}.EnableAnimations();
 
-		behavior.AnimateCommand.Execute(null);
+		behavior.AnimateCommand.Execute(CancellationToken.None);
 
 		await animationStartedTcs.Task;
 		await animationEndedTcs.Task;
@@ -97,6 +98,93 @@ void HandleAnimationEnded(object? sender, EventArgs e)
 		}
 	}
 
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public void AnimateCommandTokenCanceled()
+	{
+		TaskCanceledException? exception = null;
+		var animationEndedTcs = new TaskCompletionSource();
+		var animationCommandCts = new CancellationTokenSource();
+
+		var mockAnimation = new MockAnimation();
+		mockAnimation.AnimationEnded += HandleAnimationEnded;
+
+		var behavior = new AnimationBehavior
+		{
+			AnimationType = mockAnimation
+		};
+
+		new Label
+		{
+			Behaviors = { behavior }
+		}.EnableAnimations();
+
+		try
+		{
+			// Run using AsyncContext to catch Exception thrown by fire-and-forget AnimateCommand (ICommand)
+			AsyncContext.Run(async () =>
+			{
+				await animationCommandCts.CancelAsync();
+				behavior.AnimateCommand.Execute(animationCommandCts.Token);
+				await animationEndedTcs.Task;
+			});
+		}
+		catch (TaskCanceledException e)
+		{
+			exception = e;
+		}
+
+		Assert.NotNull(exception);
+
+		void HandleAnimationEnded(object? sender, EventArgs e)
+		{
+			mockAnimation.AnimationEnded -= HandleAnimationEnded;
+			animationEndedTcs.SetResult();
+		}
+	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public void AnimateCommandTokenExpired()
+	{
+		TaskCanceledException? exception = null;
+		var animationEndedTcs = new TaskCompletionSource();
+		var animationCommandCts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
+
+		var mockAnimation = new MockAnimation();
+		mockAnimation.AnimationEnded += HandleAnimationEnded;
+
+		var behavior = new AnimationBehavior
+		{
+			AnimationType = mockAnimation
+		};
+
+		new Label
+		{
+			Behaviors = { behavior }
+		}.EnableAnimations();
+
+		try
+		{
+			// Run using AsyncContext to catch Exception thrown by fire-and-forget AnimateCommand (ICommand)
+			AsyncContext.Run(async () =>
+			{
+				behavior.AnimateCommand.Execute(animationCommandCts.Token);
+				await animationEndedTcs.Task;
+			});
+		}
+		catch (TaskCanceledException e)
+		{
+			exception = e;
+		}
+
+		Assert.NotNull(exception);
+
+		void HandleAnimationEnded(object? sender, EventArgs e)
+		{
+			mockAnimation.AnimationEnded -= HandleAnimationEnded;
+			animationEndedTcs.SetResult();
+		}
+	}
+
 	class MockAnimation : BaseAnimation
 	{
 		public bool HasAnimated { get; private set; }
@@ -104,13 +192,13 @@ class MockAnimation : BaseAnimation
 		public event EventHandler? AnimationStarted;
 		public event EventHandler? AnimationEnded;
 
-		public override async Task Animate(VisualElement element)
+		public override async Task Animate(VisualElement element, CancellationToken token)
 		{
 			ArgumentNullException.ThrowIfNull(element);
 
 			AnimationStarted?.Invoke(this, EventArgs.Empty);
 
-			await element.RotateTo(70);
+			await element.RotateTo(70).WaitAsync(token);
 
 			HasAnimated = true;
 
diff --git a/src/CommunityToolkit.Maui.UnitTests/Behaviors/CharactersValidationBehaviorTests.cs b/src/CommunityToolkit.Maui.UnitTests/Behaviors/CharactersValidationBehaviorTests.cs
index 5cf89304c2..6882a87e91 100644
--- a/src/CommunityToolkit.Maui.UnitTests/Behaviors/CharactersValidationBehaviorTests.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/Behaviors/CharactersValidationBehaviorTests.cs
@@ -49,9 +49,57 @@ public async Task IsValid(CharacterType characterType, int minimumCharactersNumb
 		entry.Behaviors.Add(behavior);
 
 		// Act
-		await behavior.ForceValidate();
+		await behavior.ForceValidate(CancellationToken.None);
 
 		// Assert
 		Assert.Equal(expectedValue, behavior.IsValid);
 	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task CancellationTokenExpired()
+	{
+		// Arrange
+		var behavior = new CharactersValidationBehavior();
+		var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
+
+		var entry = new Entry
+		{
+			Text = "Hello"
+		};
+		entry.Behaviors.Add(behavior);
+
+		// Act
+
+		// Ensure CancellationToken expires
+		await Task.Delay(100, CancellationToken.None);
+
+		// Assert
+		await Assert.ThrowsAsync<OperationCanceledException>(async () => await behavior.ForceValidate(cts.Token));
+	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task CancellationTokenCanceled()
+	{
+		// Arrange
+		var behavior = new CharactersValidationBehavior();
+		var cts = new CancellationTokenSource();
+
+		var entry = new Entry
+		{
+			Text = "Hello"
+		};
+		entry.Behaviors.Add(behavior);
+
+		// Act
+
+		// Ensure CancellationToken expires
+		await Task.Delay(100, CancellationToken.None);
+
+		// Assert
+		await Assert.ThrowsAsync<OperationCanceledException>(async () =>
+		{
+			await cts.CancelAsync();
+			await behavior.ForceValidate(cts.Token);
+		});
+	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.UnitTests/Behaviors/EmailValidationBehaviorTests.cs b/src/CommunityToolkit.Maui.UnitTests/Behaviors/EmailValidationBehaviorTests.cs
index 0952f1e708..edee9243e9 100644
--- a/src/CommunityToolkit.Maui.UnitTests/Behaviors/EmailValidationBehaviorTests.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/Behaviors/EmailValidationBehaviorTests.cs
@@ -1,5 +1,6 @@
 using System.Text.RegularExpressions;
 using CommunityToolkit.Maui.Behaviors;
+using Microsoft.Maui.Platform;
 using Xunit;
 
 namespace CommunityToolkit.Maui.UnitTests.Behaviors;
@@ -109,12 +110,56 @@ public async Task IsValid(string? value, bool expectedValue)
 		entry.Behaviors.Add(behavior);
 
 		// Act
-		await behavior.ForceValidate();
+		await behavior.ForceValidate(CancellationToken.None);
 
 		// Assert
 		Assert.Equal(expectedValue, behavior.IsValid);
 	}
 
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task ForceValidateCancellationTokenExpired()
+	{
+		// Arrange
+		var behavior = new EmailValidationBehavior();
+		var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
+
+		var entry = new Entry
+		{
+			Text = "Hello"
+		};
+		entry.Behaviors.Add(behavior);
+
+		// Act
+
+		// Ensure CancellationToken expires 
+		await Task.Delay(100, CancellationToken.None);
+
+		// Assert
+		await Assert.ThrowsAsync<OperationCanceledException>(async () => await behavior.ForceValidate(cts.Token));
+	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task ForceValidateCancellationTokenCanceled()
+	{
+		// Arrange
+		var behavior = new EmailValidationBehavior();
+		var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
+
+		var entry = new Entry
+		{
+			Text = "Hello"
+		};
+		entry.Behaviors.Add(behavior);
+
+		// Act
+
+		// Ensure CancellationToken expires 
+		await cts.CancelAsync();
+
+		// Assert
+		await Assert.ThrowsAsync<OperationCanceledException>(async () => await behavior.ForceValidate(cts.Token));
+	}
+
 	[Fact]
 	public void EnsureEntryEmailKeyboardWhenDefaultKeyboardAssigned()
 	{
diff --git a/src/CommunityToolkit.Maui.UnitTests/Behaviors/IconTintColorBehaviorTests.cs b/src/CommunityToolkit.Maui.UnitTests/Behaviors/IconTintColorBehaviorTests.cs
index 9b03f89c80..5a199c74bb 100644
--- a/src/CommunityToolkit.Maui.UnitTests/Behaviors/IconTintColorBehaviorTests.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/Behaviors/IconTintColorBehaviorTests.cs
@@ -3,7 +3,6 @@
 
 namespace CommunityToolkit.Maui.UnitTests.Behaviors;
 
-#pragma warning disable CA1416 // Validate platform compatibility
 public class IconTintColorBehaviorTests : BaseTest
 {
 	[Fact]
@@ -26,5 +25,4 @@ public void VerifyColorChanged()
 
 		Assert.Equal(Colors.Blue, iconTintColorBehavior.TintColor);
 	}
-#pragma warning restore CA1416 // Validate platform compatibility
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.UnitTests/Behaviors/MultiValidationBehaviorTests.cs b/src/CommunityToolkit.Maui.UnitTests/Behaviors/MultiValidationBehaviorTests.cs
index 08f24c218c..7781ca89e1 100644
--- a/src/CommunityToolkit.Maui.UnitTests/Behaviors/MultiValidationBehaviorTests.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/Behaviors/MultiValidationBehaviorTests.cs
@@ -58,9 +58,65 @@ public async Task IsValid(CharacterType characterType, int minimumCharactersNumb
 		entry.Behaviors.Add(multiBehavior);
 
 		// Act
-		await multiBehavior.ForceValidate();
+		await multiBehavior.ForceValidate(CancellationToken.None);
 
 		// Assert
 		Assert.Equal(expectedValue, multiBehavior.IsValid);
 	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task ForceValidateCancellationTokenExpired()
+	{
+		// Arrange
+		var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
+
+		var characterValidationBehavior = new CharactersValidationBehavior();
+		var requiredStringValidationBehavior = new RequiredStringValidationBehavior();
+
+		var multiBehavior = new MultiValidationBehavior();
+		multiBehavior.Children.Add(characterValidationBehavior);
+		multiBehavior.Children.Add(requiredStringValidationBehavior);
+
+		var entry = new Entry
+		{
+			Text = "Hello"
+		};
+		entry.Behaviors.Add(multiBehavior);
+
+		// Act
+
+		// Ensure CancellationToken expires 
+		await Task.Delay(100, CancellationToken.None);
+
+		// Assert
+		await Assert.ThrowsAsync<OperationCanceledException>(async () => await multiBehavior.ForceValidate(cts.Token));
+	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task ForceValidateCancellationTokenCanceled()
+	{
+		// Arrange
+		var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
+
+		var characterValidationBehavior = new CharactersValidationBehavior();
+		var requiredStringValidationBehavior = new RequiredStringValidationBehavior();
+
+		var multiBehavior = new MultiValidationBehavior();
+		multiBehavior.Children.Add(characterValidationBehavior);
+		multiBehavior.Children.Add(requiredStringValidationBehavior);
+
+		var entry = new Entry
+		{
+			Text = "Hello"
+		};
+		entry.Behaviors.Add(multiBehavior);
+
+		// Act
+
+		// Ensure CancellationToken expires 
+		await cts.CancelAsync();
+
+		// Assert
+		await Assert.ThrowsAsync<OperationCanceledException>(async () => await multiBehavior.ForceValidate(cts.Token));
+	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.UnitTests/Behaviors/NumericValidationBehaviorTests.cs b/src/CommunityToolkit.Maui.UnitTests/Behaviors/NumericValidationBehaviorTests.cs
index 73c81bdda2..5456f42f8e 100644
--- a/src/CommunityToolkit.Maui.UnitTests/Behaviors/NumericValidationBehaviorTests.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/Behaviors/NumericValidationBehaviorTests.cs
@@ -61,7 +61,7 @@ public async Task IsValid(string culture, string? value, double minValue, double
 		try
 		{
 			// Act
-			await behavior.ForceValidate();
+			await behavior.ForceValidate(CancellationToken.None);
 
 			// Assert
 			Assert.Equal(expectedValue, behavior.IsValid);
@@ -72,7 +72,7 @@ public async Task IsValid(string culture, string? value, double minValue, double
 		}
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task IsNull()
 	{
 		// Arrange
@@ -86,10 +86,10 @@ public async Task IsNull()
 		};
 		entry.Behaviors.Add(behavior);
 
-		await Assert.ThrowsAsync<ArgumentNullException>(async () => await behavior.ForceValidate());
+		await Assert.ThrowsAsync<ArgumentNullException>(async () => await behavior.ForceValidate(CancellationToken.None));
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task ShouldNotThrowIsNull()
 	{
 		var options = new Options();
@@ -106,9 +106,57 @@ public async Task ShouldNotThrowIsNull()
 		};
 		entry.Behaviors.Add(behavior);
 
-		var action = (async () => await behavior.ForceValidate());
+		var action = (async () => await behavior.ForceValidate(CancellationToken.None));
 		await action.Should().NotThrowAsync<ArgumentNullException>();
 
 		options.SetShouldSuppressExceptionsInBehaviors(false);
 	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task CancellationTokenExpired()
+	{
+		// Arrange
+		var behavior = new NumericValidationBehavior();
+		var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
+
+		var entry = new Entry
+		{
+			Text = "Hello"
+		};
+		entry.Behaviors.Add(behavior);
+
+		// Act
+
+		// Ensure CancellationToken expires
+		await Task.Delay(100, CancellationToken.None);
+
+		// Assert
+		await Assert.ThrowsAsync<OperationCanceledException>(async () => await behavior.ForceValidate(cts.Token));
+	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task CancellationTokenCanceled()
+	{
+		// Arrange
+		var behavior = new NumericValidationBehavior();
+		var cts = new CancellationTokenSource();
+
+		var entry = new Entry
+		{
+			Text = "Hello"
+		};
+		entry.Behaviors.Add(behavior);
+
+		// Act
+
+		// Ensure CancellationToken expires
+		await Task.Delay(100, CancellationToken.None);
+
+		// Assert
+		await Assert.ThrowsAsync<OperationCanceledException>(async () =>
+		{
+			await cts.CancelAsync();
+			await behavior.ForceValidate(cts.Token);
+		});
+	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.UnitTests/Behaviors/TextValidationBehaviorTests.cs b/src/CommunityToolkit.Maui.UnitTests/Behaviors/TextValidationBehaviorTests.cs
index 094bbeafde..68c91ad1a7 100644
--- a/src/CommunityToolkit.Maui.UnitTests/Behaviors/TextValidationBehaviorTests.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/Behaviors/TextValidationBehaviorTests.cs
@@ -31,9 +31,57 @@ public async Task IsValid(string pattern, RegexOptions options, int minLength, i
 		entry.Behaviors.Add(behavior);
 
 		// Act
-		await behavior.ForceValidate();
+		await behavior.ForceValidate(CancellationToken.None);
 
 		// Assert
 		Assert.Equal(expectedValue, behavior.IsValid);
 	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task CancellationTokenExpired()
+	{
+		// Arrange
+		var behavior = new TextValidationBehavior();
+		var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
+
+		var entry = new Entry
+		{
+			Text = "Hello"
+		};
+		entry.Behaviors.Add(behavior);
+
+		// Act
+
+		// Ensure CancellationToken expires
+		await Task.Delay(100, CancellationToken.None);
+
+		// Assert
+		await Assert.ThrowsAsync<OperationCanceledException>(async () => await behavior.ForceValidate(cts.Token));
+	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task CancellationTokenCanceled()
+	{
+		// Arrange
+		var behavior = new TextValidationBehavior();
+		var cts = new CancellationTokenSource();
+
+		var entry = new Entry
+		{
+			Text = "Hello"
+		};
+		entry.Behaviors.Add(behavior);
+
+		// Act
+
+		// Ensure CancellationToken expires
+		await Task.Delay(100, CancellationToken.None);
+
+		// Assert
+		await Assert.ThrowsAsync<OperationCanceledException>(async () =>
+		{
+			await cts.CancelAsync();
+			await behavior.ForceValidate(cts.Token);
+		});
+	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.UnitTests/Behaviors/UriValidationBehaviorTests.cs b/src/CommunityToolkit.Maui.UnitTests/Behaviors/UriValidationBehaviorTests.cs
index 24a80e0f94..bb03c356a4 100644
--- a/src/CommunityToolkit.Maui.UnitTests/Behaviors/UriValidationBehaviorTests.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/Behaviors/UriValidationBehaviorTests.cs
@@ -22,9 +22,57 @@ public async Task IsValid(string value, UriKind uriKind, bool expectedValue)
 		};
 
 		// Act
-		await behavior.ForceValidate();
+		await behavior.ForceValidate(CancellationToken.None);
 
 		// Assert
 		Assert.Equal(expectedValue, behavior.IsValid);
 	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task CancellationTokenExpired()
+	{
+		// Arrange
+		var behavior = new UriValidationBehavior();
+		var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
+
+		var entry = new Entry
+		{
+			Text = "Hello"
+		};
+		entry.Behaviors.Add(behavior);
+
+		// Act
+
+		// Ensure CancellationToken expires
+		await Task.Delay(100, CancellationToken.None);
+
+		// Assert
+		await Assert.ThrowsAsync<OperationCanceledException>(async () => await behavior.ForceValidate(cts.Token));
+	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task CancellationTokenCanceled()
+	{
+		// Arrange
+		var behavior = new UriValidationBehavior();
+		var cts = new CancellationTokenSource();
+
+		var entry = new Entry
+		{
+			Text = "Hello"
+		};
+		entry.Behaviors.Add(behavior);
+
+		// Act
+
+		// Ensure CancellationToken expires
+		await Task.Delay(100, CancellationToken.None);
+
+		// Assert
+		await Assert.ThrowsAsync<OperationCanceledException>(async () =>
+		{
+			await cts.CancelAsync();
+			await behavior.ForceValidate(cts.Token);
+		});
+	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.UnitTests/Behaviors/UserStoppedTypingBehaviorTests.cs b/src/CommunityToolkit.Maui.UnitTests/Behaviors/UserStoppedTypingBehaviorTests.cs
index f89658af04..4ae9fbe3db 100644
--- a/src/CommunityToolkit.Maui.UnitTests/Behaviors/UserStoppedTypingBehaviorTests.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/Behaviors/UserStoppedTypingBehaviorTests.cs
@@ -6,182 +6,273 @@ namespace CommunityToolkit.Maui.UnitTests.Behaviors;
 
 public class UserStoppedTypingBehaviorTests : BaseTest
 {
-	const int defaultTimeThreshold = 1000;
-	const int defaultLengthThreshold = 0;
-	const int defaultTimeoutThreshold = defaultTimeThreshold * 2;
-
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task ShouldExecuteCommandWhenTimeThresholdHasExpired()
 	{
 		// arrange
+		var commandTCS = new TaskCompletionSource();
 		var commandHasBeenExecuted = false;
-		var entry = CreateEntryWithBehavior(command: new Command<string>(_ => commandHasBeenExecuted = true));
+
+		var entry = CreateEntryWithBehavior(command: new Command<string>(_ =>
+		{
+			commandHasBeenExecuted = true;
+			commandTCS.SetResult();
+		}));
 
 		// act
 		entry.Text = "1";
-		await Task.Delay(defaultTimeoutThreshold);
+		await commandTCS.Task;
 
 		// assert
 		Assert.True(commandHasBeenExecuted);
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task ShouldExecuteCommandWithSpecificParameterWhenSpecified()
 	{
 		// arrange
+		var commandTCS = new TaskCompletionSource();
 		var commandHasBeenExecuted = false;
-		var entry = CreateEntryWithBehavior(command: new Command<bool>(_ => commandHasBeenExecuted = true),
-											commandParameter: true);
+		var entry = CreateEntryWithBehavior(command: new Command<bool>(_ =>
+		{
+			commandHasBeenExecuted = true;
+			commandTCS.SetResult();
+		}), commandParameter: true);
 
 		// act
 		entry.Text = "1";
-		await Task.Delay(defaultTimeoutThreshold);
+		await commandTCS.Task;
 
 		// assert
 		Assert.True(commandHasBeenExecuted);
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task ShouldNotExecuteCommandBeforeTimeThresholdHasExpired()
 	{
 		// arrange
+		var commandTCS = new TaskCompletionSource();
 		var commandHasBeenExecuted = false;
-		var entry = CreateEntryWithBehavior(command: new Command<string>(_ => commandHasBeenExecuted = true));
+		var entry = CreateEntryWithBehavior(command: new Command<string>(_ =>
+		{
+			commandHasBeenExecuted = true;
+			commandTCS.SetResult();
+		}));
 
 		// act
 		entry.Text = "1";
-		await Task.Delay(10);
 
 		// assert
 		Assert.False(commandHasBeenExecuted);
+
+		// act
+		await commandTCS.Task;
+
+		Assert.True(commandHasBeenExecuted);
 	}
 
-	[Fact]
-	public async Task ShouldOnlyExectueCommandOnceWhenTextChangedHasOccurredMultipleTimes()
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task ShouldOnlyExecuteCommandOnceWhenTextChangedHasOccurredMultipleTimes()
 	{
 		// arrange
+		var commandTCS = new TaskCompletionSource();
 		var timesExecuted = 0;
-		var entry = CreateEntryWithBehavior(command: new Command<string>(_ => timesExecuted++));
+		var entry = CreateEntryWithBehavior(command: new Command<string>(_ =>
+		{
+			timesExecuted++;
+			commandTCS.SetResult();
+		}));
 
 		// act
 		entry.Text = "1";
 		entry.Text = "12";
 		entry.Text = "123";
 		entry.Text = "1234";
-		await Task.Delay(defaultTimeoutThreshold);
+		await commandTCS.Task;
 
 		// assert
 		Assert.Equal(1, timesExecuted);
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task ShouldDismissKeyboardWhenTimeThresholdHasExpired()
 	{
 		// arrange
+		var unfocusTCS = new TaskCompletionSource();
 		var entry = CreateEntryWithBehavior(shouldDismissKeyboardAutomatically: true);
+		entry.Unfocused += HandleEntryUnfocused;
 
 		// act
 		entry.Focus();
 		entry.Text = "1";
 
-		await Task.Delay(defaultTimeoutThreshold);
+		await unfocusTCS.Task;
 
 		// assert
 		Assert.False(entry.IsFocused);
+
+		void HandleEntryUnfocused(object? sender, FocusEventArgs e)
+		{
+			entry.Unfocused -= HandleEntryUnfocused;
+			unfocusTCS.SetResult();
+		}
 	}
 
-	[Fact]
-	public async Task ShouldExecuteCommandWhenMinimumLengthThreholdHasBeenReached()
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task ShouldExecuteCommandWhenMinimumLengthThresholdHasBeenReached()
 	{
 		// arrange
+		var commandTCS = new TaskCompletionSource();
 		var commandHasBeenExecuted = false;
-		var entry = CreateEntryWithBehavior(command: new Command<string>(_ => commandHasBeenExecuted = true),
-											lengthThreshold: 3);
+		var entry = CreateEntryWithBehavior(command: new Command<string>(_ =>
+		{
+			commandHasBeenExecuted = true;
+			commandTCS.SetResult();
+		}),
+		minimumLengthThreshold: 3);
 
 		// act
 		entry.Text = "1";
 		entry.Text = "12";
 		entry.Text = "123";
-		await Task.Delay(defaultTimeoutThreshold);
+		await commandTCS.Task;
 
 		// assert
 		Assert.True(commandHasBeenExecuted);
 	}
 
-	[Fact]
-	public async Task ShouldNotExecuteCommandWhenMinimumLengthThreholdHasNotBeenReached()
+	[Fact(Timeout = (int)TestDuration.Long)]
+	public async Task ShouldNotExecuteCommandWhenMinimumLengthThresholdHasNotBeenReached()
 	{
 		// arrange
+		var focusTCS = new TaskCompletionSource();
+		var commandTCS = new TaskCompletionSource();
 		var commandHasBeenExecuted = false;
-		var entry = CreateEntryWithBehavior(command: new Command<string>(_ => commandHasBeenExecuted = true),
-											lengthThreshold: 2);
+		var entry = CreateEntryWithBehavior(command: new Command<string>(_ =>
+		{
+			commandHasBeenExecuted = true;
+			commandTCS.SetResult();
+		}),
+		minimumLengthThreshold: 2);
+
+		entry.Focused += HandleFocused;
 
 		// act
+		entry.Focus();
 		entry.Text = "1";
-		await Task.Delay(defaultTimeoutThreshold);
+		await focusTCS.Task;
 
 		// assert
 		Assert.False(commandHasBeenExecuted);
+
+		// act
+		entry.Text = "123";
+		await commandTCS.Task;
+
+		// assert
+		Assert.True(commandHasBeenExecuted);
+
+		void HandleFocused(object? sender, FocusEventArgs e)
+		{
+			entry.Focused -= HandleFocused;
+			focusTCS.SetResult();
+		}
 	}
 
-	[Fact]
-	public async Task ShouldNotDismissKeyboardWhenMinimumLengthThreholdHasNotBeenReached()
+	[Fact(Timeout = (int)TestDuration.Long)]
+	public async Task ShouldNotDismissKeyboardWhenMinimumLengthThresholdHasNotBeenReached()
 	{
 		// arrange
-		var entry = CreateEntryWithBehavior(lengthThreshold: 3,
-											shouldDismissKeyboardAutomatically: true);
+		var focusTCS = new TaskCompletionSource();
+		var unfocusTCS = new TaskCompletionSource();
+		var entry = CreateEntryWithBehavior(minimumLengthThreshold: 3,
+			shouldDismissKeyboardAutomatically: true);
+		entry.Focused += HandleFocused;
+		entry.Unfocused += HandleUnfocused;
 
 		// act
 		entry.Focus();
 
 		entry.Text = "1";
-		await Task.Delay(defaultTimeoutThreshold);
+		await focusTCS.Task;
 
 		// assert
 		Assert.True(entry.IsFocused);
+
+		// act
+		entry.Text = "123";
+		await unfocusTCS.Task;
+
+		// assert
+		Assert.False(entry.IsFocused);
+
+		void HandleFocused(object? sender, FocusEventArgs e)
+		{
+			entry.Focused -= HandleFocused;
+			focusTCS.SetResult();
+		}
+
+		void HandleUnfocused(object? sender, FocusEventArgs e)
+		{
+			entry.Unfocused -= HandleUnfocused;
+			unfocusTCS.SetResult();
+		}
 	}
 
-	[Fact]
-	public async Task ShouldExecuteCommandImmediatelyWhenMinimumLengthThreholdHasNotBeenSet()
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task ShouldExecuteCommandImmediatelyWhenMinimumLengthThresholdHasNotBeenSet()
 	{
 		// arrange
+		var commandTCS = new TaskCompletionSource();
 		var commandHasBeenExecuted = false;
-		var entry = CreateEntryWithBehavior(command: new Command<string>(_ => commandHasBeenExecuted = true));
+		var entry = CreateEntryWithBehavior(command: new Command<string>(_ =>
+		{
+			commandHasBeenExecuted = true;
+			commandTCS.SetResult();
+		}));
 
 		// act
 		entry.Text = "1";
-		await Task.Delay(defaultTimeoutThreshold);
+		await commandTCS.Task;
 
 		// assert
 		Assert.True(commandHasBeenExecuted);
 	}
 
-	static Entry CreateEntryWithBehavior(int timeThreshold = defaultTimeThreshold,
-										 int lengthThreshold = defaultLengthThreshold,
-										 bool shouldDismissKeyboardAutomatically = false,
-										 ICommand? command = null,
-										 object? commandParameter = null)
+	static Entry CreateEntryWithBehavior(int stoppedTypingTimeThreshold = 500,
+		int minimumLengthThreshold = 0,
+		bool shouldDismissKeyboardAutomatically = false,
+		ICommand? command = null,
+		object? commandParameter = null)
 	{
 		var entry = new Entry
 		{
 			Behaviors =
+			{
+				new UserStoppedTypingBehavior
 				{
-					new UserStoppedTypingBehavior
-					{
-						StoppedTypingTimeThreshold = timeThreshold,
-						MinimumLengthThreshold = lengthThreshold,
-						ShouldDismissKeyboardAutomatically = shouldDismissKeyboardAutomatically,
-						Command = command,
-						CommandParameter = commandParameter
-					}
+					StoppedTypingTimeThreshold = stoppedTypingTimeThreshold,
+					MinimumLengthThreshold = minimumLengthThreshold,
+					ShouldDismissKeyboardAutomatically = shouldDismissKeyboardAutomatically,
+					Command = command,
+					CommandParameter = commandParameter
 				}
+			}
 		};
 
 		// We simulate Focus/Unfocus behavior ourselves
 		// because unit tests doesn't have "platform-specific" part
 		// where IsFocused is controlled in the real app
-		entry.FocusChangeRequested += (s, e) => entry.SetValue(VisualElement.IsFocusedPropertyKey, e.Focus);
+		entry.FocusChangeRequested += HandleEntryFocusChangeRequested;
 
 		return entry;
+
+		static void HandleEntryFocusChangeRequested(object? sender, VisualElement.FocusRequestArgs e)
+		{
+			ArgumentNullException.ThrowIfNull(sender);
+
+			var entry = (Entry)sender;
+			entry.SetValue(VisualElement.IsFocusedPropertyKey, e.Focus);
+		}
 	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.UnitTests/Behaviors/ValidationBehaviorTests.cs b/src/CommunityToolkit.Maui.UnitTests/Behaviors/ValidationBehaviorTests.cs
index 8be29d7504..ebfa84881f 100644
--- a/src/CommunityToolkit.Maui.UnitTests/Behaviors/ValidationBehaviorTests.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/Behaviors/ValidationBehaviorTests.cs
@@ -28,7 +28,7 @@ public void ValidateOnValueChanged()
 		Assert.True(behavior.IsValid);
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Medium)]
 	public async Task ValidValue_ValidStyle()
 	{
 		// Arrange
@@ -54,13 +54,13 @@ public async Task ValidValue_ValidStyle()
 
 		// Act
 		entry.Text = "321";
-		await behavior.ForceValidate();
+		await behavior.ForceValidate(CancellationToken.None);
 
 		// Assert
 		Assert.Equal(entry.Style, validStyle);
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task InvalidValue_InvalidStyle()
 	{
 		// Arrange
@@ -86,13 +86,13 @@ public async Task InvalidValue_InvalidStyle()
 
 		// Act
 		entry.Text = "321";
-		await behavior.ForceValidate();
+		await behavior.ForceValidate(CancellationToken.None);
 
 		// Assert
 		Assert.Equal(entry.Style, invalidStyle);
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task IsRunning()
 	{
 		// Arrange
@@ -115,7 +115,7 @@ public async Task IsRunning()
 		Assert.False(behavior.IsRunning);
 
 		// Act
-		var forceValidateTask = behavior.ForceValidate();
+		var forceValidateTask = behavior.ForceValidate(CancellationToken.None);
 
 		// Assert
 		Assert.True(behavior.IsRunning);
@@ -135,7 +135,7 @@ public void ForceValidateCommand()
 		var behavior = new MockValidationBehavior()
 		{
 			ExpectedValue = "321",
-			ForceValidateCommand = new Command(() =>
+			ForceValidateCommand = new Command<CancellationToken>(token =>
 			{
 				entry.Text = "321";
 			})
@@ -150,16 +150,64 @@ public void ForceValidateCommand()
 		Assert.True(behavior.IsValid);
 	}
 
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task CancellationTokenExpired()
+	{
+		// Arrange
+		var behavior = new MockValidationBehavior();
+		var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
+
+		var entry = new Entry
+		{
+			Text = "Hello"
+		};
+		entry.Behaviors.Add(behavior);
+
+		// Act
+
+		// Ensure CancellationToken expires
+		await Task.Delay(100, CancellationToken.None);
+
+		// Assert
+		await Assert.ThrowsAsync<OperationCanceledException>(async () => await behavior.ForceValidate(cts.Token));
+	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task CancellationTokenCanceled()
+	{
+		// Arrange
+		var behavior = new MockValidationBehavior();
+		var cts = new CancellationTokenSource();
+
+		var entry = new Entry
+		{
+			Text = "Hello"
+		};
+		entry.Behaviors.Add(behavior);
+
+		// Act
+
+		// Ensure CancellationToken expires
+		await Task.Delay(100, CancellationToken.None);
+
+		// Assert
+		await Assert.ThrowsAsync<OperationCanceledException>(async () =>
+		{
+			await cts.CancelAsync();
+			await behavior.ForceValidate(cts.Token);
+		});
+	}
+
 	class MockValidationBehavior : ValidationBehavior<string>
 	{
-		public string? ExpectedValue { get; set; }
-		public bool SimulateValidationDelay { get; set; } = false;
+		public string? ExpectedValue { get; init; }
+		public bool SimulateValidationDelay { get; init; } = false;
 
 		protected override async ValueTask<bool> ValidateAsync(string? value, CancellationToken token)
 		{
 			if (SimulateValidationDelay)
 			{
-				await Task.Delay(1000, token);
+				await Task.Delay(500, token);
 			}
 
 			return value == ExpectedValue;
diff --git a/src/CommunityToolkit.Maui.UnitTests/CommunityToolkit.Maui.UnitTests.csproj b/src/CommunityToolkit.Maui.UnitTests/CommunityToolkit.Maui.UnitTests.csproj
index 95aaf85727..9cd357e901 100644
--- a/src/CommunityToolkit.Maui.UnitTests/CommunityToolkit.Maui.UnitTests.csproj
+++ b/src/CommunityToolkit.Maui.UnitTests/CommunityToolkit.Maui.UnitTests.csproj
@@ -11,6 +11,7 @@
   <ItemGroup>
     <PackageReference Include="AutoFixture.Xunit2" Version="4.18.0" />
     <PackageReference Include="FluentAssertions" Version="6.12.0" />
+    <PackageReference Include="Nito.AsyncEx" Version="5.1.2" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
     <PackageReference Include="xunit" Version="2.6.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3" PrivateAssets="All" />
diff --git a/src/CommunityToolkit.Maui.UnitTests/Converters/ByteArrayToImageSourceConverterTests.cs b/src/CommunityToolkit.Maui.UnitTests/Converters/ByteArrayToImageSourceConverterTests.cs
index 081ef8c6a5..1f0ba0a0b0 100644
--- a/src/CommunityToolkit.Maui.UnitTests/Converters/ByteArrayToImageSourceConverterTests.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/Converters/ByteArrayToImageSourceConverterTests.cs
@@ -13,7 +13,7 @@ public class ByteArrayToImageSourceConverterTests : BaseConverterTest<ByteArrayT
 		new object[] { new object() } // objects
 	};
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task ByteArrayToImageSourceConverter()
 	{
 		var byteArray = new byte[] { 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20 };
diff --git a/src/CommunityToolkit.Maui.UnitTests/Converters/ImageResourceConverterTests.cs b/src/CommunityToolkit.Maui.UnitTests/Converters/ImageResourceConverterTests.cs
index 894a78e73b..d6a17213c5 100644
--- a/src/CommunityToolkit.Maui.UnitTests/Converters/ImageResourceConverterTests.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/Converters/ImageResourceConverterTests.cs
@@ -7,7 +7,7 @@ namespace CommunityToolkit.Maui.UnitTests.Converters;
 
 public class ImageResourceConverterTests : BaseOneWayConverterTest<ImageResourceConverter>
 {
-	public ImageResourceConverterTests() : base()
+	public ImageResourceConverterTests()
 	{
 		Application.Current = new MockApplication();
 	}
@@ -16,7 +16,7 @@ public ImageResourceConverterTests() : base()
 	{
 		new object[] { 3 }, // primitive type
 		new object[] { DateTime.UtcNow }, // Struct
-		new object[] { new () } // objects
+		new object[] { new() } // objects
 	};
 
 	protected override void Dispose(bool isDisposing)
@@ -26,7 +26,7 @@ protected override void Dispose(bool isDisposing)
 		base.Dispose(isDisposing);
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task ImageResourceConverter()
 	{
 		const string resourceToLoad = "CommunityToolkit.Maui.UnitTests.Resources.dotnet-bot.png";
@@ -45,6 +45,38 @@ public async Task ImageResourceConverter()
 		Assert.True(StreamEquals(expectedMemoryStream, streamFromResult));
 	}
 
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task ImageResourceConverter_CancellationTokenExpired()
+	{
+		const string resourceToLoad = "CommunityToolkit.Maui.UnitTests.Resources.dotnet-bot.png";
+		var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
+
+		var imageResourceConverter = new ImageResourceConverter();
+
+		var convertFromResult = (StreamImageSource)imageResourceConverter.ConvertFrom(resourceToLoad, CultureInfo.CurrentCulture);
+
+		// Ensure CancellationToken has expired
+		await Task.Delay(100, CancellationToken.None);
+
+		await Assert.ThrowsAsync<TaskCanceledException>(() => GetStreamFromImageSource(convertFromResult, cts.Token));
+	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task ImageResourceConverter_CancellationTokenCancelled()
+	{
+		const string resourceToLoad = "CommunityToolkit.Maui.UnitTests.Resources.dotnet-bot.png";
+		var cts = new CancellationTokenSource();
+
+		var imageResourceConverter = new ImageResourceConverter();
+
+		var convertFromResult = (StreamImageSource)imageResourceConverter.ConvertFrom(resourceToLoad, CultureInfo.CurrentCulture);
+
+		// Ensure CancellationToken has expired
+		await cts.CancelAsync();
+
+		await Assert.ThrowsAsync<TaskCanceledException>(() => GetStreamFromImageSource(convertFromResult, cts.Token));
+	}
+
 	[Fact]
 	public void NullValueReturnsNull()
 	{
diff --git a/src/CommunityToolkit.Maui.UnitTests/Essentials/BadgeTests.cs b/src/CommunityToolkit.Maui.UnitTests/Essentials/BadgeTests.cs
index ae1b7bdd99..197a99662a 100644
--- a/src/CommunityToolkit.Maui.UnitTests/Essentials/BadgeTests.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/Essentials/BadgeTests.cs
@@ -5,7 +5,7 @@
 
 namespace CommunityToolkit.Maui.UnitTests.Essentials;
 
-public class BadgeTests
+public class BadgeTests : BaseTest
 {
 	[Fact]
 	public void BadgeTestsSetDefaultUpdatesInstance()
diff --git a/src/CommunityToolkit.Maui.UnitTests/Essentials/FileSaverTests.cs b/src/CommunityToolkit.Maui.UnitTests/Essentials/FileSaverTests.cs
index 0c7ea32b79..a6a6783ef8 100644
--- a/src/CommunityToolkit.Maui.UnitTests/Essentials/FileSaverTests.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/Essentials/FileSaverTests.cs
@@ -5,7 +5,7 @@
 
 namespace CommunityToolkit.Maui.UnitTests.Essentials;
 
-public class FileSaverTests
+public class FileSaverTests : BaseTest
 {
 	[Fact]
 	public void FileSaverTestsSetDefaultUpdatesInstance()
@@ -16,7 +16,7 @@ public void FileSaverTestsSetDefaultUpdatesInstance()
 		fileSaver.Should().BeSameAs(fileSaverImplementationMock);
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task SaveAsyncFailsOnNet()
 	{
 		FileSaver.SetDefault(new FileSaverImplementation());
@@ -28,7 +28,7 @@ public async Task SaveAsyncFailsOnNet()
 		Assert.Throws<NotImplementedException>(result.EnsureSuccess);
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task SaveAsyncWithInitialPathFailsOnNet()
 	{
 		FileSaver.SetDefault(new FileSaverImplementation());
diff --git a/src/CommunityToolkit.Maui.UnitTests/Essentials/FolderPickerTests.cs b/src/CommunityToolkit.Maui.UnitTests/Essentials/FolderPickerTests.cs
index b3648e1210..2ebbb3305a 100644
--- a/src/CommunityToolkit.Maui.UnitTests/Essentials/FolderPickerTests.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/Essentials/FolderPickerTests.cs
@@ -5,7 +5,7 @@
 
 namespace CommunityToolkit.Maui.UnitTests.Essentials;
 
-public class FolderPickerTests
+public class FolderPickerTests : BaseTest
 {
 	[Fact]
 	public void FolderPickerSetDefaultUpdatesInstance()
@@ -16,7 +16,7 @@ public void FolderPickerSetDefaultUpdatesInstance()
 		folderPickerInstance.Should().BeSameAs(folderPickerMock);
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task PickAsyncFailsOnNet()
 	{
 		FolderPicker.SetDefault(new FolderPickerImplementation());
@@ -28,7 +28,7 @@ public async Task PickAsyncFailsOnNet()
 		Assert.Throws<NotImplementedException>(result.EnsureSuccess);
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task PickAsyncWithInitialPathFailsOnNet()
 	{
 		FolderPicker.SetDefault(new FolderPickerImplementation());
diff --git a/src/CommunityToolkit.Maui.UnitTests/Essentials/SpeechToTextTests.cs b/src/CommunityToolkit.Maui.UnitTests/Essentials/SpeechToTextTests.cs
index da463adc04..1ffb9ffa3e 100644
--- a/src/CommunityToolkit.Maui.UnitTests/Essentials/SpeechToTextTests.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/Essentials/SpeechToTextTests.cs
@@ -7,15 +7,8 @@
 
 namespace CommunityToolkit.Maui.UnitTests.Essentials;
 
-public class SpeechToTextTests
+public class SpeechToTextTests(ITestOutputHelper testOutputHelper) : BaseTest
 {
-	readonly ITestOutputHelper testOutputHelper;
-
-	public SpeechToTextTests(ITestOutputHelper testOutputHelper)
-	{
-		this.testOutputHelper = testOutputHelper;
-	}
-
 	[Fact]
 	public void SpeechToTextTestsSetDefaultUpdatesInstance()
 	{
@@ -25,7 +18,7 @@ public void SpeechToTextTestsSetDefaultUpdatesInstance()
 		speechToText.Should().BeSameAs(speechToTextImplementationMock);
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task ListenAsyncFailsOnNet()
 	{
 		SpeechToText.SetDefault(new SpeechToTextImplementation());
@@ -34,14 +27,14 @@ public async Task ListenAsyncFailsOnNet()
 		result.Exception.Should().BeOfType<NotImplementedInReferenceAssemblyException>();
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task StartListenAsyncFailsOnNet()
 	{
 		SpeechToText.SetDefault(new SpeechToTextImplementation());
 		await Assert.ThrowsAsync<NotImplementedInReferenceAssemblyException>(() => SpeechToText.StartListenAsync(CultureInfo.CurrentCulture, CancellationToken.None));
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Long)]
 	public async Task StartStopListenAsyncShouldChangeState()
 	{
 		SpeechToText.SetDefault(new SpeechToTextImplementationMock(string.Empty, string.Empty));
@@ -58,7 +51,7 @@ void OnStateChanged(object? sender, SpeechToTextStateChangedEventArgs args)
 		};
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Long)]
 	public async Task StartStopListenAsyncShouldChangeRecognitionText()
 	{
 		var expectedPartialText = ".NET MAUI";
@@ -69,7 +62,7 @@ public async Task StartStopListenAsyncShouldChangeRecognitionText()
 		SpeechToText.Default.RecognitionResultUpdated += OnRecognitionTextUpdated;
 		SpeechToText.Default.RecognitionResultCompleted += OnRecognitionTextCompleted;
 		await SpeechToText.StartListenAsync(CultureInfo.CurrentCulture, CancellationToken.None);
-		await Task.Delay(2000);
+		await Task.Delay(500);
 		await SpeechToText.StopListenAsync(CancellationToken.None);
 		SpeechToText.Default.RecognitionResultUpdated -= OnRecognitionTextUpdated;
 		SpeechToText.Default.RecognitionResultCompleted -= OnRecognitionTextCompleted;
@@ -86,14 +79,14 @@ void OnRecognitionTextCompleted(object? sender, SpeechToTextRecognitionResultCom
 		};
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task StopListenAsyncFailsOnNet()
 	{
 		SpeechToText.SetDefault(new SpeechToTextImplementation());
 		await Assert.ThrowsAsync<NotSupportedException>(() => SpeechToText.StopListenAsync(CancellationToken.None));
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task RequestPermissionsFailsOnNet()
 	{
 		SpeechToText.SetDefault(new SpeechToTextImplementation());
diff --git a/src/CommunityToolkit.Maui.UnitTests/Extensions/BackgroundColorToTests.cs b/src/CommunityToolkit.Maui.UnitTests/Extensions/BackgroundColorToTests.cs
index 05c70d12b8..fea5c0bae8 100644
--- a/src/CommunityToolkit.Maui.UnitTests/Extensions/BackgroundColorToTests.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/Extensions/BackgroundColorToTests.cs
@@ -6,7 +6,7 @@ namespace CommunityToolkit.Maui.UnitTests.Extensions;
 
 public class BackgroundColorToTests : BaseTest
 {
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task BackgroundColorTo_VerifyColorChanged()
 	{
 		Color originalBackgroundColor = Colors.Blue, updatedBackgroundColor = Colors.Red;
@@ -22,7 +22,35 @@ public async Task BackgroundColorTo_VerifyColorChanged()
 		Assert.Equal(updatedBackgroundColor, element.BackgroundColor);
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task BackgroundColorTo_CancellationTokenExpired()
+	{
+		var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
+
+		VisualElement element = new Label { BackgroundColor = Colors.Blue };
+		element.EnableAnimations();
+
+		// Ensure CancellationToken has expired
+		await Task.Delay(100, CancellationToken.None);
+
+		await Assert.ThrowsAsync<TaskCanceledException>(() => element.BackgroundColorTo(Colors.Green, token: cts.Token));
+	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task BackgroundColorTo_CancellationTokenCanceled()
+	{
+		var cts = new CancellationTokenSource();
+
+		VisualElement element = new Label { BackgroundColor = Colors.Blue };
+		element.EnableAnimations();
+
+		// Ensure CancellationToken has expired
+		await cts.CancelAsync();
+
+		await Assert.ThrowsAsync<TaskCanceledException>(() => element.BackgroundColorTo(Colors.Green, token: cts.Token));
+	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task BackgroundColorTo_VerifyColorChangedForDefaultBackgroundColor()
 	{
 		Color updatedBackgroundColor = Colors.Yellow;
@@ -36,7 +64,7 @@ public async Task BackgroundColorTo_VerifyColorChangedForDefaultBackgroundColor(
 		Assert.Equal(updatedBackgroundColor, element.BackgroundColor);
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task BackgroundColorTo_DoesNotAllowNullVisualElement()
 	{
 		VisualElement? element = null;
@@ -46,7 +74,7 @@ public async Task BackgroundColorTo_DoesNotAllowNullVisualElement()
 #pragma warning restore CS8603 // Possible null reference return.
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task BackgroundColorTo_DoesNotAllowNullColor()
 	{
 		VisualElement element = new Label();
diff --git a/src/CommunityToolkit.Maui.UnitTests/Extensions/ColorConversionExtensionsTests.cs b/src/CommunityToolkit.Maui.UnitTests/Extensions/ColorConversionExtensionsTests.cs
index 6c64cc7473..8636c08328 100644
--- a/src/CommunityToolkit.Maui.UnitTests/Extensions/ColorConversionExtensionsTests.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/Extensions/ColorConversionExtensionsTests.cs
@@ -3,7 +3,7 @@
 
 namespace CommunityToolkit.Maui.UnitTests.Extensions;
 
-public class ColorConversionExtensionsTests
+public class ColorConversionExtensionsTests : BaseTest
 {
 	const double tolerance = 0.000001;
 
diff --git a/src/CommunityToolkit.Maui.UnitTests/Extensions/TextColorToTests.cs b/src/CommunityToolkit.Maui.UnitTests/Extensions/TextColorToTests.cs
index 5ba1fc8571..3b8c8cad75 100644
--- a/src/CommunityToolkit.Maui.UnitTests/Extensions/TextColorToTests.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/Extensions/TextColorToTests.cs
@@ -25,6 +25,34 @@ public async Task PublicTextColorTo_VerifyColorChanged()
 			Assert.Equal(updatedTextColor, textStyleView.TextColor);
 		}
 
+		[Fact(Timeout = (int)TestDuration.Short)]
+		public async Task TextColorTo_CancellationTokenExpired()
+		{
+			var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
+
+			var label = new Label { TextColor = Colors.Blue };
+			label.EnableAnimations();
+
+			// Ensure CancellationToken has expired
+			await Task.Delay(100, CancellationToken.None);
+
+			await Assert.ThrowsAsync<TaskCanceledException>(() => label.TextColorTo(Colors.Green, token: cts.Token));
+		}
+
+		[Fact(Timeout = (int)TestDuration.Short)]
+		public async Task TextColorTo_CancellationTokenCanceled()
+		{
+			var cts = new CancellationTokenSource();
+
+			var label = new Label { TextColor = Colors.Blue };
+			label.EnableAnimations();
+
+			// Ensure CancellationToken has expired
+			await cts.CancelAsync();
+
+			await Assert.ThrowsAsync<TaskCanceledException>(() => label.TextColorTo(Colors.Green, token: cts.Token));
+		}
+
 		[Fact]
 		public async Task InternalTextColorTo_VerifyColorChanged()
 		{
diff --git a/src/CommunityToolkit.Maui.UnitTests/ImageSources/GravatarImageSource/GravatarImageSourceTests.cs b/src/CommunityToolkit.Maui.UnitTests/ImageSources/GravatarImageSource/GravatarImageSourceTests.cs
index 7be932086c..f179f41ba7 100644
--- a/src/CommunityToolkit.Maui.UnitTests/ImageSources/GravatarImageSource/GravatarImageSourceTests.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/ImageSources/GravatarImageSource/GravatarImageSourceTests.cs
@@ -342,7 +342,7 @@ public void TestDataPackage()
 		Assert.Equal(new Uri("https://www.gravatar.com/avatar/"), ((GravatarImageSource)testControl.Image).Uri);
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task TestDefaultStream()
 	{
 		CancellationTokenSource cts = new();
@@ -351,7 +351,7 @@ public async Task TestDefaultStream()
 		stream.Should().NotBeNull();
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task TestDefaultStreamCanceled()
 	{
 		CancellationTokenSource cts = new();
@@ -434,6 +434,6 @@ public void TestToolbar()
 	public void ToStringTest()
 	{
 		var gravatarImageSource = new GravatarImageSource();
-		Assert.Equal("Uri: https://www.gravatar.com/avatar/\nEmail: \nSize: -1\nImage: mp\nCacheValidity: 1.00:00:00\nCachingEnabled: True", gravatarImageSource.ToString());
+		Assert.Equal("Uri: https://www.gravatar.com/avatar/\nEmail: \nSize: \nImage: mp\nCacheValidity: 1.00:00:00\nCachingEnabled: True", gravatarImageSource.ToString());
 	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.UnitTests/Layouts/StateContainerTests.cs b/src/CommunityToolkit.Maui.UnitTests/Layouts/StateContainerTests.cs
index 64a1a6a6a8..1e7ae7fa99 100644
--- a/src/CommunityToolkit.Maui.UnitTests/Layouts/StateContainerTests.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/Layouts/StateContainerTests.cs
@@ -104,7 +104,41 @@ public void StateContainer_CanStateChangePropertyReadOnly()
 		Assert.True(StateContainer.GetCanStateChange(layout));
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task StateContainer_CancellationTokenExpired()
+	{
+		var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
+
+		layout.EnableAnimations();
+		foreach (var child in layout.Children)
+		{
+			child.EnableAnimations();
+		}
+
+		// Ensure CancellationToken has expired
+		await Task.Delay(100, CancellationToken.None);
+
+		await Assert.ThrowsAsync<TaskCanceledException>(() => StateContainer.ChangeStateWithAnimation(layout, StateKey.Error, cts.Token));
+	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task StateContainer_CancellationTokenCanceled()
+	{
+		var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
+
+		layout.EnableAnimations();
+		foreach (var child in layout.Children)
+		{
+			child.EnableAnimations();
+		}
+
+		// Ensure CancellationToken has expired
+		await cts.CancelAsync();
+
+		await Assert.ThrowsAsync<TaskCanceledException>(() => StateContainer.ChangeStateWithAnimation(layout, StateKey.Error, cts.Token));
+	}
+
+	[Fact(Timeout = (int)TestDuration.Long)]
 	public async Task StateContainer_DefaultAnimation()
 	{
 		layout.EnableAnimations();
@@ -122,7 +156,7 @@ public async Task StateContainer_DefaultAnimation()
 		Assert.Equal(StateKey.Error, StateContainer.GetCurrentState(layout));
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Long)]
 	public async Task StateContainer_CustomAnimation()
 	{
 		layout.EnableAnimations();
@@ -133,12 +167,12 @@ public async Task StateContainer_CustomAnimation()
 
 		var beforeStateChangeAnimation = new Animation
 		{
-			Duration = 1
+			Duration = 0.5
 		};
 
 		var afterStateChangeAnimation = new Animation
 		{
-			Duration = 1
+			Duration = 0.5
 		};
 
 		var changeStateWithAnimationTask = StateContainer.ChangeStateWithAnimation(layout, StateKey.Error, beforeStateChangeAnimation, afterStateChangeAnimation, CancellationToken.None);
@@ -150,7 +184,7 @@ public async Task StateContainer_CustomAnimation()
 		Assert.Equal(StateKey.Error, StateContainer.GetCurrentState(layout));
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Long)]
 	public async Task StateContainer_FuncAnimation()
 	{
 		layout.EnableAnimations();
@@ -168,10 +202,10 @@ public async Task StateContainer_FuncAnimation()
 		Assert.True(StateContainer.GetCanStateChange(layout));
 		Assert.Equal(StateKey.Error, StateContainer.GetCurrentState(layout));
 
-		static Task CustomAnimation(VisualElement element, CancellationToken token) => element.RotateTo(0.75, 1000).WaitAsync(token);
+		static Task CustomAnimation(VisualElement element, CancellationToken token) => element.RotateTo(0.75, 500).WaitAsync(token);
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Long)]
 	public async Task StateContainer_DefaultAnimation_Timeout()
 	{
 		layout.EnableAnimations();
@@ -184,7 +218,7 @@ public async Task StateContainer_DefaultAnimation_Timeout()
 		await Assert.ThrowsAsync<TaskCanceledException>(() => StateContainer.ChangeStateWithAnimation(layout, StateKey.Error, cancelledTokenSource.Token));
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Long)]
 	public async Task StateContainer_CustomAnimation_Timeout()
 	{
 		layout.EnableAnimations();
@@ -207,7 +241,7 @@ public async Task StateContainer_CustomAnimation_Timeout()
 		await Assert.ThrowsAsync<TaskCanceledException>(() => StateContainer.ChangeStateWithAnimation(layout, StateKey.Error, beforeStateChangeAnimation, afterStateChangeAnimation, cancelledTokenSource.Token));
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Long)]
 	public async Task StateContainer_FuncAnimation_Timeout()
 	{
 		layout.EnableAnimations();
@@ -222,7 +256,7 @@ public async Task StateContainer_FuncAnimation_Timeout()
 		static Task CustomAnimation(VisualElement element, CancellationToken token) => element.RotateTo(0.75, 1000).WaitAsync(token);
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Long)]
 	public async Task StateContainer_ChangingStateWhenCanStateChangePropertyIsFalse_DefaultAnimation()
 	{
 		layout.EnableAnimations();
@@ -249,7 +283,7 @@ public async Task StateContainer_ChangingStateWhenCanStateChangePropertyIsFalse_
 		Assert.True(StateContainer.GetCanStateChange(layout));
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Long)]
 	public async Task StateContainer_ChangingStateWhenCanStateChangePropertyIsFalse_CustomBeforeAnimation()
 	{
 		layout.EnableAnimations();
@@ -281,7 +315,7 @@ public async Task StateContainer_ChangingStateWhenCanStateChangePropertyIsFalse_
 		Assert.True(StateContainer.GetCanStateChange(layout));
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Long)]
 	public async Task StateContainer_ChangingStateWhenCanStateChangePropertyIsFalse_CustomAfterAnimation()
 	{
 		layout.EnableAnimations();
@@ -313,7 +347,7 @@ public async Task StateContainer_ChangingStateWhenCanStateChangePropertyIsFalse_
 		Assert.True(StateContainer.GetCanStateChange(layout));
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Long)]
 	public async Task StateContainer_ChangingStateWhenCanStateChangePropertyIsFalse_CustomBeforeAndAfterAnimation()
 	{
 		layout.EnableAnimations();
@@ -350,25 +384,25 @@ public async Task StateContainer_ChangingStateWhenCanStateChangePropertyIsFalse_
 		Assert.True(StateContainer.GetCanStateChange(layout));
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task StateContainer_ChangingStateWhenCanStateChangePropertyIsFalse_NullAnimations()
 	{
 		var exception = await Assert.ThrowsAsync<ArgumentException>(() => StateContainer.ChangeStateWithAnimation(layout, StateKey.Error, (Animation?)null, null, CancellationToken.None));
 
-		Assert.Equal("Anmiation required. Parameters beforeStateChange and afterStateChange cannot both be null", exception.Message);
+		Assert.Equal("Animation required. Parameters beforeStateChange and afterStateChange cannot both be null", exception.Message);
 		Assert.True(StateContainer.GetCanStateChange(layout));
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task StateContainer_ChangingStateWhenCanStateChangePropertyIsFalse_NullFuncs()
 	{
 		var exception = await Assert.ThrowsAsync<ArgumentException>(() => StateContainer.ChangeStateWithAnimation(layout, StateKey.Error, (Func<VisualElement, CancellationToken, Task>?)null, null, CancellationToken.None));
 
-		Assert.Equal("Anmiation required. Parameters beforeStateChange and afterStateChange cannot both be null", exception.Message);
+		Assert.Equal("Animation required. Parameters beforeStateChange and afterStateChange cannot both be null", exception.Message);
 		Assert.True(StateContainer.GetCanStateChange(layout));
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Long)]
 	public async Task StateContainer_ChangingStateWhenCanStateChangePropertyIsFalse_CustomBeforeAnimationFuncs()
 	{
 		layout.EnableAnimations();
@@ -394,10 +428,10 @@ public async Task StateContainer_ChangingStateWhenCanStateChangePropertyIsFalse_
 
 		Assert.True(StateContainer.GetCanStateChange(layout));
 
-		static Task CustomAnimation(VisualElement element, CancellationToken token) => element.RotateTo(0.75, 1000).WaitAsync(token);
+		static Task CustomAnimation(VisualElement element, CancellationToken token) => element.RotateTo(0.75, 500).WaitAsync(token);
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Long)]
 	public async Task StateContainer_ChangingStateWhenCanStateChangePropertyIsFalse_CustomAfterAnimationFuncs()
 	{
 		layout.EnableAnimations();
@@ -423,10 +457,10 @@ public async Task StateContainer_ChangingStateWhenCanStateChangePropertyIsFalse_
 
 		Assert.True(StateContainer.GetCanStateChange(layout));
 
-		static Task CustomAnimation(VisualElement element, CancellationToken token) => element.RotateTo(0.75, 1000).WaitAsync(token);
+		static Task CustomAnimation(VisualElement element, CancellationToken token) => element.RotateTo(0.75, 500).WaitAsync(token);
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Long)]
 	public async Task StateContainer_ChangingStateWhenCanStateChangePropertyIsFalse_CustomBeforeAndAfterAnimationFuncs()
 	{
 		layout.EnableAnimations();
@@ -452,7 +486,7 @@ public async Task StateContainer_ChangingStateWhenCanStateChangePropertyIsFalse_
 
 		Assert.True(StateContainer.GetCanStateChange(layout));
 
-		static Task CustomAnimation(VisualElement element, CancellationToken token) => element.RotateTo(0.75, 1000).WaitAsync(token);
+		static Task CustomAnimation(VisualElement element, CancellationToken token) => element.RotateTo(0.75, 500).WaitAsync(token);
 	}
 
 	[Fact]
diff --git a/src/CommunityToolkit.Maui.UnitTests/Mocks/MockDrawingViewHandler.cs b/src/CommunityToolkit.Maui.UnitTests/Mocks/MockDrawingViewHandler.cs
index 115281b135..48b914c66b 100644
--- a/src/CommunityToolkit.Maui.UnitTests/Mocks/MockDrawingViewHandler.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/Mocks/MockDrawingViewHandler.cs
@@ -130,8 +130,9 @@ class MockDrawingLine : IDrawingLine
 	public float LineWidth { get; set; }
 	public ObservableCollection<PointF> Points { get; set; } = new();
 	public bool ShouldSmoothPathWhenDrawn { get; set; }
-	public ValueTask<Stream> GetImageStream(double imageSizeWidth, double imageSizeHeight, Paint background)
+	public ValueTask<Stream> GetImageStream(double imageSizeWidth, double imageSizeHeight, Paint background, CancellationToken token)
 	{
+		token.ThrowIfCancellationRequested();
 		return ValueTask.FromResult(Stream.Null);
 	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.UnitTests/PopupServiceTests.cs b/src/CommunityToolkit.Maui.UnitTests/PopupServiceTests.cs
index a3afd3c746..fc76682fbc 100644
--- a/src/CommunityToolkit.Maui.UnitTests/PopupServiceTests.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/PopupServiceTests.cs
@@ -33,7 +33,7 @@ public void ShowPopupAsyncWithNullViewModelShouldThrowArgumentNullException()
 
 #pragma warning disable CS8625 // Cannot convert null literal to non-nullable reference type.
 		Assert.ThrowsAsync<ArgumentNullException>(() =>
-			popupService.ShowPopupAsync<INotifyPropertyChanged>(viewModel: null));
+			popupService.ShowPopupAsync<INotifyPropertyChanged>(viewModel: null, CancellationToken.None));
 #pragma warning restore CS8625 // Cannot convert null literal to non-nullable reference type.
 	}
 
@@ -44,10 +44,48 @@ public void ShowPopupAsyncWithNullOnPresentingShouldThrowArgumentNullException()
 
 #pragma warning disable CS8625 // Cannot convert null literal to non-nullable reference type.
 		Assert.ThrowsAsync<ArgumentNullException>(() =>
-			popupService.ShowPopupAsync<INotifyPropertyChanged>(onPresenting: null));
+			popupService.ShowPopupAsync<INotifyPropertyChanged>(onPresenting: null, CancellationToken.None));
 #pragma warning restore CS8625 // Cannot convert null literal to non-nullable reference type.
 	}
 
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task ShowPopupAsync_CancellationTokenExpired()
+	{
+		var popupViewModel = new MockPageViewModel();
+		var popupInstance = new MockSelfClosingPopup(string.Empty)
+		{
+			BindingContext = popupViewModel
+		};
+
+		SetupTest(popupInstance, () => popupViewModel, out var popupService);
+
+		var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
+
+		// Ensure CancellationToken has expired
+		await Task.Delay(100, CancellationToken.None);
+
+		await Assert.ThrowsAsync<TaskCanceledException>(() => popupService.ShowPopupAsync<MockPageViewModel>(cts.Token));
+	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task ShowPopupAsync_CancellationTokenCanceled()
+	{
+		var popupViewModel = new MockPageViewModel();
+		var popupInstance = new MockSelfClosingPopup(string.Empty)
+		{
+			BindingContext = popupViewModel
+		};
+
+		SetupTest(popupInstance, () => popupViewModel, out var popupService);
+
+		var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
+
+		// Ensure CancellationToken has expired
+		await cts.CancelAsync();
+
+		await Assert.ThrowsAsync<TaskCanceledException>(() => popupService.ShowPopupAsync<MockPageViewModel>(cts.Token));
+	}
+
 	[Fact]
 	public void ShowPopupAsyncWithMismatchedViewModelTypeShouldThrowInvalidOperationException()
 	{
@@ -55,11 +93,11 @@ public void ShowPopupAsyncWithMismatchedViewModelTypeShouldThrowInvalidOperation
 
 #pragma warning disable CS8625 // Cannot convert null literal to non-nullable reference type.
 		Assert.ThrowsAsync<ArgumentNullException>(() =>
-			popupService.ShowPopupAsync<INotifyPropertyChanged>(viewModel: null));
+			popupService.ShowPopupAsync<INotifyPropertyChanged>(viewModel: null, CancellationToken.None));
 #pragma warning restore CS8625 // Cannot convert null literal to non-nullable reference type.
 	}
 
-	[Fact(Timeout = 2000)]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public void ShowPopupAsyncShouldThrowInvalidOperationExceptionWhenNoViewModelIsRegistered()
 	{
 		var popupInstance = new MockMismatchedPopup();
@@ -67,10 +105,10 @@ public void ShowPopupAsyncShouldThrowInvalidOperationExceptionWhenNoViewModelIsR
 
 		SetupTest(popupInstance, () => popupViewModel, out var popupService);
 
-		Assert.ThrowsAsync<InvalidOperationException>(popupService.ShowPopupAsync<MockPageViewModel>);
+		Assert.ThrowsAsync<InvalidOperationException>(() => popupService.ShowPopupAsync<MockPageViewModel>(CancellationToken.None));
 	}
 
-	[Fact(Timeout = 2000)]
+	[Fact(Timeout = (int)TestDuration.Medium)]
 	public async Task ShowPopupAsyncShouldValidateProperBindingContext()
 	{
 		var popupViewModel = new MockPageViewModel();
@@ -81,12 +119,50 @@ public async Task ShowPopupAsyncShouldValidateProperBindingContext()
 
 		SetupTest(popupInstance, () => popupViewModel, out var popupService);
 
-		await popupService.ShowPopupAsync<MockPageViewModel>();
+		await popupService.ShowPopupAsync<MockPageViewModel>(CancellationToken.None);
 
 		Assert.Same(popupInstance.BindingContext, popupViewModel);
 	}
 
-	[Fact(Timeout = 2000)]
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task ShowPopupAsyncWithOnPresenting_CancellationTokenExpired()
+	{
+		var popupViewModel = new MockPageViewModel();
+		var popupInstance = new MockSelfClosingPopup(string.Empty)
+		{
+			BindingContext = popupViewModel
+		};
+
+		SetupTest(popupInstance, () => popupViewModel, out var popupService);
+
+		var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
+
+		// Ensure CancellationToken has expired
+		await Task.Delay(100, CancellationToken.None);
+
+		await Assert.ThrowsAsync<TaskCanceledException>(() => popupService.ShowPopupAsync<MockPageViewModel>(viewModel => viewModel.HasLoaded = true, cts.Token));
+	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task ShowPopupAsyncWithOnPresenting_CancellationTokenCanceled()
+	{
+		var popupViewModel = new MockPageViewModel();
+		var popupInstance = new MockSelfClosingPopup(string.Empty)
+		{
+			BindingContext = popupViewModel
+		};
+
+		SetupTest(popupInstance, () => popupViewModel, out var popupService);
+
+		var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
+
+		// Ensure CancellationToken has expired
+		await cts.CancelAsync();
+
+		await Assert.ThrowsAsync<TaskCanceledException>(() => popupService.ShowPopupAsync<MockPageViewModel>(viewModel => viewModel.HasLoaded = true, cts.Token));
+	}
+
+	[Fact(Timeout = (int)TestDuration.Medium)]
 	public async Task ShowPopupAsyncWithOnPresentingShouldBeInvoked()
 	{
 		var popupViewModel = new MockPageViewModel();
@@ -97,12 +173,12 @@ public async Task ShowPopupAsyncWithOnPresentingShouldBeInvoked()
 
 		SetupTest(popupInstance, () => popupViewModel, out var popupService);
 
-		await popupService.ShowPopupAsync<MockPageViewModel>(onPresenting: viewModel => viewModel.HasLoaded = true);
+		await popupService.ShowPopupAsync<MockPageViewModel>(onPresenting: viewModel => viewModel.HasLoaded = true, CancellationToken.None);
 
 		Assert.True(popupViewModel.HasLoaded);
 	}
 
-	[Fact(Timeout = 2000)]
+	[Fact(Timeout = (int)TestDuration.Medium)]
 	public async Task ShowPopupAsyncShouldReturnResultOnceClosed()
 	{
 		var expectedResult = new object();
@@ -115,7 +191,7 @@ public async Task ShowPopupAsyncShouldReturnResultOnceClosed()
 
 		SetupTest(popupInstance, () => popupViewModel, out var popupService);
 
-		var result = await popupService.ShowPopupAsync<MockPageViewModel>();
+		var result = await popupService.ShowPopupAsync<MockPageViewModel>(CancellationToken.None);
 
 		Assert.Same(expectedResult, result);
 	}
@@ -150,6 +226,44 @@ public void ShowPopupWithMismatchedViewModelTypeShouldThrowInvalidOperationExcep
 #pragma warning restore CS8625 // Cannot convert null literal to non-nullable reference type.
 	}
 
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task ShowPopupAsyncWithViewModel_CancellationTokenExpired()
+	{
+		var popupViewModel = new MockPageViewModel();
+		var popupInstance = new MockSelfClosingPopup(string.Empty)
+		{
+			BindingContext = popupViewModel
+		};
+
+		SetupTest(popupInstance, () => popupViewModel, out var popupService);
+
+		var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
+
+		// Ensure CancellationToken has expired
+		await Task.Delay(100, CancellationToken.None);
+
+		await Assert.ThrowsAsync<TaskCanceledException>(() => popupService.ShowPopupAsync(popupViewModel, cts.Token));
+	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task ShowPopupAsyncWithViewModel_CancellationTokenCanceled()
+	{
+		var popupViewModel = new MockPageViewModel();
+		var popupInstance = new MockSelfClosingPopup(string.Empty)
+		{
+			BindingContext = popupViewModel
+		};
+
+		SetupTest(popupInstance, () => popupViewModel, out var popupService);
+
+		var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
+
+		// Ensure CancellationToken has expired
+		await cts.CancelAsync();
+
+		await Assert.ThrowsAsync<TaskCanceledException>(() => popupService.ShowPopupAsync(popupViewModel, cts.Token));
+	}
+
 	[Fact]
 	public void ShowPopupShouldThrowInvalidOperationExceptionWhenNoViewModelIsRegistered()
 	{
@@ -260,7 +374,7 @@ internal override async void OnOpened()
 		{
 			base.OnOpened();
 
-			await Task.Delay(TimeSpan.FromSeconds(1));
+			await Task.Delay(TimeSpan.FromMilliseconds(500));
 
 			Close(result);
 		}
diff --git a/src/CommunityToolkit.Maui.UnitTests/Views/DrawingView/DrawingLineTests.cs b/src/CommunityToolkit.Maui.UnitTests/Views/DrawingView/DrawingLineTests.cs
index 1b898d3f1d..546c74ddef 100644
--- a/src/CommunityToolkit.Maui.UnitTests/Views/DrawingView/DrawingLineTests.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/Views/DrawingView/DrawingLineTests.cs
@@ -70,17 +70,39 @@ public void GranularityCheckRange(int value, int expectedValue)
 		drawingLine.Granularity.Should().Be(expectedValue);
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task GetImageStream_CancellationTokenExpired()
+	{
+		var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
+
+		// Ensure CancellationToken Expired
+		await Task.Delay(100, CancellationToken.None);
+
+		await Assert.ThrowsAsync<OperationCanceledException>(async () => await drawingLine.GetImageStream(10, 10, Colors.Blue.AsPaint(), cts.Token));
+	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task GetImageStream_CancellationTokenCanceled()
+	{
+		var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
+
+		// Ensure CancellationToken Expired
+		await cts.CancelAsync();
+
+		await Assert.ThrowsAsync<OperationCanceledException>(async () => await drawingLine.GetImageStream(10, 10, Colors.Blue.AsPaint(), cts.Token));
+	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task GetImageStreamReturnsNullStream()
 	{
-		var stream = await drawingLine.GetImageStream(10, 10, Colors.Blue.AsPaint());
+		var stream = await drawingLine.GetImageStream(10, 10, Colors.Blue.AsPaint(), CancellationToken.None);
 		Assert.Equal(Stream.Null, stream);
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task GetImageStreamStaticReturnsNullStream()
 	{
-		var stream = await DrawingLine.GetImageStream(Array.Empty<PointF>(), new Size(10, 10), 5, Colors.Yellow, Colors.Blue.AsPaint());
+		var stream = await DrawingLine.GetImageStream(Array.Empty<PointF>(), new Size(10, 10), 5, Colors.Yellow, Colors.Blue.AsPaint(), CancellationToken.None);
 		Assert.Equal(Stream.Null, stream);
 	}
 
diff --git a/src/CommunityToolkit.Maui.UnitTests/Views/DrawingView/DrawingViewTests.cs b/src/CommunityToolkit.Maui.UnitTests/Views/DrawingView/DrawingViewTests.cs
index 9ba226cb34..0df55f829c 100644
--- a/src/CommunityToolkit.Maui.UnitTests/Views/DrawingView/DrawingViewTests.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/Views/DrawingView/DrawingViewTests.cs
@@ -145,17 +145,39 @@ public void ClearShouldClearLines()
 		drawingView.Lines.Should().BeEmpty();
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task GetImageStream_CancellationTokenExpired()
+	{
+		var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
+
+		// Ensure CancellationToken Expired
+		await Task.Delay(100, CancellationToken.None);
+
+		await Assert.ThrowsAsync<OperationCanceledException>(async () => await Maui.Views.DrawingView.GetImageStream(new[] { new DrawingLine() }, Size.Zero, Colors.Blue, cts.Token));
+	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task GetImageStream_CancellationTokenCanceled()
+	{
+		var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
+
+		// Ensure CancellationToken Expired
+		await cts.CancelAsync();
+
+		await Assert.ThrowsAsync<OperationCanceledException>(async () => await Maui.Views.DrawingView.GetImageStream(new[] { new DrawingLine() }, Size.Zero, Colors.Blue, cts.Token));
+	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task GetImageStreamReturnsNullStream()
 	{
-		var stream = await drawingView.GetImageStream(10, 10);
+		var stream = await drawingView.GetImageStream(10, 10, CancellationToken.None);
 		stream.Should().BeSameAs(Stream.Null);
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task GetImageStreamStaticReturnsNullStream()
 	{
-		var stream = await Maui.Views.DrawingView.GetImageStream(new[] { new DrawingLine() }, Size.Zero, Colors.Blue);
+		var stream = await Maui.Views.DrawingView.GetImageStream(new[] { new DrawingLine() }, Size.Zero, Colors.Blue, CancellationToken.None);
 		stream.Should().BeSameAs(Stream.Null);
 	}
 
diff --git a/src/CommunityToolkit.Maui.UnitTests/Views/LazyView/LazyViewTests.cs b/src/CommunityToolkit.Maui.UnitTests/Views/LazyView/LazyViewTests.cs
index 3fc9ee23d7..a8a1e64f3c 100644
--- a/src/CommunityToolkit.Maui.UnitTests/Views/LazyView/LazyViewTests.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/Views/LazyView/LazyViewTests.cs
@@ -13,35 +13,59 @@ public void CheckHasLoadedFalseAfterConstruction()
 		Assert.False(lazyView.HasLazyViewLoaded);
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task LoadViewAsync_CancellationTokenExpired()
+	{
+		var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
+		var lazyView = new LazyView<Button>();
+
+		// Ensure CancellationToken Expired
+		await Task.Delay(100, CancellationToken.None);
+
+		await Assert.ThrowsAsync<OperationCanceledException>(async () => await lazyView.LoadViewAsync(cts.Token));
+	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task LoadViewAsync_CancellationTokenCanceled()
+	{
+		var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
+		var lazyView = new LazyView<Button>();
+
+		// Ensure CancellationToken Expired
+		await cts.CancelAsync();
+
+		await Assert.ThrowsAsync<OperationCanceledException>(async () => await lazyView.LoadViewAsync(cts.Token));
+	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task CheckHasLoadedTrueAfterCallLoadView()
 	{
 		var lazyView = new LazyView<Button>();
 
-		await lazyView.LoadViewAsync();
+		await lazyView.LoadViewAsync(CancellationToken.None);
 
 		Assert.True(lazyView.HasLazyViewLoaded);
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task CheckContentSetAfterLoadView()
 	{
 		var lazyView = new LazyView<Button>();
 
-		await lazyView.LoadViewAsync();
+		await lazyView.LoadViewAsync(CancellationToken.None);
 
 		Assert.True(lazyView.HasLazyViewLoaded);
 		Assert.IsAssignableFrom<Button>(lazyView.Content);
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task CheckBindingContextIsPassedToCreatedView()
 	{
 		var lazyView = new LazyView<Button>();
 		var bindingContext = new object();
 		lazyView.BindingContext = bindingContext;
 
-		await lazyView.LoadViewAsync();
+		await lazyView.LoadViewAsync(CancellationToken.None);
 
 		Assert.True(lazyView.HasLazyViewLoaded);
 		Assert.IsAssignableFrom<Button>(lazyView.Content);
diff --git a/src/CommunityToolkit.Maui.UnitTests/Views/MediaElement/MediaSourceConverterTests.cs b/src/CommunityToolkit.Maui.UnitTests/Views/MediaElement/MediaSourceConverterTests.cs
index 2403d6641f..c0a2dd984a 100644
--- a/src/CommunityToolkit.Maui.UnitTests/Views/MediaElement/MediaSourceConverterTests.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/Views/MediaElement/MediaSourceConverterTests.cs
@@ -6,7 +6,7 @@
 
 namespace CommunityToolkit.Maui.UnitTests.Views;
 
-public class MediaSourceConverterTests
+public class MediaSourceConverterTests : BaseTest
 {
 	[Fact]
 	public void MediaSourceConverterShouldConvertFromStringType()
diff --git a/src/CommunityToolkit.Maui.UnitTests/Views/MediaElement/MediaSourceTests.cs b/src/CommunityToolkit.Maui.UnitTests/Views/MediaElement/MediaSourceTests.cs
index 265ea16b4f..dc87f8094b 100644
--- a/src/CommunityToolkit.Maui.UnitTests/Views/MediaElement/MediaSourceTests.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/Views/MediaElement/MediaSourceTests.cs
@@ -4,7 +4,7 @@
 
 namespace CommunityToolkit.Maui.UnitTests.Views;
 
-public class MediaSourceTests
+public class MediaSourceTests : BaseTest
 {
 	[Fact]
 	public void MediaSourceFromResourceShouldBeUriMediaSource()
diff --git a/src/CommunityToolkit.Maui.UnitTests/Views/Popup/PopupTests.cs b/src/CommunityToolkit.Maui.UnitTests/Views/Popup/PopupTests.cs
index c570e5a5d6..cbb4f69465 100644
--- a/src/CommunityToolkit.Maui.UnitTests/Views/Popup/PopupTests.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/Views/Popup/PopupTests.cs
@@ -29,7 +29,131 @@ public void GetRequiredServiceThrowsOnNoContext()
 		Assert.Contains("MauiContext", ex.Message);
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task ShowPopupAsync_CancellationTokenExpired()
+	{
+		var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
+
+		var app = Application.Current ?? throw new NullReferenceException();
+
+		var page = new ContentPage
+		{
+			Content = new Label
+			{
+				Text = "Hello there"
+			}
+		};
+
+		// Make sure that our page will have a Handler
+		CreateViewHandler<MockPageHandler>(page);
+
+		app.MainPage = page;
+
+		var popupHandler = CreateElementHandler<MockPopupHandler>(popup);
+
+		Assert.NotNull(popup.Handler);
+		Assert.NotNull(page.Handler);
+
+		// Ensure CancellationToken Has Expired
+		await Task.Delay(100, CancellationToken.None);
+
+		await Assert.ThrowsAsync<TaskCanceledException>(() => page.ShowPopupAsync((MockPopup)popup, cts.Token));
+	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task ShowPopupAsync_CancellationTokenCancelled()
+	{
+		var cts = new CancellationTokenSource();
+
+		var app = Application.Current ?? throw new NullReferenceException();
+
+		var page = new ContentPage
+		{
+			Content = new Label
+			{
+				Text = "Hello there"
+			}
+		};
+
+		// Make sure that our page will have a Handler
+		CreateViewHandler<MockPageHandler>(page);
+
+		app.MainPage = page;
+
+		var popupHandler = CreateElementHandler<MockPopupHandler>(popup);
+
+		Assert.NotNull(popup.Handler);
+		Assert.NotNull(page.Handler);
+
+		// Ensure CancellationToken Has Expired
+		await cts.CancelAsync();
+
+		await Assert.ThrowsAsync<TaskCanceledException>(() => page.ShowPopupAsync((MockPopup)popup, cts.Token));
+	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task CloseAsync_CancellationTokenExpired()
+	{
+		var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
+
+		var app = Application.Current ?? throw new NullReferenceException();
+
+		var page = new ContentPage
+		{
+			Content = new Label
+			{
+				Text = "Hello there"
+			}
+		};
+
+		// Make sure that our page will have a Handler
+		CreateViewHandler<MockPageHandler>(page);
+
+		app.MainPage = page;
+
+		var popupHandler = CreateElementHandler<MockPopupHandler>(popup);
+
+		Assert.NotNull(popup.Handler);
+		Assert.NotNull(page.Handler);
+
+		// Ensure CancellationToken Has Expired
+		await Task.Delay(100, CancellationToken.None);
+
+		await Assert.ThrowsAsync<TaskCanceledException>(() => ((MockPopup)popup).CloseAsync(token: cts.Token));
+	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
+	public async Task CloseAsync_CancellationTokenCancelled()
+	{
+		var cts = new CancellationTokenSource();
+
+		var app = Application.Current ?? throw new NullReferenceException();
+
+		var page = new ContentPage
+		{
+			Content = new Label
+			{
+				Text = "Hello there"
+			}
+		};
+
+		// Make sure that our page will have a Handler
+		CreateViewHandler<MockPageHandler>(page);
+
+		app.MainPage = page;
+
+		var popupHandler = CreateElementHandler<MockPopupHandler>(popup);
+
+		Assert.NotNull(popup.Handler);
+		Assert.NotNull(page.Handler);
+
+		// Ensure CancellationToken Has Expired
+		await cts.CancelAsync();
+
+		await Assert.ThrowsAsync<TaskCanceledException>(() => ((MockPopup)popup).CloseAsync(token: cts.Token));
+	}
+
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task OnOpenedMapperIsCalled()
 	{
 		var app = Application.Current ?? throw new NullReferenceException();
@@ -56,7 +180,7 @@ public async Task OnOpenedMapperIsCalled()
 		Assert.Equal(1, popupHandler.OnOpenedCount);
 		popup.OnDismissedByTappingOutsideOfPopup();
 
-		var popupTask = page.ShowPopupAsync((MockPopup)popup);
+		var popupTask = page.ShowPopupAsync((MockPopup)popup, CancellationToken.None);
 		popup.OnDismissedByTappingOutsideOfPopup();
 
 		await popupTask;
@@ -64,11 +188,10 @@ public async Task OnOpenedMapperIsCalled()
 		Assert.Equal(2, popupHandler.OnOpenedCount);
 	}
 
-	[Fact]
-	public void PopupDismissedByTappingOutsideOfPopup()
+	[Fact(Timeout = (int)TestDuration.Medium)]
+	public async Task PopupDismissedByTappingOutsideOfPopup()
 	{
-		string? dismissedByTappingOutsideOfPopupResult = null;
-		var isPopupDismissedByTappingOutsideOfPopup = false;
+		var popupClosedTCS = new TaskCompletionSource<(string? Result, bool WasDismissedByTappingOutsideOfPopup)>();
 		var app = Application.Current ?? throw new NullReferenceException();
 
 		var page = new ContentPage
@@ -82,9 +205,7 @@ public void PopupDismissedByTappingOutsideOfPopup()
 		((MockPopup)popup).Closed += (s, e) =>
 		{
 			Assert.Equal(popup, s);
-
-			isPopupDismissedByTappingOutsideOfPopup = e.WasDismissedByTappingOutsideOfPopup;
-			dismissedByTappingOutsideOfPopupResult = (string?)e.Result;
+			popupClosedTCS.SetResult(((string?)e.Result, e.WasDismissedByTappingOutsideOfPopup));
 		};
 
 		// Make sure that our page will have a Handler
@@ -99,11 +220,13 @@ public void PopupDismissedByTappingOutsideOfPopup()
 
 		popup.OnDismissedByTappingOutsideOfPopup();
 
-		Assert.True(isPopupDismissedByTappingOutsideOfPopup);
-		Assert.Equal(resultWhenUserTapsOutsideOfPopup, dismissedByTappingOutsideOfPopupResult);
+		var (result, wasDismissedByTappingOutsideOfPopup) = await popupClosedTCS.Task;
+
+		Assert.True(wasDismissedByTappingOutsideOfPopup);
+		Assert.Equal(resultWhenUserTapsOutsideOfPopup, result);
 	}
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task OnDismissedWithResult()
 	{
 		object? result = null;
@@ -145,7 +268,7 @@ public async Task OnDismissedWithResult()
 	}
 
 
-	[Fact]
+	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task OnDismissedWithoutResult()
 	{
 		object? result = null;
@@ -177,7 +300,7 @@ public async Task OnDismissedWithoutResult()
 			isPopupDismissed = true;
 		};
 
-		await ((MockPopup)popup).CloseAsync();
+		await ((MockPopup)popup).CloseAsync(token: CancellationToken.None);
 
 		Assert.True(isPopupDismissed);
 		Assert.Null(result);
@@ -207,10 +330,13 @@ public MockPopup()
 			ResultWhenUserTapsOutsideOfPopup = resultWhenUserTapsOutsideOfPopup;
 		}
 
-		protected override Task OnClosed(object? result, bool wasDismissedByTappingOutsideOfPopup)
+		protected override async Task OnClosed(object? result, bool wasDismissedByTappingOutsideOfPopup, CancellationToken token)
 		{
+			await Task.Delay(100, token);
+
 			((IPopup)this).HandlerCompleteTCS.TrySetResult();
-			return base.OnClosed(result, wasDismissedByTappingOutsideOfPopup);
+
+			await base.OnClosed(result, wasDismissedByTappingOutsideOfPopup, token);
 		}
 	}
 
@@ -225,7 +351,7 @@ public Color? Color
 			get => color;
 			set
 			{
-				if (value != color)
+				if (!Equals(value, color))
 				{
 					color = value;
 					PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Color)));
diff --git a/src/CommunityToolkit.Maui/Alerts/Snackbar/Snackbar.android.cs b/src/CommunityToolkit.Maui/Alerts/Snackbar/Snackbar.android.cs
index dc6d951e21..684779afe4 100644
--- a/src/CommunityToolkit.Maui/Alerts/Snackbar/Snackbar.android.cs
+++ b/src/CommunityToolkit.Maui/Alerts/Snackbar/Snackbar.android.cs
@@ -86,7 +86,7 @@ async Task DismissPlatform(CancellationToken token)
 
 		if (dismissedTCS is not null)
 		{
-			await dismissedTCS.Task;
+			await dismissedTCS.Task.WaitAsync(token);
 		}
 	}
 
diff --git a/src/CommunityToolkit.Maui/Alerts/Snackbar/Snackbar.macios.cs b/src/CommunityToolkit.Maui/Alerts/Snackbar/Snackbar.macios.cs
index 834c9c1f48..23d8774899 100644
--- a/src/CommunityToolkit.Maui/Alerts/Snackbar/Snackbar.macios.cs
+++ b/src/CommunityToolkit.Maui/Alerts/Snackbar/Snackbar.macios.cs
@@ -33,9 +33,10 @@ protected virtual void Dispose(bool isDisposing)
 	/// </summary>
 	static Task DismissPlatform(CancellationToken token)
 	{
+		token.ThrowIfCancellationRequested();
+
 		if (PlatformSnackbar is not null)
 		{
-			token.ThrowIfCancellationRequested();
 			PlatformSnackbar.Dismiss();
 			PlatformSnackbar = null;
 		}
diff --git a/src/CommunityToolkit.Maui/Alerts/Snackbar/Snackbar.tizen.cs b/src/CommunityToolkit.Maui/Alerts/Snackbar/Snackbar.tizen.cs
index ae9a01b8cb..f38ba79c86 100644
--- a/src/CommunityToolkit.Maui/Alerts/Snackbar/Snackbar.tizen.cs
+++ b/src/CommunityToolkit.Maui/Alerts/Snackbar/Snackbar.tizen.cs
@@ -38,6 +38,7 @@ protected virtual void Dispose(bool isDisposing)
 	/// <inheritdoc/>
 	Task ShowPlatform(CancellationToken token)
 	{
+		token.ThrowIfCancellationRequested();
 		var dispatcher = Dispatcher.GetForCurrentThread() ?? Application.Current?.Dispatcher ?? throw new InvalidOperationException($"There is no IDispatcher object, application is not initalized");
 
 		// close and cleanup the previously opened snackbar
diff --git a/src/CommunityToolkit.Maui/Animations/BaseAnimation.shared.cs b/src/CommunityToolkit.Maui/Animations/BaseAnimation.shared.cs
index f827bdc666..1c4aaa39d4 100644
--- a/src/CommunityToolkit.Maui/Animations/BaseAnimation.shared.cs
+++ b/src/CommunityToolkit.Maui/Animations/BaseAnimation.shared.cs
@@ -48,7 +48,8 @@ public Easing Easing
 	/// Performs the animation on the View
 	/// </summary>
 	/// <param name="view">The view to perform the animation on.</param>
-	public abstract Task Animate(TAnimatable view);
+	/// <param name="token"> <see cref="CancellationToken"/>.</param>
+	public abstract Task Animate(TAnimatable view, CancellationToken token = default);
 }
 
 /// <inheritdoc/>
diff --git a/src/CommunityToolkit.Maui/Animations/FadeAnimation.shared.cs b/src/CommunityToolkit.Maui/Animations/FadeAnimation.shared.cs
index 914af71d95..f600e3a71d 100644
--- a/src/CommunityToolkit.Maui/Animations/FadeAnimation.shared.cs
+++ b/src/CommunityToolkit.Maui/Animations/FadeAnimation.shared.cs
@@ -35,13 +35,13 @@ public double Opacity
 	}
 
 	/// <inheritdoc />
-	public override async Task Animate(VisualElement view)
+	public override async Task Animate(VisualElement view, CancellationToken token = default)
 	{
 		ArgumentNullException.ThrowIfNull(view);
 
 		var originalOpacity = view.Opacity;
 
-		await view.FadeTo(Opacity, Length, Easing);
-		await view.FadeTo(originalOpacity, Length, Easing);
+		await view.FadeTo(Opacity, Length, Easing).WaitAsync(token);
+		await view.FadeTo(originalOpacity, Length, Easing).WaitAsync(token);
 	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui/Behaviors/AnimationBehavior.shared.cs b/src/CommunityToolkit.Maui/Behaviors/AnimationBehavior.shared.cs
index 9f1490dfcb..6e45205fac 100644
--- a/src/CommunityToolkit.Maui/Behaviors/AnimationBehavior.shared.cs
+++ b/src/CommunityToolkit.Maui/Behaviors/AnimationBehavior.shared.cs
@@ -1,5 +1,4 @@
 using System.Diagnostics;
-using System.Windows.Input;
 using CommunityToolkit.Maui.Animations;
 
 namespace CommunityToolkit.Maui.Behaviors;
@@ -19,14 +18,17 @@ public class AnimationBehavior : EventToCommandBehavior
 	/// Backing BindableProperty for the <see cref="AnimateCommand"/> property.
 	/// </summary>
 	public static readonly BindableProperty AnimateCommandProperty =
-		BindableProperty.CreateReadOnly(nameof(AnimateCommand), typeof(ICommand), typeof(AnimationBehavior), default, BindingMode.OneWayToSource, defaultValueCreator: CreateAnimateCommand).BindableProperty;
+		BindableProperty.CreateReadOnly(nameof(AnimateCommand), typeof(Command<CancellationToken>), typeof(AnimationBehavior), default, BindingMode.OneWayToSource, propertyChanging: OnAnimateCommandChanging, defaultValueCreator: CreateAnimateCommand).BindableProperty;
 
 	TapGestureRecognizer? tapGestureRecognizer;
 
 	/// <summary>
 	/// Gets the Command that allows the triggering of the animation.
 	/// </summary>
-	public ICommand AnimateCommand => (ICommand)GetValue(AnimateCommandProperty);
+	/// <remarks>
+ 	/// <see cref="AnimateCommand"/> has a <see cref="Type"/> of Command&lt;CancellationToken&gt; which requires a <see cref="CancellationToken"/> as a CommandParameter. See <see cref="Command{CancellationToken}"/> and <see cref="System.Windows.Input.ICommand.Execute(object)"/> for more information on passing a <see cref="CancellationToken"/> into <see cref="Command{T}"/> as a CommandParameter"
+ 	/// </remarks>
+	public Command<CancellationToken> AnimateCommand => (Command<CancellationToken>)GetValue(AnimateCommandProperty);
 
 	/// <summary>
 	/// The type of animation to perform.
@@ -76,31 +78,44 @@ protected override void OnDetachingFrom(VisualElement bindable)
 	/// <inheritdoc/>
 	protected override async void OnTriggerHandled(object? sender = null, object? eventArgs = null)
 	{
-		await OnAnimate();
+		await OnAnimate(CancellationToken.None);
 
 		base.OnTriggerHandled(sender, eventArgs);
 	}
 
-	static object CreateAnimateCommand(BindableObject bindable)
-		=> new Command(async () => await ((AnimationBehavior)bindable).OnAnimate().ConfigureAwait(false));
+	static Command<CancellationToken> CreateAnimateCommand(BindableObject bindable)
+	{
+		var animationBehavior = (AnimationBehavior)bindable;
+		return new Command<CancellationToken>(async token => await animationBehavior.OnAnimate(token).ConfigureAwait(false));
+	}
+
+	static void OnAnimateCommandChanging(BindableObject bindable, object oldValue, object newValue)
+	{
+		if (newValue is not Command<CancellationToken>)
+		{
+			var animationBehavior = (AnimationBehavior)bindable;
+			throw new InvalidOperationException($"{nameof(AnimateCommand)} must of Type {animationBehavior.AnimateCommand.GetType().FullName}");
+		}
+	}
 
-	Task OnAnimate()
+	async Task OnAnimate(CancellationToken token)
 	{
 		if (View is null || AnimationType is null)
 		{
-			return Task.CompletedTask;
+			return;
 		}
 
 		View.CancelAnimations();
 
 		try
 		{
-			return AnimationType.Animate(View);
+			// We must `await` `AnimationType.Animate()` here in order to properly implement `Options.ShouldSuppressExceptionsInAnimations`
+			// Returning the `Task` would cause the `OnAnimate()` method to return immediately, before `AnimationType.Animate()` has completed. Returning immediately exits our try/catch block and thus negates our opportunity to handle any Exceptions which breaks `Options.ShouldSuppressExceptionsInAnimations`.
+			await AnimationType.Animate(View, token);
 		}
 		catch (Exception ex) when (Options.ShouldSuppressExceptionsInAnimations)
 		{
 			Trace.WriteLine(ex);
-			return Task.CompletedTask;
 		}
 	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui/Behaviors/MaskedBehavior.shared.cs b/src/CommunityToolkit.Maui/Behaviors/MaskedBehavior.shared.cs
index 7ef2a66de9..4c34d22262 100644
--- a/src/CommunityToolkit.Maui/Behaviors/MaskedBehavior.shared.cs
+++ b/src/CommunityToolkit.Maui/Behaviors/MaskedBehavior.shared.cs
@@ -84,7 +84,7 @@ protected override async void OnViewPropertyChanged(InputView sender, PropertyCh
 
 		if (e.PropertyName == InputView.TextProperty.PropertyName)
 		{
-			await OnTextPropertyChanged();
+			await OnTextPropertyChanged(CancellationToken.None);
 		}
 	}
 
@@ -99,10 +99,10 @@ static void OnMaskPropertyChanged(BindableObject bindable, object oldValue, obje
 	static async void OnUnmaskedCharacterPropertyChanged(BindableObject bindable, object oldValue, object newValue)
 	{
 		var maskedBehavior = (MaskedBehavior)bindable;
-		await maskedBehavior.OnMaskChanged(maskedBehavior.Mask).ConfigureAwait(false);
+		await maskedBehavior.OnMaskChanged(maskedBehavior.Mask, CancellationToken.None).ConfigureAwait(false);
 	}
 
-	Task OnTextPropertyChanged(CancellationToken token = default) => ApplyMask(View?.Text, token);
+	Task OnTextPropertyChanged(CancellationToken token) => ApplyMask(View?.Text, token);
 
 	void SetMaskPositions(in string? mask)
 	{
@@ -125,7 +125,7 @@ void SetMaskPositions(in string? mask)
 		maskPositions = list;
 	}
 
-	async ValueTask OnMaskChanged(string? mask, CancellationToken token = default)
+	async ValueTask OnMaskChanged(string? mask, CancellationToken token)
 	{
 		if (string.IsNullOrEmpty(mask))
 		{
@@ -156,7 +156,7 @@ async ValueTask OnMaskChanged(string? mask, CancellationToken token = default)
 		return string.Join(string.Empty, text.Split(maskChars));
 	}
 
-	async Task ApplyMask(string? text, CancellationToken token = default)
+	async Task ApplyMask(string? text, CancellationToken token)
 	{
 		await applyMaskSemaphoreSlim.WaitAsync(token);
 
diff --git a/src/CommunityToolkit.Maui/Behaviors/ProgressBarAnimationBehavior.shared.cs b/src/CommunityToolkit.Maui/Behaviors/ProgressBarAnimationBehavior.shared.cs
index 5030353a09..17d5fe3b92 100644
--- a/src/CommunityToolkit.Maui/Behaviors/ProgressBarAnimationBehavior.shared.cs
+++ b/src/CommunityToolkit.Maui/Behaviors/ProgressBarAnimationBehavior.shared.cs
@@ -72,16 +72,16 @@ static async void OnAnimateProgressPropertyChanged(BindableObject bindable, obje
 			await AnimateProgress(progressBarAnimationBehavior.View,
 									progressBarAnimationBehavior.Progress,
 									progressBarAnimationBehavior.Length,
-									progressBarAnimationBehavior.Easing);
+									progressBarAnimationBehavior.Easing,
+									CancellationToken.None);
 
 			progressBarAnimationBehavior.OnAnimationCompleted();
 		}
 	}
 
-	static Task AnimateProgress(in ProgressBar progressBar, in double progress, in uint animationLength, in Easing animationEasing, in CancellationToken token = default)
+	static Task AnimateProgress(in ProgressBar progressBar, in double progress, in uint animationLength, in Easing animationEasing, in CancellationToken token)
 	{
-		token.ThrowIfCancellationRequested();
-		return progressBar.ProgressTo(progress, animationLength, animationEasing);
+		return progressBar.ProgressTo(progress, animationLength, animationEasing).WaitAsync(token);
 	}
 
 	void OnAnimationCompleted() => animationCompletedEventManager.HandleEvent(this, EventArgs.Empty, nameof(AnimationCompleted));
diff --git a/src/CommunityToolkit.Maui/Behaviors/Validators/ValidationBehavior.shared.cs b/src/CommunityToolkit.Maui/Behaviors/Validators/ValidationBehavior.shared.cs
index c761f4991b..d1c50745a3 100644
--- a/src/CommunityToolkit.Maui/Behaviors/Validators/ValidationBehavior.shared.cs
+++ b/src/CommunityToolkit.Maui/Behaviors/Validators/ValidationBehavior.shared.cs
@@ -104,7 +104,10 @@ public abstract class ValidationBehavior : BaseBehavior<VisualElement>, IDisposa
 	/// <summary>
 	/// Initialize a new instance of ValidationBehavior
 	/// </summary>
-	public ValidationBehavior() => DefaultForceValidateCommand = new Command(async () => await ForceValidate().ConfigureAwait(false));
+	protected ValidationBehavior()
+	{
+		DefaultForceValidateCommand = new Command<CancellationToken>(async token => await ForceValidate(token).ConfigureAwait(false));
+	}
 
 	/// <summary>
 	/// Finalizer
@@ -189,9 +192,12 @@ public string? ValuePropertyName
 	/// <summary>
 	/// Allows the user to provide a custom <see cref="ICommand"/> that handles forcing validation. This is a bindable property.
 	/// </summary>
-	public ICommand? ForceValidateCommand
+	/// <remarks>
+	/// The Default Value for <see cref="ForceValidateCommand"/> has a <see cref="Type"/> of Command&lt;CancellationToken&gt; which requires a <see cref="CancellationToken"/> as a CommandParameter. See <see cref="Command{CancellationToken}"/> and <see cref="System.Windows.Input.ICommand.Execute(object)"/> for more information on passing a <see cref="CancellationToken"/> into <see cref="Command{T}"/> as a CommandParameter"
+	/// </remarks>
+	public ICommand ForceValidateCommand
 	{
-		get => (ICommand?)GetValue(ForceValidateCommandProperty);
+		get => (ICommand)GetValue(ForceValidateCommandProperty);
 		set => SetValue(ForceValidateCommandProperty, value);
 	}
 
@@ -203,12 +209,12 @@ public ICommand? ForceValidateCommand
 	/// <summary>
 	/// Default force validate command
 	/// </summary>
-	protected virtual ICommand DefaultForceValidateCommand { get; }
+	protected virtual Command<CancellationToken> DefaultForceValidateCommand { get; }
 
 	/// <summary>
 	/// Forces the behavior to make a validation pass.
 	/// </summary>
-	public ValueTask ForceValidate() => UpdateStateAsync(View, Flags, true);
+	public ValueTask ForceValidate(CancellationToken token = default) => UpdateStateAsync(View, Flags, true, token);
 
 	/// <inheritdoc/>
 	public void Dispose()
@@ -288,7 +294,7 @@ protected override async void OnViewPropertyChanged(VisualElement sender, Proper
 			currentStatus = sender.IsFocused switch
 			{
 				true => ValidationFlags.ValidateOnFocusing,
-				_ => ValidationFlags.ValidateOnUnfocusing
+				false => ValidationFlags.ValidateOnUnfocusing
 			};
 
 			await UpdateStateAsync(View, Flags, false).ConfigureAwait(false);
@@ -307,7 +313,7 @@ static void OnIsValidPropertyChanged(BindableObject bindable, object oldValue, o
 
 	static async void OnValuePropertyChanged(BindableObject bindable, object oldValue, object newValue)
 	{
-		await ((ValidationBehavior)bindable).OnValuePropertyChanged();
+		await ((ValidationBehavior)bindable).OnValuePropertyChanged(CancellationToken.None);
 		OnValidationPropertyChanged(bindable, oldValue, newValue);
 	}
 
@@ -322,9 +328,9 @@ static object GetDefaultValuePropertyName(BindableObject bindable)
 
 	void OnIsValidPropertyChanged() => IsNotValid = !IsValid;
 
-	async Task OnValuePropertyChanged()
+	async Task OnValuePropertyChanged(CancellationToken token)
 	{
-		await isAttachingSemaphoreSlim.WaitAsync();
+		await isAttachingSemaphoreSlim.WaitAsync(token);
 
 		try
 		{
@@ -354,10 +360,7 @@ void OnValuePropertyNamePropertyChanged()
 
 	async ValueTask UpdateStateAsync(VisualElement? view, ValidationFlags flags, bool isForced, CancellationToken? parentToken = null)
 	{
-		if (parentToken?.IsCancellationRequested is true)
-		{
-			return;
-		}
+		parentToken?.ThrowIfCancellationRequested();
 
 		if ((view?.IsFocused ?? false) && flags.HasFlag(ValidationFlags.ForceMakeValidWhenFocused))
 		{
diff --git a/src/CommunityToolkit.Maui/Extensions/ColorAnimationExtensions.shared.cs b/src/CommunityToolkit.Maui/Extensions/ColorAnimationExtensions.shared.cs
index cabdf16ab2..f56454ef1e 100644
--- a/src/CommunityToolkit.Maui/Extensions/ColorAnimationExtensions.shared.cs
+++ b/src/CommunityToolkit.Maui/Extensions/ColorAnimationExtensions.shared.cs
@@ -15,14 +15,15 @@ public static partial class ColorAnimationExtensions
 	/// <param name="rate">The time, in milliseconds, between the frames of the animation</param>
 	/// <param name="length">The duration, in milliseconds, of the animation</param>
 	/// <param name="easing">The easing function to be used in the animation</param>
+	/// <param name="token"><see cref="CancellationToken"/></param>
 	/// <returns>Value indicating if the animation completed successfully or not</returns>
-	public static Task<bool> BackgroundColorTo(this VisualElement element, Color color, uint rate = 16u, uint length = 250u, Easing? easing = null)
+	public static Task<bool> BackgroundColorTo(this VisualElement element, Color color, uint rate = 16u, uint length = 250u, Easing? easing = null, CancellationToken token = default)
 	{
 		ArgumentNullException.ThrowIfNull(element);
 		ArgumentNullException.ThrowIfNull(color);
 
-		//Although BackgroundColor is defined as not-nullable, it CAN be null
-		//If null => set it to Transparent as Animation will crash on null BackgroundColor
+		// Although BackgroundColor is defined as not-nullable, it CAN be null
+		// If null => set it to Transparent as Animation will crash on null BackgroundColor
 		element.BackgroundColor ??= Colors.Transparent;
 
 		var animationCompletionSource = new TaskCompletionSource<bool>();
@@ -46,7 +47,7 @@ public static Task<bool> BackgroundColorTo(this VisualElement element, Color col
 			animationCompletionSource.SetResult(false);
 		}
 
-		return animationCompletionSource.Task;
+		return animationCompletionSource.Task.WaitAsync(token);
 
 
 		static Animation GetRedTransformAnimation(VisualElement element, float targetRed) =>
diff --git a/src/CommunityToolkit.Maui/ImageSources/GravatarImageSource.shared.cs b/src/CommunityToolkit.Maui/ImageSources/GravatarImageSource.shared.cs
index c9c51ef7b3..c8b35a52e5 100644
--- a/src/CommunityToolkit.Maui/ImageSources/GravatarImageSource.shared.cs
+++ b/src/CommunityToolkit.Maui/ImageSources/GravatarImageSource.shared.cs
@@ -31,7 +31,7 @@ public class GravatarImageSource : StreamImageSource, IDisposable
 
 	static readonly Lazy<HttpClient> singletonHttpClientHolder = new();
 
-	int gravatarSize = -1;
+	int? gravatarSize;
 	Uri? lastDispatch;
 
 	/// <summary>Initializes a new instance of the <see cref="GravatarImageSource"/> class.</summary>
@@ -86,11 +86,24 @@ public DefaultImage Image
 	internal int ParentWidth => (int)GetValue(ParentWidthProperty);
 
 	/// <summary>Gets or sets the image size.</summary>
-	/// <remarks>Size is limited to be in the range of 1 to 2048.</remarks>
-	int GravatarSize
+	/// <remarks>
+	/// Size is limited to be in the range of 1 to 2048.
+	/// A null value indicates that the size has not yet been set
+	/// </remarks>
+	int? GravatarSize
 	{
 		get => gravatarSize;
-		set => gravatarSize = Math.Clamp(value, 1, 2048);
+		set
+		{
+			if (value is null)
+			{
+				gravatarSize = null;
+			}
+			else
+			{
+				gravatarSize = Math.Clamp(value.Value, 1, 2048);
+			}
+		}
 	}
 
 	static HttpClient SingletonHttpClient => singletonHttpClientHolder.Value;
@@ -144,13 +157,13 @@ protected override void OnParentSet()
 	static async void OnDefaultImagePropertyChanged(BindableObject bindable, object oldValue, object newValue)
 	{
 		GravatarImageSource gravatarImageSource = (GravatarImageSource)bindable;
-		await gravatarImageSource.HandleNewUriRequested(gravatarImageSource.Email, (DefaultImage)newValue);
+		await gravatarImageSource.HandleNewUriRequested(gravatarImageSource.Email, (DefaultImage)newValue, gravatarImageSource.CancellationTokenSource?.Token ?? CancellationToken.None);
 	}
 
 	static async void OnEmailPropertyChanged(BindableObject bindable, object oldValue, object newValue)
 	{
 		GravatarImageSource gravatarImageSource = (GravatarImageSource)bindable;
-		await gravatarImageSource.HandleNewUriRequested((string?)newValue, gravatarImageSource.Image);
+		await gravatarImageSource.HandleNewUriRequested((string?)newValue, gravatarImageSource.Image, gravatarImageSource.CancellationTokenSource?.Token ?? CancellationToken.None);
 	}
 
 	static async void OnSizePropertyChanged(BindableObject bindable, object oldValue, object newValue)
@@ -161,19 +174,19 @@ static async void OnSizePropertyChanged(BindableObject bindable, object oldValue
 		}
 
 		GravatarImageSource gravatarImageSource = (GravatarImageSource)bindable;
-		if (gravatarImageSource.GravatarSize is -1)
+		if (gravatarImageSource.GravatarSize is null)
 		{
 			gravatarImageSource.GravatarSize = intNewValue;
 			return;
 		}
 
 		gravatarImageSource.GravatarSize = Math.Min(gravatarImageSource.ParentWidth, gravatarImageSource.ParentHeight);
-		await gravatarImageSource.HandleNewUriRequested(gravatarImageSource.Email, gravatarImageSource.Image);
+		await gravatarImageSource.HandleNewUriRequested(gravatarImageSource.Email, gravatarImageSource.Image, gravatarImageSource.CancellationTokenSource?.Token ?? CancellationToken.None);
 	}
 
-	Task HandleNewUriRequested(string? email, DefaultImage image)
+	Task HandleNewUriRequested(string? email, DefaultImage image, CancellationToken token)
 	{
-		if (GravatarSize is -1)
+		if (GravatarSize is null)
 		{
 			return Task.CompletedTask;
 		}
@@ -182,10 +195,10 @@ Task HandleNewUriRequested(string? email, DefaultImage image)
 			? new Uri($"{defaultGravatarImageAddress}?s={GravatarSize}")
 			: new Uri($"{defaultGravatarImageAddress}{email?.GetMd5Hash(string.Empty).ToLowerInvariant()}?s={GravatarSize}&d={DefaultGravatarName(image)}");
 
-		return OnUriChanged();
+		return OnUriChanged(token);
 	}
 
-	async Task OnUriChanged()
+	async Task OnUriChanged(CancellationToken token)
 	{
 		if (Uri.Equals(lastDispatch))
 		{
@@ -194,10 +207,10 @@ async Task OnUriChanged()
 
 		try
 		{
-			await Task.Delay(cancellationTokenSourceTimeout);
-			CancellationTokenSource?.Cancel();
+			await Task.Delay(cancellationTokenSourceTimeout, token);
+			await (CancellationTokenSource?.CancelAsync() ?? Task.CompletedTask);
 			lastDispatch = Uri;
-			await Dispatcher.DispatchIfRequiredAsync(OnSourceChanged);
+			await Dispatcher.DispatchIfRequiredAsync(OnSourceChanged).WaitAsync(token);
 		}
 		catch (TaskCanceledException)
 		{
diff --git a/src/CommunityToolkit.Maui/Layouts/StateContainer/StateContainer.shared.cs b/src/CommunityToolkit.Maui/Layouts/StateContainer/StateContainer.shared.cs
index 56dd8d66ee..75e9c26a34 100644
--- a/src/CommunityToolkit.Maui/Layouts/StateContainer/StateContainer.shared.cs
+++ b/src/CommunityToolkit.Maui/Layouts/StateContainer/StateContainer.shared.cs
@@ -71,11 +71,11 @@ public static async Task ChangeStateWithAnimation(
 		string? state,
 		Animation? beforeStateChange,
 		Animation? afterStateChange,
-		CancellationToken token)
+		CancellationToken token = default)
 	{
 		if (beforeStateChange is null && afterStateChange is null)
 		{
-			throw new ArgumentException($"Anmiation required. Parameters {nameof(beforeStateChange)} and {nameof(afterStateChange)} cannot both be null");
+			throw new ArgumentException($"Animation required. Parameters {nameof(beforeStateChange)} and {nameof(afterStateChange)} cannot both be null");
 		}
 
 		ValidateCanStateChange(bindable);
@@ -118,11 +118,11 @@ public static async Task ChangeStateWithAnimation(
 		string? state,
 		Func<VisualElement, CancellationToken, Task>? beforeStateChange,
 		Func<VisualElement, CancellationToken, Task>? afterStateChange,
-		CancellationToken cancellationToken)
+		CancellationToken cancellationToken = default)
 	{
 		if (beforeStateChange is null && afterStateChange is null)
 		{
-			throw new ArgumentException($"Anmiation required. Parameters {nameof(beforeStateChange)} and {nameof(afterStateChange)} cannot both be null");
+			throw new ArgumentException($"Animation required. Parameters {nameof(beforeStateChange)} and {nameof(afterStateChange)} cannot both be null");
 		}
 
 		ValidateCanStateChange(bindable);
@@ -155,7 +155,7 @@ public static async Task ChangeStateWithAnimation(
 	/// <summary>
 	/// Change state using the default fade animation.
 	/// </summary>
-	public static async Task ChangeStateWithAnimation(BindableObject bindable, string? state, CancellationToken token)
+	public static async Task ChangeStateWithAnimation(BindableObject bindable, string? state, CancellationToken token = default)
 	{
 		ValidateCanStateChange(bindable);
 		SetCanStateChange(bindable, false);
diff --git a/src/CommunityToolkit.Maui/PopupService.cs b/src/CommunityToolkit.Maui/PopupService.cs
index 63e85fb372..848e90967d 100644
--- a/src/CommunityToolkit.Maui/PopupService.cs
+++ b/src/CommunityToolkit.Maui/PopupService.cs
@@ -81,18 +81,18 @@ public void ShowPopup<TViewModel>(Action<TViewModel> onPresenting) where TViewMo
 		CurrentPage.ShowPopup(popup);
 	}
 
-	/// <inheritdoc cref="IPopupService.ShowPopupAsync{TViewModel}()"/>
-	public Task<object?> ShowPopupAsync<TViewModel>() where TViewModel : INotifyPropertyChanged
+	/// <inheritdoc cref="IPopupService.ShowPopupAsync{TViewModel}(CancellationToken)"/>
+	public Task<object?> ShowPopupAsync<TViewModel>(CancellationToken token = default) where TViewModel : INotifyPropertyChanged
 	{
 		var popup = GetPopup(typeof(TViewModel));
 
 		ValidateBindingContext<TViewModel>(popup, out _);
 
-		return CurrentPage.ShowPopupAsync(popup);
+		return CurrentPage.ShowPopupAsync(popup, token);
 	}
 
-	/// <inheritdoc cref="IPopupService.ShowPopupAsync{TViewModel}(TViewModel)"/>
-	public Task<object?> ShowPopupAsync<TViewModel>(TViewModel viewModel) where TViewModel : INotifyPropertyChanged
+	/// <inheritdoc cref="IPopupService.ShowPopupAsync{TViewModel}(TViewModel, CancellationToken)"/>
+	public Task<object?> ShowPopupAsync<TViewModel>(TViewModel viewModel, CancellationToken token = default) where TViewModel : INotifyPropertyChanged
 	{
 		ArgumentNullException.ThrowIfNull(viewModel);
 
@@ -100,11 +100,11 @@ public void ShowPopup<TViewModel>(Action<TViewModel> onPresenting) where TViewMo
 
 		ValidateBindingContext<TViewModel>(popup, out _);
 
-		return CurrentPage.ShowPopupAsync(popup);
+		return CurrentPage.ShowPopupAsync(popup, token);
 	}
 
-	/// <inheritdoc cref="IPopupService.ShowPopupAsync{TViewModel}(Action{TViewModel})"/>
-	public Task<object?> ShowPopupAsync<TViewModel>(Action<TViewModel> onPresenting) where TViewModel : INotifyPropertyChanged
+	/// <inheritdoc cref="IPopupService.ShowPopupAsync{TViewModel}(Action{TViewModel}, CancellationToken)"/>
+	public Task<object?> ShowPopupAsync<TViewModel>(Action<TViewModel> onPresenting, CancellationToken token = default) where TViewModel : INotifyPropertyChanged
 	{
 		ArgumentNullException.ThrowIfNull(onPresenting);
 
@@ -114,7 +114,7 @@ public void ShowPopup<TViewModel>(Action<TViewModel> onPresenting) where TViewMo
 
 		onPresenting.Invoke(viewModel);
 
-		return CurrentPage.ShowPopupAsync(popup);
+		return CurrentPage.ShowPopupAsync(popup, token);
 	}
 
 	/// <summary>
diff --git a/src/CommunityToolkit.Maui/Views/DrawingView/DrawingView.shared.cs b/src/CommunityToolkit.Maui/Views/DrawingView/DrawingView.shared.cs
index 88a60f551c..5a5c8e3341 100644
--- a/src/CommunityToolkit.Maui/Views/DrawingView/DrawingView.shared.cs
+++ b/src/CommunityToolkit.Maui/Views/DrawingView/DrawingView.shared.cs
@@ -217,19 +217,23 @@ public Action<ICanvas, RectF>? DrawAction
 	/// <param name="lines">A collection of <see cref="IDrawingLine"/> that a image is generated from.</param>
 	/// <param name="imageSize">The desired dimensions of the generated image. The image will be resized proportionally.</param>
 	/// <param name="background">Background of the generated image. If color is null, default background color is used.</param>
+	/// <param name="token"><see cref="CancellationToken"/></param>
 	/// <returns><see cref="ValueTask{Stream}"/> containing the data of the requested image with data that's provided through the <paramref name="lines"/> parameter.</returns>
 	public static ValueTask<Stream> GetImageStream(IEnumerable<IDrawingLine> lines,
-		Size imageSize,
-		Brush? background) =>
-		DrawingViewService.GetImageStream(lines.ToList(), imageSize, background);
+													Size imageSize,
+													Brush? background,
+													CancellationToken token = default) =>
+		DrawingViewService.GetImageStream(lines.ToList(), imageSize, background, token);
 
 	/// <summary>
 	/// Retrieves a <see cref="Stream"/> containing an image of the <see cref="Lines"/> that are currently drawn on the <see cref="DrawingView"/>.
 	/// </summary>
 	/// <param name="imageSizeWidth">Desired width of the image that is returned. The image will be resized proportionally.</param>
 	/// <param name="imageSizeHeight">Desired height of the image that is returned. The image will be resized proportionally.</param>
+	/// <param name="token"><see cref="CancellationToken"/></param>
 	/// <returns><see cref="ValueTask{Stream}"/> containing the data of the requested image with data that's currently on the <see cref="DrawingView"/>.</returns>
-	public ValueTask<Stream> GetImageStream(double imageSizeWidth, double imageSizeHeight) => DrawingViewService.GetImageStream(Lines.ToList(), new Size(imageSizeWidth, imageSizeHeight), Background);
+	public ValueTask<Stream> GetImageStream(double imageSizeWidth, double imageSizeHeight, CancellationToken token = default) =>
+		DrawingViewService.GetImageStream(Lines.ToList(), new Size(imageSizeWidth, imageSizeHeight), Background, token);
 
 	/// <summary>
 	/// Clears the <see cref="Lines"/> collection.
diff --git a/src/CommunityToolkit.Maui/Views/LazyView/LazyView.shared.cs b/src/CommunityToolkit.Maui/Views/LazyView/LazyView.shared.cs
index 29c74de844..5bf550488d 100644
--- a/src/CommunityToolkit.Maui/Views/LazyView/LazyView.shared.cs
+++ b/src/CommunityToolkit.Maui/Views/LazyView/LazyView.shared.cs
@@ -10,8 +10,10 @@
 	/// This method initializes <see cref="LazyView{TView}"/>.
 	/// </summary>
 	/// <returns><see cref="ValueTask"/></returns>
-	public override ValueTask LoadViewAsync()
+	public override ValueTask LoadViewAsync(CancellationToken token = default)
 	{
+		token.ThrowIfCancellationRequested();
+
 		Content = new TView { BindingContext = BindingContext };
 
 		SetHasLazyViewLoaded(true);
@@ -41,7 +43,7 @@ public abstract class LazyView : ContentView
 	/// Use this method to do the initialization of the <see cref="View"/> and change the status HasViewLoaded value here.
 	/// </summary>
 	/// <returns><see cref="ValueTask"/></returns>
-	public abstract ValueTask LoadViewAsync();
+	public abstract ValueTask LoadViewAsync(CancellationToken token = default);
 
 	/// <inheritdoc/>
 	protected override void OnBindingContextChanged()
diff --git a/src/CommunityToolkit.Maui/Views/Popup/Popup.shared.cs b/src/CommunityToolkit.Maui/Views/Popup/Popup.shared.cs
index 37836d9c10..3d6b65448d 100644
--- a/src/CommunityToolkit.Maui/Views/Popup/Popup.shared.cs
+++ b/src/CommunityToolkit.Maui/Views/Popup/Popup.shared.cs
@@ -267,12 +267,10 @@ public void Reset()
 	/// <remarks>
 	/// <see cref="Close(object?)"/> is an <see langword="async"/> <see langword="void"/> method, commonly referred to as a fire-and-forget method.
 	/// It will complete and return to the calling thread before the operating system has dismissed the <see cref="Popup"/> from the screen.
-	/// If you need to pause the execution of your method until the operating system has dismissed the <see cref="Popup"/> from the screen, use instead <see cref="CloseAsync(object?)"/>.
+	/// If you need to pause the execution of your method until the operating system has dismissed the <see cref="Popup"/> from the screen, use instead <see cref="CloseAsync(object?, CancellationToken)"/>.
 	/// </remarks>
-	/// <param name="result">
-	/// The result to return.
-	/// </param>
-	public async void Close(object? result = null) => await CloseAsync(result);
+	/// <param name="result">The result to return.</param>
+	public async void Close(object? result = null) => await CloseAsync(result, CancellationToken.None);
 
 	/// <summary>
 	/// Close the current popup.
@@ -280,12 +278,11 @@ public void Reset()
 	/// <remarks>
 	/// Returns once the operating system has dismissed the <see cref="IPopup"/> from the page
 	/// </remarks>
-	/// <param name="result">
-	/// The result to return.
-	/// </param>
-	public async Task CloseAsync(object? result = null)
+	/// <param name="result">The result to return.</param>
+	/// <param name="token"><see cref="CancellationToken"/></param>
+	public async Task CloseAsync(object? result = null, CancellationToken token = default)
 	{
-		await OnClosed(result, false);
+		await OnClosed(result, false, token);
 		resultTaskCompletionSource.TrySetResult(result);
 	}
 
@@ -343,18 +340,15 @@ internal virtual void OnOpened() =>
 	/// <summary>
 	/// Invokes the <see cref="Closed"/> event.
 	/// </summary>
-	/// <param name="result">
-	/// Sets the <see cref="PopupClosedEventArgs"/> Property of <see cref="PopupClosedEventArgs.Result"/>.
-	/// </param>
-	/// /// <param name="wasDismissedByTappingOutsideOfPopup">
-	/// Sets the <see cref="PopupClosedEventArgs"/> Property of <see cref="PopupClosedEventArgs.WasDismissedByTappingOutsideOfPopup"/>/>.
-	/// </param>
-	protected virtual async Task OnClosed(object? result, bool wasDismissedByTappingOutsideOfPopup)
+	/// <param name="result">Sets the <see cref="PopupClosedEventArgs"/> Property of <see cref="PopupClosedEventArgs.Result"/>.</param>
+	/// <param name="wasDismissedByTappingOutsideOfPopup">Sets the <see cref="PopupClosedEventArgs"/> Property of <see cref="PopupClosedEventArgs.WasDismissedByTappingOutsideOfPopup"/>/>.</param>
+	/// <param name="token"><see cref="CancellationToken"/></param>
+	protected virtual async Task OnClosed(object? result, bool wasDismissedByTappingOutsideOfPopup, CancellationToken token = default)
 	{
 		((IPopup)this).OnClosed(result);
 		((IResourceDictionary)resources).ValuesChanged -= OnResourcesChanged;
 
-		await popupDismissedTaskCompletionSource.Task;
+		await popupDismissedTaskCompletionSource.Task.WaitAsync(token);
 		Parent = null;
 
 		dismissWeakEventManager.HandleEvent(this, new PopupClosedEventArgs(result, wasDismissedByTappingOutsideOfPopup), nameof(Closed));
@@ -363,9 +357,9 @@ protected virtual async Task OnClosed(object? result, bool wasDismissedByTapping
 	/// <summary>
 	/// Invoked when the popup is dismissed by tapping outside of the popup.
 	/// </summary>
-	protected internal virtual async Task OnDismissedByTappingOutsideOfPopup()
+	protected internal virtual async Task OnDismissedByTappingOutsideOfPopup(CancellationToken token = default)
 	{
-		await OnClosed(ResultWhenUserTapsOutsideOfPopup, true);
+		await OnClosed(ResultWhenUserTapsOutsideOfPopup, true, token);
 		resultTaskCompletionSource.TrySetResult(ResultWhenUserTapsOutsideOfPopup);
 	}
 
@@ -398,7 +392,7 @@ static void OnColorChanged(BindableObject bindable, object oldValue, object newV
 
 	void IPopup.OnOpened() => OnOpened();
 
-	async void IPopup.OnDismissedByTappingOutsideOfPopup() => await OnDismissedByTappingOutsideOfPopup();
+	async void IPopup.OnDismissedByTappingOutsideOfPopup() => await OnDismissedByTappingOutsideOfPopup(CancellationToken.None);
 
 	void IPropertyPropagationController.PropagatePropertyChanged(string propertyName) =>
 		PropertyPropagationExtensions.PropagatePropertyChanged(propertyName, this, ((IVisualTreeElement)this).GetVisualChildren());
diff --git a/src/CommunityToolkit.Maui/Views/Popup/PopupExtensions.shared.cs b/src/CommunityToolkit.Maui/Views/Popup/PopupExtensions.shared.cs
index 20fee2197b..9b70b06ffe 100644
--- a/src/CommunityToolkit.Maui/Views/Popup/PopupExtensions.shared.cs
+++ b/src/CommunityToolkit.Maui/Views/Popup/PopupExtensions.shared.cs
@@ -13,12 +13,8 @@ public static partial class PopupExtensions
 	/// <summary>
 	/// Displays a popup.
 	/// </summary>
-	/// <param name="page">
-	/// The current <see cref="Page"/>.
-	/// </param>
-	/// <param name="popup">
-	/// The <see cref="Popup"/> to display.
-	/// </param>
+	/// <param name="page">The current <see cref="Page"/>.</param>
+	/// <param name="popup">The <see cref="Popup"/> to display.</param>
 	public static void ShowPopup<TPopup>(this Page page, TPopup popup) where TPopup : Popup
 	{
 #if WINDOWS
@@ -53,16 +49,13 @@ void handler(object? sender, EventArgs args)
 	/// <summary>
 	/// Displays a popup and returns a result.
 	/// </summary>
-	/// <param name="page">
-	/// The current <see cref="Page"/>.
-	/// </param>
-	/// <param name="popup">
-	/// The <see cref="Popup"/> to display.
-	/// </param>
+	/// <param name="page">The current <see cref="Page"/>.</param>
+	/// <param name="popup">The <see cref="Popup"/> to display.</param>
+	/// <param name="token"><see cref="CancellationToken"/></param>
 	/// <returns>
 	/// A task that will complete once the <see cref="Popup"/> is dismissed.
 	/// </returns>
-	public static Task<object?> ShowPopupAsync<TPopup>(this Page page, TPopup popup) where TPopup : Popup
+	public static Task<object?> ShowPopupAsync<TPopup>(this Page page, TPopup popup, CancellationToken token = default) where TPopup : Popup
 	{
 #if WINDOWS
 		// TODO: This is a workaround for https://github.com/dotnet/maui/issues/12970. Remove this `#if Windows` block when the issue is closed   
@@ -74,7 +67,7 @@ async void handler(object? sender, EventArgs args)
 
 			try
 			{
-				var result = await CreateAndShowPopupAsync(page, popup);
+				var result = await CreateAndShowPopupAsync(page, popup, token);
 
 				taskCompletionSource.TrySetResult(result);
 			}
@@ -85,11 +78,11 @@ async void handler(object? sender, EventArgs args)
 		}
 		page.GetCurrentPage().Loaded += handler;
 
-		return taskCompletionSource.Task;
+		return taskCompletionSource.Task.WaitAsync(token);
 #else
 		if (page.IsPlatformEnabled)
 		{
-			return CreateAndShowPopupAsync(page, popup);
+			return CreateAndShowPopupAsync(page, popup, token);
 		}
 		else
 		{
@@ -101,7 +94,7 @@ async void handler(object? sender, EventArgs args)
 
 				try
 				{
-					var result = await CreateAndShowPopupAsync(page, popup);
+					var result = await CreateAndShowPopupAsync(page, popup, token);
 
 					taskCompletionSource.TrySetResult(result);
 				}
@@ -121,7 +114,7 @@ async void handler(object? sender, EventArgs args)
 	static void CreatePopup(Page page, Popup popup)
 	{
 		var mauiContext = GetMauiContext(page);
-		popup.Parent = PageExtensions.GetCurrentPage(page);
+		popup.Parent = page.GetCurrentPage();
 		var platformPopup = popup.ToHandler(mauiContext);
 		platformPopup.Invoke(nameof(IPopup.OnOpened));
 	}
@@ -141,14 +134,14 @@ static void CreateAndShowPopup<TPopup>(Page page, TPopup popup) where TPopup : P
 #endif
 	}
 
-	static Task<object?> CreateAndShowPopupAsync<TPopup>(this Page page, TPopup popup) where TPopup : Popup
+	static Task<object?> CreateAndShowPopupAsync<TPopup>(this Page page, TPopup popup, CancellationToken token) where TPopup : Popup
 	{
 #if WINDOWS
-		return PlatformShowPopupAsync(popup, GetMauiContext(page));
+		return PlatformShowPopupAsync(popup, GetMauiContext(page), token);
 #else
 		CreatePopup(page, popup);
 
-		return popup.Result;
+		return popup.Result.WaitAsync(token);
 #endif
 	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui/Views/Popup/PopupExtensions.windows.cs b/src/CommunityToolkit.Maui/Views/Popup/PopupExtensions.windows.cs
index f0fa342bd1..b641b327fb 100644
--- a/src/CommunityToolkit.Maui/Views/Popup/PopupExtensions.windows.cs
+++ b/src/CommunityToolkit.Maui/Views/Popup/PopupExtensions.windows.cs
@@ -18,9 +18,9 @@ static void PlatformShowPopup(Popup popup, IMauiContext mauiContext)
 		platform?.Invoke(nameof(IPopup.OnOpened));
 	}
 
-	static Task<object?> PlatformShowPopupAsync(Popup popup, IMauiContext mauiContext)
+	static Task<object?> PlatformShowPopupAsync(Popup popup, IMauiContext mauiContext, CancellationToken token)
 	{
 		PlatformShowPopup(popup, mauiContext);
-		return popup.Result;
+		return popup.Result.WaitAsync(token);
 	}
 }
\ No newline at end of file