navigator.geolocation.getCurrentPosition a volte funziona a volte no

Quindi ho un po 'piuttosto semplice di JS usando il 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

Fondamentalmente quello che sta succedendo qui è che otteniamo la posizione corrente, se viene ottenuta, due "filigrane" vengono posizionate in due campi che dicono "Posizione corrente" e due campi nascosti vengono creati con i dati lat-long come loro valore (vengono rimossi all'inizio in modo che non vengano duplicati ogni volta). Ci sono anche due pulsanti con una funzione click collegata a loro che fanno la stessa cosa. Sfortunatamente, ogni terza volta circa, funziona. Qual è il problema qui ???

Ho avuto esattamente lo stesso problema e non ho trovato quasi nessuna informazione online al riguardo. Niente di niente nei libri. Alla fine ho trovato questa query sobria su StackOverflow e (ah!) È 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 sul back-end.

Per assicurarti di ottenere un timeout, aggiungi il terzo parametro facoltativo alla tua chiamata a getCurrentPosition, ad esempio, se desideri che l'utente non attenda più di 10 secondi prima di dare loro un'idea di ciò che sta accadendo, usa:

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

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

Al lavoro, tuttavia, sperimento variazioni piuttosto bizzarre nel comportamento: la geolocalizzazione funziona sempre su alcuni computer (IE escluso, ovviamente), altri funzionano solo su Chrome e Safari ma non su Firefox (problema geco?), Altri funzionano una volta, quindi successivamente fallisce - e lo schema cambia di ora in ora, di giorno in giorno. A volte hai un computer "fortunato", a volte no. Forse macellare le capre alla luna piena sarebbe di 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. Vorrei davvero che fossero un po 'più chiari su quanto questa funzionalità sia instabile e su quanto sia importante questa impostazione di timeout, se si desidera che il gestore degli errori funzioni correttamente .

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

Spero comunque che questo aiuti alcuni di voi ragazzi. Grazie per il controllo di sanità mentale!

Questo è il modo caotico in cui mi sto muovendo, 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();
}

Questo funzionerà anche se qualcuno fa clic sulla chiusura o sceglie no o sceglie l'opzione Non condividere mai 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 rimanda a circa 100 metri (ogni volta), ma se vado sulle mappe di Google trova esattamente la mia posizione. Quindi, anche se penso che enableHighAccuracy: true lo aiuti a funzionare in modo coerente, non sembra renderlo più preciso ...

Questa è già una vecchia domanda, ma tutte le risposte non hanno risolto il mio problema, quindi aggiungiamo quella che ho finalmente trovato. Odora 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
});

Stesso qui gente, funziona perfettamente tra Chrome (stable, dev e canary) ma non in FF e Safari. Funziona perfettamente anche sul mio iPhone e iPad (Safari!). Ciò potrebbe essere dovuto alla relativa novità di questa funzione (ovvero è un bug). Ho trascorso quasi una settimana su questo ora e non riesco proprio 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 attiva 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). Ho pensato di poterlo risolvere con maximumAge, ma questo non sembra funzionare poiché si suppone che funzioni:

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

questo dovrebbe impedire effettivamente di chiamare la funzione getCurrentPosition se la si chiama entro 60 secondi, ma la ignora (tuttavia, ciò potrebbe essere dovuto al fatto che aggiorno effettivamente la mia pagina per attivare la seconda chiamata, non sono sicuro che si tratti di chiamate persistenti)

a proposito, anche gli esempi di google falliscono 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.

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

La mia funzione funziona benissimo in Chrome ma ottengo un timeout ogni volta in Firefox.

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

Consiglio di guardare attentamente i tuoi errori. Aspettati per tutto. Avere un piano di backup per tutto. Uso personalmente alcuni valori predefiniti o quelli del mio database nel caso in cui sia la geolocalizzazione di Google sia la geolocalizzazione del navigatore falliscano.

Sto ancora ottenendo risultati chiazzati nel 2017 e ho una teoria: la documentazione dell'API afferma che la chiamata è ora disponibile solo "in un contesto sicuro", ovvero su HTTPS. Ho problemi a ottenere un risultato nel mio ambiente di sviluppo (http su localhost) e credo che questo sia il motivo.

Lo posterò qui nel caso sia utile a chiunque ...

Su iOS Safari, le chiamate a navigator.geolocation.getCurrentPositionsarebbero scadute se avessi una navigator.geolocation.watchPositionfunzione attiva in esecuzione.

Avvio e arresto del watchPositioncorretto utilizzo clearWatch() come descritto qui, ha funzionato: https://developer.mozilla.org/en-US/docs/Web/API/Geolocation/watchPosition

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

Quindi stavo incontrando la 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 l'ho avuto una volta mi ha dato la posizione sbagliata. Ho avuto il timeout colpito un paio di volte e non restituire altro che altro che funzioni alla grande. So che è ancora un po 'confuso e non vedo l'ora che qualcuno trovi la vera soluzione.

O se vuoi assicurarti che continuerà a provare fino a quando non vuoi arrenderti, potresti provare qualcosa del genere.

//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 di errori e alcuni errori di ortografia qui, ma spero che tu abbia l'idea. Fammi sapere se qualcuno ha domande o se qualcuno trova qualcosa di meglio.

Per chiunque lavori su un'app per iPhone ...

Se il tuo codice è in esecuzione in UIWebView su iOS 9+, devi impostare NSLocationWhenInUseUsageDescriptionil programma di app.

Se non lo si imposta, non getCurrentPositionverrà mai richiamato e l'utente non verrà mai richiesto.

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

La risposta di @ brennanyoung è ottima, ma se ti stai chiedendo cosa fare in caso di errore, potresti utilizzare un'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 https://ipinfo.io/developers/replacing-getcurrentposition per maggiori dettagli.

Ho riscontrato problemi simili e ho esaminato la possibilità che i browser abbiano limiti sulla frequenza con cui è possibile chiamare getCurrentPosition. Sembra che spesso riesca a trovare una posizione, ma se aggiorno subito la pagina, andrà in timeout. Se aspetto un po ', di solito riesco a trovare di nuovo una posizione. Questo di solito accade con FF. In Chrome e Safari, non ho ancora notato il timeout di getCurrentPosition. Solo un pensiero...

Anche se non riesco 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 navigatore predefinito in Android (solo 4.2 testato):

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 Geolocation.getCurrentPosition()è la funzione che si desidera gestire eventuali errori di geolocalizzazione. La stessa funzione del gestore degli errori riceve un PositionErroroggetto con i dettagli sul perché il tentativo di geolocalizzazione non è riuscito. Ti consiglio 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);
  }
}

In questo modo nel mio codice ho rivelato il messaggio "Network location provider at ' https://www.googleapis.com/ ': codice di errore restituito 400". Risulta 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 build sviluppatore di Chrome (come Chromium su Ubuntu) non esiste una chiave di accesso API inclusa nella build del browser. Ciò causa il fallimento silenzioso della richiesta API. Vedi Chromium, numero 179686: geolocalizzazione con errore 403 per i dettagli.

Ho questo problema in Mozilla. Sempre: errore: errore sconosciuto nell'acquisizione della posizione .

Ora sto usando 47 Mozilla. Ho provato di tutto, ma sempre questo problema. MA poi apro about: config nella mia barra degli indirizzi, vai su geo.wifi.ui e lo ho cambiato in " https://location.services.mozilla.com/v1/geolocate?key=test ". lavori!

Se si verifica un errore di timeout dell'acquisizione della posizione , provare ad aumentare il valore di timeout:

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

Potrebbe essere una buona idea utilizzare un servizio di geo-localizzazione dell'indirizzo IP come metodo di fallback quando getCurrentPositionfallisce. Ad esempio con la nostra API https://ip-api.io

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

Nel nostro caso funziona sempre la prima volta ma rieseguendo la funzione più di 3-4 volte, fallisce.

Soluzione semplice: memorizzarne il valore in LocalStorage.

Prima:

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

Dopo:

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

Di recente ho notato questo problema da solo, e non sono sicuro di come si verifichi, ma a volte sembrerebbe che Firefox si blocchi su qualcosa caricato nella cache. Dopo aver svuotato la cache e riavviato Firefox sembra funzionare di nuovo.

Questa libreria aggiunge un'opzione desiderata Accuracy e maxWait alle chiamate di geolocalizzazione, il che significa che continuerà a cercare di ottenere una posizione fino a quando l'accuratezza non rientra in un intervallo specificato.

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

Oltre a dover usare watchPosition () invece di getCurrentPosition (), ho anche scoperto che dovevo spostare la chiamata da document.ready () alla testa.

Questo mi è successo durante l'utilizzo della modalità di progettazione reattiva di Firefox. È stata presentata una segnalazione di bug . Per ora, non utilizzare la modalità di progettazione reattiva durante l'utilizzo dell'API di geolocalizzazione.

Può essere di aiuto a qualcuno, su Android ho avuto lo stesso problema ma l'ho capito usando l' setTimeout interno, document.ready quindi ha funzionato per me in secondo luogo devi aumentare il timeout in caso si accada se l'utente consente la sua posizione dopo pochi secondi, quindi l'ho tenuto a 60000 mili secondi (1 minuto) che consente di chiamare la mia funzione di successo se l'utente fa clic sul pulsante Consenti entro 1 minuto.