public App(string pushNotifParameter = null) { //INITIALIZATION if (AppContext == null) { IGeolocator geoLocator = CrossGeolocator.Current; IRepository repository = new AzureRepository("http://xdevmessaging.azurewebsites.net/"); IPositionUpdater positionUpdater = new PositionUpdater(repository); IDisplayNameProvider <User> userDisplayNameProvider = new UserDisplayNameProvider(); MeetupRepository meetupRepository = new MeetupRepository(); AppContext = new AppContext(repository, geoLocator, positionUpdater, userDisplayNameProvider, meetupRepository); } //Check stored data //if (AppContext.IsUserStored) //{ // AppContext.LoginFromStorageAsync().Wait(); // var mapPage = new NavigationPage(new MapPage(AppContext)); // MainPage = mapPage; //} //else //{ var loginPage = new NavigationPage(new LoginPage(AppContext)); MainPage = loginPage; //} }
public MapViewModel() { _geolocator = Resolver.Resolve <IGeolocator>(); // GetWeb(); GetPosition(); NavigateToBack = new Command(() => Navigation.PopAsync()); }
public MapViewModel() { _geolocator = Resolver.Resolve<IGeolocator>(); // GetWeb(); GetPosition(); NavigateToBack = new Command(() => Navigation.PopAsync()); }
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); } }
private double[] GetCurrentLocation() { double[] data = new double[2]; int platform = 0; switch (Device.RuntimePlatform) { case Device.iOS: platform = 1; break; } if (platform == 0) // Android { IGeolocator locator = DependencyService.Get <IGeolocator>(); double currentLatitude = 0, currentLongitude = 0; locator.locationObtained += (sender, e) => { currentLatitude = e.lat; currentLatitude = Math.Round(currentLatitude * 100000.00) / 100000.00; currentLongitude = e.lng; currentLongitude = Math.Round(currentLongitude * 100000.00) / 100000.00; }; locator.ObtainMyLocation(); data[0] = currentLatitude; data[1] = currentLongitude; } else // iOS { data[0] = MainPage.currrentLatitude; data[1] = MainPage.currentLongitude; } return(data); }
public MainMapPage() { _geolocator = CrossGeolocator.Current; _map = new Map { MapType = MapType.Street, IsShowingUser = true }; _incidentBtn = new Button() { BackgroundColor = (Color)App.Current.Resources["Blue"], TextColor = Color.White, Text = "Nuevo reporte" }; _incidentBtn.Clicked += _incidentBtn_Clicked; var grid = new Grid { RowDefinitions = new RowDefinitionCollection { new RowDefinition { Height = GridLength.Star }, new RowDefinition { Height = 40 } }, RowSpacing = 0 }; grid.Children.Add(_map); grid.Children.Add(_incidentBtn, 0, 1); Content = grid; }
public async Task <IGeolocator> GetGeolocator() { IGeolocator geoLocator = null; if (deviceCanonicalNames != null && deviceCanonicalNames.Length > 0) { var qstarsGeolocator = new QstarzGeolocator(); foreach (string deviceName in deviceCanonicalNames) { BluetoothConnectionStatus status = await qstarsGeolocator.ConnectToDevice(deviceName); if (status == BluetoothConnectionStatus.BluetoothDisabled) { qstarsGeolocator.Dispose(); break; } if (status == BluetoothConnectionStatus.DeviceNotFound) { qstarsGeolocator.Dispose(); continue; } geoLocator = qstarsGeolocator; break; } } if (geoLocator == null) { geoLocator = new InternalGeolocator(); } return(geoLocator); }
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; } }
private void SetLocation() { IGeolocator locator = DependencyService.Get <IGeolocator>(); locator.locationObtained += (sender, e) => { UserLatitude = e.lat; UserLatitude = Math.Round(UserLatitude * 100000.00) / 100000.00; userLatitude = UserLatitude; UserLongitude = e.lng; UserLongitude = Math.Round(userLongitude * 100000.00) / 100000.00; userLongitude = UserLongitude; }; locator.ObtainMyLocation(); Debug.WriteLine("userLatitude: " + userLatitude + ", userLongitude: " + userLongitude); userOffset = new DateTimeOffset(DateTime.Now).Offset.Hours; DateLocation defaultSettings = new DateLocation { myDate = DateTime.Now, myLatitude = userLatitude, myLongitude = userLongitude, myOffset = userOffset }; Application.Current.Properties["Default"] = defaultSettings; }
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); }
private async void AutoSuggestBox_TextChanged(AutoSuggestBox sender, AutoSuggestBoxTextChangedEventArgs args) { string address = SuggestBox.Text; if (!CrossGeolocator.Current.IsListening) { IGeolocator locator = await LocationLogic.GetGeolocator(PermissionsLogic.IsLocationAccessPermitted); } var location = await LocationLogic.GetLocation(); string PositionNow = LocationLogic.LocationStringBuilder(location); var places = await GoogleAPIRequest.GetPlaces(PositionNow, address); // Only get results when it was a user typing, // otherwise assume the value got filled in by TextMemberPath // or the handler for SuggestionChosen. if (args.Reason == AutoSuggestionBoxTextChangeReason.UserInput) { //Set the ItemsSource to be your filtered dataset //sender.ItemsSource = dataset; var PlacesList = places.predictions.ToList(); List <string> AddresList = new List <string>(); PlacesList.ForEach(l => AddresList.Add(l.description)); SuggestBox.ItemsSource = AddresList; } }
/// <summary> /// Creates a new maps page to explore /// </summary> public ExploreMapPage() { this.zoomToMyPosition = false; this.geolocator = Plugin.Geolocator.CrossGeolocator.Current; Task.Factory.StartNew(this.InitLayoutAsync); }
private void geolocator_StatusChanged(IGeolocator sender, StatusChangedEventArgs args) { if (GeolocatorStatusChanged != null) { GeolocatorStatusChanged(this, args); } }
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 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); }
/// <summary> /// Initializes a new instance of the <see cref="T:Locator.Portable.ViewModels.MapPageViewModel"/> class. /// </summary> /// <param name="navigation">Navigation.</param> /// <param name="geolocator">Geolocator.</param> /// <param name="commandFactory">Command factory.</param> /// <param name="geocodingWebServiceController">Geocoding repository.</param> public MapPageViewModel(INavigationService navigation, IGeolocator geolocator, Func <Action, ICommand> commandFactory, IGeocodingWebServiceController geocodingWebServiceController) : base(navigation) { _geolocator = geolocator; _geocodingWebServiceController = geocodingWebServiceController; _nearestAddressCommand = commandFactory(() => FindNearestSite()); _geolocationCommand = commandFactory(() => { if (_geolocationUpdating) { geolocator.Stop(); } else { geolocator.Start(); } GeolocationButtonTitle = _geolocationUpdating ? "Start" : "Stop"; _geolocationUpdating = !_geolocationUpdating; }); _positions = new List <IPosition> (); LocationUpdates = new Subject <IPosition> (); ClosestUpdates = new Subject <IPosition> (); }
/// <summary> /// Creates a new maps page /// </summary> public MapPage() { this.Title = Constants.AppTitle; this.pageIsVisible = false; this.zoomToMyPosition = false; this.updateMapSettings = false; this.updateLocationsList = false; this.updateTrackList = false; this.geolocator = DependencyService.Get <GeolocationService>().Geolocator; Task.Run(this.InitLayoutAsync); MessagingCenter.Subscribe <App, Layer>(this, Constants.MessageAddLayer, this.OnMessageAddLayer); MessagingCenter.Subscribe <App, Layer>(this, Constants.MessageZoomToLayer, (app, layer) => this.OnMessageZoomToLayer(layer)); MessagingCenter.Subscribe <App, Layer>(this, Constants.MessageSetLayerVisibility, (app, layer) => this.OnMessageSetLayerVisibility(layer)); MessagingCenter.Subscribe <App, Layer>(this, Constants.MessageRemoveLayer, (app, layer) => this.OnMessageRemoveLayer(layer)); MessagingCenter.Subscribe <App>(this, Constants.MessageClearLayerList, (app) => this.OnMessageClearLayerList()); MessagingCenter.Subscribe <App, Track>(this, Constants.MessageAddTrack, this.OnMessageAddTrack); MessagingCenter.Subscribe <App, Location>( this, Constants.MessageAddTourPlanLocation, async(app, location) => await this.OnMessageAddTourPlanLocation(location)); MessagingCenter.Subscribe <App, MapPoint>(this, Constants.MessageZoomToLocation, async(app, location) => await this.OnMessageZoomToLocation(location)); MessagingCenter.Subscribe <App, Track>(this, Constants.MessageZoomToTrack, async(app, track) => await this.OnMessageZoomToTrack(track)); MessagingCenter.Subscribe <App>(this, Constants.MessageUpdateMapSettings, this.OnMessageUpdateMapSettings); MessagingCenter.Subscribe <App>(this, Constants.MessageUpdateMapLocations, this.OnMessageUpdateMapLocations); MessagingCenter.Subscribe <App>(this, Constants.MessageUpdateMapTracks, this.OnMessageUpdateMapTracks); }
public SearchFilersPage() { Utils.SetupPage(this); BuildLayout(); locator = Xamarin.Forms.DependencyService.Get <IGeolocator>(); locator.PositionChanged += (o, arg) => { locator.StopListening(); if (arg.Position != null) { LocationFilter = new LocationFilter() { Lat = arg.Position.Latitude, Lon = arg.Position.Longitude, Radius = RADIUS }; LocationAddress = "Current location"; } }; locator.PositionError += (o, arg) => { locator.StopListening(); }; locator.StopListening(); locator.StartListening(0, 0); }
public GeoLocator() { locator = CrossGeolocator.Current; locator.PositionChanged += PositionChanged; Listen(); }
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); }
private void geolocator_UnrecoverableError(IGeolocator sender, GeolocationErrorEventArgs args) { if (GeolocatorUnrecoverableError != null) { GeolocatorUnrecoverableError(this, args); } }
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; }
private Geolocator() { locator = Xamarin.Forms.DependencyService.Get <IGeolocator>(); //locator.DesiredAccuracy = 1000; locator.PositionChanged += Locator_PositionChanged; locator.PositionError += Locator_PositionError; }
public SagslistePage() { cache = Resolver.Resolve <ISimpleCache>(); geolocator = Resolver.Resolve <IGeolocator>(); sager = new ObservableCollection <Group <string, Sag> >(); InitializeComponent(); }
void Setup(){ if (this.geolocator != null) return; this.geolocator = DependencyService.Get<IGeolocator> (); this.geolocator.PositionError += OnListeningError; this.geolocator.PositionChanged += OnPositionChanged; }
public LocationService() { locator = CrossGeolocator.Current; locator.DesiredAccuracy = 75; maps = CrossExternalMaps.Current; }
async Task GetPosition() { if (geolocator == null) { geolocator = DependencyService.Get <IGeolocator>() ?? Resolver.Resolve <IGeolocator>(); } await this.geolocator.GetPositionAsync(timeout : 10000) .ContinueWith(t => { if (t.IsFaulted) { PositionStatus = ((GeolocationException)t.Exception.InnerException).Error.ToString(); } else if (t.IsCanceled) { PositionStatus = "Cancelado"; } else { PositionStatus = t.Result.Timestamp.ToString("G"); App.Latitude = t.Result.Latitude; App.Longitude = t.Result.Longitude; } }); }
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; }
protected async override void OnAppearing() { base.OnAppearing(); var hasPermission = await Utils.CheckPermissions(Permission.Location); if (!hasPermission) { return; } if (CrossGeolocator.Current.IsListening) { return; } await CrossGeolocator.Current.StartListeningAsync(TimeSpan.FromSeconds(5), 10, true); locator = CrossGeolocator.Current; locator.PositionChanged += Locator_PositionChanged; if (OrientationSensor.IsMonitoring) { OrientationSensor.Stop(); } else { OrientationSensor.Start(SensorSpeed.Normal); } OrientationSensor.ReadingChanged += OrientationSensor_ReadingChanged;; }
public bool CheckService() { this.locator = CrossGeolocator.Current; this.locator.DesiredAccuracy = desiredAccuracyInMeters; this.Validate(); return(this.CurrentInfo.Status == PositionResult.Statuses.OK); }
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); } } }
public CrossLocationProvider() { locator = CrossGeolocator.Current; locator.AllowsBackgroundUpdates = true; locator.DesiredAccuracy = 100; locator.PositionChanged += OnChanged; }
void Setup () { if (_geolocator != null) return; _geolocator = DependencyService.Get<IGeolocator> (); _geolocator.PositionError += GeolocatorOnPositionError; }
void Setup() { if (this.geolocator != null) return; this.geolocator = DependencyService.Get<IGeolocator> (); if(!this.geolocator.IsListening) this.geolocator.StartListening (1000, 5); }
public GeoCoordinatesViewModel () { Locator = CrossGeolocator.Current; Locator.DesiredAccuracy = 50; //Locator.StartListeningAsync (1, 0); Locator.PositionChanged += (object sender, PositionEventArgs e) => { Latitude = e.Position.Latitude.ToString(); Longitude = e.Position.Longitude.ToString(); }; }
public void EnableGPSTracking(AccessRights rights) { Console.WriteLine ("EnableGPSTracking rights.IsGPSTracking {0}",rights.IsGPSTracking); if (rights.IsGPSTracking) { locator = CrossGeolocator.Current; if (locator.IsGeolocationAvailable) { if (!locator.IsListening) { GetMyLocation (); } } } }
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 { } }); }
void SetupGeolocator() { if (this._geolocator != null) return; else { this._geolocator = new Geolocator (); } //this._geolocator = DependencyService.Get<IGeolocator> (); this._geolocator.PositionError += OnListeningError; this._geolocator.PositionChanged += OnPositionChanged; this._geolocator.StartListening (500, 1); }
void SetupGeolocator() { if (this._geolocator != null) return; else { this._geolocator = new Geolocator (); } this._geolocator.PositionError += OnListeningError; this._geolocator.PositionChanged += OnPositionChanged; this._geolocator.StartListening (500, 1); }
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(); } }
private GpsReceiver() { _readingIsComing = false; _readingWait = new ManualResetEvent(false); _reading = null; _readingTimeoutMS = 120000; _locator = CrossGeolocator.Current; _listenerHeadings = new List<Tuple<EventHandler<PositionEventArgs>, bool>>(); _locator.PositionChanged += (o, e) => { SensusServiceHelper.Get().Logger.Log("GPS position has changed.", LoggingLevel.Verbose, GetType()); if (PositionChanged != null) PositionChanged(o, e); }; }
public UpdateLocationPage () { locator = CrossGeolocator.Current; locator.DesiredAccuracy = 5; longitude = new Label (); latitude = new Label (); Content = new StackLayout { HorizontalOptions = LayoutOptions.Center, VerticalOptions = LayoutOptions.Center, Children = { longitude, latitude } }; }
private GpsReceiver() { _readingIsComing = false; _readingWait = new ManualResetEvent(false); _reading = null; _readingTimeoutMS = 120000; _minimumTimeHintMS = 5000; _locator = CrossGeolocator.Current; _locator.AllowsBackgroundUpdates = true; _locator.PausesLocationUpdatesAutomatically = false; _locator.DesiredAccuracy = 50; // setting this too low appears to result in very delayed GPS fixes. _listenerHeadings = new List<Tuple<EventHandler<PositionEventArgs>, bool>>(); _locator.PositionChanged += (o, e) => { SensusServiceHelper.Get().Logger.Log("GPS position has changed.", LoggingLevel.Verbose, GetType()); if (PositionChanged != null) PositionChanged(o, e); }; }
public SiteService(IGeolocator geolocator, ISiteStorage siteStorage, IArtportalenService artportalenService) { _geolocator = geolocator; _siteStorage = siteStorage; _artportalenService = artportalenService; }
/// <summary> /// Method that does the initial gps setup /// </summary> public void SetupGps() { _locator = DependencyService.Get<IGeolocator>(); if (_locator.DesiredAccuracy != Definitions.Accuracy) { _locator.DesiredAccuracy = Definitions.Accuracy; } _cancelSource = new CancellationTokenSource(); _locator.PositionChanged += PositionChanged; _locator.PositionError += PositionError; }
public LocationManager () { locator=CrossGeolocator.Current; }
public Location() { this._geolocator = DependencyService.Get<IGeolocator>(); }
public InstagramVM(IGeolocator locationProvider) { locationProvider.Locations.Subscribe((loc) => ) }
//private string _parameterText; protected override void OnCreate(Bundle bundle) { base.OnCreate(bundle); SetContentView(Resource.Layout.Main); _locator = CrossGeolocator.Current; // New in iOS 9 allowsBackgroundLocationUpdates must be set if you are running a background agent to track location. I have exposed this on the Geolocator via: // disable because it drill down the battery very quickly _locator.AllowsBackgroundUpdates = false; _locator.DesiredAccuracy = 50; _locator.PositionChanged -= Locator_PositionChanged; _locator.PositionChanged += Locator_PositionChanged; // parse params to show any shared location if it exists ParseIntent(); var tintManager = new SystemBarTintManager(this); // set the transparent color of the status bar, 30% darker tintManager.SetTintColor(Color.ParseColor("#30000000")); tintManager.SetNavigationBarTintEnabled(true); tintManager.StatusBarTintEnabled = true; // prevent the soft keyboard from pushing the view up Window.SetSoftInputMode(SoftInput.AdjustNothing); // prepare icons for location / compass button var iconGenerator = new IconGenerator(this); iconGenerator.SetBackground(ResourcesCompat.GetDrawable(Resources, Resource.Drawable.ic_location, null)); _iconUserLocation = iconGenerator.MakeIcon(); iconGenerator.SetBackground(ResourcesCompat.GetDrawable(Resources, Resource.Drawable.ic_compass, null)); _iconCompass = iconGenerator.MakeIcon(); //var uiOptions = (int)this.Window.DecorView.SystemUiVisibility; //var newUiOptions = (int)uiOptions; //newUiOptions &= ~(int)SystemUiFlags.LowProfile; //newUiOptions &= ~(int)SystemUiFlags.Fullscreen; //newUiOptions &= ~(int)SystemUiFlags.HideNavigation; //newUiOptions &= ~(int)SystemUiFlags.Immersive; //newUiOptions |= (int)SystemUiFlags.ImmersiveSticky; //this.Window.DecorView.SystemUiVisibility = (StatusBarVisibility)newUiOptions; //Window.SetFlags(WindowManagerFlags.LayoutNoLimits, WindowManagerFlags.LayoutNoLimits); var toolbar = FindViewById<Toolbar>(Resource.Id.toolbar); //toolbar.Background.SetAlpha(200); ViewCompat.SetElevation(toolbar, 6f); SetSupportActionBar(toolbar); //Enable support action bar to display hamburger and back arrow // http://stackoverflow.com/questions/28071763/toolbar-navigation-hamburger-icon-missing _drawerLayout = FindViewById<DrawerLayout>(Resource.Id.drawer_layout); //_drawerToggle = new CustomActionBarDrawerToggle(this, _drawerLayout, toolbar, Resource.String.ApplicationName, Resource.String.ApplicationName); //_drawerToggle.DrawerIndicatorEnabled = true; _drawerLayout.SetDrawerListener(new CustomDrawerToggle(this)); //Enable support action bar to display hamburger var burgerImage = FindViewById<ImageButton>(Resource.Id.burgerImage); burgerImage.SetOnClickListener(new HomeButtonClickListener(this)); // SupportActionBar.SetHomeAsUpIndicator(Resource.Drawable.ic_menu); SupportActionBar.SetHomeButtonEnabled(false); SupportActionBar.SetDisplayHomeAsUpEnabled(false); SupportActionBar.SetDisplayShowCustomEnabled(false); navigationView = FindViewById<NavigationView>(Resource.Id.nav_view); navigationView.SetNavigationItemSelectedListener(new NavigationItemSelectedListener(this)); _bikesButton = FindViewById<FloatingActionButton>(Resource.Id.bikesButton); _bikesButton.BackgroundTintList = ColorStateList.ValueOf(Resources.GetColor(Resource.Color.primary_light)); _bikesButton.Click += BikesButton_Click; _parkingButton = FindViewById<FloatingActionButton>(Resource.Id.parkingButton); _parkingButton.BackgroundTintList = ColorStateList.ValueOf(Resources.GetColor(Resource.Color.primary_light)); _parkingButton.Click += ParkingButton_Click; _locationButton = FindViewById<FloatingActionButton>(Resource.Id.locationButton); _locationButton.BackgroundTintList = ColorStateList.ValueOf(Color.White); _locationButton.SetColorFilter(Color.Gray); _searchProgressBar = FindViewById<ProgressBar>(Resource.Id.searchProgressBar); // Doesn't work on Kitkat 4.4, use SetColorFilter instead //_locationButton.ImageTintList = ColorStateList.ValueOf(Color.Black); _locationButton.Click += LocationButton_Click; _tileButton = FindViewById<FloatingActionButton>(Resource.Id.tileButton); _tileButton.BackgroundTintList = ColorStateList.ValueOf(Color.White); _tileButton.SetColorFilter(Color.DarkGray); _tileButton.Click += TileButton_Click; var parent = (View)_tileButton.Parent; // Gets the parent view and posts a Runnable on the UI thread. // This ensures that the parent lays out its children before calling the getHitRect() method. // The getHitRect() method gets the child's hit rectangle (touchable area) in the parent's coordinates. parent.Post(() => { var touchRect = new Rect(); _tileButton.GetHitRect(touchRect); touchRect.Top -= 200; touchRect.Left -= 200; touchRect.Bottom += 200; touchRect.Right += 200; parent.TouchDelegate = new TouchDelegate(touchRect, _tileButton); }); _currentTileName = FindViewById<TextView>(Resource.Id.currentTileName); _currentTileNameAnimation = AnimationUtils.LoadAnimation(this, Resource.Animation.placeholder); _disappearTileNameAnimation = AnimationUtils.LoadAnimation(this, Resource.Animation.disappearAnimation); _currentTileNameAnimation.AnimationEnd += _currentTileNameAnimation_AnimationEnd; UnStickUserLocation(); AutoCompleteSearchPlaceTextView = FindViewById<AutoCompleteTextView>(Resource.Id.autoCompleteSearchPlaceTextView); AutoCompleteSearchPlaceTextView.ItemClick += AutoCompleteSearchPlaceTextView_ItemClick; googlePlacesAutocompleteAdapter = new GooglePlacesAutocompleteAdapter(this, Android.Resource.Layout.SimpleDropDownItem1Line); AutoCompleteSearchPlaceTextView.Adapter = googlePlacesAutocompleteAdapter; Observable.FromEventPattern(AutoCompleteSearchPlaceTextView, "TextChanged") .Throttle(TimeSpan.FromMilliseconds(300)) .Where(x => AutoCompleteSearchPlaceTextView.Text.Length >= 2) .Subscribe(async x => { try { RunOnUiThread(() => { _searchProgressBar.Visibility = ViewStates.Visible; }); using (var client = new HttpClient(new NativeMessageHandler())) { var response = await client.GetAsync(strAutoCompleteGoogleApi + AutoCompleteSearchPlaceTextView.Text + "&key=" + strGoogleApiKey).ConfigureAwait(false); var responseBodyAsText = await response.Content.ReadAsStringAsync().ConfigureAwait(false); var predictions = JsonConvert.DeserializeObject<PlaceApiModel>(responseBodyAsText).predictions.ToList(); googlePlacesAutocompleteAdapter.Results = predictions; if (AutoCompleteSearchPlaceTextView.Text.Length >= 2) { RunOnUiThread(() => { googlePlacesAutocompleteAdapter.NotifyDataSetChanged(); EndPlacesSearch(); }); } } } catch { RunOnUiThread(() => { EndPlacesSearch(); }); } }); //navigationView.NavigationItemSelected += (sender, e) => //{ // e.MenuItem.SetChecked(true); // //react to click here and swap fragments or navigate // drawerLayout.CloseDrawers(); //}; // trigger the creation of the injected dependencies _settingsService = SimpleIoc.Default.GetInstance<ISettingsService>(); _favoritesService = SimpleIoc.Default.GetInstance<IFavoritesService>(); }
public LocationTestService() { locator = CrossGeolocator.Current; locator.DesiredAccuracy = 10; }
private void GetMyLocation() { Console.WriteLine ("Start MyLocation"); locator = CrossGeolocator.Current; if (!locator.IsGeolocationEnabled) { enableGPS (); } locator.DesiredAccuracy = 20; locator.AllowsBackgroundUpdates = true; locator.PositionChanged+= Locator_PositionChanged; locator.PositionError+= Locator_PositionError; locator.StartListeningAsync(300000, 100, false); //5 min , 100 meter Console.WriteLine ("IsGeolocationAvailable {0}",locator.IsGeolocationAvailable); Console.WriteLine ("IsGeolocationEnabled {0}",locator.IsGeolocationEnabled); Console.WriteLine ("IsListening {0}",locator.IsListening); }
/// <summary> /// Method that handles cleanup of the viewmodel /// </summary> public void Dispose() { Definitions.GpsIsActive = false; _parentPage.Dispose(); Unsubscribe(); HandleStopGpsMessage(); _stopErrorTimer = true; // stop timer; if (_cancelSource != null) { _cancelSource.Cancel(); } _locator = null; }
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 MainViewModel() { _geolocator = DependencyService.Get<IGeolocator>(); _ws = new WeatherService(); GetGeolocationAndWeather(); }