From 918d1cec708a2c926dbd47cac156ef8d1554ede1 Mon Sep 17 00:00:00 2001
From: vividos <michael.fink@asamnet.de>
Date: Mon, 13 Feb 2023 19:22:29 +0100
Subject: [PATCH] [Essentials] Geolocation foreground listening (#9572)

* added geolocation foreground listening public API without implementation

* added section on geolocation sample page for foreground listening feature

* implemented geolocation foreground listening for Android, iOS, MacOS and UWP

* moved common code for determining DesiredAccuracy on UWP to extension method

* renamed class ListeningRequest to GeolocationListeningRequest

* renamed property IsListening to IsListeningForeground

* added xml documentation for all new public methods and properties

* implemented event LocationError, using enum GeolocationError and class GeolocationErrorEventArgs

* fixed potential leak where ContinuousLocationListener keeps the reference to the GeolocationImplementation on iOS

* changed StopListeningForegroundAsync() to StopListeningForeground() and return void

* fixed error in Essentials samples where async keyword is not necessary anymore

* enabled nullable checks for GeolocationListeningRequest class

* renamed ListeningRequest.ios.macos.cs to match class name; no source code changes

* call StopListeningForeground() on Android, iOS and macOS before signalling LocationError event, to make behavior consistent with Windows

* replaced throwing ArgumentNullException with ArgumentNullException.ThrowIfNull()

* added xml documentation for all newly added public geolocaion foreground listening APIs

* removed duplicated code for determining GeolocationAccuracy on iOS and macOS

* renamed event LocationError to ListeningFailed and GeolocationErrorEventArgs to GeolocationListeningFailedEventArgs

* fixed IsListeningForeground property on Windows

* Fixed naming

---------

Co-authored-by: Gerald Versluis <gerald.versluis@microsoft.com>
---
 .../samples/Samples/View/GeolocationPage.xaml |  10 ++
 .../Samples/ViewModel/GeolocationViewModel.cs |  74 ++++++++
 .../src/Geolocation/Geolocation.android.cs    | 169 +++++++++++++++++-
 .../src/Geolocation/Geolocation.ios.macos.cs  | 136 +++++++++++++-
 .../Geolocation.netstandard.tvos.watchos.cs   |   9 +
 .../src/Geolocation/Geolocation.shared.cs     | 100 +++++++++++
 .../src/Geolocation/Geolocation.tizen.cs      |  10 +-
 .../src/Geolocation/Geolocation.uwp.cs        | 105 ++++++++++-
 ...ationAccuracyExtensionMethods.ios.macos.cs |  28 +++
 ...GeolocationAccuracyExtensionMethods.uwp.cs |  25 +++
 .../Geolocation/GeolocationError.shared.cs    |  30 ++++
 ...locationListeningFailedEventArgs.shared.cs |  25 +++
 .../GeolocationListeningRequest.ios.macos.cs  |  15 ++
 .../GeolocationListeningRequest.shared.cs     |  51 ++++++
 .../GeolocationListeningRequest.uwp.cs        |  15 ++
 ...locationLocationChangedEventArgs.shared.cs |  18 ++
 .../GeolocationRequest.ios.macos.cs           |  22 +--
 .../src/Geolocation/GeolocationRequest.uwp.cs |  21 +--
 .../net-android/PublicAPI.Unshipped.txt       |  29 ++-
 .../PublicAPI/net-ios/PublicAPI.Unshipped.txt |  29 ++-
 .../net-maccatalyst/PublicAPI.Unshipped.txt   |  29 ++-
 .../net-tizen/PublicAPI.Unshipped.txt         |  29 ++-
 .../net-windows/PublicAPI.Unshipped.txt       |  29 ++-
 .../src/PublicAPI/net/PublicAPI.Unshipped.txt |  27 +++
 .../netstandard/PublicAPI.Unshipped.txt       |  29 ++-
 25 files changed, 1007 insertions(+), 57 deletions(-)
 create mode 100644 src/Essentials/src/Geolocation/GeolocationAccuracyExtensionMethods.ios.macos.cs
 create mode 100644 src/Essentials/src/Geolocation/GeolocationAccuracyExtensionMethods.uwp.cs
 create mode 100644 src/Essentials/src/Geolocation/GeolocationError.shared.cs
 create mode 100644 src/Essentials/src/Geolocation/GeolocationListeningFailedEventArgs.shared.cs
 create mode 100644 src/Essentials/src/Geolocation/GeolocationListeningRequest.ios.macos.cs
 create mode 100644 src/Essentials/src/Geolocation/GeolocationListeningRequest.shared.cs
 create mode 100644 src/Essentials/src/Geolocation/GeolocationListeningRequest.uwp.cs
 create mode 100644 src/Essentials/src/Geolocation/GeolocationLocationChangedEventArgs.shared.cs

diff --git a/src/Essentials/samples/Samples/View/GeolocationPage.xaml b/src/Essentials/samples/Samples/View/GeolocationPage.xaml
index c10eeb38c638..67475e119435 100644
--- a/src/Essentials/samples/Samples/View/GeolocationPage.xaml
+++ b/src/Essentials/samples/Samples/View/GeolocationPage.xaml
@@ -27,6 +27,16 @@
                         IsEnabled="{Binding IsNotBusy}"
                         HorizontalOptions="FillAndExpand" />
                 <Button Text="Refresh" Command="{Binding GetCurrentLocationCommand}" IsEnabled="{Binding IsNotBusy}" />
+
+                <Label Text="Foreground listener for Location:" FontAttributes="Bold" Margin="0,6,0,0" />
+                <StackLayout Orientation="Horizontal" Spacing="6">
+                    <Button Text="Start Listening" HorizontalOptions="FillAndExpand"
+                            Command="{Binding StartListeningCommand}" IsEnabled="{Binding IsNotListening}" />
+                    <Button Text="Stop listening" HorizontalOptions="FillAndExpand"
+                            Command="{Binding StopListeningCommand}" IsEnabled="{Binding IsListening}" />
+                </StackLayout>
+                <Label Text="{Binding ListeningLocationStatus}" />
+                <Label Text="{Binding ListeningLocation}" />
             </StackLayout>
         </ScrollView>
     </Grid>
diff --git a/src/Essentials/samples/Samples/ViewModel/GeolocationViewModel.cs b/src/Essentials/samples/Samples/ViewModel/GeolocationViewModel.cs
index 9a937ee239c6..ed9d3c0275f4 100644
--- a/src/Essentials/samples/Samples/ViewModel/GeolocationViewModel.cs
+++ b/src/Essentials/samples/Samples/ViewModel/GeolocationViewModel.cs
@@ -13,17 +13,25 @@ public class GeolocationViewModel : BaseViewModel
 		string currentLocation;
 		int accuracy = (int)GeolocationAccuracy.Default;
 		CancellationTokenSource cts;
+		string listeningLocation;
+		string listeningLocationStatus;
 
 		public GeolocationViewModel()
 		{
 			GetLastLocationCommand = new Command(OnGetLastLocation);
 			GetCurrentLocationCommand = new Command(OnGetCurrentLocation);
+			StartListeningCommand = new Command(OnStartListening);
+			StopListeningCommand = new Command(OnStopListening);
 		}
 
 		public ICommand GetLastLocationCommand { get; }
 
 		public ICommand GetCurrentLocationCommand { get; }
 
+		public ICommand StartListeningCommand { get; }
+
+		public ICommand StopListeningCommand { get; }
+
 		public string LastLocation
 		{
 			get => lastLocation;
@@ -45,6 +53,22 @@ public int Accuracy
 			set => SetProperty(ref accuracy, value);
 		}
 
+		public bool IsListening => Geolocation.IsListeningForeground;
+
+		public bool IsNotListening => !IsListening;
+
+		public string ListeningLocation
+		{
+			get => listeningLocation;
+			set => SetProperty(ref listeningLocation, value);
+		}
+
+		public string ListeningLocationStatus
+		{
+			get => listeningLocationStatus;
+			set => SetProperty(ref listeningLocationStatus, value);
+		}
+
 		async void OnGetLastLocation()
 		{
 			if (IsBusy)
@@ -88,6 +112,53 @@ async void OnGetCurrentLocation()
 			IsBusy = false;
 		}
 
+		async void OnStartListening()
+		{
+			try
+			{
+				Geolocation.LocationChanged += Geolocation_LocationChanged;
+
+				var request = new GeolocationListeningRequest((GeolocationAccuracy)Accuracy);
+
+				var success = await Geolocation.StartListeningForegroundAsync(request);
+
+				ListeningLocationStatus = success
+					? "Started listening for foreground location updates"
+					: "Couldn't start listening";
+			}
+			catch (Exception ex)
+			{
+				ListeningLocationStatus = FormatLocation(null, ex);
+			}
+
+			OnPropertyChanged(nameof(IsListening));
+			OnPropertyChanged(nameof(IsNotListening));
+		}
+
+		void Geolocation_LocationChanged(object sender, GeolocationLocationChangedEventArgs e)
+		{
+			ListeningLocation = FormatLocation(e.Location);
+		}
+
+		void OnStopListening()
+		{
+			try
+			{
+				Geolocation.LocationChanged -= Geolocation_LocationChanged;
+
+				Geolocation.StopListeningForeground();
+
+				ListeningLocationStatus = "Stopped listening for foreground location updates";
+			}
+			catch (Exception ex)
+			{
+				ListeningLocationStatus = FormatLocation(null, ex);
+			}
+
+			OnPropertyChanged(nameof(IsListening));
+			OnPropertyChanged(nameof(IsNotListening));
+		}
+
 		string FormatLocation(Location location, Exception ex = null)
 		{
 			if (location == null)
@@ -116,6 +187,9 @@ public override void OnDisappearing()
 				if (cts != null && !cts.IsCancellationRequested)
 					cts.Cancel();
 			}
+
+			OnStopListening();
+
 			base.OnDisappearing();
 		}
 	}
diff --git a/src/Essentials/src/Geolocation/Geolocation.android.cs b/src/Essentials/src/Geolocation/Geolocation.android.cs
index f2f8454efd21..b7035227b163 100644
--- a/src/Essentials/src/Geolocation/Geolocation.android.cs
+++ b/src/Essentials/src/Geolocation/Geolocation.android.cs
@@ -18,11 +18,19 @@ partial class GeolocationImplementation : IGeolocation
 		const long twoMinutes = 120000;
 		static readonly string[] ignoredProviders = new string[] { LocationManager.PassiveProvider, "local_database" };
 
+		static ContinuousLocationListener continuousListener;
+		static List<string> listeningProviders;
+
 		static LocationManager locationManager;
 
 		static LocationManager LocationManager =>
 			locationManager ??= Application.Context.GetSystemService(Context.LocationService) as LocationManager;
 
+		/// <summary>
+		/// Indicates if currently listening to location updates while the app is in foreground.
+		/// </summary>
+		public bool IsListeningForeground { get => continuousListener != null; }
+
 		public async Task<Location> GetLastKnownLocationAsync()
 		{
 			await Permissions.EnsureGrantedOrRestrictedAsync<Permissions.LocationWhenInUse>();
@@ -42,7 +50,7 @@ public async Task<Location> GetLastKnownLocationAsync()
 
 		public async Task<Location> GetLocationAsync(GeolocationRequest request, CancellationToken cancellationToken)
 		{
-			_ = request ?? throw new ArgumentNullException(nameof(request));
+			ArgumentNullException.ThrowIfNull(request);
 
 			await Permissions.EnsureGrantedOrRestrictedAsync<Permissions.LocationWhenInUse>();
 
@@ -112,6 +120,101 @@ void RemoveUpdates()
 			}
 		}
 
+		/// <summary>
+		/// Starts listening to location updates using the <see cref="Geolocation.LocationChanged"/>
+		/// event or the <see cref="Geolocation.ListeningFailed"/> event. Events may only sent when
+		/// the app is in the foreground. Requests <see cref="Permissions.LocationWhenInUse"/>
+		/// from the user.
+		/// </summary>
+		/// <exception cref="ArgumentNullException">Thrown when <paramref name="request"/> is <see langword="null"/>.</exception>
+		/// <exception cref="FeatureNotSupportedException">Thrown if listening is not supported on this platform.</exception>
+		/// <exception cref="InvalidOperationException">Thrown if already listening and <see cref="IsListeningForeground"/> returns <see langword="true"/>.</exception>
+		/// <param name="request">The listening request parameters to use.</param>
+		/// <returns><see langword="true"/> when listening was started, or <see langword="false"/> when listening couldn't be started.</returns>
+		public async Task<bool> StartListeningForegroundAsync(GeolocationListeningRequest request)
+		{
+			ArgumentNullException.ThrowIfNull(request);
+
+			if (IsListeningForeground)
+				throw new InvalidOperationException("Already listening to location changes.");
+
+			await Permissions.EnsureGrantedOrRestrictedAsync<Permissions.LocationWhenInUse>();
+
+			var enabledProviders = LocationManager.GetProviders(true);
+			var hasProviders = enabledProviders.Any(p => !ignoredProviders.Contains(p));
+
+			if (!hasProviders)
+				throw new FeatureNotEnabledException("Location services are not enabled on device.");
+
+			// get the best possible provider for the requested accuracy
+			var providerInfo = GetBestProvider(LocationManager, request.DesiredAccuracy);
+
+			// if no providers exist, we can't listen for locations
+			if (string.IsNullOrEmpty(providerInfo.Provider))
+				return false;
+
+			var allProviders = LocationManager.GetProviders(false);
+
+			listeningProviders = new List<string>();
+			if (allProviders.Contains(Android.Locations.LocationManager.GpsProvider))
+				listeningProviders.Add(Android.Locations.LocationManager.GpsProvider);
+			if (allProviders.Contains(Android.Locations.LocationManager.NetworkProvider))
+				listeningProviders.Add(Android.Locations.LocationManager.NetworkProvider);
+
+			if (listeningProviders.Count == 0)
+				listeningProviders.Add(providerInfo.Provider);
+
+			var continuousListener = new ContinuousLocationListener(LocationManager, providerInfo.Accuracy, listeningProviders);
+			continuousListener.LocationHandler = HandleLocation;
+			continuousListener.ErrorHandler = HandleError;
+
+			// start getting location updates
+			// make sure to use a thread with a looper
+			var looper = Looper.MyLooper() ?? Looper.MainLooper;
+
+			var minTimeMilliseconds = (long)request.MinimumTime.TotalMilliseconds;
+
+			foreach (var provider in listeningProviders)
+				LocationManager.RequestLocationUpdates(provider, minTimeMilliseconds, providerInfo.Accuracy, continuousListener, looper);
+
+			return true;
+
+			void HandleLocation(AndroidLocation location)
+			{
+				OnLocationChanged(location.ToLocation());
+			}
+
+			void HandleError(GeolocationError geolocationError)
+			{
+				StopListeningForeground();
+				OnLocationError(geolocationError);
+			}
+		}
+
+		/// <summary>
+		/// Stop listening for location updates when the app is in the foreground.
+		/// Has no effect when not listening and <see cref="Geolocation.IsListeningForeground"/>
+		/// is currently <see langword="false"/>.
+		/// </summary>
+		public void StopListeningForeground()
+		{
+			if (continuousListener == null)
+				return;
+
+			continuousListener.LocationHandler = null;
+			continuousListener.ErrorHandler = null;
+
+			if (listeningProviders == null)
+				return;
+
+			for (var i = 0; i < listeningProviders.Count; i++)
+			{
+				LocationManager.RemoveUpdates(continuousListener);
+			}
+
+			continuousListener = null;
+		}
+
 		static (string Provider, float Accuracy) GetBestProvider(LocationManager locationManager, GeolocationAccuracy accuracy)
 		{
 			// Criteria: https://developer.android.com/reference/android/location/Criteria
@@ -276,4 +379,68 @@ void ILocationListener.OnStatusChanged(string provider, Availability status, Bun
 			}
 		}
 	}
+
+	class ContinuousLocationListener : Java.Lang.Object, ILocationListener
+	{
+		readonly LocationManager manager;
+
+		float desiredAccuracy;
+
+		HashSet<string> activeProviders = new HashSet<string>();
+
+		internal Action<AndroidLocation> LocationHandler { get; set; }
+
+		internal Action<GeolocationError> ErrorHandler { get; set; }
+
+		internal ContinuousLocationListener(LocationManager manager, float desiredAccuracy, IEnumerable<string> providers)
+		{
+			this.manager = manager;
+			this.desiredAccuracy = desiredAccuracy;
+
+			foreach (var provider in providers)
+			{
+				if (manager.IsProviderEnabled(provider))
+					activeProviders.Add(provider);
+			}
+		}
+
+		void ILocationListener.OnLocationChanged(AndroidLocation location)
+		{
+			if (location.Accuracy <= desiredAccuracy)
+			{
+				LocationHandler?.Invoke(location);
+				return;
+			}
+		}
+
+		void ILocationListener.OnProviderDisabled(string provider)
+		{
+			lock (activeProviders)
+			{
+				if (activeProviders.Remove(provider) &&
+					activeProviders.Count == 0)
+					ErrorHandler?.Invoke(GeolocationError.PositionUnavailable);
+			}
+		}
+
+		void ILocationListener.OnProviderEnabled(string provider)
+		{
+			lock (activeProviders)
+				activeProviders.Add(provider);
+		}
+
+		void ILocationListener.OnStatusChanged(string provider, Availability status, Bundle extras)
+		{
+			switch (status)
+			{
+				case Availability.Available:
+					((ILocationListener)this).OnProviderEnabled(provider);
+					break;
+
+				case Availability.OutOfService:
+					((ILocationListener)this).OnProviderDisabled(provider);
+					break;
+			}
+		}
+	}
 }
diff --git a/src/Essentials/src/Geolocation/Geolocation.ios.macos.cs b/src/Essentials/src/Geolocation/Geolocation.ios.macos.cs
index 3a7ea40794bd..e2c93bace244 100644
--- a/src/Essentials/src/Geolocation/Geolocation.ios.macos.cs
+++ b/src/Essentials/src/Geolocation/Geolocation.ios.macos.cs
@@ -3,12 +3,20 @@
 using System.Threading;
 using System.Threading.Tasks;
 using CoreLocation;
+using Foundation;
 using Microsoft.Maui.ApplicationModel;
 
 namespace Microsoft.Maui.Devices.Sensors
 {
 	partial class GeolocationImplementation : IGeolocation
 	{
+		CLLocationManager listeningManager;
+
+		/// <summary>
+		/// Indicates if currently listening to location updates while the app is in foreground.
+		/// </summary>
+		public bool IsListeningForeground { get => listeningManager != null; }
+
 		public async Task<Location> GetLastKnownLocationAsync()
 		{
 			if (!CLLocationManager.LocationServicesEnabled)
@@ -31,7 +39,7 @@ public async Task<Location> GetLastKnownLocationAsync()
 
 		public async Task<Location> GetLocationAsync(GeolocationRequest request, CancellationToken cancellationToken)
 		{
-			_ = request ?? throw new ArgumentNullException(nameof(request));
+			ArgumentNullException.ThrowIfNull(request);
 
 			if (!CLLocationManager.LocationServicesEnabled)
 				throw new FeatureNotEnabledException("Location services are not enabled on device.");
@@ -91,6 +99,94 @@ void Cancel()
 				tcs.TrySetResult(null);
 			}
 		}
+
+		/// <summary>
+		/// Starts listening to location updates using the <see cref="Geolocation.LocationChanged"/>
+		/// event or the <see cref="Geolocation.ListeningFailed"/> event. Events may only sent when
+		/// the app is in the foreground. Requests <see cref="Permissions.LocationWhenInUse"/>
+		/// from the user.
+		/// </summary>
+		/// <exception cref="ArgumentNullException">Thrown when <paramref name="request"/> is <see langword="null"/>.</exception>
+		/// <exception cref="FeatureNotSupportedException">Thrown if listening is not supported on this platform.</exception>
+		/// <exception cref="InvalidOperationException">Thrown if already listening and <see cref="IsListeningForeground"/> returns <see langword="true"/>.</exception>
+		/// <param name="request">The listening request parameters to use.</param>
+		/// <returns><see langword="true"/> when listening was started, or <see langword="false"/> when listening couldn't be started.</returns>
+		public async Task<bool> StartListeningForegroundAsync(GeolocationListeningRequest request)
+		{
+			ArgumentNullException.ThrowIfNull(request);
+
+			if (IsListeningForeground)
+				throw new InvalidOperationException("Already listening to location changes.");
+
+			if (!CLLocationManager.LocationServicesEnabled)
+				throw new FeatureNotEnabledException("Location services are not enabled on device.");
+
+			await Permissions.EnsureGrantedAsync<Permissions.LocationWhenInUse>();
+
+			// the location manager requires an active run loop
+			// so just use the main loop
+			listeningManager = MainThread.InvokeOnMainThread(() => new CLLocationManager());
+
+			var reducedAccuracy = false;
+#if __IOS__
+			if (OperatingSystem.IsIOSVersionAtLeast(14, 0))
+			{
+				reducedAccuracy = listeningManager.AccuracyAuthorization == CLAccuracyAuthorization.ReducedAccuracy;
+			}
+#endif
+
+			var listener = new ContinuousLocationListener();
+			listener.LocationHandler += HandleLocation;
+			listener.ErrorHandler += HandleError;
+
+			listeningManager.DesiredAccuracy = request.PlatformDesiredAccuracy;
+			listeningManager.Delegate = listener;
+
+#if __IOS__
+#pragma warning disable CA1416 // https://github.com/xamarin/xamarin-macios/issues/14619
+			// allow pausing updates
+			listeningManager.PausesLocationUpdatesAutomatically = true;
+#pragma warning restore CA1416
+#endif
+
+			listeningManager.StartUpdatingLocation();
+
+			return true;
+
+			void HandleLocation(CLLocation clLocation)
+			{
+				OnLocationChanged(clLocation?.ToLocation(reducedAccuracy));
+			}
+
+			void HandleError(GeolocationError error)
+			{
+				StopListeningForeground();
+				OnLocationError(error);
+			}
+		}
+
+		/// <summary>
+		/// Stop listening for location updates when the app is in the foreground.
+		/// Has no effect when not listening and <see cref="Geolocation.IsListeningForeground"/>
+		/// is currently <see langword="false"/>.
+		/// </summary>
+		public void StopListeningForeground()
+		{
+			if (!IsListeningForeground)
+				return;
+
+			listeningManager.StopUpdatingLocation();
+
+			if (listeningManager.Delegate is ContinuousLocationListener listener)
+			{
+				listener.LocationHandler = null;
+				listener.ErrorHandler = null;
+			}
+
+			listeningManager.Delegate = null;
+
+			listeningManager = null;
+		}
 	}
 
 	class SingleLocationListener : CLLocationManagerDelegate
@@ -99,6 +195,7 @@ class SingleLocationListener : CLLocationManagerDelegate
 
 		internal Action<CLLocation> LocationHandler { get; set; }
 
+		/// <inheritdoc/>
 		public override void LocationsUpdated(CLLocationManager manager, CLLocation[] locations)
 		{
 			if (wasRaised)
@@ -114,6 +211,43 @@ public override void LocationsUpdated(CLLocationManager manager, CLLocation[] lo
 			LocationHandler?.Invoke(location);
 		}
 
+		/// <inheritdoc/>
+		public override bool ShouldDisplayHeadingCalibration(CLLocationManager manager) => false;
+	}
+
+	class ContinuousLocationListener : CLLocationManagerDelegate
+	{
+		internal Action<CLLocation> LocationHandler { get; set; }
+
+		internal Action<GeolocationError> ErrorHandler { get; set; }
+
+		/// <inheritdoc/>
+		public override void LocationsUpdated(CLLocationManager manager, CLLocation[] locations)
+		{
+			var location = locations?.LastOrDefault();
+
+			if (location == null)
+				return;
+
+			LocationHandler?.Invoke(location);
+		}
+
+		/// <inheritdoc/>
+		public override void Failed(CLLocationManager manager, NSError error)
+		{
+			if ((CLError)error.Code == CLError.Network)
+				ErrorHandler?.Invoke(GeolocationError.PositionUnavailable);
+		}
+
+		/// <inheritdoc/>
+		public override void AuthorizationChanged(CLLocationManager manager, CLAuthorizationStatus status)
+		{
+			if (status == CLAuthorizationStatus.Denied ||
+				status == CLAuthorizationStatus.Restricted)
+				ErrorHandler?.Invoke(GeolocationError.Unauthorized);
+		}
+
+		/// <inheritdoc/>
 		public override bool ShouldDisplayHeadingCalibration(CLLocationManager manager) => false;
 	}
 }
diff --git a/src/Essentials/src/Geolocation/Geolocation.netstandard.tvos.watchos.cs b/src/Essentials/src/Geolocation/Geolocation.netstandard.tvos.watchos.cs
index 67c10b2ec813..4fc89b6e5a1e 100644
--- a/src/Essentials/src/Geolocation/Geolocation.netstandard.tvos.watchos.cs
+++ b/src/Essentials/src/Geolocation/Geolocation.netstandard.tvos.watchos.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Maui.ApplicationModel;
@@ -11,5 +12,13 @@ public Task<Location> GetLastKnownLocationAsync() =>
 
 		public Task<Location> GetLocationAsync(GeolocationRequest request, CancellationToken cancellationToken) =>
 			throw ExceptionUtils.NotSupportedOrImplementedException;
+
+		public bool IsListeningForeground { get => false; }
+
+		public Task<bool> StartListeningForegroundAsync(GeolocationListeningRequest request) =>
+			throw ExceptionUtils.NotSupportedOrImplementedException;
+
+		public void StopListeningForeground() =>
+			throw ExceptionUtils.NotSupportedOrImplementedException;
 	}
 }
diff --git a/src/Essentials/src/Geolocation/Geolocation.shared.cs b/src/Essentials/src/Geolocation/Geolocation.shared.cs
index 753d13ed5fc0..64809d25cd89 100644
--- a/src/Essentials/src/Geolocation/Geolocation.shared.cs
+++ b/src/Essentials/src/Geolocation/Geolocation.shared.cs
@@ -1,6 +1,8 @@
 #nullable enable
+using System;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.Maui.ApplicationModel;
 
 namespace Microsoft.Maui.Devices.Sensors
 {
@@ -27,6 +29,41 @@ public interface IGeolocation
 		/// <remarks>The location permissions will be requested at runtime if needed. You might still need to declare something in your app manifest.</remarks>
 		/// <returns>A <see cref="Location"/> object containing current location information or <see langword="null"/> if no location could be determined.</returns>
 		Task<Location?> GetLocationAsync(GeolocationRequest request, CancellationToken cancelToken);
+
+		/// <summary>
+		/// Indicates if currently listening to location updates while the app is in foreground.
+		/// </summary>
+		bool IsListeningForeground { get; }
+
+		/// <summary>
+		/// Occurs while listening to location updates.
+		/// </summary>
+		event EventHandler<GeolocationLocationChangedEventArgs>? LocationChanged;
+
+		/// <summary>
+		/// Occurs when an error during listening for location updates arises. When the event is
+		/// fired, listening for further location updates has been stopped and no further
+		/// <see cref="LocationChanged"/> events are sent.
+		/// </summary>
+		event EventHandler<GeolocationListeningFailedEventArgs>? ListeningFailed;
+
+		/// <summary>
+		/// Starts listening to location updates using the <see cref="LocationChanged"/> event. Events
+		/// may only sent when the app is in the foreground. Requests
+		/// <see cref="Permissions.LocationWhenInUse"/> from the user.
+		/// </summary>
+		/// <exception cref="ArgumentNullException">Thrown when <paramref name="request"/> is <see langword="null"/>.</exception>
+		/// <exception cref="FeatureNotSupportedException">Thrown if listening is not supported on this platform.</exception>
+		/// <exception cref="InvalidOperationException">Thrown if already listening and <see cref="IsListeningForeground"/> returns <see langword="true"/>.</exception>
+		/// <param name="request">The listening request parameters to use.</param>
+		/// <returns><see langword="true"/> when listening was started, or <see langword="false"/> when listening couldn't be started.</returns>
+		Task<bool> StartListeningForegroundAsync(GeolocationListeningRequest request);
+
+		/// <summary>
+		/// Stop listening for location updates when the app is in the foreground.
+		/// Has no effect when <see cref="IsListeningForeground"/> is currently <see langword="false"/>.
+		/// </summary>
+		void StopListeningForeground();
 	}
 
 	/// <summary>
@@ -72,6 +109,53 @@ public static partial class Geolocation
 		public static Task<Location?> GetLocationAsync(GeolocationRequest request, CancellationToken cancelToken) =>
 			Current.GetLocationAsync(request, cancelToken);
 
+		/// <summary>
+		/// Indicates if currently listening to location updates while the app is in foreground.
+		/// </summary>
+		public static bool IsListeningForeground { get => Current.IsListeningForeground; }
+
+		/// <summary>
+		/// Occurs while listening to location updates.
+		/// </summary>
+		public static event EventHandler<GeolocationLocationChangedEventArgs> LocationChanged
+		{
+			add => Current.LocationChanged += value;
+			remove => Current.LocationChanged -= value;
+		}
+
+		/// <summary>
+		/// Occurs when an error during listening for location updates arises. When the event is
+		/// fired, listening for further location updates has been stopped and no further
+		/// <see cref="LocationChanged"/> events are sent.
+		/// </summary>
+		public static event EventHandler<GeolocationListeningFailedEventArgs> ListeningFailed
+		{
+			add => Current.ListeningFailed += value;
+			remove => Current.ListeningFailed -= value;
+		}
+
+		/// <summary>
+		/// Starts listening to location updates using the <see cref="Geolocation.LocationChanged"/>
+		/// event or the <see cref="Geolocation.ListeningFailed"/> event. Events may only sent when
+		/// the app is in the foreground. Requests <see cref="Permissions.LocationWhenInUse"/>
+		/// from the user.
+		/// </summary>
+		/// <exception cref="ArgumentNullException">Thrown when <paramref name="request"/> is <see langword="null"/>.</exception>
+		/// <exception cref="FeatureNotSupportedException">Thrown if listening is not supported on this platform.</exception>
+		/// <exception cref="InvalidOperationException">Thrown if already listening and <see cref="IsListeningForeground"/> returns <see langword="true"/>.</exception>
+		/// <param name="request">The listening request parameters to use.</param>
+		/// <returns><see langword="true"/> when listening was started, or <see langword="false"/> when listening couldn't be started.</returns>
+		public static Task<bool> StartListeningForegroundAsync(GeolocationListeningRequest request) =>
+			Current.StartListeningForegroundAsync(request);
+
+		/// <summary>
+		/// Stop listening for location updates when the app is in the foreground.
+		/// Has no effect when not listening and <see cref="Geolocation.IsListeningForeground"/>
+		/// is currently <see langword="false"/>.
+		/// </summary>
+		public static void StopListeningForeground() =>
+			Current.StopListeningForeground();
+
 		static IGeolocation Current => Devices.Sensors.Geolocation.Default;
 
 		static IGeolocation? defaultImplementation;
@@ -86,6 +170,22 @@ internal static void SetDefault(IGeolocation? implementation) =>
 			defaultImplementation = implementation;
 	}
 
+	partial class GeolocationImplementation : IGeolocation
+	{
+		public event EventHandler<GeolocationLocationChangedEventArgs>? LocationChanged;
+
+		public event EventHandler<GeolocationListeningFailedEventArgs>? ListeningFailed;
+
+		internal void OnLocationChanged(Location location) =>
+			OnLocationChanged(new GeolocationLocationChangedEventArgs(location));
+
+		internal void OnLocationChanged(GeolocationLocationChangedEventArgs e) =>
+			LocationChanged?.Invoke(null, e);
+
+		internal void OnLocationError(GeolocationError geolocationError) =>
+			ListeningFailed?.Invoke(null, new GeolocationListeningFailedEventArgs(geolocationError));
+	}
+
 	/// <summary>
 	/// Static class with extension methods for the <see cref="IGeolocation"/> APIs.
 	/// </summary>
diff --git a/src/Essentials/src/Geolocation/Geolocation.tizen.cs b/src/Essentials/src/Geolocation/Geolocation.tizen.cs
index 70f601cedbcb..9ed480844860 100644
--- a/src/Essentials/src/Geolocation/Geolocation.tizen.cs
+++ b/src/Essentials/src/Geolocation/Geolocation.tizen.cs
@@ -10,11 +10,13 @@ partial class GeolocationImplementation : IGeolocation
 	{
 		Location lastKnownLocation = new Location();
 
+		public bool IsListeningForeground { get => false; }
+
 		public Task<Location> GetLastKnownLocationAsync() => Task.FromResult(lastKnownLocation);
 
 		public async Task<Location> GetLocationAsync(GeolocationRequest request, CancellationToken cancellationToken)
 		{
-			_ = request ?? throw new ArgumentNullException(nameof(request));
+			ArgumentNullException.ThrowIfNull(request);
 
 			await Permissions.EnsureGrantedAsync<Permissions.LocationWhenInUse>();
 
@@ -67,5 +69,11 @@ public async Task<Location> GetLocationAsync(GeolocationRequest request, Cancell
 
 			return lastKnownLocation;
 		}
+
+		public Task<bool> StartListeningForegroundAsync(GeolocationListeningRequest request) =>
+			throw ExceptionUtils.NotSupportedOrImplementedException;
+
+		public void StopListeningForeground() =>
+			throw ExceptionUtils.NotSupportedOrImplementedException;
 	}
 }
diff --git a/src/Essentials/src/Geolocation/Geolocation.uwp.cs b/src/Essentials/src/Geolocation/Geolocation.uwp.cs
index ce9778380055..4c80fbd0b200 100644
--- a/src/Essentials/src/Geolocation/Geolocation.uwp.cs
+++ b/src/Essentials/src/Geolocation/Geolocation.uwp.cs
@@ -9,6 +9,13 @@ namespace Microsoft.Maui.Devices.Sensors
 {
 	partial class GeolocationImplementation : IGeolocation
 	{
+		Geolocator? listeningGeolocator;
+
+		/// <summary>
+		/// Indicates if currently listening to location updates while the app is in foreground.
+		/// </summary>
+		public bool IsListeningForeground { get => listeningGeolocator != null; }
+
 		public async Task<Location?> GetLastKnownLocationAsync()
 		{
 			// no need for permissions as AllowFallbackToConsentlessPositions
@@ -27,7 +34,7 @@ partial class GeolocationImplementation : IGeolocation
 
 		public async Task<Location?> GetLocationAsync(GeolocationRequest request, CancellationToken cancellationToken)
 		{
-			_ = request ?? throw new ArgumentNullException(nameof(request));
+			ArgumentNullException.ThrowIfNull(request);
 
 			await Permissions.EnsureGrantedAsync<Permissions.LocationWhenInUse>();
 
@@ -43,16 +50,98 @@ partial class GeolocationImplementation : IGeolocation
 			var location = await geolocator.GetGeopositionAsync().AsTask(cancellationToken);
 
 			return location?.Coordinate?.ToLocation();
+		}
 
-			static void CheckStatus(PositionStatus status)
+		static void CheckStatus(PositionStatus status)
+		{
+			switch (status)
 			{
-				switch (status)
-				{
-					case PositionStatus.Disabled:
-					case PositionStatus.NotAvailable:
-						throw new FeatureNotEnabledException("Location services are not enabled on device.");
-				}
+				case PositionStatus.Disabled:
+				case PositionStatus.NotAvailable:
+					throw new FeatureNotEnabledException("Location services are not enabled on device.");
 			}
 		}
+
+		/// <summary>
+		/// Starts listening to location updates using the <see cref="Geolocation.LocationChanged"/>
+		/// event or the <see cref="Geolocation.ListeningFailed"/> event. Events may only sent when
+		/// the app is in the foreground. Requests <see cref="Permissions.LocationWhenInUse"/>
+		/// from the user.
+		/// </summary>
+		/// <exception cref="ArgumentNullException">Thrown when <paramref name="request"/> is <see langword="null"/>.</exception>
+		/// <exception cref="FeatureNotSupportedException">Thrown if listening is not supported on this platform.</exception>
+		/// <exception cref="InvalidOperationException">Thrown if already listening and <see cref="IsListeningForeground"/> returns <see langword="true"/>.</exception>
+		/// <param name="request">The listening request parameters to use.</param>
+		/// <returns><see langword="true"/> when listening was started, or <see langword="false"/> when listening couldn't be started.</returns>
+		public async Task<bool> StartListeningForegroundAsync(GeolocationListeningRequest request)
+		{
+			ArgumentNullException.ThrowIfNull(request);
+
+			if (request.MinimumTime.TotalMilliseconds < 0)
+				throw new ArgumentOutOfRangeException(nameof(request), "MinimumTime must be positive.");
+
+			if (IsListeningForeground)
+				throw new InvalidOperationException("Already listening to location updates.");
+
+			await Permissions.EnsureGrantedAsync<Permissions.LocationWhenInUse>();
+
+			listeningGeolocator = new Geolocator
+			{
+				DesiredAccuracyInMeters = request.PlatformDesiredAccuracy,
+				ReportInterval = (uint)request.MinimumTime.TotalMilliseconds,
+				MovementThreshold = request.PlatformDesiredAccuracy,
+			};
+
+			CheckStatus(listeningGeolocator.LocationStatus);
+
+			listeningGeolocator.PositionChanged += OnLocatorPositionChanged;
+			listeningGeolocator.StatusChanged += OnLocatorStatusChanged;
+
+			return true;
+		}
+
+		/// <summary>
+		/// Stop listening for location updates when the app is in the foreground.
+		/// Has no effect when not listening and <see cref="Geolocation.IsListeningForeground"/>
+		/// is currently <see langword="false"/>.
+		/// </summary>
+		public void StopListeningForeground()
+		{
+			if (!IsListeningForeground || listeningGeolocator == null)
+				return;
+
+			listeningGeolocator.PositionChanged -= OnLocatorPositionChanged;
+			listeningGeolocator.StatusChanged -= OnLocatorStatusChanged;
+
+			listeningGeolocator = null;
+		}
+
+		void OnLocatorPositionChanged(Geolocator sender, PositionChangedEventArgs e) =>
+			OnLocationChanged(e.Position.ToLocation());
+
+		void OnLocatorStatusChanged(Geolocator sender, StatusChangedEventArgs e)
+		{
+			if (!IsListeningForeground)
+				return;
+
+			StopListeningForeground();
+
+			GeolocationError error;
+			switch (e.Status)
+			{
+				case PositionStatus.Disabled:
+					error = GeolocationError.Unauthorized;
+					break;
+
+				case PositionStatus.NoData:
+					error = GeolocationError.PositionUnavailable;
+					break;
+
+				default:
+					return;
+			}
+
+			OnLocationError(error);
+		}
 	}
 }
diff --git a/src/Essentials/src/Geolocation/GeolocationAccuracyExtensionMethods.ios.macos.cs b/src/Essentials/src/Geolocation/GeolocationAccuracyExtensionMethods.ios.macos.cs
new file mode 100644
index 000000000000..be42c328cf9a
--- /dev/null
+++ b/src/Essentials/src/Geolocation/GeolocationAccuracyExtensionMethods.ios.macos.cs
@@ -0,0 +1,28 @@
+#nullable enable
+using CoreLocation;
+
+namespace Microsoft.Maui.Devices.Sensors
+{
+	static class GeolocationAccuracyExtensionMethods
+	{
+		internal static double PlatformDesiredAccuracy(this GeolocationAccuracy desiredAccuracy)
+		{
+			switch (desiredAccuracy)
+			{
+				case GeolocationAccuracy.Lowest:
+					return CLLocation.AccuracyThreeKilometers;
+				case GeolocationAccuracy.Low:
+					return CLLocation.AccuracyKilometer;
+				case GeolocationAccuracy.Default:
+				case GeolocationAccuracy.Medium:
+					return CLLocation.AccuracyHundredMeters;
+				case GeolocationAccuracy.High:
+					return CLLocation.AccuracyNearestTenMeters;
+				case GeolocationAccuracy.Best:
+					return CLLocation.AccurracyBestForNavigation;
+				default:
+					return CLLocation.AccuracyHundredMeters;
+			}
+		}
+	}
+}
diff --git a/src/Essentials/src/Geolocation/GeolocationAccuracyExtensionMethods.uwp.cs b/src/Essentials/src/Geolocation/GeolocationAccuracyExtensionMethods.uwp.cs
new file mode 100644
index 000000000000..aa5bad7d6e05
--- /dev/null
+++ b/src/Essentials/src/Geolocation/GeolocationAccuracyExtensionMethods.uwp.cs
@@ -0,0 +1,25 @@
+namespace Microsoft.Maui.Devices.Sensors
+{
+	static class GeolocationAccuracyExtensionMethods
+	{
+		internal static uint PlatformGetDesiredAccuracy(this GeolocationAccuracy desiredAccuracy)
+		{
+			switch (desiredAccuracy)
+			{
+				case GeolocationAccuracy.Lowest:
+					return 3000;
+				case GeolocationAccuracy.Low:
+					return 1000;
+				case GeolocationAccuracy.Default:
+				case GeolocationAccuracy.Medium:
+					return 100;
+				case GeolocationAccuracy.High:
+					return 10; // Equivalent to PositionAccuracy.High
+				case GeolocationAccuracy.Best:
+					return 1;
+				default:
+					return 500; // Equivalent to PositionAccuracy.Default
+			}
+		}
+	}
+}
diff --git a/src/Essentials/src/Geolocation/GeolocationError.shared.cs b/src/Essentials/src/Geolocation/GeolocationError.shared.cs
new file mode 100644
index 000000000000..5008f4660953
--- /dev/null
+++ b/src/Essentials/src/Geolocation/GeolocationError.shared.cs
@@ -0,0 +1,30 @@
+#nullable enable
+
+namespace Microsoft.Maui.Devices.Sensors
+{
+	/// <summary>
+	/// Error values for listening for geolocation changes
+	/// </summary>
+	public enum GeolocationError
+	{
+		/// <summary>
+		/// The provider was unable to retrieve any position data.
+		/// </summary>
+		/// <remarks>
+		/// Android: Sent when no location provider is available that satisfies the requested geolocation accuracy.
+		/// iOS: Getting location data has failed.
+		/// Windows: No location data is available from any source.
+		/// </remarks>
+		PositionUnavailable,
+
+		/// <summary>
+		/// The app is not, or no longer, authorized to receive location data.
+		/// </summary>
+		/// <remarks>
+		/// Android: Not used.
+		/// iOS: Authorization for getting locations has changed.
+		/// Windows: Location sources are turned off.
+		/// </remarks>
+		Unauthorized,
+	}
+}
\ No newline at end of file
diff --git a/src/Essentials/src/Geolocation/GeolocationListeningFailedEventArgs.shared.cs b/src/Essentials/src/Geolocation/GeolocationListeningFailedEventArgs.shared.cs
new file mode 100644
index 000000000000..f32ca843d6c3
--- /dev/null
+++ b/src/Essentials/src/Geolocation/GeolocationListeningFailedEventArgs.shared.cs
@@ -0,0 +1,25 @@
+#nullable enable
+using System;
+
+namespace Microsoft.Maui.Devices.Sensors
+{
+	/// <summary>
+	/// Event args for the geolocation listening error event.
+	/// </summary>
+	public class GeolocationListeningFailedEventArgs : EventArgs
+	{
+		/// <summary>
+		/// The geolocation error that describes the error that occurred.
+		/// </summary>
+		public GeolocationError Error { get; }
+
+		/// <summary>
+		/// Creates a new geolocation error event args object
+		/// </summary>
+		/// <param name="geolocationError">gelocation error to use for this object</param>
+		public GeolocationListeningFailedEventArgs(GeolocationError geolocationError)
+		{
+			Error = geolocationError;
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Essentials/src/Geolocation/GeolocationListeningRequest.ios.macos.cs b/src/Essentials/src/Geolocation/GeolocationListeningRequest.ios.macos.cs
new file mode 100644
index 000000000000..2bfa09596819
--- /dev/null
+++ b/src/Essentials/src/Geolocation/GeolocationListeningRequest.ios.macos.cs
@@ -0,0 +1,15 @@
+#nullable enable
+
+namespace Microsoft.Maui.Devices.Sensors
+{
+	public partial class GeolocationListeningRequest
+	{
+		internal double PlatformDesiredAccuracy
+		{
+			get
+			{
+				return DesiredAccuracy.PlatformDesiredAccuracy();
+			}
+		}
+	}
+}
diff --git a/src/Essentials/src/Geolocation/GeolocationListeningRequest.shared.cs b/src/Essentials/src/Geolocation/GeolocationListeningRequest.shared.cs
new file mode 100644
index 000000000000..7420ca575551
--- /dev/null
+++ b/src/Essentials/src/Geolocation/GeolocationListeningRequest.shared.cs
@@ -0,0 +1,51 @@
+#nullable enable
+using System;
+
+namespace Microsoft.Maui.Devices.Sensors
+{
+	/// <summary>
+	/// Request options for listening to geolocations
+	/// </summary>
+	public partial class GeolocationListeningRequest
+	{
+		/// <summary>
+		/// Creates a new request object with default values
+		/// </summary>
+		public GeolocationListeningRequest()
+			: this(GeolocationAccuracy.Default)
+		{
+		}
+
+		/// <summary>
+		/// Creates a new request object with given accuracy.
+		/// </summary>
+		/// <param name="accuracy">The desired geolocation accuracy.</param>
+		public GeolocationListeningRequest(GeolocationAccuracy accuracy)
+			: this(accuracy, TimeSpan.FromSeconds(1))
+		{
+		}
+
+		/// <summary>
+		/// Creates a new request object with given accuracy and minimum time.
+		/// </summary>
+		/// <param name="accuracy">The desired geolocation accuracy.</param>
+		/// <param name="minimumTime">The minimum time between location updates being sent.</param>
+		public GeolocationListeningRequest(GeolocationAccuracy accuracy, TimeSpan minimumTime)
+		{
+			DesiredAccuracy = accuracy;
+			MinimumTime = minimumTime;
+		}
+
+		/// <summary>
+		/// Minimum time between location updates being sent. This value must positive. Most location
+		/// sensors may not return locations in intervals shorter than 1 second.
+		/// </summary>
+		public TimeSpan MinimumTime { get; set; } = TimeSpan.FromSeconds(1);
+
+		/// <summary>
+		/// The desired minimum accuracy for the location updates being sent. Locations that don't
+		/// satisfy this accuracy are not sent using the event handler.
+		/// </summary>
+		public GeolocationAccuracy DesiredAccuracy { get; set; } = GeolocationAccuracy.Default;
+	}
+}
diff --git a/src/Essentials/src/Geolocation/GeolocationListeningRequest.uwp.cs b/src/Essentials/src/Geolocation/GeolocationListeningRequest.uwp.cs
new file mode 100644
index 000000000000..d6b276d792e1
--- /dev/null
+++ b/src/Essentials/src/Geolocation/GeolocationListeningRequest.uwp.cs
@@ -0,0 +1,15 @@
+#nullable enable
+
+namespace Microsoft.Maui.Devices.Sensors
+{
+	public partial class GeolocationListeningRequest
+	{
+		internal uint PlatformDesiredAccuracy
+		{
+			get
+			{
+				return DesiredAccuracy.PlatformGetDesiredAccuracy();
+			}
+		}
+	}
+}
diff --git a/src/Essentials/src/Geolocation/GeolocationLocationChangedEventArgs.shared.cs b/src/Essentials/src/Geolocation/GeolocationLocationChangedEventArgs.shared.cs
new file mode 100644
index 000000000000..4cb3f8bb6f06
--- /dev/null
+++ b/src/Essentials/src/Geolocation/GeolocationLocationChangedEventArgs.shared.cs
@@ -0,0 +1,18 @@
+#nullable enable
+using System;
+
+namespace Microsoft.Maui.Devices.Sensors
+{
+	public class GeolocationLocationChangedEventArgs : EventArgs
+	{
+		public Location Location { get; }
+
+		public GeolocationLocationChangedEventArgs(Location location)
+		{
+			if (location == null)
+				throw new ArgumentNullException(nameof(location));
+
+			Location = location;
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Essentials/src/Geolocation/GeolocationRequest.ios.macos.cs b/src/Essentials/src/Geolocation/GeolocationRequest.ios.macos.cs
index a6a96532e782..616cffec59a9 100644
--- a/src/Essentials/src/Geolocation/GeolocationRequest.ios.macos.cs
+++ b/src/Essentials/src/Geolocation/GeolocationRequest.ios.macos.cs
@@ -1,7 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using CoreLocation;
+#nullable enable
 
 namespace Microsoft.Maui.Devices.Sensors
 {
@@ -11,22 +8,7 @@ internal double PlatformDesiredAccuracy
 		{
 			get
 			{
-				switch (DesiredAccuracy)
-				{
-					case GeolocationAccuracy.Lowest:
-						return CLLocation.AccuracyThreeKilometers;
-					case GeolocationAccuracy.Low:
-						return CLLocation.AccuracyKilometer;
-					case GeolocationAccuracy.Default:
-					case GeolocationAccuracy.Medium:
-						return CLLocation.AccuracyHundredMeters;
-					case GeolocationAccuracy.High:
-						return CLLocation.AccuracyNearestTenMeters;
-					case GeolocationAccuracy.Best:
-						return CLLocation.AccurracyBestForNavigation;
-					default:
-						return CLLocation.AccuracyHundredMeters;
-				}
+				return DesiredAccuracy.PlatformDesiredAccuracy();
 			}
 		}
 	}
diff --git a/src/Essentials/src/Geolocation/GeolocationRequest.uwp.cs b/src/Essentials/src/Geolocation/GeolocationRequest.uwp.cs
index f4670c35d0b2..c35c2605fad3 100644
--- a/src/Essentials/src/Geolocation/GeolocationRequest.uwp.cs
+++ b/src/Essentials/src/Geolocation/GeolocationRequest.uwp.cs
@@ -1,7 +1,3 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
 namespace Microsoft.Maui.Devices.Sensors
 {
 	public partial class GeolocationRequest
@@ -10,22 +6,7 @@ internal uint PlatformDesiredAccuracy
 		{
 			get
 			{
-				switch (DesiredAccuracy)
-				{
-					case GeolocationAccuracy.Lowest:
-						return 3000;
-					case GeolocationAccuracy.Low:
-						return 1000;
-					case GeolocationAccuracy.Default:
-					case GeolocationAccuracy.Medium:
-						return 100;
-					case GeolocationAccuracy.High:
-						return 10; // Equivalent to PositionAccuracy.High
-					case GeolocationAccuracy.Best:
-						return 1;
-					default:
-						return 500; // Equivalent to PositionAccuracy.Default
-				}
+				return DesiredAccuracy.PlatformGetDesiredAccuracy();
 			}
 		}
 	}
diff --git a/src/Essentials/src/PublicAPI/net-android/PublicAPI.Unshipped.txt b/src/Essentials/src/PublicAPI/net-android/PublicAPI.Unshipped.txt
index 59a09cb0ab11..c64aedf4601a 100644
--- a/src/Essentials/src/PublicAPI/net-android/PublicAPI.Unshipped.txt
+++ b/src/Essentials/src/PublicAPI/net-android/PublicAPI.Unshipped.txt
@@ -7,6 +7,33 @@ Microsoft.Maui.Authentication.WebAuthenticatorOptions.ResponseDecoder.set -> voi
 ~Microsoft.Maui.Authentication.WebAuthenticatorResult.WebAuthenticatorResult(System.Uri uri, Microsoft.Maui.Authentication.IWebAuthenticatorResponseDecoder responseDecoder) -> void
 *REMOVED*Microsoft.Maui.Storage.ISecureStorage.GetAsync(string! key) -> System.Threading.Tasks.Task<string!>!
 *REMOVED*static Microsoft.Maui.Storage.SecureStorage.GetAsync(string! key) -> System.Threading.Tasks.Task<string!>!
+Microsoft.Maui.Devices.Sensors.GeolocationError
+Microsoft.Maui.Devices.Sensors.GeolocationError.PositionUnavailable = 0 -> Microsoft.Maui.Devices.Sensors.GeolocationError
+Microsoft.Maui.Devices.Sensors.GeolocationError.Unauthorized = 1 -> Microsoft.Maui.Devices.Sensors.GeolocationError
+Microsoft.Maui.Devices.Sensors.GeolocationListeningFailedEventArgs
+Microsoft.Maui.Devices.Sensors.GeolocationListeningFailedEventArgs.Error.get -> Microsoft.Maui.Devices.Sensors.GeolocationError
+Microsoft.Maui.Devices.Sensors.GeolocationListeningFailedEventArgs.GeolocationListeningFailedEventArgs(Microsoft.Maui.Devices.Sensors.GeolocationError geolocationError) -> void
+Microsoft.Maui.Devices.Sensors.IGeolocation.ListeningFailed -> System.EventHandler<Microsoft.Maui.Devices.Sensors.GeolocationListeningFailedEventArgs!>?
 Microsoft.Maui.Storage.ISecureStorage.GetAsync(string! key) -> System.Threading.Tasks.Task<string?>!
+static Microsoft.Maui.Devices.Sensors.Geolocation.ListeningFailed -> System.EventHandler<Microsoft.Maui.Devices.Sensors.GeolocationListeningFailedEventArgs!>!
 static Microsoft.Maui.Storage.SecureStorage.GetAsync(string! key) -> System.Threading.Tasks.Task<string?>!
-*REMOVED*static Microsoft.Maui.ApplicationModel.Communication.PhoneDialer.Current.get -> Microsoft.Maui.ApplicationModel.Communication.IPhoneDialer!
\ No newline at end of file
+Microsoft.Maui.Devices.Sensors.IGeolocation.IsListeningForeground.get -> bool
+Microsoft.Maui.Devices.Sensors.IGeolocation.LocationChanged -> System.EventHandler<Microsoft.Maui.Devices.Sensors.GeolocationLocationChangedEventArgs!>?
+Microsoft.Maui.Devices.Sensors.IGeolocation.StartListeningForegroundAsync(Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest! request) -> System.Threading.Tasks.Task<bool>!
+Microsoft.Maui.Devices.Sensors.IGeolocation.StopListeningForeground() -> void
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.DesiredAccuracy.get -> Microsoft.Maui.Devices.Sensors.GeolocationAccuracy
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.DesiredAccuracy.set -> void
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.GeolocationListeningRequest() -> void
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.GeolocationListeningRequest(Microsoft.Maui.Devices.Sensors.GeolocationAccuracy accuracy) -> void
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.GeolocationListeningRequest(Microsoft.Maui.Devices.Sensors.GeolocationAccuracy accuracy, System.TimeSpan minimumTime) -> void
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.MinimumTime.get -> System.TimeSpan
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.MinimumTime.set -> void
+Microsoft.Maui.Devices.Sensors.GeolocationLocationChangedEventArgs
+Microsoft.Maui.Devices.Sensors.GeolocationLocationChangedEventArgs.Location.get -> Microsoft.Maui.Devices.Sensors.Location!
+Microsoft.Maui.Devices.Sensors.GeolocationLocationChangedEventArgs.GeolocationLocationChangedEventArgs(Microsoft.Maui.Devices.Sensors.Location! location) -> void
+static Microsoft.Maui.Devices.Sensors.Geolocation.IsListeningForeground.get -> bool
+static Microsoft.Maui.Devices.Sensors.Geolocation.LocationChanged -> System.EventHandler<Microsoft.Maui.Devices.Sensors.GeolocationLocationChangedEventArgs!>!
+static Microsoft.Maui.Devices.Sensors.Geolocation.StartListeningForegroundAsync(Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest! request) -> System.Threading.Tasks.Task<bool>!
+static Microsoft.Maui.Devices.Sensors.Geolocation.StopListeningForeground() -> void
+*REMOVED*static Microsoft.Maui.ApplicationModel.Communication.PhoneDialer.Current.get -> Microsoft.Maui.ApplicationModel.Communication.IPhoneDialer!
diff --git a/src/Essentials/src/PublicAPI/net-ios/PublicAPI.Unshipped.txt b/src/Essentials/src/PublicAPI/net-ios/PublicAPI.Unshipped.txt
index 59a09cb0ab11..c64aedf4601a 100644
--- a/src/Essentials/src/PublicAPI/net-ios/PublicAPI.Unshipped.txt
+++ b/src/Essentials/src/PublicAPI/net-ios/PublicAPI.Unshipped.txt
@@ -7,6 +7,33 @@ Microsoft.Maui.Authentication.WebAuthenticatorOptions.ResponseDecoder.set -> voi
 ~Microsoft.Maui.Authentication.WebAuthenticatorResult.WebAuthenticatorResult(System.Uri uri, Microsoft.Maui.Authentication.IWebAuthenticatorResponseDecoder responseDecoder) -> void
 *REMOVED*Microsoft.Maui.Storage.ISecureStorage.GetAsync(string! key) -> System.Threading.Tasks.Task<string!>!
 *REMOVED*static Microsoft.Maui.Storage.SecureStorage.GetAsync(string! key) -> System.Threading.Tasks.Task<string!>!
+Microsoft.Maui.Devices.Sensors.GeolocationError
+Microsoft.Maui.Devices.Sensors.GeolocationError.PositionUnavailable = 0 -> Microsoft.Maui.Devices.Sensors.GeolocationError
+Microsoft.Maui.Devices.Sensors.GeolocationError.Unauthorized = 1 -> Microsoft.Maui.Devices.Sensors.GeolocationError
+Microsoft.Maui.Devices.Sensors.GeolocationListeningFailedEventArgs
+Microsoft.Maui.Devices.Sensors.GeolocationListeningFailedEventArgs.Error.get -> Microsoft.Maui.Devices.Sensors.GeolocationError
+Microsoft.Maui.Devices.Sensors.GeolocationListeningFailedEventArgs.GeolocationListeningFailedEventArgs(Microsoft.Maui.Devices.Sensors.GeolocationError geolocationError) -> void
+Microsoft.Maui.Devices.Sensors.IGeolocation.ListeningFailed -> System.EventHandler<Microsoft.Maui.Devices.Sensors.GeolocationListeningFailedEventArgs!>?
 Microsoft.Maui.Storage.ISecureStorage.GetAsync(string! key) -> System.Threading.Tasks.Task<string?>!
+static Microsoft.Maui.Devices.Sensors.Geolocation.ListeningFailed -> System.EventHandler<Microsoft.Maui.Devices.Sensors.GeolocationListeningFailedEventArgs!>!
 static Microsoft.Maui.Storage.SecureStorage.GetAsync(string! key) -> System.Threading.Tasks.Task<string?>!
-*REMOVED*static Microsoft.Maui.ApplicationModel.Communication.PhoneDialer.Current.get -> Microsoft.Maui.ApplicationModel.Communication.IPhoneDialer!
\ No newline at end of file
+Microsoft.Maui.Devices.Sensors.IGeolocation.IsListeningForeground.get -> bool
+Microsoft.Maui.Devices.Sensors.IGeolocation.LocationChanged -> System.EventHandler<Microsoft.Maui.Devices.Sensors.GeolocationLocationChangedEventArgs!>?
+Microsoft.Maui.Devices.Sensors.IGeolocation.StartListeningForegroundAsync(Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest! request) -> System.Threading.Tasks.Task<bool>!
+Microsoft.Maui.Devices.Sensors.IGeolocation.StopListeningForeground() -> void
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.DesiredAccuracy.get -> Microsoft.Maui.Devices.Sensors.GeolocationAccuracy
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.DesiredAccuracy.set -> void
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.GeolocationListeningRequest() -> void
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.GeolocationListeningRequest(Microsoft.Maui.Devices.Sensors.GeolocationAccuracy accuracy) -> void
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.GeolocationListeningRequest(Microsoft.Maui.Devices.Sensors.GeolocationAccuracy accuracy, System.TimeSpan minimumTime) -> void
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.MinimumTime.get -> System.TimeSpan
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.MinimumTime.set -> void
+Microsoft.Maui.Devices.Sensors.GeolocationLocationChangedEventArgs
+Microsoft.Maui.Devices.Sensors.GeolocationLocationChangedEventArgs.Location.get -> Microsoft.Maui.Devices.Sensors.Location!
+Microsoft.Maui.Devices.Sensors.GeolocationLocationChangedEventArgs.GeolocationLocationChangedEventArgs(Microsoft.Maui.Devices.Sensors.Location! location) -> void
+static Microsoft.Maui.Devices.Sensors.Geolocation.IsListeningForeground.get -> bool
+static Microsoft.Maui.Devices.Sensors.Geolocation.LocationChanged -> System.EventHandler<Microsoft.Maui.Devices.Sensors.GeolocationLocationChangedEventArgs!>!
+static Microsoft.Maui.Devices.Sensors.Geolocation.StartListeningForegroundAsync(Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest! request) -> System.Threading.Tasks.Task<bool>!
+static Microsoft.Maui.Devices.Sensors.Geolocation.StopListeningForeground() -> void
+*REMOVED*static Microsoft.Maui.ApplicationModel.Communication.PhoneDialer.Current.get -> Microsoft.Maui.ApplicationModel.Communication.IPhoneDialer!
diff --git a/src/Essentials/src/PublicAPI/net-maccatalyst/PublicAPI.Unshipped.txt b/src/Essentials/src/PublicAPI/net-maccatalyst/PublicAPI.Unshipped.txt
index 59a09cb0ab11..c64aedf4601a 100644
--- a/src/Essentials/src/PublicAPI/net-maccatalyst/PublicAPI.Unshipped.txt
+++ b/src/Essentials/src/PublicAPI/net-maccatalyst/PublicAPI.Unshipped.txt
@@ -7,6 +7,33 @@ Microsoft.Maui.Authentication.WebAuthenticatorOptions.ResponseDecoder.set -> voi
 ~Microsoft.Maui.Authentication.WebAuthenticatorResult.WebAuthenticatorResult(System.Uri uri, Microsoft.Maui.Authentication.IWebAuthenticatorResponseDecoder responseDecoder) -> void
 *REMOVED*Microsoft.Maui.Storage.ISecureStorage.GetAsync(string! key) -> System.Threading.Tasks.Task<string!>!
 *REMOVED*static Microsoft.Maui.Storage.SecureStorage.GetAsync(string! key) -> System.Threading.Tasks.Task<string!>!
+Microsoft.Maui.Devices.Sensors.GeolocationError
+Microsoft.Maui.Devices.Sensors.GeolocationError.PositionUnavailable = 0 -> Microsoft.Maui.Devices.Sensors.GeolocationError
+Microsoft.Maui.Devices.Sensors.GeolocationError.Unauthorized = 1 -> Microsoft.Maui.Devices.Sensors.GeolocationError
+Microsoft.Maui.Devices.Sensors.GeolocationListeningFailedEventArgs
+Microsoft.Maui.Devices.Sensors.GeolocationListeningFailedEventArgs.Error.get -> Microsoft.Maui.Devices.Sensors.GeolocationError
+Microsoft.Maui.Devices.Sensors.GeolocationListeningFailedEventArgs.GeolocationListeningFailedEventArgs(Microsoft.Maui.Devices.Sensors.GeolocationError geolocationError) -> void
+Microsoft.Maui.Devices.Sensors.IGeolocation.ListeningFailed -> System.EventHandler<Microsoft.Maui.Devices.Sensors.GeolocationListeningFailedEventArgs!>?
 Microsoft.Maui.Storage.ISecureStorage.GetAsync(string! key) -> System.Threading.Tasks.Task<string?>!
+static Microsoft.Maui.Devices.Sensors.Geolocation.ListeningFailed -> System.EventHandler<Microsoft.Maui.Devices.Sensors.GeolocationListeningFailedEventArgs!>!
 static Microsoft.Maui.Storage.SecureStorage.GetAsync(string! key) -> System.Threading.Tasks.Task<string?>!
-*REMOVED*static Microsoft.Maui.ApplicationModel.Communication.PhoneDialer.Current.get -> Microsoft.Maui.ApplicationModel.Communication.IPhoneDialer!
\ No newline at end of file
+Microsoft.Maui.Devices.Sensors.IGeolocation.IsListeningForeground.get -> bool
+Microsoft.Maui.Devices.Sensors.IGeolocation.LocationChanged -> System.EventHandler<Microsoft.Maui.Devices.Sensors.GeolocationLocationChangedEventArgs!>?
+Microsoft.Maui.Devices.Sensors.IGeolocation.StartListeningForegroundAsync(Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest! request) -> System.Threading.Tasks.Task<bool>!
+Microsoft.Maui.Devices.Sensors.IGeolocation.StopListeningForeground() -> void
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.DesiredAccuracy.get -> Microsoft.Maui.Devices.Sensors.GeolocationAccuracy
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.DesiredAccuracy.set -> void
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.GeolocationListeningRequest() -> void
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.GeolocationListeningRequest(Microsoft.Maui.Devices.Sensors.GeolocationAccuracy accuracy) -> void
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.GeolocationListeningRequest(Microsoft.Maui.Devices.Sensors.GeolocationAccuracy accuracy, System.TimeSpan minimumTime) -> void
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.MinimumTime.get -> System.TimeSpan
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.MinimumTime.set -> void
+Microsoft.Maui.Devices.Sensors.GeolocationLocationChangedEventArgs
+Microsoft.Maui.Devices.Sensors.GeolocationLocationChangedEventArgs.Location.get -> Microsoft.Maui.Devices.Sensors.Location!
+Microsoft.Maui.Devices.Sensors.GeolocationLocationChangedEventArgs.GeolocationLocationChangedEventArgs(Microsoft.Maui.Devices.Sensors.Location! location) -> void
+static Microsoft.Maui.Devices.Sensors.Geolocation.IsListeningForeground.get -> bool
+static Microsoft.Maui.Devices.Sensors.Geolocation.LocationChanged -> System.EventHandler<Microsoft.Maui.Devices.Sensors.GeolocationLocationChangedEventArgs!>!
+static Microsoft.Maui.Devices.Sensors.Geolocation.StartListeningForegroundAsync(Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest! request) -> System.Threading.Tasks.Task<bool>!
+static Microsoft.Maui.Devices.Sensors.Geolocation.StopListeningForeground() -> void
+*REMOVED*static Microsoft.Maui.ApplicationModel.Communication.PhoneDialer.Current.get -> Microsoft.Maui.ApplicationModel.Communication.IPhoneDialer!
diff --git a/src/Essentials/src/PublicAPI/net-tizen/PublicAPI.Unshipped.txt b/src/Essentials/src/PublicAPI/net-tizen/PublicAPI.Unshipped.txt
index 59a09cb0ab11..c64aedf4601a 100644
--- a/src/Essentials/src/PublicAPI/net-tizen/PublicAPI.Unshipped.txt
+++ b/src/Essentials/src/PublicAPI/net-tizen/PublicAPI.Unshipped.txt
@@ -7,6 +7,33 @@ Microsoft.Maui.Authentication.WebAuthenticatorOptions.ResponseDecoder.set -> voi
 ~Microsoft.Maui.Authentication.WebAuthenticatorResult.WebAuthenticatorResult(System.Uri uri, Microsoft.Maui.Authentication.IWebAuthenticatorResponseDecoder responseDecoder) -> void
 *REMOVED*Microsoft.Maui.Storage.ISecureStorage.GetAsync(string! key) -> System.Threading.Tasks.Task<string!>!
 *REMOVED*static Microsoft.Maui.Storage.SecureStorage.GetAsync(string! key) -> System.Threading.Tasks.Task<string!>!
+Microsoft.Maui.Devices.Sensors.GeolocationError
+Microsoft.Maui.Devices.Sensors.GeolocationError.PositionUnavailable = 0 -> Microsoft.Maui.Devices.Sensors.GeolocationError
+Microsoft.Maui.Devices.Sensors.GeolocationError.Unauthorized = 1 -> Microsoft.Maui.Devices.Sensors.GeolocationError
+Microsoft.Maui.Devices.Sensors.GeolocationListeningFailedEventArgs
+Microsoft.Maui.Devices.Sensors.GeolocationListeningFailedEventArgs.Error.get -> Microsoft.Maui.Devices.Sensors.GeolocationError
+Microsoft.Maui.Devices.Sensors.GeolocationListeningFailedEventArgs.GeolocationListeningFailedEventArgs(Microsoft.Maui.Devices.Sensors.GeolocationError geolocationError) -> void
+Microsoft.Maui.Devices.Sensors.IGeolocation.ListeningFailed -> System.EventHandler<Microsoft.Maui.Devices.Sensors.GeolocationListeningFailedEventArgs!>?
 Microsoft.Maui.Storage.ISecureStorage.GetAsync(string! key) -> System.Threading.Tasks.Task<string?>!
+static Microsoft.Maui.Devices.Sensors.Geolocation.ListeningFailed -> System.EventHandler<Microsoft.Maui.Devices.Sensors.GeolocationListeningFailedEventArgs!>!
 static Microsoft.Maui.Storage.SecureStorage.GetAsync(string! key) -> System.Threading.Tasks.Task<string?>!
-*REMOVED*static Microsoft.Maui.ApplicationModel.Communication.PhoneDialer.Current.get -> Microsoft.Maui.ApplicationModel.Communication.IPhoneDialer!
\ No newline at end of file
+Microsoft.Maui.Devices.Sensors.IGeolocation.IsListeningForeground.get -> bool
+Microsoft.Maui.Devices.Sensors.IGeolocation.LocationChanged -> System.EventHandler<Microsoft.Maui.Devices.Sensors.GeolocationLocationChangedEventArgs!>?
+Microsoft.Maui.Devices.Sensors.IGeolocation.StartListeningForegroundAsync(Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest! request) -> System.Threading.Tasks.Task<bool>!
+Microsoft.Maui.Devices.Sensors.IGeolocation.StopListeningForeground() -> void
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.DesiredAccuracy.get -> Microsoft.Maui.Devices.Sensors.GeolocationAccuracy
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.DesiredAccuracy.set -> void
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.GeolocationListeningRequest() -> void
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.GeolocationListeningRequest(Microsoft.Maui.Devices.Sensors.GeolocationAccuracy accuracy) -> void
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.GeolocationListeningRequest(Microsoft.Maui.Devices.Sensors.GeolocationAccuracy accuracy, System.TimeSpan minimumTime) -> void
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.MinimumTime.get -> System.TimeSpan
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.MinimumTime.set -> void
+Microsoft.Maui.Devices.Sensors.GeolocationLocationChangedEventArgs
+Microsoft.Maui.Devices.Sensors.GeolocationLocationChangedEventArgs.Location.get -> Microsoft.Maui.Devices.Sensors.Location!
+Microsoft.Maui.Devices.Sensors.GeolocationLocationChangedEventArgs.GeolocationLocationChangedEventArgs(Microsoft.Maui.Devices.Sensors.Location! location) -> void
+static Microsoft.Maui.Devices.Sensors.Geolocation.IsListeningForeground.get -> bool
+static Microsoft.Maui.Devices.Sensors.Geolocation.LocationChanged -> System.EventHandler<Microsoft.Maui.Devices.Sensors.GeolocationLocationChangedEventArgs!>!
+static Microsoft.Maui.Devices.Sensors.Geolocation.StartListeningForegroundAsync(Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest! request) -> System.Threading.Tasks.Task<bool>!
+static Microsoft.Maui.Devices.Sensors.Geolocation.StopListeningForeground() -> void
+*REMOVED*static Microsoft.Maui.ApplicationModel.Communication.PhoneDialer.Current.get -> Microsoft.Maui.ApplicationModel.Communication.IPhoneDialer!
diff --git a/src/Essentials/src/PublicAPI/net-windows/PublicAPI.Unshipped.txt b/src/Essentials/src/PublicAPI/net-windows/PublicAPI.Unshipped.txt
index 59a09cb0ab11..c64aedf4601a 100644
--- a/src/Essentials/src/PublicAPI/net-windows/PublicAPI.Unshipped.txt
+++ b/src/Essentials/src/PublicAPI/net-windows/PublicAPI.Unshipped.txt
@@ -7,6 +7,33 @@ Microsoft.Maui.Authentication.WebAuthenticatorOptions.ResponseDecoder.set -> voi
 ~Microsoft.Maui.Authentication.WebAuthenticatorResult.WebAuthenticatorResult(System.Uri uri, Microsoft.Maui.Authentication.IWebAuthenticatorResponseDecoder responseDecoder) -> void
 *REMOVED*Microsoft.Maui.Storage.ISecureStorage.GetAsync(string! key) -> System.Threading.Tasks.Task<string!>!
 *REMOVED*static Microsoft.Maui.Storage.SecureStorage.GetAsync(string! key) -> System.Threading.Tasks.Task<string!>!
+Microsoft.Maui.Devices.Sensors.GeolocationError
+Microsoft.Maui.Devices.Sensors.GeolocationError.PositionUnavailable = 0 -> Microsoft.Maui.Devices.Sensors.GeolocationError
+Microsoft.Maui.Devices.Sensors.GeolocationError.Unauthorized = 1 -> Microsoft.Maui.Devices.Sensors.GeolocationError
+Microsoft.Maui.Devices.Sensors.GeolocationListeningFailedEventArgs
+Microsoft.Maui.Devices.Sensors.GeolocationListeningFailedEventArgs.Error.get -> Microsoft.Maui.Devices.Sensors.GeolocationError
+Microsoft.Maui.Devices.Sensors.GeolocationListeningFailedEventArgs.GeolocationListeningFailedEventArgs(Microsoft.Maui.Devices.Sensors.GeolocationError geolocationError) -> void
+Microsoft.Maui.Devices.Sensors.IGeolocation.ListeningFailed -> System.EventHandler<Microsoft.Maui.Devices.Sensors.GeolocationListeningFailedEventArgs!>?
 Microsoft.Maui.Storage.ISecureStorage.GetAsync(string! key) -> System.Threading.Tasks.Task<string?>!
+static Microsoft.Maui.Devices.Sensors.Geolocation.ListeningFailed -> System.EventHandler<Microsoft.Maui.Devices.Sensors.GeolocationListeningFailedEventArgs!>!
 static Microsoft.Maui.Storage.SecureStorage.GetAsync(string! key) -> System.Threading.Tasks.Task<string?>!
-*REMOVED*static Microsoft.Maui.ApplicationModel.Communication.PhoneDialer.Current.get -> Microsoft.Maui.ApplicationModel.Communication.IPhoneDialer!
\ No newline at end of file
+Microsoft.Maui.Devices.Sensors.IGeolocation.IsListeningForeground.get -> bool
+Microsoft.Maui.Devices.Sensors.IGeolocation.LocationChanged -> System.EventHandler<Microsoft.Maui.Devices.Sensors.GeolocationLocationChangedEventArgs!>?
+Microsoft.Maui.Devices.Sensors.IGeolocation.StartListeningForegroundAsync(Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest! request) -> System.Threading.Tasks.Task<bool>!
+Microsoft.Maui.Devices.Sensors.IGeolocation.StopListeningForeground() -> void
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.DesiredAccuracy.get -> Microsoft.Maui.Devices.Sensors.GeolocationAccuracy
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.DesiredAccuracy.set -> void
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.GeolocationListeningRequest() -> void
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.GeolocationListeningRequest(Microsoft.Maui.Devices.Sensors.GeolocationAccuracy accuracy) -> void
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.GeolocationListeningRequest(Microsoft.Maui.Devices.Sensors.GeolocationAccuracy accuracy, System.TimeSpan minimumTime) -> void
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.MinimumTime.get -> System.TimeSpan
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.MinimumTime.set -> void
+Microsoft.Maui.Devices.Sensors.GeolocationLocationChangedEventArgs
+Microsoft.Maui.Devices.Sensors.GeolocationLocationChangedEventArgs.Location.get -> Microsoft.Maui.Devices.Sensors.Location!
+Microsoft.Maui.Devices.Sensors.GeolocationLocationChangedEventArgs.GeolocationLocationChangedEventArgs(Microsoft.Maui.Devices.Sensors.Location! location) -> void
+static Microsoft.Maui.Devices.Sensors.Geolocation.IsListeningForeground.get -> bool
+static Microsoft.Maui.Devices.Sensors.Geolocation.LocationChanged -> System.EventHandler<Microsoft.Maui.Devices.Sensors.GeolocationLocationChangedEventArgs!>!
+static Microsoft.Maui.Devices.Sensors.Geolocation.StartListeningForegroundAsync(Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest! request) -> System.Threading.Tasks.Task<bool>!
+static Microsoft.Maui.Devices.Sensors.Geolocation.StopListeningForeground() -> void
+*REMOVED*static Microsoft.Maui.ApplicationModel.Communication.PhoneDialer.Current.get -> Microsoft.Maui.ApplicationModel.Communication.IPhoneDialer!
diff --git a/src/Essentials/src/PublicAPI/net/PublicAPI.Unshipped.txt b/src/Essentials/src/PublicAPI/net/PublicAPI.Unshipped.txt
index b47dafce2fc3..c64aedf4601a 100644
--- a/src/Essentials/src/PublicAPI/net/PublicAPI.Unshipped.txt
+++ b/src/Essentials/src/PublicAPI/net/PublicAPI.Unshipped.txt
@@ -7,6 +7,33 @@ Microsoft.Maui.Authentication.WebAuthenticatorOptions.ResponseDecoder.set -> voi
 ~Microsoft.Maui.Authentication.WebAuthenticatorResult.WebAuthenticatorResult(System.Uri uri, Microsoft.Maui.Authentication.IWebAuthenticatorResponseDecoder responseDecoder) -> void
 *REMOVED*Microsoft.Maui.Storage.ISecureStorage.GetAsync(string! key) -> System.Threading.Tasks.Task<string!>!
 *REMOVED*static Microsoft.Maui.Storage.SecureStorage.GetAsync(string! key) -> System.Threading.Tasks.Task<string!>!
+Microsoft.Maui.Devices.Sensors.GeolocationError
+Microsoft.Maui.Devices.Sensors.GeolocationError.PositionUnavailable = 0 -> Microsoft.Maui.Devices.Sensors.GeolocationError
+Microsoft.Maui.Devices.Sensors.GeolocationError.Unauthorized = 1 -> Microsoft.Maui.Devices.Sensors.GeolocationError
+Microsoft.Maui.Devices.Sensors.GeolocationListeningFailedEventArgs
+Microsoft.Maui.Devices.Sensors.GeolocationListeningFailedEventArgs.Error.get -> Microsoft.Maui.Devices.Sensors.GeolocationError
+Microsoft.Maui.Devices.Sensors.GeolocationListeningFailedEventArgs.GeolocationListeningFailedEventArgs(Microsoft.Maui.Devices.Sensors.GeolocationError geolocationError) -> void
+Microsoft.Maui.Devices.Sensors.IGeolocation.ListeningFailed -> System.EventHandler<Microsoft.Maui.Devices.Sensors.GeolocationListeningFailedEventArgs!>?
 Microsoft.Maui.Storage.ISecureStorage.GetAsync(string! key) -> System.Threading.Tasks.Task<string?>!
+static Microsoft.Maui.Devices.Sensors.Geolocation.ListeningFailed -> System.EventHandler<Microsoft.Maui.Devices.Sensors.GeolocationListeningFailedEventArgs!>!
 static Microsoft.Maui.Storage.SecureStorage.GetAsync(string! key) -> System.Threading.Tasks.Task<string?>!
+Microsoft.Maui.Devices.Sensors.IGeolocation.IsListeningForeground.get -> bool
+Microsoft.Maui.Devices.Sensors.IGeolocation.LocationChanged -> System.EventHandler<Microsoft.Maui.Devices.Sensors.GeolocationLocationChangedEventArgs!>?
+Microsoft.Maui.Devices.Sensors.IGeolocation.StartListeningForegroundAsync(Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest! request) -> System.Threading.Tasks.Task<bool>!
+Microsoft.Maui.Devices.Sensors.IGeolocation.StopListeningForeground() -> void
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.DesiredAccuracy.get -> Microsoft.Maui.Devices.Sensors.GeolocationAccuracy
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.DesiredAccuracy.set -> void
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.GeolocationListeningRequest() -> void
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.GeolocationListeningRequest(Microsoft.Maui.Devices.Sensors.GeolocationAccuracy accuracy) -> void
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.GeolocationListeningRequest(Microsoft.Maui.Devices.Sensors.GeolocationAccuracy accuracy, System.TimeSpan minimumTime) -> void
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.MinimumTime.get -> System.TimeSpan
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.MinimumTime.set -> void
+Microsoft.Maui.Devices.Sensors.GeolocationLocationChangedEventArgs
+Microsoft.Maui.Devices.Sensors.GeolocationLocationChangedEventArgs.Location.get -> Microsoft.Maui.Devices.Sensors.Location!
+Microsoft.Maui.Devices.Sensors.GeolocationLocationChangedEventArgs.GeolocationLocationChangedEventArgs(Microsoft.Maui.Devices.Sensors.Location! location) -> void
+static Microsoft.Maui.Devices.Sensors.Geolocation.IsListeningForeground.get -> bool
+static Microsoft.Maui.Devices.Sensors.Geolocation.LocationChanged -> System.EventHandler<Microsoft.Maui.Devices.Sensors.GeolocationLocationChangedEventArgs!>!
+static Microsoft.Maui.Devices.Sensors.Geolocation.StartListeningForegroundAsync(Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest! request) -> System.Threading.Tasks.Task<bool>!
+static Microsoft.Maui.Devices.Sensors.Geolocation.StopListeningForeground() -> void
 *REMOVED*static Microsoft.Maui.ApplicationModel.Communication.PhoneDialer.Current.get -> Microsoft.Maui.ApplicationModel.Communication.IPhoneDialer!
diff --git a/src/Essentials/src/PublicAPI/netstandard/PublicAPI.Unshipped.txt b/src/Essentials/src/PublicAPI/netstandard/PublicAPI.Unshipped.txt
index 59a09cb0ab11..c64aedf4601a 100644
--- a/src/Essentials/src/PublicAPI/netstandard/PublicAPI.Unshipped.txt
+++ b/src/Essentials/src/PublicAPI/netstandard/PublicAPI.Unshipped.txt
@@ -7,6 +7,33 @@ Microsoft.Maui.Authentication.WebAuthenticatorOptions.ResponseDecoder.set -> voi
 ~Microsoft.Maui.Authentication.WebAuthenticatorResult.WebAuthenticatorResult(System.Uri uri, Microsoft.Maui.Authentication.IWebAuthenticatorResponseDecoder responseDecoder) -> void
 *REMOVED*Microsoft.Maui.Storage.ISecureStorage.GetAsync(string! key) -> System.Threading.Tasks.Task<string!>!
 *REMOVED*static Microsoft.Maui.Storage.SecureStorage.GetAsync(string! key) -> System.Threading.Tasks.Task<string!>!
+Microsoft.Maui.Devices.Sensors.GeolocationError
+Microsoft.Maui.Devices.Sensors.GeolocationError.PositionUnavailable = 0 -> Microsoft.Maui.Devices.Sensors.GeolocationError
+Microsoft.Maui.Devices.Sensors.GeolocationError.Unauthorized = 1 -> Microsoft.Maui.Devices.Sensors.GeolocationError
+Microsoft.Maui.Devices.Sensors.GeolocationListeningFailedEventArgs
+Microsoft.Maui.Devices.Sensors.GeolocationListeningFailedEventArgs.Error.get -> Microsoft.Maui.Devices.Sensors.GeolocationError
+Microsoft.Maui.Devices.Sensors.GeolocationListeningFailedEventArgs.GeolocationListeningFailedEventArgs(Microsoft.Maui.Devices.Sensors.GeolocationError geolocationError) -> void
+Microsoft.Maui.Devices.Sensors.IGeolocation.ListeningFailed -> System.EventHandler<Microsoft.Maui.Devices.Sensors.GeolocationListeningFailedEventArgs!>?
 Microsoft.Maui.Storage.ISecureStorage.GetAsync(string! key) -> System.Threading.Tasks.Task<string?>!
+static Microsoft.Maui.Devices.Sensors.Geolocation.ListeningFailed -> System.EventHandler<Microsoft.Maui.Devices.Sensors.GeolocationListeningFailedEventArgs!>!
 static Microsoft.Maui.Storage.SecureStorage.GetAsync(string! key) -> System.Threading.Tasks.Task<string?>!
-*REMOVED*static Microsoft.Maui.ApplicationModel.Communication.PhoneDialer.Current.get -> Microsoft.Maui.ApplicationModel.Communication.IPhoneDialer!
\ No newline at end of file
+Microsoft.Maui.Devices.Sensors.IGeolocation.IsListeningForeground.get -> bool
+Microsoft.Maui.Devices.Sensors.IGeolocation.LocationChanged -> System.EventHandler<Microsoft.Maui.Devices.Sensors.GeolocationLocationChangedEventArgs!>?
+Microsoft.Maui.Devices.Sensors.IGeolocation.StartListeningForegroundAsync(Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest! request) -> System.Threading.Tasks.Task<bool>!
+Microsoft.Maui.Devices.Sensors.IGeolocation.StopListeningForeground() -> void
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.DesiredAccuracy.get -> Microsoft.Maui.Devices.Sensors.GeolocationAccuracy
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.DesiredAccuracy.set -> void
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.GeolocationListeningRequest() -> void
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.GeolocationListeningRequest(Microsoft.Maui.Devices.Sensors.GeolocationAccuracy accuracy) -> void
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.GeolocationListeningRequest(Microsoft.Maui.Devices.Sensors.GeolocationAccuracy accuracy, System.TimeSpan minimumTime) -> void
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.MinimumTime.get -> System.TimeSpan
+Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest.MinimumTime.set -> void
+Microsoft.Maui.Devices.Sensors.GeolocationLocationChangedEventArgs
+Microsoft.Maui.Devices.Sensors.GeolocationLocationChangedEventArgs.Location.get -> Microsoft.Maui.Devices.Sensors.Location!
+Microsoft.Maui.Devices.Sensors.GeolocationLocationChangedEventArgs.GeolocationLocationChangedEventArgs(Microsoft.Maui.Devices.Sensors.Location! location) -> void
+static Microsoft.Maui.Devices.Sensors.Geolocation.IsListeningForeground.get -> bool
+static Microsoft.Maui.Devices.Sensors.Geolocation.LocationChanged -> System.EventHandler<Microsoft.Maui.Devices.Sensors.GeolocationLocationChangedEventArgs!>!
+static Microsoft.Maui.Devices.Sensors.Geolocation.StartListeningForegroundAsync(Microsoft.Maui.Devices.Sensors.GeolocationListeningRequest! request) -> System.Threading.Tasks.Task<bool>!
+static Microsoft.Maui.Devices.Sensors.Geolocation.StopListeningForeground() -> void
+*REMOVED*static Microsoft.Maui.ApplicationModel.Communication.PhoneDialer.Current.get -> Microsoft.Maui.ApplicationModel.Communication.IPhoneDialer!