static async Task <IEnumerable <FilePickerResult> > PlatformPickAsync(PickOptions options, bool allowMultiple = false) { // we only need the permission when accessing the file, but it's more natural // to ask the user first, then show the picker. await Permissions.RequestAsync <Permissions.StorageRead>(); // Essentials supports >= API 19 where this action is available var action = Intent.ActionOpenDocument; var intent = new Intent(action); intent.SetType("*/*"); intent.AddFlags(ActivityFlags.GrantPersistableUriPermission); intent.PutExtra(Intent.ExtraAllowMultiple, allowMultiple); var allowedTypes = options?.FileTypes?.Value?.ToArray(); if (allowedTypes?.Length > 0) { intent.PutExtra(Intent.ExtraMimeTypes, allowedTypes); } var pickerIntent = Intent.CreateChooser(intent, options?.PickerTitle ?? "Select file"); try { var result = await IntermediateActivity.StartAsync(pickerIntent, requestCodeFilePicker); var resultList = new List <FilePickerResult>(); var clipData = new List <global::Android.Net.Uri>(); if (result.ClipData == null) { clipData.Add(result.Data); } else { for (var i = 0; i < result.ClipData.ItemCount; i++) { clipData.Add(result.ClipData.GetItemAt(i).Uri); } } foreach (var contentUri in clipData) { Platform.AppContext.ContentResolver.TakePersistableUriPermission( contentUri, ActivityFlags.GrantReadUriPermission); resultList.Add(new FilePickerResult(contentUri)); } return(resultList); } catch (OperationCanceledException) { return(null); } }
static async Task <FileResult> PlatformPickAsync(MediaPickerOptions options, bool photo) { // We only need the permission when accessing the file, but it's more natural // to ask the user first, then show the picker. await Permissions.RequestAsync <Permissions.StorageRead>(); var intent = new Intent(Intent.ActionGetContent); intent.SetType(photo ? FileSystem.MimeTypes.ImageAll : FileSystem.MimeTypes.VideoAll); var pickerIntent = Intent.CreateChooser(intent, options?.Title); try { string path = null; void OnResult(Intent intent) { // The uri returned is only temporary and only lives as long as the Activity that requested it, // so this means that it will always be cleaned up by the time we need it because we are using // an intermediate activity. path = FileSystem.EnsurePhysicalPath(intent.Data); } await IntermediateActivity.StartAsync(pickerIntent, Platform.requestCodeMediaPicker, onResult : OnResult); return(new FileResult(path)); } catch (OperationCanceledException) { return(null); } }
static async Task <Location> PlatformLocationAsync(GeolocationRequest request, CancellationToken cancellationToken) { await Permissions.RequestAsync <Permissions.LocationWhenInUse>(); var geolocator = new Geolocator { DesiredAccuracyInMeters = request.PlatformDesiredAccuracy }; CheckStatus(geolocator.LocationStatus); cancellationToken = Utils.TimeoutToken(cancellationToken, request.Timeout); var location = await geolocator.GetGeopositionAsync().AsTask(cancellationToken); return(location?.Coordinate?.ToLocation()); void CheckStatus(PositionStatus status) { switch (status) { case PositionStatus.Disabled: case PositionStatus.NotAvailable: throw new FeatureNotEnabledException("Location services are not enabled on device."); } } }
internal virtual async Task <Stream> PlatformOpenReadAsync() { await Permissions.RequestAsync <Permissions.StorageRead>(); var stream = File.Open(FullPath, FileMode.Open, FileAccess.Read); return(Task.FromResult <Stream>(stream).Result); }
static async Task <IEnumerable <FileResult> > PlatformPickAsync(PickOptions options, bool allowMultiple = false) { // we only need the permission when accessing the file, but it's more natural // to ask the user first, then show the picker. await Permissions.RequestAsync <Permissions.StorageRead>(); // Essentials supports >= API 19 where this action is available var action = Intent.ActionOpenDocument; var intent = new Intent(action); intent.SetType(FileSystem.MimeTypes.All); intent.PutExtra(Intent.ExtraAllowMultiple, allowMultiple); var allowedTypes = options?.FileTypes?.Value?.ToArray(); if (allowedTypes?.Length > 0) { intent.PutExtra(Intent.ExtraMimeTypes, allowedTypes); } var pickerIntent = Intent.CreateChooser(intent, options?.PickerTitle ?? "Select file"); try { var resultList = new List <FileResult>(); void OnResult(Intent intent) { // The uri returned is only temporary and only lives as long as the Activity that requested it, // so this means that it will always be cleaned up by the time we need it because we are using // an intermediate activity. if (intent.ClipData == null) { var path = FileSystem.EnsurePhysicalPath(intent.Data); resultList.Add(new FileResult(path)); } else { for (var i = 0; i < intent.ClipData.ItemCount; i++) { var uri = intent.ClipData.GetItemAt(i).Uri; var path = FileSystem.EnsurePhysicalPath(uri); resultList.Add(new FileResult(path)); } } } await IntermediateActivity.StartAsync(pickerIntent, Platform.requestCodeFilePicker, onResult : OnResult); return(resultList); } catch (OperationCanceledException) { return(null); } }
/// <inheritdoc /> public async Task <PermissionStatus> RequestPermissionsAsync <T>() where T : BasePermission, new() { return(await MainThread.InvokeOnMainThreadAsync(async() => { var result = await EssentialsPermissions.RequestAsync <T>().ConfigureAwait(false); return result.ToPermissionStatus(); })); }
static async Task CheckSupportAsync() { if (!IsSupported) { throw new FeatureNotSupportedException(); } await Permissions.RequestAsync <Permissions.Flashlight>(); }
static async Task <Location> PlatformLocationAsync(GeolocationRequest request, CancellationToken cancellationToken) { if (!CLLocationManager.LocationServicesEnabled) { throw new FeatureNotEnabledException("Location services are not enabled on device."); } await Permissions.RequestAsync <Permissions.LocationWhenInUse>(); // the location manager requires an active run loop // so just use the main loop CLLocationManager manager = null; NSRunLoop.Main.InvokeOnMainThread(() => manager = new CLLocationManager()); var tcs = new TaskCompletionSource <CLLocation>(manager); var listener = new SingleLocationListener(); listener.LocationHandler += HandleLocation; cancellationToken = Utils.TimeoutToken(cancellationToken, request.Timeout); cancellationToken.Register(Cancel); manager.DesiredAccuracy = request.PlatformDesiredAccuracy; manager.Delegate = listener; #if __IOS__ // we're only listening for a single update manager.PausesLocationUpdatesAutomatically = false; #endif manager.StartUpdatingLocation(); var clLocation = await tcs.Task; return(clLocation?.ToLocation()); void HandleLocation(CLLocation location) { manager.StopUpdatingLocation(); tcs.TrySetResult(location); } void Cancel() { manager.StopUpdatingLocation(); tcs.TrySetResult(null); } }
static async Task <Location> PlatformLastKnownLocationAsync() { if (!CLLocationManager.LocationServicesEnabled) { throw new FeatureNotEnabledException("Location services are not enabled on device."); } await Permissions.RequestAsync <Permissions.LocationWhenInUse>(); var manager = new CLLocationManager(); var location = manager.Location; return(location?.ToLocation()); }
/// <inheritdoc /> public async Task <PermissionStatus> RequestPermissionsAsync <T>() where T : BasePermission, new() { return(await MainThread.InvokeOnMainThreadAsync(async() => { if (typeof(T) == typeof(NotificationsPermission)) { return await RequestNotificationPermissionAsync().ConfigureAwait(false); } var result = await EssentialsPermissions.RequestAsync <T>().ConfigureAwait(false); return result.ToPermissionStatus(); })); }
static async Task <Location> PlatformLastKnownLocationAsync() { await Permissions.RequestAsync <Permissions.LocationWhenInUse>(); var lm = Platform.LocationManager; AndroidLocation bestLocation = null; foreach (var provider in lm.GetProviders(true)) { var location = lm.GetLastKnownLocation(provider); if (location != null && IsBetterLocation(location, bestLocation)) { bestLocation = location; } } return(bestLocation?.ToLocation()); }
static async Task <FileResult> PlatformPickAsync(MediaPickerOptions options, bool photo) { // we only need the permission when accessing the file, but it's more natural // to ask the user first, then show the picker. await Permissions.RequestAsync <Permissions.StorageRead>(); var intent = new Intent(Intent.ActionGetContent); intent.SetType(photo ? "image/*" : "video/*"); var pickerIntent = Intent.CreateChooser(intent, options?.Title); try { var result = await IntermediateActivity.StartAsync(pickerIntent, Platform.requestCodeMediaPicker); return(new FileResult(result.Data)); } catch (OperationCanceledException) { return(null); } }
static async Task <Location> PlatformLocationAsync(GeolocationRequest request, CancellationToken cancellationToken) { await Permissions.RequestAsync <Permissions.LocationWhenInUse>(); var locationManager = Platform.LocationManager; 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 get a location // let's punt and try to get the last known location if (string.IsNullOrEmpty(providerInfo.Provider)) { return(await GetLastKnownLocationAsync()); } var tcs = new TaskCompletionSource <AndroidLocation>(); var allProviders = locationManager.GetProviders(false); var providers = new List <string>(); if (allProviders.Contains(LocationManager.GpsProvider)) { providers.Add(LocationManager.GpsProvider); } if (allProviders.Contains(LocationManager.NetworkProvider)) { providers.Add(LocationManager.NetworkProvider); } if (providers.Count == 0) { providers.Add(providerInfo.Provider); } var listener = new SingleLocationListener(locationManager, providerInfo.Accuracy, providers); listener.LocationHandler = HandleLocation; cancellationToken = Utils.TimeoutToken(cancellationToken, request.Timeout); cancellationToken.Register(Cancel); // start getting location updates // make sure to use a thread with a looper var looper = Looper.MyLooper() ?? Looper.MainLooper; foreach (var provider in providers) { locationManager.RequestLocationUpdates(provider, 0, 0, listener, looper); } var androidLocation = await tcs.Task; if (androidLocation == null) { return(null); } return(androidLocation.ToLocation()); void HandleLocation(AndroidLocation location) { RemoveUpdates(); tcs.TrySetResult(location); } void Cancel() { RemoveUpdates(); tcs.TrySetResult(listener.BestLocation); } void RemoveUpdates() { for (var i = 0; i < providers.Count; i++) { locationManager.RemoveUpdates(listener); } } }
static async Task <Location> PlatformLastKnownLocationAsync() { await Permissions.RequestAsync(PermissionType.LocationWhenInUse); return(lastKnownLocation); }
static async Task <Location> PlatformLocationAsync(GeolocationRequest request, CancellationToken cancellationToken) { await Permissions.RequestAsync <Permissions.LocationWhenInUse>(); Locator service = null; var gps = Platform.GetFeatureInfo <bool>("location.gps"); var wps = Platform.GetFeatureInfo <bool>("location.wps"); if (gps) { if (wps) { service = new Locator(LocationType.Hybrid); } else { service = new Locator(LocationType.Gps); } } else { if (wps) { service = new Locator(LocationType.Wps); } else { service = new Locator(LocationType.Passive); } } var tcs = new TaskCompletionSource <bool>(); cancellationToken = Utils.TimeoutToken(cancellationToken, request.Timeout); cancellationToken.Register(() => { service?.Stop(); tcs.TrySetResult(false); }); double KmToMetersPerSecond(double km) => km * 0.277778; service.LocationChanged += (s, e) => { if (e.Location != null) { lastKnownLocation.Accuracy = e.Location.Accuracy; lastKnownLocation.Altitude = e.Location.Altitude; lastKnownLocation.Course = e.Location.Direction; lastKnownLocation.Latitude = e.Location.Latitude; lastKnownLocation.Longitude = e.Location.Longitude; lastKnownLocation.Speed = KmToMetersPerSecond(e.Location.Speed); lastKnownLocation.Timestamp = e.Location.Timestamp; } service?.Stop(); tcs.TrySetResult(true); }; service.Start(); await tcs.Task; return(lastKnownLocation); }