private async Task <Geoposition> GetGeoposition() { if (geolocator == null) { return(null); } return(await geolocator?.GetGeopositionAsync()); }
public static async Task <Geoposition> GetLocation() { var accessStatus = await Geolocator.RequestAccessAsync(); if (accessStatus == GeolocationAccessStatus.Allowed) { var geolocator = new Geolocator { DesiredAccuracyInMeters = 1000 }; var pos = await geolocator.GetGeopositionAsync(); return(pos); } throw new Exception("Locating Failed"); }
public async Task <Geoposition> GetUserLocation(PositionAccuracy accuracy) { // Get cancellation token _cts = new CancellationTokenSource(); CancellationToken token = _cts.Token; // Carry out the operation // geolocator and location permissions are initialized and checked on page creation. var geolocator = new Geolocator(); // Request a high accuracy position for better accuracy locating the geofence geolocator.DesiredAccuracy = accuracy; return(await geolocator.GetGeopositionAsync().AsTask(token)); }
/// <summary> /// Initializes the singleton application object. This is the first line of authored code /// executed, and as such is the logical equivalent of main() or WinMain(). /// </summary> public App() { this.InitializeComponent(); this.Suspending += OnSuspending; this.Resuming += OnResuming; Mapper.Initialize(cfg => { cfg.CreateMap <Signal, SignalService.SignalDto>().ConvertUsing(new SignalConvert()); cfg.CreateMap <WiFiSignal, SignalService.WifiSignalDto>().ConvertUsing(new WifiSignalsConvert()); }); Mapper.AssertConfigurationIsValid(); Geolocator geolocator = new Geolocator(); geolocator.GetGeopositionAsync(); }
async Task <Geoposition> GetUsersPositionAsync() { Geoposition position = null; var status = await Geolocator.RequestAccessAsync(); if (status == GeolocationAccessStatus.Allowed) { Geolocator locator = new Geolocator(); // Where's the user? position = await locator.GetGeopositionAsync(); } return(position); }
private async Task <Geoposition> GetInnerGeoPositionAsync() { if (!HasUserOptedIn() || _geolocator.LocationStatus == PositionStatus.Disabled) { return(null); } _geolocator.DesiredAccuracyInMeters = 10; Geoposition geo = await _geolocator.GetGeopositionAsync(); return(geo); }
//TODO: add insert data method #endregion #region Positioning private async void getCurrentPosition() { if (currentPosition == null) { currentPosition = new Position(); } Geolocator geo = new Geolocator(); Position result = new Position(); Geoposition pos = await geo.GetGeopositionAsync(); currentPosition.Longitude = pos.Coordinate.Point.Position.Longitude; currentPosition.Latitude = pos.Coordinate.Point.Position.Latitude; LatitudeTextBlock.Text = currentPosition.Latitude.ToString(); LongitudeTextBlock.Text = currentPosition.Longitude.ToString(); }
async private void FindCurrentLocation() { var currentPosition = await _geolocator.GetGeopositionAsync(); var locationFound = new Location { Latitude = currentPosition.Coordinate.Latitude, Longitude = currentPosition.Coordinate.Longitude }; MapLayer.SetPosition(pin, locationFound); map.SetView(locationFound, 15.0f); }
public IObservable <IGpsReading> GetLastReading() => Observable.FromAsync(async ct => { var geolocator = new Geolocator(); geolocator.AllowFallbackToConsentlessPositions(); var location = await geolocator .GetGeopositionAsync() .AsTask(ct); if (location?.Coordinate == null) { return(null); } return(new GpsReading(location.Coordinate)); });
public async static Task <Geoposition> GetPosition() { var accessStatus = await Geolocator.RequestAccessAsync(); if (accessStatus != GeolocationAccessStatus.Allowed) { throw new Exception(); } var geolocator = new Geolocator { DesiredAccuracyInMeters = 0 }; var position = await geolocator.GetGeopositionAsync(); return(position); }
//private async void AddNote_Loaded(object setter, NavigationEventArgs e) protected async override void OnNavigatedTo(NavigationEventArgs e) { //map service token from bing maps Map.MapServiceToken = "TOfdeDRJwGImuiaL7W88~SlMn6bqFU6GCmOupV2lB-g~AsoKvGZZisSkTudn4cs2nwQzmGl7eS58HojnUjiskKBwBEYkH-7yUV7sRAXsADIr"; //set map style for add note feature. Map.Style = MapStyle.AerialWithRoads; Geopoint pos; if (e.Parameter == null) { viewing = false; var location = new Geolocator(); location.DesiredAccuracyInMeters = 50; var position = await location.GetGeopositionAsync(); pos = position.Coordinate.Point; } else { viewing = true; myText = (MyMapNote)e.Parameter; titleTextBox.Text = myText.Title; noteTextBox.Text = myText.Note; //if viewing =true then we are in the delete mode // and add button content will change to delete // and the function will change to a delete function addBtn.Content = "Delete"; var myPos = new Windows.Devices.Geolocation.BasicGeoposition(); myPos.Latitude = myText.Latitude; myPos.Longitude = myText.Longitude; //drop a ancor pin to mark center point pos = new Geopoint(myPos); MapIcon icon = new MapIcon(); icon.Location = pos; icon.NormalizedAnchorPoint = new Point(0.5, 1.0); icon.Title = "Note Location"; icon.Image = RandomAccessStreamReference.CreateFromUri(new Uri("ms-appx:///Assets/Pin.png")); icon.ZIndex = 0; Map.MapElements.Add(icon); Map.Center = pos; } await Map.TrySetViewAsync(pos, 14D); }
private async Task AccesstoLocate() { try { var accessStatus = await Geolocator.RequestAccessAsync(); if (accessStatus == GeolocationAccessStatus.Allowed) { LocateAllowed.Begin(); if (Context.EnablePosition) { try { _geolocator = new Geolocator(); ShowRefreshing(); pos = await _geolocator.GetGeopositionAsync(); if ((_geolocator.LocationStatus != PositionStatus.NoData) && (_geolocator.LocationStatus != PositionStatus.NotAvailable) && (_geolocator.LocationStatus != PositionStatus.Disabled)) { await UpdatePosition(pos); } else { DeniePos(); } _geolocator.StatusChanged += OnStatusChanged; } catch (Exception) { DeniePos(); } } else { HidePos(); } } else { DeniePos(); } } catch (Exception) { DeniePos(); } }
/// <summary> /// Helper method to invoke Geolocator.GetGeopositionAsync. /// </summary> async private void GetGeopositionAsync() { rootPage.NotifyUser("Checking permissions...", NotifyType.StatusMessage); try { // Get cancellation token cts = new CancellationTokenSource(); CancellationToken token = cts.Token; // Carry out the operation Geoposition pos = await geolocator.GetGeopositionAsync().AsTask(token); // got permissions so clear the status string rootPage.NotifyUser("", NotifyType.StatusMessage); } #if WINDOWS_APP catch (UnauthorizedAccessException) { rootPage.NotifyUser("Location Permissions disabled by user. Enable access through the settings charm to enable the background task.", NotifyType.StatusMessage); } #endif catch (TaskCanceledException) { rootPage.NotifyUser("Permission check operation canceled.", NotifyType.StatusMessage); } catch (Exception ex) { #if WINDOWS_APP // If there are no location sensors GetGeopositionAsync() // will timeout -- that is acceptable. const int WaitTimeoutHResult = unchecked ((int)0x80070102); if (ex.HResult == WaitTimeoutHResult) // WAIT_TIMEOUT { rootPage.NotifyUser("Operation accessing location sensors timed out. Possibly there are no location sensors.", NotifyType.StatusMessage); } else #endif { rootPage.NotifyUser(ex.ToString(), NotifyType.ErrorMessage); } } finally { cts = null; } }
/// <summary> /// Starts the timer to update map objects and the handler to update position /// </summary> public static async Task InitializeDataUpdate() { _geolocator = new Geolocator { DesiredAccuracy = PositionAccuracy.High, DesiredAccuracyInMeters = 5, ReportInterval = 5000, MovementThreshold = 5 }; Busy.SetBusy(true, Resources.Translation.GetString("GettingGPSSignal")); Geoposition = Geoposition ?? await _geolocator.GetGeopositionAsync(); GeopositionUpdated?.Invoke(null, Geoposition); _geolocator.PositionChanged += (s, e) => { Geoposition = e.Position; GeopositionUpdated?.Invoke(null, Geoposition); }; _mapUpdateTimer = new DispatcherTimer { Interval = TimeSpan.FromSeconds(10) }; _mapUpdateTimer.Tick += async(s, e) => { if (!UpdateDataMutex.WaitOne(0)) { return; } if (_skipNextUpdate) { _skipNextUpdate = false; } else { Logger.Write("Updating map"); await UpdateMapObjects(); } UpdateDataMutex.ReleaseMutex(); }; // Update before starting timer Busy.SetBusy(true, Resources.Translation.GetString("GettingUserData")); await UpdateMapObjects(); await UpdateInventory(); _mapUpdateTimer.Start(); Busy.SetBusy(false); }
public async void GetCoordinatesWithCallback(Action <string> resolve, Action <string> reject) { try { Geolocator geolocator = new Geolocator(); var position = await geolocator.GetGeopositionAsync(); string result = $"Latitude: {position.Coordinate.Point.Position.Latitude} - Longitude: {position.Coordinate.Point.Position.Longitude}"; resolve(result); } catch (Exception e) { reject(e.Message); } }
public async static Task ReadLocation(bool saveInHistory) { try { CurrentPosition = await locator.GetGeopositionAsync().AsTask(); if (saveInHistory) { SaveCurrentLocation(); } } catch (Exception exception) { Log.Error(exception); } }
public async Task <BasicGeoposition> GetLocationPoint() { Geolocator geo = new Geolocator(); geo.DesiredAccuracy = PositionAccuracy.High; geo.DesiredAccuracyInMeters = 5; geo.ReportInterval = 3000; geo.MovementThreshold = 5; Geoposition location = await geo.GetGeopositionAsync(); BasicGeoposition point = location.Coordinate.Point.Position; return(point); }
private async Task <Geoposition> getLocation() { Geolocator geolocator = new Geolocator(); Geoposition geoposition = null; try { geoposition = await geolocator.GetGeopositionAsync(); } catch (Exception ex) { // Handle errors like unauthorized access to location // services or no Internet access. } return(geoposition); }
/// <summary> /// get my positon /// </summary> /// <returns></returns> private async Task <Geoposition> getCoordinates() { Geolocator geolocator = new Geolocator(); geolocator.DesiredAccuracyInMeters = 50; try { return(await geolocator.GetGeopositionAsync(maximumAge : TimeSpan.FromMinutes(5), timeout : TimeSpan.FromSeconds(10))); } catch (Exception) { MessageDialog dialog = new MessageDialog("Không thể xác định vị trí của bạn", "Thông báo"); return(null); } }
private async void geolocator_PositionChanged(Geolocator sender, PositionChangedEventArgs args) { geoposition = await geolocator.GetGeopositionAsync(); Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() => { latTbl.Text = geoposition.Coordinate.Latitude.ToString(); longTbl.Text = geoposition.Coordinate.Longitude.ToString(); getLat = geoposition.Coordinate.Latitude.ToString(); getLong = geoposition.Coordinate.Longitude.ToString(); myMap.Center = geoposition.Coordinate.Point; currentPin.Location = geoposition.Coordinate.Point; }); }
public async static Task <Geoposition> GetPosition() { var accessStatus = await Geolocator.RequestAccessAsync(); //request access if (accessStatus != GeolocationAccessStatus.Allowed) { throw new LocationPermissionException("Access to Location Services Required"); } var geolocator = new Geolocator { DesiredAccuracyInMeters = 0 }; //0 means give what ever you got var position = await geolocator.GetGeopositionAsync(); return(position); }
public override async void OnNavigatedTo(object navigationParameter, Windows.UI.Xaml.Navigation.NavigationMode navigationMode, Dictionary <string, object> viewModelState) { Geolocator locator = new Geolocator(); Position = await locator.GetGeopositionAsync(); if (Distance == 0) { Distance = DistanceOptions.First(); } if (PageSize == 0) { PageSize = PageSizeOptions.First(); } }
private async Task <string> GetPosition() { var g = new Geolocator(); var pos = await g.GetGeopositionAsync(); if (pos != null) { var loc = await MapLocationFinder.FindLocationsAtAsync(pos.Coordinate.Point); if (loc != null && loc.Locations.Count > 0) { return(loc.Locations.First().Address.Town); } } return(""); }
private async void Button_Click(object sender, System.Windows.RoutedEventArgs e) { Geolocator geolocator = new Geolocator() { DesiredAccuracyInMeters = 5 }; Geoposition pos = await geolocator.GetGeopositionAsync(); string longitude = pos.Coordinate.Point.Position.Longitude.ToString(); string latitude = pos.Coordinate.Point.Position.Latitude.ToString(); LongBlock.Text = longitude; LatBlock.Text = latitude; await TheMap.TrySetViewAsync(pos.Coordinate.Point, 15.0); }
public async Task <Location> GetLocation() { var geolocator = new Geolocator(); geolocator.DesiredAccuracyInMeters = 50; Geoposition geoposition = await geolocator.GetGeopositionAsync( maximumAge : TimeSpan.FromMinutes(5), timeout : TimeSpan.FromSeconds(10) ); return(new Location() { Latitude = geoposition.Coordinate.Latitude, Longitude = geoposition.Coordinate.Longitude }); }
public MainPage() { this.InitializeComponent(); geolocator = new Geolocator(); geolocator.DesiredAccuracyInMeters = 10; geolocator.ReportInterval = 0; myButton.Click += async(sender, e) => { geoposition = await geolocator.GetGeopositionAsync(); string latitude = geoposition.Coordinate.Latitude.ToString("0.0000000000"); string Longitude = geoposition.Coordinate.Longitude.ToString("0.0000000000"); string Accuracy = geoposition.Coordinate.Accuracy.ToString("0.0000000000"); }; }
public LocationHelper() { _geolocator = new Geolocator(); _geolocator.PositionChanged += (s, e) => { this.Position = e.Position; if (PositionChanged != null) { try { PositionChanged(this.Position); } catch { } } }; // initial value this.Position = _geolocator.GetGeopositionAsync().AsTask <Geoposition>().Result; }
public async static void GetGPS(Map myMap) { Geolocator locator = new Geolocator(); if (locator.LocationStatus == PositionStatus.Disabled) { MessageBox.Show("GPS của bạn đang tắt, bất lên để sử dụng tính năng này !!"); } else { locator.DesiredAccuracyInMeters = 50; var mypoint = await locator.GetGeopositionAsync(); myMap.SetView(new GeoCoordinate(mypoint.Coordinate.Latitude, mypoint.Coordinate.Longitude), 17D); } }
public async Task <Location?> GetLastKnownLocationAsync() { // no need for permissions as AllowFallbackToConsentlessPositions // will allow the device to return a location regardless var geolocator = new Geolocator { DesiredAccuracy = PositionAccuracy.Default, }; geolocator.AllowFallbackToConsentlessPositions(); var location = await geolocator.GetGeopositionAsync().AsTask(); return(location?.Coordinate?.ToLocation()); }
private async void MarcarMinhaLocalizacao() { try { var locationFinder = new Geolocator { DesiredAccuracyInMeters = 50, DesiredAccuracy = PositionAccuracy.Default, MovementThreshold = 50 }; locationFinder.PositionChanged += LocationFinder_PositionChanged; locationFinder.GetGeopositionAsync(maximumAge: TimeSpan.FromSeconds(120), timeout: TimeSpan.FromSeconds(10)); } catch { } }