navigator.geolocation.getCurrentPosition czasami działa, a czasem nie

Mam więc dość prostą wersję JS, używając jammy navigator.geolocation.getCurrentPosition.

$(document).ready(function(){
  $("#business-locate, #people-locate").click(function() {
    navigator.geolocation.getCurrentPosition(foundLocation, noLocation);
  });

  navigator.geolocation.getCurrentPosition(foundLocation, noLocation);

  function foundLocation(position) {
    var lat = position.coords.latitude;
    var lon = position.coords.longitude;
    var userLocation = lat + ', ' + lon;
    $("#business-current-location, #people-current-location").remove();
    $("#Near-Me")
      .watermark("Current Location")
      .after("<input type='hidden' name='business-current-location' id='business-current-location' value='"+userLocation+"' />");
    $("#people-Near-Me")
      .watermark("Current Location")
      .after("<input type='hidden' name='people-current-location' id='people-current-location' value='"+userLocation+"' />");
  }
  function noLocation() {
    $("#Near-Me").watermark("Could not find location");
    $("#people-Near-Me").watermark("Could not find location");
  }
})//end DocReady

Zasadniczo dzieje się tutaj, gdy otrzymujemy bieżącą pozycję, jeśli zostanie uzyskana, dwa „znaki wodne” zostaną umieszczone w dwóch polach z napisem „Bieżąca pozycja”, a dwa ukryte pola zostaną utworzone z danymi z długich lat (są usuwane na początku, aby nie były duplikowane za każdym razem). Istnieją również dwa przyciski z przypisaną funkcją kliknięcia, które robią to samo. Niestety co trzeci raz działa. W czym problem?

Miałem dokładnie ten sam problem i nie znalazłem prawie żadnych informacji na ten temat w Internecie. W książkach nic nie ma. W końcu znalazłem to trzeźwe zapytanie przy przepełnieniu stosu i (ha!) Był to ostatni impuls, którego potrzebowałem, aby założyć tutaj konto.

I mam częściową odpowiedź, ale niestety nie pełną.

Przede wszystkim zdaj sobie sprawę, że domyślny limit czasu dla getCurrentPosition jest nieskończony (!). Oznacza to, że Twój program obsługi błędów nigdy nie zostanie wywołany, jeśli getCurrentPosition zawiesi się gdzieś na zapleczu.

Aby mieć pewność, że otrzymasz limit czasu, dodaj opcjonalny trzeci parametr do swojego wywołania, aby uzyskać getCurrentPosition, na przykład jeśli chcesz, aby użytkownik czekał nie więcej niż 10 sekund, zanim podpowie, co się dzieje, użyj:

navigator.geolocation.getCurrentPosition(successCallback,errorCallback,{timeout:10000});

Po drugie, doświadczyłem zupełnie innej niezawodności w różnych kontekstach. W domu dostaję oddzwonienie w ciągu sekundy lub dwóch, chociaż dokładność jest niska.

Jednak w pracy występują dziwne odmiany zachowania: Geolokalizacja działa na niektórych komputerach przez cały czas (oczywiście z wyjątkiem IE), inne działają tylko w Chrome i Safari, ale nie Firefox (problem z gekonem?), Inne działają raz, a następnie później zawodzi - a wzór zmienia się z godziny na godzinę, z dnia na dzień. Czasami masz „szczęśliwy” komputer, czasem nie. Może pomógłby ubój kóz w pełni księżyca?

Nie byłem w stanie tego pojąć, ale podejrzewam, że infrastruktura zaplecza jest bardziej nierówna niż reklamowana w różnych książkach i witrynach Gung-ho, które promują tę funkcję. Naprawdę chciałbym, aby byli nieco bardziej bezpośredni na temat tego, jak płatna jest ta funkcja i jak ważne jest to ustawienie limitu czasu, jeśli chcesz, aby program obsługi błędów działał poprawnie .

Próbowałem dzisiaj uczyć tego rodzaju rzeczy studentom i miałem zawstydzającą sytuację, w której mój komputer (na projektorze i kilku dużych ekranach) zawodził cicho, podczas gdy około 80% uczniów osiągało wynik niemal natychmiast (używając dokładnie ta sama sieć bezprzewodowa). Bardzo trudno jest rozwiązać te problemy, gdy moi uczniowie również piszą literówki i inne gafy, a gdy mój własny komputer również zawodzi.

W każdym razie mam nadzieję, że to pomoże niektórym z was. Dzięki za kontrolę zdrowia psychicznego!

To jest hacky sposób, w jaki mi się to obchodzi, przynajmniej działa we wszystkich obecnych przeglądarkach (w systemie Windows nie mam komputera Mac):

if (navigator.geolocation) {
    var location_timeout = setTimeout("geolocFail()", 10000);

    navigator.geolocation.getCurrentPosition(function(position) {
        clearTimeout(location_timeout);

        var lat = position.coords.latitude;
        var lng = position.coords.longitude;

        geocodeLatLng(lat, lng);
    }, function(error) {
        clearTimeout(location_timeout);
        geolocFail();
    });
} else {
    // Fallback for no geolocation
    geolocFail();
}

Będzie to również działać, jeśli ktoś kliknie zamknięcie lub wybierze opcję nie lub wybierze opcję Nigdy nie udostępniaj w przeglądarce Firefox.

Clunky, ale działa.

Działa to dla mnie za każdym razem:

navigator.geolocation.getCurrentPosition(getCoor, errorCoor, {maximumAge:60000, timeout:5000, enableHighAccuracy:true});

Chociaż nie jest to zbyt dokładne. Zabawne jest to, że na tym samym urządzeniu, jeśli go uruchomię, zniechęca mnie to około 100 metrów (za każdym razem), ale jeśli przejdę do map Google, dokładnie znajdzie moją lokalizację. Więc chociaż myślę, że enableHighAccuracy: true pomaga mu działać konsekwentnie, nie wydaje się, aby był bardziej dokładny ...

To już stare pytanie, ale wszystkie odpowiedzi nie rozwiązały mojego problemu, więc dodajmy to, które w końcu znalazłem. Pachnie jak hack (i to jeden), ale zawsze działa w mojej sytuacji. Mam również nadzieję na swoją sytuację.

//Dummy one, which will result in a working next statement.
navigator.geolocation.getCurrentPosition(function () {}, function () {}, {});
//The working next statement.
navigator.geolocation.getCurrentPosition(function (position) {
    //Your code here
}, function (e) {
    //Your error handling here
}, {
    enableHighAccuracy: true
});

Te same osoby tutaj, działa idealnie btw w Chrome (stabilny, deweloper i kanarek) po prostu nie w FF i Safari. Działa również doskonale na moim iPhonie i iPadzie (Safari!). Może to być spowodowane względną nowością tej funkcji (tj. Jest to błąd). Spędzam teraz na tym prawie tydzień i po prostu nie mogę go uruchomić w tych przeglądarkach

Oto, co znalazłem:

Przy pierwszym wywołaniu getCurrentPosition działa idealnie. Każde kolejne wywołanie nigdy nie zwraca, tzn. Nie uruchamia funkcji SuccessCallback lub errorCallback. Dodałem kilka opcji pozycji do mojego wezwania, aby udowodnić swój punkt widzenia:

 navigator.geolocation.getCurrentPosition(successCallback, errorCallback,  {timeout: 10000});

i upływa limit czasu za każdym razem (po pierwszym udanym połączeniu). Pomyślałem, że mogę to naprawić za pomocą MaximumAge, ale wydaje się, że to nie działa, ponieważ powinno działać:

navigator.geolocation.getCurrentPosition(successCallback, errorCallback,  {maximumAge:60000, timeout: 2000});

powinno to zapobiec faktycznemu wywołaniu funkcji getCurrentPosition, jeśli wywołasz ją w ciągu 60 sekund, ale to zignoruje (może to jednak wynikać z faktu, że odświeżam stronę, aby wywołać drugie połączenie, nie jestem pewien, czy jest to trwałe połączenie między)

btw, nawet przykłady Google'a zawodzą w tych przeglądarkach, co prowadzi mnie do przekonania, że ​​to rzeczywiście błędy przeglądarki, spróbuj, załaduj go dwukrotnie w Safari i nie zadziała po raz drugi.

Jeśli ktoś znajdzie rozwiązanie tego problemu, PROSZĘ daj mi znać :-)

Twoje zdrowie.

Nie pojawia się komunikat o błędzie, ponieważ domyślnie nie ma limitu czasu (przynajmniej tak mi się wydaje). Miałem ten sam problem z firefoxem tylko dla mnie firefox zawsze daje limit czasu. Możesz sam ustawić limit czasu w ten sposób.

Moja funkcja działa świetnie w Chrome, ale za każdym razem dostaję limit czasu w Firefoksie.

    navigator.geolocation.getCurrentPosition(
        function(position) {
            //do succes handling
        },
        function errorCallback(error) {
            //do error handling
        },
        {
            timeout:5000
        }
    );

Zalecam uważne obserwowanie błędów. Oczekuj wszystkiego. Przygotuj plan tworzenia kopii zapasowych wszystkiego. Sam używam niektórych wartości domyślnych lub wartości z mojej bazy danych na wypadek, gdyby zawiodły zarówno geolokalizacje Google, jak i geolokalizacje nawigatora.

W 2017 roku wciąż otrzymuję nierówne wyniki i mam teorię: dokumentacja API mówi, że połączenie jest teraz dostępne tylko „w bezpiecznym kontekście”, tj. Przez HTTPS. Mam problem z uzyskaniem wyniku w moim środowisku programistycznym (http na localhost) i wierzę, że właśnie dlatego.

Zamieszczę to tutaj, na wypadek, gdyby był użyteczny dla każdego…

W iOS Safari wywołania navigator.geolocation.getCurrentPositionprzekroczą limit czasu, gdybym miał aktywną navigator.geolocation.watchPositionfunkcję.

Uruchamianie i zatrzymywanie watchPositionpoprawnego używania, clearWatch() jak opisano tutaj, działało: https://developer.mozilla.org/en-US/docs/Web/API/Geolocation/watchPosition

oto moje rozwiązanie dzięki zamknięciu:

  function geoloc(success, fail){
    var is_echo = false;
    if(navigator && navigator.geolocation) {
      navigator.geolocation.getCurrentPosition(
        function(pos) {
          if (is_echo){ return; }
          is_echo = true;
          success(pos.coords.latitude,pos.coords.longitude);
        }, 
        function() {
          if (is_echo){ return; }
          is_echo = true;
          fail();
        }
      );
    } else {
      fail();
    }
  }

  function success(lat, lng){
    alert(lat + " , " + lng);
  }
  function fail(){
    alert("failed");
  }

  geoloc(success, fail);

Więc wpadłem na to samo. Wypróbowałem rozwiązanie przekroczenia limitu czasu, które działało, ale niezawodnie. Odkryłem, że jeśli zadzwonisz dwukrotnie, lokalizacja zostanie odpowiednio odświeżona

function getLocation(callback)
{   
    if(navigator.geolocation)
    {
        navigator.geolocation.getCurrentPosition(function(position)
        {
            navigator.geolocation.getCurrentPosition(callback, function(){},{maximumAge:0, timeout:10000});
        },function(){}, {maximumAge:0, timeout:10000});
    }
    return true;
}

to oczywiście jest trochę wolniejsze, ale nigdy nie miałem tej sytuacji, która dawała mi niewłaściwą pozycję. Przekroczyłem limit czasu kilka razy i nie zwróciłem nic poza tym, że działa świetnie. Wiem, że wciąż jest to trochę zuchwałe i nie mogę się doczekać, aż ktoś znajdzie prawdziwe rozwiązanie.

Lub jeśli chcesz się upewnić, że będzie próbował, aż będziesz chciał się poddać, możesz spróbować czegoś takiego.

//example
$(document).ready(function(){
    getLocation(function(position){
        //do something cool with position
        console.log(position);
    });
});


var GPSTimeout = 10; //init global var NOTE: I noticed that 10 gives me the quickest result but play around with this number to your own liking


//function to be called where you want the location with the callback(position)
function getLocation(callback)
{   
    if(navigator.geolocation)
    {
        var clickedTime = (new Date()).getTime(); //get the current time
        GPSTimeout = 10; //reset the timeout just in case you call it more then once
        ensurePosition(callback, clickedTime); //call recursive function to get position
    }
    return true;
}

//recursive position function
function ensurePosition(callback, timestamp)
{
    if(GPSTimeout < 6000)//set at what point you want to just give up
    {
        //call the geolocation function
        navigator.geolocation.getCurrentPosition(
            function(position) //on success
        {
                //if the timestamp that is returned minus the time that was set when called is greater then 0 the position is up to date
            if(position.timestamp - timestamp >= 0)
                {
                    GPSTimeout = 10; //reset timeout just in case
                    callback(position); //call the callback function you created
                }
                else //the gps that was returned is not current and needs to be refreshed
                {
                    GPSTimeout += GPSTimeout; //increase the timeout by itself n*2
                    ensurePosition(callback, timestamp); //call itself to refresh
                }
            },
            function() //error: gps failed so we will try again
            {
                GPSTimeout += GPSTimeout; //increase the timeout by itself n*2
                ensurePosition(callback, timestamp);//call itself to try again
            },
            {maximumAge:0, timeout:GPSTimeout}
        )
    }       
}

Prawdopodobnie mam tu kilka literówek i kilka błędów ortograficznych, ale mam nadzieję, że rozumiesz. Daj mi znać, jeśli ktoś ma pytania lub jeśli ktoś znajdzie coś lepszego.

Dla każdego, kto pracuje na aplikacji na iPhone'a ...

Jeśli Twój kod działa w UIWebView na iOS 9+, musisz ustawić go NSLocationWhenInUseUsageDescriptionw liście aplikacji.

Jeśli nie zostanie ustawiony, getCurrentPositionnigdy nie oddzwoni, a użytkownik nigdy nie będzie monitowany.

Przekonałem się, że ten sposób nie działa

navigator.geolocation.getCurrentPosition(function() {...}, function(err) {...}, {});

Ale

w ten sposób działa idealnie

function storeCoordinates(position) {
    console.log(position.coords.latitude, position.coords.longitude);
}    

function errorHandler() {...}

navigator.geolocation.getCurrentPosition(storeCoordinates, errorHandler, { enableHighAccuracy: true, timeout: 20000, maximumAge: 0 });

Odpowiedź @ brennanyoung jest świetna, ale jeśli zastanawiasz się, co zrobić w przypadku awarii, możesz użyć interfejsu API geolokalizacji IP, takiego jak https://ipinfo.io (który jest moją usługą). Oto przykład:

function do_something(coords) {
    // Do something with the coords here
    // eg. show the user on a map, or customize
    // the site contents somehow
}

navigator.geolocation.getCurrentPosition(function(position) { 
    do_something(position.coords);
    },
    function(failure) {
        $.getJSON('https://ipinfo.io/geo', function(response) { 
        var loc = response.loc.split(',');
        var coords = {
            latitude: loc[0],
            longitude: loc[1]
        };
        do_something(coords);
        });  
    };
});

Więcej informacji na stronie https://ipinfo.io/developers/replacing-getcurrentposition .

Miałem podobne problemy i zastanawiałem się nad możliwością, że przeglądarki mają ograniczenia dotyczące częstotliwości wywoływania getCurrentPosition. Wygląda na to, że często mogę znaleźć lokalizację, ale jeśli od razu odświeżę stronę, upłynie limit czasu. Jeśli trochę poczekam, zwykle mogę ponownie uzyskać lokalizację. Zwykle dzieje się tak w przypadku FF. W Chrome i Safari nie zauważyłem jeszcze przekroczenia limitu czasu getCurrentPosition. Tylko myśl ...

Chociaż nie mogę znaleźć żadnej dokumentacji na poparcie tego, był to wniosek, do którego doszedłem po wielu testach. Być może ktoś ma jakieś informacje na ten temat?

W końcu znalazłem działającą wersję dla Firefoxa, Chrome i domyślnego nawigatora w Androidzie (tylko w wersji 4.2):

function getGeoLocation() {
        var options = null;
        if (navigator.geolocation) {
            if (browserChrome) //set this var looking for Chrome un user-agent header
                options={enableHighAccuracy: false, maximumAge: 15000, timeout: 30000};
            else
                options={maximumAge:Infinity, timeout:0};
            navigator.geolocation.getCurrentPosition(getGeoLocationCallback,
                    getGeoLocationErrorCallback,
                   options);
        }
    }

Drugi przekazany parametr Geolocation.getCurrentPosition()to funkcja, która ma obsługiwać wszelkie błędy geolokalizacji. Sama funkcja obsługi błędów odbiera PositionErrorobiekt ze szczegółami, dlaczego próba geolokalizacji nie powiodła się. Jeśli masz jakiekolwiek problemy, zalecamy wysłanie błędu do konsoli.

var positionOptions = { timeout: 10000 };
navigator.geolocation.getCurrentPosition(updateLocation, errorHandler, positionOptions);
function updateLocation(position) {
  // The geolocation succeeded, and the position is available
}
function errorHandler(positionError) {
  if (window.console) {
    console.log(positionError);
  }
}

Wykonanie tego w moim kodzie ujawniło komunikat „Dostawca lokalizacji sieciowej pod adresem „ https://www.googleapis.com/ ”: Zwrócony kod błędu 400”. Okazuje się, że Google Chrome używa interfejsów API Google, aby uzyskać lokalizację na urządzeniach, które nie mają wbudowanego GPS (na przykład na większości komputerów stacjonarnych). Google zwraca przybliżoną szerokość / długość geograficzną na podstawie adresu IP użytkownika. Jednak w wersjach Chrome dla programistów (takich jak Chromium w systemie Ubuntu) klucz kompilacji przeglądarki nie zawiera klucza dostępu do interfejsu API. Powoduje to cichą awarię żądania API. Zobacz Chromium nr 179686: Geolokalizacja dająca błąd 403, aby poznać szczegóły.

Mam ten problem w Mozilli. Cały czas: Błąd: nieznany błąd podczas uzyskiwania pozycji .

Teraz używam 47 Mozilli. Próbowałem wszystkiego, ale cały czas ten problem. ALE potem otwieram about: config na moim pasku adresu, idę geo.wifi.ui i zmieniłem wartość na „ https://location.services.mozilla.com/v1/geolocate?key=test ”. Pracuje!

Jeśli masz błąd przekroczenia limitu czasu pozyskiwania pozycji , spróbuj zwiększyć wartość limitu czasu:

var options = {
  enableHighAccuracy: true,
  timeout: 5000,
  maximumAge: 0       
};
navigator.geolocation.getCurrentPosition(success, error, options);

Dobrym pomysłem może być skorzystanie z usługi lokalizacji geograficznej adresu IP jako metody rezerwowej w przypadku getCurrentPositionniepowodzenia. Na przykład za pomocą naszego interfejsu API https://ip-api.io

$.getJSON("http://ip-api.io/json/",
    function(result) {
        console.log(result);
    });

W naszym przypadku zawsze działa za pierwszym razem, ale ponowne uruchomienie funkcji więcej niż 3-4 razy, kończy się niepowodzeniem.

Proste obejście: przechowuj jego wartość w LocalStorage.

Przed:

navigator.geolocation.getCurrentPosition((position) => {
  let val = results[0].address_components[2].long_name;
  doSthWithVal(val);      
}, (error) => { });

Po:

if(localStorage.getItem('getCurrentPosition') !== null) {
  doSthWithVal(localStorage.getItem('getCurrentPosition'));
}
else {
  navigator.geolocation.getCurrentPosition((position) => {
      let val = results[0].address_components[2].long_name;
      localStorage.setItem('getCurrentPosition',val);
      doSthWithVal(val);      
  }, (error) => { });
}

Niedawno zauważyłem ten problem i nie jestem pewien, jak to się dzieje, ale czasami wydaje się, że firefox utknął na czymś załadowanym do pamięci podręcznej. Po wyczyszczeniu pamięci podręcznej i ponownym uruchomieniu Firefoksa wydaje się, że znów działa.

Ta biblioteka dodaje do połączeń geolokalizacyjnych żądaną opcję Dokładności i maksymalnej wartości, co oznacza, że ​​będzie próbowała uzyskać pozycję, dopóki dokładność nie znajdzie się w określonym zakresie.

Dzięki wszystkim za wkład, pomogło mi to.

Oprócz konieczności użycia watchPosition () zamiast getCurrentPosition (), odkryłem również, że muszę przenieść wywołanie z document.ready () do głowy.

Stało się tak podczas używania responsywnego trybu projektowania Firefoksa. Zgłoszono zgłoszenie błędu . Na razie nie używaj responsywnego trybu projektowania podczas korzystania z Geolokalizacji API.

Może to pomaga komuś, na Androidzie miałem ten sam problem, ale pomyślałem o tym, używając go setTimeout wewnątrz, document.ready więc zadziałało dla mnie po drugie, musisz zwiększyć limit czasu, po prostu zwiększyć, jeśli użytkownik zezwoli na jego lokalizację po kilku sekundach, więc utrzymałem go na 60000 mili sekund (1 minuta), pozwalając mojej funkcji powodzenia zadzwonić, jeśli użytkownik kliknie przycisk zezwolenia w ciągu 1 minuty.