protected override async void OnAppearing() { base.OnAppearing(); if (hasLocationPermission) { if (CrossGeolocator.IsSupported && CrossGeolocator.Current.IsGeolocationAvailable && CrossGeolocator.Current.IsGeolocationEnabled) { locator.PositionChanged += Locator_PositionChanged; await locator.StartListeningAsync(TimeSpan.FromSeconds(0), 50, true); var position = await locator.GetPositionAsync(); var center = new Xamarin.Forms.Maps.Position(position.Latitude, position.Longitude); var span = new Xamarin.Forms.Maps.MapSpan(center, 2, 2); locationsMap.MoveToRegion(MapSpan.FromCenterAndRadius(new Xamarin.Forms.Maps.Position(position.Latitude, position.Longitude), Distance.FromMiles(1))); //using (SQLiteConnection conn = new SQLiteConnection(App.DatabaseLocation)) //{ // conn.CreateTable<Post>(); // var posts = conn.Table<Post>().ToList(); // DisplayInMap(posts); //} var posts = await Post.Read(); DisplayInMap(posts); } } }
// build uri for request async Task <string> GenerateRequestUri() { // get user's location var position = await userLocator.GetPositionAsync(); // uri request string requestUri = $"v1/incidents/raw-data?lat={position.Latitude}" + $"&lon={position.Longitude}" + $"&distance=km" + $"&datetime_ini={DateTime.Now.AddDays(-(Int32.Parse("2"))):yyyy-MM-ddTHH:mm:ss.fffZ}" + $"&datetime_end={DateTime.Now:yyyy-MM-ddTHH:mm:ss.fffZ}"; return(requestUri); }
protected async override void OnElementChanged(ElementChangedEventArgs <Map> e) { if (_map != null) { _map.MapClick -= googleMap_MapClick; } base.OnElementChanged(e); if (Control != null) { ((MapView)Control).GetMapAsync(this); } location = CrossGeolocator.Current; location.DesiredAccuracy = 100; try { position = await location.GetPositionAsync(TimeSpan.FromSeconds(10)); await((MapTapRenderer)Element).ChangePosition(new Xamarin.Forms.Maps.Position(position.Latitude, position.Longitude)); Console.WriteLine("pos android" + position.Latitude.ToString() + " , " + position.Longitude.ToString()); SetMarker(position.Latitude, position.Longitude); } catch (Exception ex) { Console.WriteLine(ex.Message); } }
/// <summary> /// 非同期で現在座標を取得する /// </summary> /// <param name="timeout">タイムアウト時間</param> /// <returns>現在の座標</returns> public async Task <GeoCoordinate> GetGeoCoordinateAsync(int timeout) { //指定した秒数までを限度に現在の位置を取得する Position position = await _locator.GetPositionAsync(timeout : new TimeSpan(timeout)); return(this.ConvertGeoCoordinate(position)); }
protected async override void OnElementChanged(ElementChangedEventArgs <View> e) { if ((MapTapRenderer)Element != null) { if (Control != null) { Control.RemoveGestureRecognizer(_tapRecogniser); } base.OnElementChanged(e); if (Control != null && ((MapTapRenderer)Element).IsEnabled) { Control.AddGestureRecognizer(_tapRecogniser); } locationG = CrossGeolocator.Current; locationG.DesiredAccuracy = 100; try { position = await locationG.GetPositionAsync(TimeSpan.FromSeconds(10)); await((MapTapRenderer)Element).ChangePosition(new Xamarin.Forms.Maps.Position(position.Latitude, position.Longitude)); ((MapTapRenderer)Element).SetLocation(new Xamarin.Forms.Maps.Position(position.Latitude, position.Longitude)); } catch (Exception ex) { Console.WriteLine(ex.Message); } } }
private async void GetLocation() { //var locator = CrossGeolocator.Current; position = await geolocator.GetPositionAsync(); await geolocator.StartListeningAsync(TimeSpan.FromMinutes(30), 500); }
private async Task <XLabs.Platform.Services.Geolocation.Position> GetCurrentPosition() { IGeolocator geolocator = Resolver.Resolve <IGeolocator>(); XLabs.Platform.Services.Geolocation.Position result = null; if (geolocator.IsGeolocationEnabled) { try { if (!geolocator.IsListening) { geolocator.StartListening(1000, 1000); } var task = await geolocator.GetPositionAsync(10000); result = task; System.Diagnostics.Debug.WriteLine("[GetPosition] Lat. : {0} / Long. : {1}", result.Latitude.ToString("N4"), result.Longitude.ToString("N4")); } catch (Exception e) { System.Diagnostics.Debug.WriteLine("Error : {0}", e); } } return(result); }
public static async Task <Position> GetCurrentPosition() { IGeolocator locator = CrossGeolocator.Current; locator.DesiredAccuracy = Constants.MapDesiredAccuracy; Position position = await locator.GetLastKnownLocationAsync(); if (position != null) { return(position); } if (!locator.IsGeolocationAvailable || !locator.IsGeolocationEnabled) { return(null); } position = await locator.GetPositionAsync(TimeSpan.FromSeconds(Constants.TimeOutSmall), null, true); if (position == null) { return(null); } return(position); }
async void RefreshActionAsync() { IsRefreshing = true; await ItemReportStorage.Refresh(await Geolocator.GetPositionAsync(), 1.0); IsRefreshing = false; }
async Task <bool> StartTracking() { geolocator = CrossGeolocator.Current; if (!geolocator.IsGeolocationAvailable) { DisplayAlert("Error", "Location is not awailable", "Ok"); return(false); } Position result = null; try { geolocator.DesiredAccuracy = 50; if (!geolocator.IsListening) { await geolocator.StartListeningAsync(5, 10); } oldPosition = await geolocator.GetPositionAsync(50000, CancellationToken.None); geolocator.PositionChanged += Geolocator_PositionChanged; } catch (Exception ex) { System.Diagnostics.Debug.WriteLine("Error : {0}", ex); return(false); } return(true); }
public async Task <Xamarin.Forms.Maps.Position> GetPosition() { IsBusy = true; Xamarin.Forms.Maps.Position p; try { if (!locator.IsGeolocationAvailable) { p = new Xamarin.Forms.Maps.Position(); } if (!locator.IsGeolocationEnabled) { p = new Xamarin.Forms.Maps.Position(); } var position = await locator.GetPositionAsync(timeoutMilliseconds : 10000); p = new Xamarin.Forms.Maps.Position(position.Latitude, position.Longitude); } catch (Exception ex) { Debug.WriteLine(ex.Message); p = new Xamarin.Forms.Maps.Position(); } IsBusy = false; return(p); }
private async void GetGPS() { IGeolocator locator = CrossGeolocator.Current; locator.DesiredAccuracy = 50; if (locator.IsGeolocationAvailable) { if (locator.IsGeolocationEnabled) { try { position = await locator.GetPositionAsync(timeoutMilliseconds : 10000); AddListItem("Latitude:\t" + position.Latitude + "\nLongitude:\t" + position.Longitude); } catch { await DisplayAlert("Error", "Could not get GPS data.", "OK"); } } } list.ScrollTo(listItems.Last(), ScrollToPosition.End, true); }
protected override void OnAppearing() { Device.BeginInvokeOnMainThread(async() => { if (_geolocator.IsGeolocationEnabled) { _position = await _geolocator.GetLastKnownLocationAsync(); if (_position == null) { _position = await _geolocator.GetPositionAsync(); } var formsMapPosition = new Xamarin.Forms.Maps.Position(_position.Latitude, _position.Longitude); var mapSpan = MapSpan.FromCenterAndRadius(formsMapPosition, Distance.FromKilometers(1.5)); _map.MoveToRegion(mapSpan); Incidents = await AdaptatonEndpoint.Instance.GetIncidents(); foreach (var incident in Incidents) { _map.Pins.Add(new Pin { Position = new Xamarin.Forms.Maps.Position((double)incident.Latitude, (double)incident.Longitude), Label = incident.Id }); } } else { await DisplayAlert("Un momento", "Debes activar tu GPS para usar la aplicación.", "OK"); } }); }
async private void Button_Clicked_In(object sender, EventArgs e) { try { IsBusy = true; IGeolocator locator = CrossGeolocator.Current; locator.DesiredAccuracy = 50; Position position = await locator.GetPositionAsync(TimeSpan.FromSeconds(10)); AttendanceModel model = new AttendanceModel() { IsMockedLocation = App._IsMockLocation.ToString(), Latitude = Convert.ToString(position.Latitude), Longitude = Convert.ToString(position.Longitude), UserId = Convert.ToString(App._UserId), AttendanceMode = "IN" }; await CallApiForAttendance(model); } catch (Exception ex) { lblMessage.Text = ex.Message; lblMessage.TextColor = Color.Red; } finally { IsBusy = false; } }
public async Task <Position> GetPositionAsync() { geolocator.DesiredAccuracy = 1000; var position = await geolocator.GetPositionAsync(); return(new Position(position.Latitude, position.Longitude)); }
public async Task <bool> GetLocation() { Position currentpos = null; try { currentpos = await _locator.GetPositionAsync(timeout : _timeout); } catch (Exception e) { Console.WriteLine("Geolocator.GetLocation error: " + e.Message); } if (currentpos != null) { Latitude = currentpos.Latitude; Longitude = currentpos.Longitude; Timestamp = currentpos.Timestamp.DateTime; return(true); } else { return(false); } }
private async Task GetPosition() { var _cancelSource = new CancellationTokenSource(); TaskScheduler _scheduler = TaskScheduler.FromCurrentSynchronizationContext(); var PositionStatus = string.Empty; var PositionLatitude = string.Empty; var PositionLongitude = string.Empty; var IsBusy = true; await Geolocator.GetPositionAsync(10000, _cancelSource.Token, true).ContinueWith(t => { IsBusy = false; if (t.IsFaulted) { PositionStatus = ((GeolocationException)t.Exception.InnerException).Error.ToString(); _contentpage.DisplayAlert("sdf", PositionStatus, "asd"); } else if (t.IsCanceled) { _contentpage.DisplayAlert("sdf", "IsCanceled", "asd"); } else { PositionLatitude = "La: " + t.Result.Latitude.ToString("N4"); PositionLongitude = "Lo: " + t.Result.Longitude.ToString("N4"); _contentpage.DisplayAlert("sdf", PositionLatitude + "," + PositionLongitude, "asd"); } }, _scheduler); }
protected override void OnAppearing() { Device.BeginInvokeOnMainThread(async() => { if (_geolocator.IsGeolocationEnabled) { _position = await _geolocator.GetLastKnownLocationAsync(); if (_position == null) { _position = await _geolocator.GetPositionAsync(); } var formsMapPosition = new Xamarin.Forms.Maps.Position(_position.Latitude, _position.Longitude); var mapSpan = MapSpan.FromCenterAndRadius(formsMapPosition, Distance.FromKilometers(1)); _map.MoveToRegion(mapSpan); MyPositionPin = new Pin { Address = "Mi ubicación", Position = formsMapPosition, Type = PinType.Generic, Label = "Mi ubicación" }; _map.Pins.Add(MyPositionPin); } else { await DisplayAlert("Un momento", "Debes activar tu GPS para usar la aplicación.", "OK"); } }); }
async Task GetPosition() { // Inicia o Acelelometro var device = Resolver.Resolve <IDevice>(); Debug.WriteLine(device.FirmwareVersion); this.geolocator = DependencyService.Get <IGeolocator> (); //geolocator.PositionError += OnPositionError; //geolocator.PositionChanged += OnPositionChanged; if (!geolocator.IsListening) { geolocator.StartListening(minTime: 1000, minDistance: 0); } var position = await geolocator.GetPositionAsync(timeout : 10000); string message = string.Format("Latitude: {0} | Longitude: {1}", position.Latitude, position.Longitude); Debug.WriteLine(message); device.Accelerometer.ReadingAvailable += getEixos; }
public async void MapViewInit() { CLLocationManager manager = new CLLocationManager(); manager.RequestWhenInUseAuthorization(); IGeolocator locator = CrossGeolocator.Current; locator.DesiredAccuracy = 50; Position position = await locator.GetPositionAsync(timeoutMilliseconds : 20000); Console.WriteLine("Position Status: {0}", position.Timestamp); Console.WriteLine("Position Latitude: {0}", position.Latitude); Console.WriteLine("Position Longitude: {0}", position.Longitude); CLLocationCoordinate2D mapCenter = new CLLocationCoordinate2D(position.Latitude, position.Longitude); //CLLocationCoordinate2D mapCenter = new CLLocationCoordinate2D(22.617193, 120.3032346); CenterLocation = map.CenterCoordinate = mapCenter; map.Region = MKCoordinateRegion.FromDistance(mapCenter, 1000, 1000); //map.ShowsUserLocation = true; CustomMapViewDelegate customDelegate = new CustomMapViewDelegate(); customDelegate.OnRegionChanged += MapViewOnRegionChanged; map.Delegate = customDelegate; }
// added using System.Threading.Tasks; public async Task <Position> GetLocation(TimeSpan minimumTime, int minimumMeters) { position = await locator.GetPositionAsync(); await locator.StartListeningAsync(minimumTime, minimumMeters); return(position); }
public async Task <bool> StartNavigation() { var locationPermission = DependencyService.Get <ILocationPermission>(); var permissionGranted = await locationPermission.CheckAndAsk(); GeoPosition position = null; try { position = (await _geoLocator.GetPositionAsync()).ToGeoPosition(); } catch (GeolocationException e) { var properties = new Dictionary <string, string> { { "Permission status", permissionGranted.ToString() } }; Crashes.TrackError(e, properties); return(false); } if (_route.GetSectionForPosition(position) == RouteExtensions.DefaultSection) { Application.Current.MainPage = new NotNearRoutePage(); return(false); } NextWaypoint = _route.FindClosestWaypoint(position); VisitedWaypoints = new List <RoutePoint> { NextWaypoint }; var section = _route.GetSectionForPosition(NextWaypoint); NavigationDirection = _route.DetermineLongestDirectionInSection(NextWaypoint, section); RouteEnumerator = _route.GetEnumerable(NextWaypoint, NavigationDirection).GetEnumerator(); RouteEnumerator.MoveNext(); ActivateNextWaypoint(); InitializeMap(position); await StartListeningToLocationAsync(); return(true); }
public async void GetLocation() { var position = await locator.GetPositionAsync(TimeSpan.FromSeconds(10)); lblPositionStatus.Text = position.Timestamp.ToString(); lblPositionLatitude.Text = position.Latitude.ToString(); lblPositionLongitude.Text = position.Longitude.ToString(); }
/// <summary> /// Gets the current location. /// </summary> /// <returns>The current location.</returns> public async Task <TaxiPosition> GetCurrentLocation() { var position = await m_locator.GetPositionAsync(10000); m_currentTaxiPosition = new TaxiPosition(position.Latitude, position.Longitude); return(m_currentTaxiPosition); }
/// <summary> /// Gets a GPS reading. Will block the current thread while waiting for a GPS reading. Should not /// be called from the main / UI thread, since GPS runs on main thread (will deadlock). If you need /// to get a reading from the UI thread, call GetReadingAsync instead. /// </summary> /// <returns>The reading.</returns> /// <param name="cancellationToken">Cancellation token.</param> /// <param name="checkAndObtainPermission">Whether or not to check for and obtain permission for the reading. Note that, on Android, this /// may result in bringing the Sensus UI to the foreground. If you do not wish this to happen, then obtain the user's permission prior to /// calling this method.</param> public Position GetReading(CancellationToken cancellationToken, bool checkAndObtainPermission) { lock (_locker) { if (checkAndObtainPermission && SensusServiceHelper.Get().ObtainPermission(Permission.Location) != PermissionStatus.Granted) { return(null); } if (_readingIsComing) { SensusServiceHelper.Get().Logger.Log("A GPS reading is coming. Will wait for it.", LoggingLevel.Debug, GetType()); } else { _readingIsComing = true; // tell any subsequent, concurrent callers that we're taking a reading _readingWait.Reset(); // make them wait Task.Run(async() => { try { SensusServiceHelper.Get().Logger.Log("Taking GPS reading.", LoggingLevel.Debug, GetType()); DateTimeOffset readingStart = DateTimeOffset.UtcNow; _locator.DesiredAccuracy = SensusServiceHelper.Get().GpsDesiredAccuracyMeters; Position newReading = await _locator.GetPositionAsync(TimeSpan.FromMilliseconds(_readingTimeoutMS), cancellationToken); DateTimeOffset readingEnd = DateTimeOffset.UtcNow; if (newReading != null) { // create copy of new position to keep return references separate, since the same Position object is returned multiple times when a change listener is attached. _reading = new Position(newReading); SensusServiceHelper.Get().Logger.Log("GPS reading obtained in " + (readingEnd - readingStart).TotalSeconds + " seconds.", LoggingLevel.Verbose, GetType()); } } catch (Exception ex) { SensusServiceHelper.Get().Logger.Log("GPS reading failed: " + ex.Message, LoggingLevel.Normal, GetType()); _reading = null; } _readingWait.Set(); // tell anyone waiting on the shared reading that it is ready _readingIsComing = false; // direct any future calls to this method to get their own reading }); } } _readingWait.WaitOne(_readingTimeoutMS); if (_reading == null) { SensusServiceHelper.Get().Logger.Log("GPS reading is null.", LoggingLevel.Normal, GetType()); } return(_reading); }
private async void GetLocation() { position = await locator.GetPositionAsync(); if (!locator.IsListening) { await locator.StartListeningAsync(TimeSpan.FromMinutes(30), 500); } }
public async Task <Position> GetGeoLocation() { IGeolocator locator = CrossGeolocator.Current; locator.DesiredAccuracy = 100; Position position = await locator.GetPositionAsync(TimeSpan.FromSeconds(10)); return(position); }
public async Task <Position> GetLocation(TimeSpan minimumTime, int minimumMeters) { position = await locator.GetPositionAsync(); // get current position if (!locator.IsListening) { await locator.StartListeningAsync(minimumTime, minimumMeters); } return(position); }
async public Task <Tuple <double, double> > GetCurrentLocationCodinateAsync() { var currentPosition = await _geolocator.GetPositionAsync(10000); var latitude = currentPosition.Latitude; var longitude = currentPosition.Longitude; Tuple <double, double> result = new Tuple <double, double>(latitude, longitude); return(result); }
private async void GetMyLocation() { IGeolocator geoLocator = CrossGeolocator.Current; geoLocator.DesiredAccuracy = 50; Position position = await geoLocator.GetPositionAsync(timeout : TimeSpan.FromSeconds(20)); lblLatitude.Text = position.Latitude.ToString("0:0.0000000"); lblLongitude.Text = position.Longitude.ToString("0:0.0000000"); }
public AddGeofenceViewModel(IGeofenceManager geofences, IUserDialogs dialogs, IViewModelManager viewModelMgr, IGeolocator geolocator) { this.Add = ReactiveCommand.CreateAsyncTask( this.WhenAny( x => x.RadiusMeters, x => x.Latitude, x => x.Longitude, x => x.Identifer, (radius, lat, lng, id) => { if (radius.Value < 100) return false; if (lat.Value < -90 || lat.Value > 90) return false; if (lng.Value < -180 || lng.Value > 180) return false; if (id.Value.IsEmpty()) return false; return true; } ), async x => { geofences.StartMonitoring(new GeofenceRegion { Identifier = this.Identifer, Center = new Position(this.Latitude, this.Longitude), Radius = Distance.FromMeters(this.RadiusMeters) }); await viewModelMgr.PopNav(); } ); this.UseCurrentLocation = ReactiveCommand.CreateAsyncTask(async x => { try { var current = await geolocator.GetPositionAsync(5000); this.Latitude = current.Latitude; this.Longitude = current.Longitude; } catch { } }); }
public async void Geolocate(IGeolocator locator) { try { var position = await locator.GetPositionAsync (10000); ((App)App.Current).Latitude = position.Latitude; ((App)App.Current).Longitude = position.Longitude; System.Diagnostics.Debug.WriteLine("I've got coordinates!"); if(position.Latitude == 0 && position.Longitude == 0) ((App)App.Current).LogError("GetPosition", "Координаты успешно получены, но нулевые!", "", new {}); Navigate(); } catch(GeolocationException e1) { if (e1.Error == GeolocationError.PositionUnavailable) { UseGeoError (e1); Navigate(); } else { App.IOSAppDelegate.Confirm ("Определение погоды", "Для определения точных погодных условий включите, пожалуйста, службу геолокации в настройках. Если Вы пропустите этот шаг, то местоположение будет задано по умолчанию (СПБ). Если Вы уже включили геолокацию, нажмите \"Повторить\".", async (int n) => { if(n == 0) { UseGeoError (e1, false); Navigate(); } else { Geolocate(locator); } }, "Пропустить", "Повторить"); } } catch(Exception e2) { UseGeoError (e2); Navigate(); } }
async Task GetPosition () { // Inicia o Acelelometro var device = Resolver.Resolve<IDevice>(); Debug.WriteLine (device.FirmwareVersion); this.geolocator = DependencyService.Get<IGeolocator> (); //geolocator.PositionError += OnPositionError; //geolocator.PositionChanged += OnPositionChanged; if (!geolocator.IsListening) geolocator.StartListening(minTime: 1000, minDistance: 0); var position = await geolocator.GetPositionAsync (timeout: 10000); string message = string.Format ("Latitude: {0} | Longitude: {1}", position.Latitude, position.Longitude); Debug.WriteLine (message); device.Accelerometer.ReadingAvailable += getEixos; }