navigator.geolocation.getCurrentPosition a volte funziona a volte no

Quindi ho un po ‘semplice di JS usando il navigator.geolocation.getCurrentPosition jammy.

$(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(""); $("#people-Near-Me") .watermark("Current Location") .after(""); } function noLocation() { $("#Near-Me").watermark("Could not find location"); $("#people-Near-Me").watermark("Could not find location"); } })//end DocReady 

In sostanza, ciò che sta accadendo qui è che otteniamo la posizione corrente, se è ottenuta, due “filigrane” sono poste in due campi che dicono “Posizione attuale” e vengono creati due campi nascosti con i dati lat-long come valore (vengono rimossi all’inizio quindi non vengono ripetuti ogni volta). Ci sono anche due pulsanti a cui è associata una funzione di clic che fa la stessa cosa. Sfortunatamente, ogni tre o tre anni, funziona. Qual è il problema qui ???

Ho avuto esattamente lo stesso problema e non ho trovato quasi nessuna informazione online. Niente di niente nei libri. Alla fine ho trovato questa query sobria su StackOverflow e (ha!) È stato l’impulso finale di cui avevo bisogno per creare un account qui.

E ho una risposta parziale, ma purtroppo non completa.

Prima di tutto, renditi conto che il timeout predefinito per getCurrentPosition è infinito (!). Ciò significa che il gestore degli errori non verrà mai chiamato se getCurrentPosition si blocca da qualche parte nel back-end.

Per assicurarti di ottenere un timeout, aggiungi il terzo parametro opzionale alla tua chiamata a getCurrentPosition, ad esempio, se vuoi che l’utente attenda non più di 10 secondi prima di dare loro la minima idea su cosa sta accadendo, usa:

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

In secondo luogo, ho sperimentato un’affidabilità abbastanza diversa in diversi contesti. Qui a casa, ottengo una richiamata entro un secondo o due, anche se la precisione è scarsa.

Al lavoro, tuttavia, provo variazioni del comportamento piuttosto bizzarre: la geolocalizzazione funziona su alcuni computer tutto il tempo (ad eccezione di IE, ovviamente), altri funzionano solo in chrome e safari ma non in firefox (problema gecko?), Altri funzionano una volta, quindi successivamente fallire – e il modello cambia di ora in ora, di giorno in giorno. A volte hai un computer “fortunato”, a volte no. Forse massacrare le capre alla luna piena sarebbe d’aiuto?

Non sono stato in grado di capire questo, ma sospetto che l’infrastruttura di back-end sia più irregolare di quanto pubblicizzato nei vari libri e siti Web di Gung-Ho che stanno spingendo questa funzione. Mi piacerebbe davvero che fossero un po ‘più chiari su come questa funzionalità sia perfetta, e quanto sia importante questa impostazione del timeout, se si vuole che il gestore degli errori funzioni correttamente .

Ho cercato di insegnare questa roba agli studenti oggi, e ho avuto la situazione imbarazzante in cui il mio computer (sul proiettore e diversi schermi di grandi dimensioni) stava fallendo silenziosamente, mentre circa l’80% degli studenti stava ottenendo un risultato quasi istantaneamente (usando il esatta stessa rete wireless). È molto difficile risolvere questi problemi quando i miei studenti fanno anche errori di battitura e altre gaffe e quando anche il mio PC non funziona.

Comunque, spero che questo aiuti alcuni di voi ragazzi. Grazie per il controllo di sanità mentale!

Questo è il modo in cui mi sto aggirando, almeno funziona in tutti i browser attuali (su Windows, non possiedo un 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(); } 

Ciò funzionerà anche se qualcuno fa clic su chiudi o sceglie di no o sceglie l’opzione Never Share su Firefox.

Clunky, ma funziona.

Questo funziona per me ogni volta:

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

Anche se non è molto preciso. La cosa divertente è che sullo stesso dispositivo, se eseguo questo, mi metto fuori circa 100 metri (ogni volta), ma se vado a Google Maps trova esattamente la mia posizione. Quindi, anche se penso che enableHighAccuracy: true aiuti a funzionare in modo coerente, non sembra renderlo più accurato …

Stessa gente, questo funziona perfettamente in Chrome (stabile, dev e canarino) solo in FF e Safari. Funziona perfettamente anche sul mio iPhone e iPad (Safari!). Ciò potrebbe essere dovuto alla relativa novità di questa funzionalità (cioè è un bug). Trascorro quasi una settimana su questo ora e proprio non riesco a farlo funzionare su quei browser

Ecco cosa ho trovato:

La prima volta che chiami getCurrentPosition funziona perfettamente. Qualsiasi chiamata successiva non ritorna mai, ovvero non triggers le funzioni successCallback o errorCallback. Ho aggiunto alcune opzioni di posizione alla mia chiamata per dimostrare il mio punto:

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

e scade ogni volta (dopo la prima chiamata riuscita). Pensavo di poterlo aggiustare con maximumEge, ma non sembra funzionare come si suppone che funzioni:

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

questo dovrebbe impedire effettivamente di chiamare la funzione getCurrentPosition se la chiami entro 60 secondi, ma la ignora (tuttavia, ciò potrebbe essere dovuto al fatto che in realtà aggiorno la mia pagina per triggersre la seconda chiamata, non sono sicuro se questa è persistente attraverso le chiamate)

btw, anche gli esempi di google non riescono su questi browser, il che mi porta a credere che si tratti effettivamente di bug del browser, provalo, caricalo due volte in Safari e non funzionerà la seconda volta.

Se qualcuno trova una soluzione per questo, PER FAVORE fammi sapere 🙂

Saluti.

Questa è già una vecchia domanda, ma tutte le risposte non hanno risolto il mio problema, quindi aggiungiamo quello che ho finalmente trovato. Puzza di hack (ed è uno), ma funziona sempre nella mia situazione. Spero anche nella tua situazione.

 //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 }); 

Non ricevi un messaggio di errore perché non ha un timeout predefinito (almeno credo). Ho avuto lo stesso problema con Firefox solo per me Firefox dà sempre un timeout. Puoi impostare un timeout come questo.

Ho impostato l’età massima su Infinity per assicurarmi che non sia un problema. La mia funzione funziona alla grande in chrome ma ottengo un timeout ogni volta in Firefox.

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

Raccomando di guardare attentamente i tuoi errori. Essere previsto per tutto Avere un piano di backup per tutto. Io uso alcuni valori o valori predefiniti dal mio database personalmente nel caso in cui entrambi i geolocalizzazioni di google e le geolocalizzazioni del navigatore falliscano.

Quindi mi sono imbattuto nella stessa cosa. Ho provato la soluzione di timeout che ha funzionato ma non in modo affidabile. Ho scoperto che se lo chiami due volte la posizione viene aggiornata correttamente

 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; } 

questo ovviamente è un po ‘più lento, ma non ho mai avuto una posizione sbagliata. Ho avuto qualche volta il timeout e non ho restituito altro se non che funziona perfettamente. So che questo è ancora un po ‘hacky e non vedo l’ora che qualcuno trovi la vera soluzione.

O se vuoi assicurarti che continui a provare fino a quando non vuoi rinunciare, potresti provare qualcosa di simile.

 //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} ) } } 

Probabilmente ho alcuni tipi e alcuni errori di ortografia qui, ma spero che tu abbia capito. Fammi sapere se qualcuno ha domande o se qualcuno trova qualcosa di meglio.

ecco la mia soluzione grazie a una chiusura:

  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); 

La risposta di @ brennanyoung è ottima, ma se ti stai chiedendo cosa fare nel caso di fallimento potresti utilizzare una API di geolocalizzazione IP come https://ipinfo.io (che è il mio servizio). Ecco un esempio:

 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); }); }; }); 

Vedi http://ipinfo.io/developers/replacing-navigator-geolocation-getcurrentposition per maggiori dettagli.

Ancora ottengo risultati chiari nel 2017 e ho una teoria: la documentazione dell’API dice che la chiamata è ora disponibile solo “in un contesto sicuro”, cioè su HTTPS. Sto avendo problemi a ottenere un risultato nel mio ambiente di sviluppo (http su localhost) e credo che questo sia il motivo.

Ho riscontrato problemi simili e ho esaminato la possibilità che i browser abbiano dei limiti sulla frequenza con cui getCurrentPosition può essere chiamato. Sembra che io possa ottenere spesso una posizione, ma se aggiorno la pagina subito verrà timeout. Se aspetto un po ‘, di solito riesco a trovare un posto. Questo di solito accade con FF. In Chrome e Safari, non ho ancora notato il timeout di getCurrentPosition. Solo un pensiero…

Sebbene non riesca a trovare alcuna documentazione a supporto di ciò, è stata una conclusione a cui sono giunto dopo molti test. Forse qualcun altro ha qualche informazione a riguardo?

Ho finalmente trovato una versione funzionante per Firefox, Chrome e Navigator di default in Android (solo 4.2 testati):

 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); } } 

Il secondo parametro passato a Geolocation.getCurrentPosition() è la funzione che si desidera gestire con qualsiasi errore di geolocalizzazione. La funzione di gestore degli errori riceve di per sé un object PositionError con dettagli sul perché il tentativo di geolocalizzazione non è riuscito. Raccomando di inviare l’errore alla console in caso di problemi:

 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); } } 

Nel mio codice, questo ha rivelato il messaggio “Network location provider at” https://www.googleapis.com/ “: Returned error code 400”. Si scopre che Google Chrome utilizza le API di Google per ottenere una posizione su dispositivi che non dispongono di GPS integrato (ad esempio, la maggior parte dei computer desktop). Google restituisce una latitudine / longitudine approssimativa in base all’indirizzo IP dell’utente. Tuttavia , nelle versioni sviluppate di Chrome (come Chromium su Ubuntu) non è inclusa alcuna chiave di accesso API nella build del browser. Ciò causa la mancata silenziosa richiesta API. Vedi Chromium Issue 179686: Geolocalizzazione con errore 403 per i dettagli.

Ho trovato, che in questo modo non funziona

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

Ma

in questo modo funziona perfettamente

 function storeCoordinates(position) { console.log(position.coords.latitude, position.coords.longitude); } function errorHandler() {...} navigator.geolocation.getCurrentPosition(storeCoordinates, errorHandler, { enableHighAccuracy: true, timeout: 20000, maximumAge: 0 }); 

Per chiunque lavori su un’app per iPhone …

Se il tuo codice è in esecuzione in un UIWebView su iOS 9+, devi impostare NSLocationWhenInUseUsageDescription all’interno del plist della tua app.

Se non lo si imposta, getCurrentPosition non richiamerà mai e l’utente non verrà mai richiesto.

Ho questo problema in Mozilla. Tutti i tempi: Errore: errore sconosciuto durante l’acquisizione della posizione .

Ora sto usando 47 Mozilla. Ho provato tutto, ma tutto il tempo questo problema. MA poi apro about: config nella mia barra degli address, go geo.wifi.ui e cambiato valore in ” https://location.services.mozilla.com/v1/geolocate?key=test “. lavori!

Se hai un errore di timeout nell’acquisizione della posizione , prova ad aumentare il valore di timeout:

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

Ho notato questo problema recentemente da solo, e non sono sicuro di come si verifichino, ma a volte sembra che Firefox rimanga bloccato su qualcosa caricato nella cache. Dopo aver svuotato la cache e riavviato firefox, sembra che funzioni di nuovo.

Questa libreria aggiunge un’opzione di accuratezza e maxWait desiderata alle chiamate di geolocalizzazione, il che significa che continuerà a cercare di ottenere una posizione finché la precisione non rientra nell’intervallo specificato.

Grazie a tutti per il loro contributo, questo mi ha aiutato.

Oltre a dover utilizzare watchPosition () anziché getCurrentPosition (), ho anche scoperto che avevo bisogno di spostare la chiamata da document.ready () alla testa.

Potrebbe essere una buona idea utilizzare un servizio di geolocalizzazione degli indirizzi IP come metodo di fallback quando fallisce getCurrentPosition . Ad esempio con la nostra api https://ip-api.io

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

Lo posterò qui nel caso sia utile a chiunque …

Su iOS Safari, le chiamate a navigator.geolocation.getCurrentPosition avrebbero scaduto se avessi una funzione triggers di navigator.geolocation.watchPosition esecuzione.

L’avvio e l’arresto corretto di watchPosition tramite clearWatch() come descritto qui ha funzionato: https://developer.mozilla.org/en-US/docs/Web/API/Geolocation/watchPosition