private async void GetCoordinates()
        {
            Geolocator MyGeolocator = new Geolocator();
            MyGeolocator.DesiredAccuracyInMeters = 5;
            Geoposition MyGeoPosition = null;
            try
            {
                MyGeoPosition = await MyGeolocator.GetGeopositionAsync(TimeSpan.FromMinutes(1), TimeSpan.FromSeconds(10));
                currentGeoCoordinate = ConvertGeocoordinate(MyGeoPosition.Coordinate);

                myMap.Center = currentGeoCoordinate;
                myMap.ZoomLevel = 15;

                if (!comeinGeoCoordinate.IsUnknown)
                {
                    List<GeoCoordinate> geoCoordinates = new List<GeoCoordinate>();
                    geoCoordinates.Add(currentGeoCoordinate);
                    geoCoordinates.Add(comeinGeoCoordinate);

                    RouteQuery routeQuery = new RouteQuery();
                    routeQuery.Waypoints = geoCoordinates;
                    routeQuery.QueryCompleted += routeQuery_QueryCompleted;
                    routeQuery.QueryAsync();
                }
            }
            catch (UnauthorizedAccessException)
            {
                MessageBox.Show("Location is disabled in phone settings");
            }
            catch (Exception ex)
            {
            }
        }

        async void ZoomMap()
        {
            var geoloc = new Geolocator();
            resultsMap.Center = (await geoloc.GetGeopositionAsync()).Coordinate.Point;
            resultsMap.ZoomLevel = 15;

        }

 public MainPage()
 {
     this.InitializeComponent();
     shopDataSourceModel = new ShopDataSourceModel(ShopDataSource.Instance);
     DataContext = shopDataSourceModel;
     _geolocator = new Geolocator();
 }

        public async void obtenerposactual() // Metodo que ebtiene la posicion actual del usuario 
        {
            Geolocator migeolocalizador = new Geolocator();
            //Geoposition migeoposicion = await migeolocalizador.GetGeopositionAsync();
            Geoposition migeoposicion = null;
            try
            {
                migeoposicion = await migeolocalizador.GetGeopositionAsync();
            }
            catch (Exception ex)
            {
                if ((uint)ex.HResult == 0x80004004)
                {
                    // the application does not have the right capability or the locatiokn master switch is off
                    //feedback.Text = "location  is disabled in phone settings.";
                    MessageBox.Show("location  is disabled in phone settings.");
                }
                else
                {
                    // something else happened acquring the location
                    //feedback.Text = "Something wrong happened";
                    MessageBox.Show("Something wrong happened");
                }
            }

            Geocoordinate migeocoordenada = migeoposicion.Coordinate;
            GeoCoordinate migeoCoordenada = convertidirGeocoordinate(migeocoordenada);
            dibujaru(migeoCoordenada);
            mimapa.Center = migeoCoordenada;
            mimapa.ZoomLevel =11;
            cargarlista();

        }

        private async void GetCoordinates()
        {
            // Get the phone's current location.
            Geolocator MyGeolocator = new Geolocator();
            MyGeolocator.DesiredAccuracyInMeters = 5;
            Geoposition MyGeoPosition = null;
            try
            {
                MyGeoPosition = await MyGeolocator.GetGeopositionAsync(TimeSpan.FromMinutes(1), TimeSpan.FromSeconds(10));
                MyCoordinates.Add(new GeoCoordinate(MyGeoPosition.Coordinate.Latitude, MyGeoPosition.Coordinate.Longitude));
                Debug.WriteLine(MyGeoPosition.Coordinate.Latitude + " " + MyGeoPosition.Coordinate.Longitude);

                Mygeocodequery = new GeocodeQuery();
                Mygeocodequery.SearchTerm = "Hanoi, VN";
                Mygeocodequery.GeoCoordinate = new GeoCoordinate(MyGeoPosition.Coordinate.Latitude, MyGeoPosition.Coordinate.Longitude);

                Mygeocodequery.QueryCompleted += Mygeocodequery_QueryCompleted;
                Mygeocodequery.QueryAsync();

            }
            catch (UnauthorizedAccessException)
            {
                MessageBox.Show("Location is disabled in phone settings or capabilities are not checked.");
            }
            catch (Exception ex)
            {
                // Something else happened while acquiring the location.
                MessageBox.Show(ex.Message);
            }
        }

        private async void GetMyMapLocationAsync() {
            Geolocator geolocator = new Geolocator();
            geolocator.DesiredAccuracyInMeters = 50;

            try {
                Geoposition geoposition = await geolocator.GetGeopositionAsync(
                    maximumAge: TimeSpan.FromMinutes(5),
                    timeout: TimeSpan.FromSeconds(10)
                    );

                Map.Center = new GeoCoordinate(geoposition.Coordinate.Latitude, geoposition.Coordinate.Longitude);
                Map.ZoomLevel = ZoomLevel;

                myGeoCoordinate = geoposition.Coordinate.ToGeoCoordinate();
                     
                myMapOverlay.GeoCoordinate = myGeoCoordinate;
                myMapOverlay.Content = new Pushpin() {Content = "You"};
                CalculateDistanceBetweenMeAndUser();

            } catch (Exception ex) {
                if ((uint)ex.HResult == 0x80004004) {
                    // the application does not have the right capability or the location master switch is off
                    Debug.WriteLine("Geoposition not allowed or hadrware disabled");
                }
                //else
                {
                    // something else happened acquring the location
                    Debug.WriteLine("Geoposition is not available. Failure.");

                }
            }
        }

        private void OnStatusChanged(Geolocator geolocator, StatusChangedEventArgs args)
        {
            switch (args.Status)
            {
                case PositionStatus.Ready:
                    break;

                case PositionStatus.Initializing:
                    break;

                case PositionStatus.NoData:
                    // TODO - trace could be useful here?
                    SendError(MvxLocationErrorCode.PositionUnavailable);
                    break;

                case PositionStatus.Disabled:
                    // TODO - trace could be useful here?
                    SendError(MvxLocationErrorCode.ServiceUnavailable);
                    break;

                case PositionStatus.NotInitialized:
                    // TODO - trace could be useful here?
                    SendError(MvxLocationErrorCode.ServiceUnavailable);
                    break;

                case PositionStatus.NotAvailable:
                    // TODO - trace could be useful here?
                    SendError(MvxLocationErrorCode.ServiceUnavailable);
                    break;

                default:
                    throw new ArgumentOutOfRangeException();
            }
        }

        protected override async void OnNavigatedTo(NavigationEventArgs e)
        {
            Status.Text = "Status: " + "App started";

            //compass
            var compass = Windows.Devices.Sensors.Compass.GetDefault();
            compass.ReportInterval = 10;
            //compass.ReadingChanged += compass_ReadingChanged;
            Status.Text = "Status: " + "Compass started";

            //geo
            var gloc = new Geolocator();
            gloc.GetGeopositionAsync();
            gloc.ReportInterval = 60000;
            gloc.PositionChanged += gloc_PositionChanged;
            Status.Text = "Status: " + "Geo started";

            //Accelerometer
            var aclom = Accelerometer.GetDefault();
            aclom.ReportInterval = 1;
            aclom.ReadingChanged += aclom_ReadingChanged;

            //foursquare
            await GetEstablishmentsfromWed();

            //camera
            var mediaCapture = new MediaCapture();
            await mediaCapture.InitializeAsync();
            CaptureElement.Source = mediaCapture;
            await mediaCapture.StartPreviewAsync();
            Status.Text = "Status: " + "Camera feed running";
        }

 void geolocator_StatusChanged(Geolocator sender, StatusChangedEventArgs args)
 {
     if (args.Status.Equals(PositionStatus.Ready))
     {
        
     }
 }

        private async void ShowMyLocationOnTheMap()
        {
            Geolocator myGeolocator = new Geolocator();
            Geoposition myGeoposition = await myGeolocator.GetGeopositionAsync();
            Geocoordinate myGeocoordinate = myGeoposition.Coordinate;
            GeoCoordinate myGeoCoordinate = CoordinateConverter.ConvertGeocoordinate(myGeocoordinate);

            this.BettingMap.Center = myGeoCoordinate;
            this.BettingMap.ZoomLevel = 15;

            Ellipse myCircle = new Ellipse();
            myCircle.Fill = new SolidColorBrush(Colors.Blue);
            myCircle.Height = 20;
            myCircle.Width = 20;
            myCircle.Opacity = 50;

            MapOverlay myLocationOverlay = new MapOverlay();
            myLocationOverlay.Content = myCircle;
            myLocationOverlay.PositionOrigin = new Point(0.5, 0.5);
            myLocationOverlay.GeoCoordinate = myGeoCoordinate;

            MapLayer myLocationLayer = new MapLayer();
            myLocationLayer.Add(myLocationOverlay);

            BettingMap.Layers.Add(myLocationLayer);
        }

        /// <summary>
        /// Centers the map on current location at application launch.
        /// Subsequently only makes the map visible.
        /// </summary>
        /// <param name="sender">This page</param>
        /// <param name="e">Event arguments</param>
        private async void MainPage_Loaded(object sender, System.Windows.RoutedEventArgs e)
        {
            // Make Map visible again after returning from about page.
            Map.Visibility = Visibility.Visible;

            if (geoLocator == null)
            {
                geoLocator = new Geolocator();

                try
                {
                    Geoposition pos = await geoLocator.GetGeopositionAsync();

                    if (pos != null && pos.Coordinate != null)
                    {
                        Map.SetView(new GeoCoordinate(pos.Coordinate.Latitude, pos.Coordinate.Longitude), 10);
                        GetNearbyArtists();
                    }
                }
                catch (Exception /*ex*/)
                {
                    // Couldn't get current location. Location may be disabled.
                    MessageBox.Show("Current location cannot be obtained. It is "
                                  + "recommended that location service is turned "
                                  + "on in phone settings when using Bands Around.\n"
                                  + "\nNow centering on London.");
                    Map.Center = new GeoCoordinate(51.51, -0.12);
                    Map.SetView(new GeoCoordinate(51.51, -0.12), 10);
                    GetNearbyArtists();
                }
            }
        }

        /// <summary>
        /// Invoked when this page is about to be displayed in a Frame.
        /// </summary>
        /// <param name="e">Event data that describes how this page was reached.
        /// This parameter is typically used to configure the page.</param>
        protected async override void OnNavigatedTo(NavigationEventArgs e)
        {
            //Wait for the data to be loaded from the HSL webservice
            try
            {
                await App.VehicleViewModel.LoadVehicleDetails();
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }

            //Get the geolocation of the phone to display in the map
            Geolocator geolocator = new Geolocator();
            Geoposition geoposition = null;
            try
            {
                geoposition = await geolocator.GetGeopositionAsync();
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }
            hslMapControl.Center = geoposition.Coordinate.Point;
            hslMapControl.ZoomLevel = 15;
            InitiateRefreshTimer();
        }

        /// <summary>
        /// This gets the last known location or gets a new one if the last one has expired.
        /// </summary>
        /// <param name="forceUpdate">Force updates even if the location has not expired.</param>
        /// <returns>The last good location.</returns>
        public static async Task<Geoposition> GetLocation(bool forceUpdate = false)
        {
            if (GetConfirmation())
            {
                var geolocator = new Geolocator();
                geolocator.DesiredAccuracy = PositionAccuracy.High;

                try
                {
                    if (CachedLocation == null || forceUpdate || lastUpdateTime - DateTime.Now < TimeSpan.FromMinutes(5))
                    {
                        CachedLocation = await geolocator.GetGeopositionAsync(TimeSpan.FromMinutes(5), TimeSpan.FromSeconds(10));
                    }
                    return CachedLocation; 
                }
                catch (Exception ex)
                {
                    if ((uint)ex.HResult == 0x80004004)
                    {
                        MessageBox.Show("Location is disabled in phone settings.");
                    }
                    else
                    {
                        return null;
                    }
                }
            }
            return null;
        }

        async void LookingFor_Loaded(object sender, RoutedEventArgs e)
        {
            Geolocator geolocator = new Geolocator();
            //await Task.Delay(1500);
            Geoposition geoposition = null;
            try
            {
                geoposition = AppData.GeoPosition;// await geolocator.GetGeopositionAsync();
            }

            catch (Exception ex)
            {
                // Handle errors like unauthorized access to location
                // services or no Internet access.
            }

            while (this.ViewModel.MatchingWhistles == null)
            {
                await Task.Delay(1000);
            }
            foreach (MatchingWhistles whistle in this.ViewModel.MatchingWhistles.matchingWhistles)
            {
                BasicGeoposition whistleLocation = new BasicGeoposition();
                whistleLocation.Longitude = whistle.location.coordinates[0];
                whistleLocation.Latitude = whistle.location.coordinates[1];
                AddPushpin(whistleLocation, whistle.name, whistle._id);
            }

            myMapControl.Center = geoposition.Coordinate.Point;
            myMapControl.ZoomLevel = 15;
          
        }

    private void btnStart_Click(object sender, RoutedEventArgs e) {

      try {
      geolocator = new Geolocator {
        DesiredAccuracy = PositionAccuracy.High, 
        MovementThreshold = 50
      };

        geolocator.StatusChanged += (sender1, args) =>

                                    Dispatcher.BeginInvoke(() =>
                                      { tbStatus.Text = args.Status.ToString(); });


        geolocator.PositionChanged += (sender1, args) => Dispatcher.BeginInvoke(() =>
          {
            tbPos.Text = string.Format("\r\n\t{0:#0.0000}\r\n\t{1:#0.0000}",
                                       args.Position.Coordinate.Latitude,
                                       args.Position.Coordinate.Longitude);
          });


        btnOneShot.IsEnabled = false;
        btnStart.IsEnabled = false;
        btnStop.IsEnabled = true;
      } catch (UnauthorizedAccessException) {
        MessageBox.Show("Bitte erlauben Sie den Zugriff auf die Location API für diese App.");
      }

     

    }

        public async Task<Geoposition> HandeleAccessStatus(GeolocationAccessStatus accessStatus)
        {
            Geoposition geoposition = null;

            var message = "";

            switch (accessStatus)
            {
                case GeolocationAccessStatus.Allowed:
                    Geolocator geolocator = new Geolocator { DesiredAccuracyInMeters = 1000 };
                    geoposition = await geolocator.GetGeopositionAsync();
                    break;

                case GeolocationAccessStatus.Denied:
                    message = "Access to location is denied!";
                    break;

                case GeolocationAccessStatus.Unspecified:
                    message = "Unspecified error!";
                    break;
            }

            if (message != "")
            {
                this.notificator.ShowErrorToastWithDismissButton(message);
            }

            return geoposition;
        }

        public async override Task<Location> GetLocation()
        {
            var ret = new Location();

            // create the locator
            Geolocator geolocator = new Geolocator();
            geolocator.DesiredAccuracyInMeters = 50;

            try
            {
                Geoposition geoposition = await geolocator.GetGeopositionAsync(
                    maximumAge: TimeSpan.FromMinutes(5),
                    timeout: TimeSpan.FromSeconds(10)
                    );

                // THIS IS THE ONLY DIFFERENCE
                ret.Latitude = geoposition.Coordinate.Point.Position.Latitude;
                ret.Longitude = geoposition.Coordinate.Point.Position.Longitude;
            }
            catch (Exception ex)
            {
                if ((uint)ex.HResult == 0x80004004)
                {
                    // the application does not have the right capability or the location master switch is off
                }
                else
                {
                    // something else happened acquring the location
                }
            }

            // return the location
            return ret;
        }

        public async Task<LocationResult> GetCurrentPosition()
        {
            try
            {
                if (!CheckConsentAskIfNotSet())
                {
                    return new LocationResult("No consent for location");
                }

                var geolocator = new Geolocator();
                geolocator.DesiredAccuracyInMeters = 50;

                Geoposition pos = await geolocator.GetGeopositionAsync(
                    maximumAge: TimeSpan.FromMinutes(1),
                    timeout: TimeSpan.FromSeconds(10)
                    );

                return new LocationResult(pos);
            }
            catch (UnauthorizedAccessException)
            {
                // We were not allowed the proper right for geolocation
                return new LocationResult("Location turned off / denied");
            }
            catch (Exception)
            {
            }

            return new LocationResult("Location could not be obtained");
        }

        // Constructor
        public MainPage()
        {
            InitializeComponent();

            geolocator = new Geolocator();
            geolocator.DesiredAccuracyInMeters = 50;
        }

        private async void ShowMyLocationOnTheMap()
        {
            Geolocator myGeolocator = new Geolocator();
            Geoposition myGeoposition = await myGeolocator.GetGeopositionAsync();
            Geocoordinate myGeocoordinate = myGeoposition.Coordinate;
            GeoCoordinate myGeoCoordinate =
            CoordinateConverter.ConvertGeocoordinate(myGeocoordinate);


            // Make my current location the center of the Map.
            this.mapWithMyLocation.Center = myGeoCoordinate;
            this.mapWithMyLocation.ZoomLevel = 13;

            // Create a small circle to mark the current location.
            BitmapImage bmi = new BitmapImage(new Uri("/Assets/pushpinRood.png", UriKind.Relative));
            Image img = new Image();
            img.Source = bmi;

            // Create a MapOverlay to contain the circle.
            MapOverlay myLocationOverlay = new MapOverlay();
            myLocationOverlay.Content = img;
            myLocationOverlay.PositionOrigin = new Point(0.5, 0.5);
            myLocationOverlay.GeoCoordinate = myGeoCoordinate;

            // Create a MapLayer to contain the MapOverlay.
            MapLayer myLocationLayer = new MapLayer();
            myLocationLayer.Add(myLocationOverlay);

            // Add the MapLayer to the Map.
            mapWithMyLocation.Layers.Add(myLocationLayer);


 
        }