fix: Geolocator methods invoked on Dispatcher when necessary

src/Uno.UWP/Devices/Geolocation/Geolocator.Android.cs

@@ -10,10 +10,13 @@
 using Android.Locations;
 using Android.OS;
 using Android.Runtime;
+using Uno.Extensions;
 using Windows.Extensions;
 using Windows.Foundation;
 using Windows.Foundation.Collections;
 using Windows.Foundation.Metadata;
+using Windows.UI.Core;
+
 namespace Windows.Devices.Geolocation
 {
 	public sealed partial class Geolocator : Java.Lang.Object, ILocationListener
@@ -39,12 +42,22 @@ private void TryInitialize()
 
 		public Task<Geoposition> GetGeopositionAsync()
 		{
-			TryInitialize();
+			if (CoreDispatcher.Main.HasThreadAccess)
+			{
+				TryInitialize();
 
-			BroadcastStatus(PositionStatus.Initializing);
-			var location = _locationManager.GetLastKnownLocation(_locationProvider);
-			BroadcastStatus(PositionStatus.Ready);
-			return Task.FromResult(location.ToGeoPosition());
+				BroadcastStatus(PositionStatus.Initializing);
+				var location = _locationManager.GetLastKnownLocation(_locationProvider);
+				BroadcastStatus(PositionStatus.Ready);
+				return Task.FromResult(location.ToGeoPosition());
+			}
+			else
+			{
+				return CoreDispatcher.Main.RunWithResultAsync(
+					priority: CoreDispatcherPriority.Normal,
+					task: () => GetGeopositionAsync()
+				);
+			}
 		}
 
 		public Task<Geoposition> GetGeopositionAsync(TimeSpan maximumAge, TimeSpan timeout)

src/Uno.UWP/Devices/Geolocation/Geolocator.iOSmacOS.cs

@@ -5,9 +5,12 @@
 using System.Runtime.InteropServices;
 using System.Threading.Tasks;
 using CoreLocation;
+using Uno.Extensions;
 using Windows.Foundation;
 using Windows.Foundation.Collections;
 using Windows.Foundation.Metadata;
+using Windows.UI.Core;
+
 namespace Windows.Devices.Geolocation
 {
 	public sealed partial class Geolocator
@@ -38,24 +41,34 @@ partial void StartPositionChanged()
 		}
 
 #if __IOS__
-		public async Task<Geoposition> GetGeopositionAsync() //will be removed with #2240
+		public Task<Geoposition> GetGeopositionAsync() => GetGeopositionInternalAsync(); //will be removed with #2240
 #else
-		public IAsyncOperation<Geoposition> GetGeopositionAsync()
+		public IAsyncOperation<Geoposition> GetGeopositionAsync() => GetGeopositionInternalAsync().AsAsyncOperation();
 #endif
+
+		public Task<Geoposition> GetGeopositionInternalAsync()
+
 		{
-			BroadcastStatus(PositionStatus.Initializing);
-			var location = _locationManager.Location;
-			if (location == null)
+			if (CoreDispatcher.Main.HasThreadAccess)
 			{
-				throw new InvalidOperationException("Could not obtain the location. Please make sure that NSLocationWhenInUseUsageDescription and NSLocationUsageDescription are set in info.plist.");
-			}
+				BroadcastStatus(PositionStatus.Initializing);
+				var location = _locationManager.Location;
+				if (location == null)
+				{
+					throw new InvalidOperationException("Could not obtain the location. Please make sure that NSLocationWhenInUseUsageDescription and NSLocationUsageDescription are set in info.plist.");
+				}
 
-			BroadcastStatus(PositionStatus.Ready);
-#if __IOS__
-			return ToGeoposition(location);
-#else
-			return Task.FromResult(ToGeoposition(location)).AsAsyncOperation();
-#endif
+				BroadcastStatus(PositionStatus.Ready);
+
+				return Task.FromResult(ToGeoposition(location));
+			}
+			else
+			{
+				return CoreDispatcher.Main.RunWithResultAsync<Geoposition>(
+					priority: CoreDispatcherPriority.Normal,
+					task: () => GetGeopositionInternalAsync()
+				);
+			}
 		}
 
 		private static Geoposition ToGeoposition(CLLocation location)
@@ -91,62 +104,71 @@ public IAsyncOperation<Geoposition> GetGeopositionAsync(TimeSpan maximumAge, Tim
 		private static List<CLLocationManager> _requestManagers = new List<CLLocationManager>();
 
 #if __IOS__
-		public static async Task<GeolocationAccessStatus> RequestAccessAsync() //will be removed with #2240
+		public static Task<GeolocationAccessStatus> RequestAccessAsync() => RequestAccessInternalAsync(); //will be removed with #2240
 #else
-		public static IAsyncOperation<GeolocationAccessStatus> RequestAccessAsync() =>
-			RequestAccessInternalAsync().AsAsyncOperation();
-
-		private static async Task<GeolocationAccessStatus> RequestAccessInternalAsync()
+		public static IAsyncOperation<GeolocationAccessStatus> RequestAccessAsync() => RequestAccessInternalAsync().AsAsyncOperation();
 #endif
-		{
-			var mgr = new CLLocationManager();
+		private static async Task<GeolocationAccessStatus> RequestAccessInternalAsync()
 
-			lock (_requestManagers)
+		{
+			if (CoreDispatcher.Main.HasThreadAccess)
 			{
-				_requestManagers.Add(mgr);
-			}
+				var mgr = new CLLocationManager();
 
-			try
-			{
-				GeolocationAccessStatus accessStatus;
-				var cts = new TaskCompletionSource<CLAuthorizationStatus>();
+				lock (_requestManagers)
+				{
+					_requestManagers.Add(mgr);
+				}
 
-				mgr.AuthorizationChanged += (s, e) =>
+				try
 				{
+					GeolocationAccessStatus accessStatus;
+					var cts = new TaskCompletionSource<CLAuthorizationStatus>();
 
-					if (e.Status != CLAuthorizationStatus.NotDetermined)
+					mgr.AuthorizationChanged += (s, e) =>
 					{
-						cts.TrySetResult(e.Status);
-					}
-				};
+
+						if (e.Status != CLAuthorizationStatus.NotDetermined)
+						{
+							cts.TrySetResult(e.Status);
+						}
+					};
 
 #if __IOS__ //required only for iOS
-				mgr.RequestWhenInUseAuthorization();
+					mgr.RequestWhenInUseAuthorization();
 #endif
 
-				if (CLLocationManager.Status != CLAuthorizationStatus.NotDetermined)
-				{
-					accessStatus = TranslateStatus(CLLocationManager.Status);
-				}
+					if (CLLocationManager.Status != CLAuthorizationStatus.NotDetermined)
+					{
+						accessStatus = TranslateStatus(CLLocationManager.Status);
+					}
 
-				var cLAuthorizationStatus = await cts.Task;
+					var cLAuthorizationStatus = await cts.Task;
 
-				accessStatus = TranslateStatus(cLAuthorizationStatus);
-
-				//if geolocation is not well accessible, default geoposition should be recommended
-				if (accessStatus != GeolocationAccessStatus.Allowed)
+					accessStatus = TranslateStatus(cLAuthorizationStatus);
+
+					//if geolocation is not well accessible, default geoposition should be recommended
+					if (accessStatus != GeolocationAccessStatus.Allowed)
+					{
+						IsDefaultGeopositionRecommended = true;
+					}
+
+					return accessStatus;
+				}
+				finally
 				{
-					IsDefaultGeopositionRecommended = true;
+					lock (_requestManagers)
+					{
+						_requestManagers.Remove(mgr);
+					}
 				}
-
-				return accessStatus;
 			}
-			finally
+			else
 			{
-				lock (_requestManagers)
-				{
-					_requestManagers.Remove(mgr);
-				}
+				return await CoreDispatcher.Main.RunWithResultAsync<GeolocationAccessStatus>(
+					priority: CoreDispatcherPriority.Normal,
+					task: () => RequestAccessInternalAsync()
+				);
 			}
 		}