navigator.geolocation.getCurrentPosition a veces funciona a veces no

Así que tengo un poco de JS bastante simple usando el 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

Básicamente, lo que está sucediendo aquí es que obtenemos la posición actual, si se obtiene, se colocan dos "marcas de agua" en dos campos que dicen "Posición actual" y se crean dos campos ocultos con los datos largos como su valor (se eliminan al principio para que no se dupliquen cada vez). También hay dos botones que tienen una función de clic vinculada a ellos que hacen lo mismo. Desafortunadamente, cada tercera vez más o menos, funciona. ¿Cuál es el problema aquí?

He tenido exactamente el mismo problema y casi no encuentro información en línea sobre el tema. Nada en absoluto en los libros. Finalmente encontré esta consulta sobria en stackoverflow y (¡ja!) Fue el ímpetu final que necesitaba para configurar una cuenta aquí.

Y tengo una respuesta parcial, pero desafortunadamente no completa.

En primer lugar, tenga en cuenta que el tiempo de espera predeterminado para getCurrentPosition es infinito (!). Eso significa que su controlador de errores nunca se llamará si getCurrentPosition se bloquea en algún lugar del back-end.

Para asegurarse de obtener un tiempo de espera, agregue el tercer parámetro opcional a su llamada a getCurrentPosition, por ejemplo, si desea que el usuario no espere más de 10 segundos antes de darles una pista de lo que está sucediendo, use:

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

En segundo lugar, he experimentado una fiabilidad bastante diferente en diferentes contextos. Aquí en casa, recibo una devolución de llamada en un segundo o dos, aunque la precisión es pobre.

Sin embargo, en el trabajo, experimento variaciones bastante extrañas en el comportamiento: la geolocalización funciona en algunas computadoras todo el tiempo (es decir, excepto IE), otras solo funcionan en Chrome y Safari pero no en Firefox (¿problema de gecko?), Otras funcionan una vez y luego fallar, y el patrón cambia de una hora a otra, de un día a otro. A veces tienes una computadora 'afortunada', a veces no. ¿Quizás ayudaría sacrificar cabras en luna llena?

No he podido entender esto, pero sospecho que la infraestructura de back-end es más desigual de lo que se anuncia en los diversos libros y sitios web de Gung-ho que impulsan esta característica. Realmente desearía que fueran un poco más claros acerca de cuán descabellada es esta característica y cuán importante es la configuración del tiempo de espera, si desea que su controlador de errores funcione correctamente .

He estado tratando de enseñarles esto a los estudiantes hoy, y tuve la vergonzosa situación de que mi propia computadora (en el proyector y varias pantallas grandes) fallaba en silencio, mientras que alrededor del 80% de los estudiantes obtenían un resultado casi instantáneamente (usando el exactamente la misma red inalámbrica). Es muy difícil resolver estos problemas cuando mis alumnos también están cometiendo errores tipográficos y otros errores, y cuando mi propia computadora también falla.

De todos modos, espero que esto ayude a algunos de ustedes. Gracias por el control de cordura!

Esta es la forma hacky que estoy evitando, al menos funciona en todos los navegadores actuales (en Windows, no tengo una 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();
}

Esto también funcionará si alguien hace clic en el cierre o elige no o elige la opción Nunca compartir en Firefox.

Clunky, pero funciona.

Esto funciona para mí cada vez:

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

Aunque no es muy preciso. Lo curioso es que en el mismo dispositivo si ejecuto esto, me aleja unos 100 metros (cada vez), pero si voy a los mapas de Google, encuentra mi ubicación exactamente. Entonces, aunque creo que enableHighAccuracy: true lo ayuda a funcionar de manera consistente, no parece hacerlo más preciso ...

Esta ya es una pregunta antigua, pero todas las respuestas no resolvieron mi problema, así que agreguemos la que finalmente encontré. Huele a un truco (y es uno), pero siempre funciona en mi situación. Espero en tu situación también.

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

Lo mismo aquí, gente, esto funciona perfectamente por cierto en Chrome (estable, dev y canario) simplemente no en FF y Safari. También funciona perfecto en mi iPhone y iPad (¡Safari!). Esto podría deberse a la relativa novedad de esta función (es decir, es un error). Ahora paso casi una semana en esto y simplemente no puedo hacer que funcione en esos navegadores

Esto es lo que encontré:

La primera vez que llamas a getCurrentPosition funciona perfecto. Cualquier llamada posterior nunca regresa, es decir, no activa las funciones successCallback o errorCallback. Agregué algunas opciones de posición a mi llamada para probar mi punto:

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

y se agota cada vez (después de la primera llamada exitosa). Pensé que podría solucionarlo con maximumAge, pero eso no parece funcionar, ya que se supone que funciona:

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

esto debería evitar llamar realmente a la función getCurrentPosition si la llama dentro de los 60 segundos, pero ignora esto (sin embargo, esto podría deberse a que realmente actualizo mi página para activar la segunda llamada, no estoy seguro de si esto es persistente entre llamadas)

por cierto, incluso los ejemplos de google fallan en estos navegadores, lo que me lleva a creer que de hecho se trata de errores del navegador, pruébalo, cárgalo dos veces en Safari y no funcionará la segunda vez.

Si alguien encuentra una solución para esto, POR FAVOR hágamelo saber :-)

Salud.

No recibe un mensaje de error porque no tiene tiempo de espera por defecto (al menos eso creo). He tenido el mismo problema con Firefox solo para mí. Firefox siempre da un tiempo de espera. Puede establecer un tiempo de espera de esta manera.

Mi función funciona muy bien en Chrome, pero siempre tengo un tiempo de espera en Firefox.

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

Recomiendo ver sus errores cuidadosamente. Ser esperado por todo. Tenga un plan de respaldo para todo. Yo mismo uso algunos valores predeterminados o valores de mi base de datos en caso de que falle tanto la geolocalización de Google como la geolocalización del navegador.

Todavía estoy obteniendo resultados irregulares en 2017, y tengo una teoría: la documentación de la API dice que la llamada ahora solo está disponible "en un contexto seguro", es decir, a través de HTTPS. Tengo problemas para obtener un resultado en mi entorno de desarrollo (http en localhost) y creo que es por eso.

Publicaré esto aquí en caso de que sea útil para alguien ...

En iOS Safari, las llamadas a navigator.geolocation.getCurrentPositionexpirarían si tuviera una navigator.geolocation.watchPositionfunción activa ejecutándose.

Comenzar y detener el watchPositionuso correctamente clearWatch() como se describe aquí, funcionó: https://developer.mozilla.org/en-US/docs/Web/API/Geolocation/watchPosition

Aquí está mi solución gracias a un cierre:

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

Entonces me encontré con lo mismo. Probé la solución de tiempo de espera que funcionó pero no de manera confiable. Descubrí que si lo llamas dos veces, la ubicación se actualiza correctamente

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

esto, por supuesto, es un poco más lento, pero no he tenido que darme la posición incorrecta una vez. He tenido que superar el tiempo de espera varias veces y no devolver nada, pero aparte de eso, funciona muy bien. Sé que esto todavía es un poco hacky y espero que alguien encuentre la solución real.

O si quiere asegurarse de que seguirá intentándolo hasta que quiera renunciar, puede intentar algo como esto.

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

Probablemente tengo algunos errores tipográficos y algunos errores ortográficos aquí, pero espero que entiendas la idea. Avíseme si alguien tiene preguntas o si alguien encuentra algo mejor.

Para cualquiera que trabaje en una aplicación de iPhone ...

Si su código se ejecuta en UIWebView en iOS 9+, debe configurarlo NSLocationWhenInUseUsageDescriptiondentro de la lista de aplicaciones.

Si no lo configura getCurrentPosition, nunca devolverá la llamada y nunca se le solicitará al usuario.

Descubrí que de esta manera no funciona

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

Pero

de esta manera funciona perfecto

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 respuesta de @ brennanyoung es excelente, pero si se pregunta qué hacer en el caso de falla, puede usar una API de geolocalización IP como https://ipinfo.io (que es mi servicio). Aquí hay un ejemplo:

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

Consulte https://ipinfo.io/developers/replacing-getcurrentposition para obtener más detalles.

He tenido problemas similares y he estado buscando la posibilidad de que los navegadores tengan límites sobre la frecuencia con la que se puede llamar a getCurrentPosition. Parece que a menudo puedo obtener una ubicación, pero si actualizo la página de inmediato, se agota el tiempo de espera. Si espero un momento, generalmente puedo obtener una ubicación nuevamente. Esto generalmente ocurre con FF. En Chrome y Safari, aún no he notado que getCurrentPosition agota el tiempo de espera. Solo un pensamiento...

Aunque no puedo encontrar ninguna documentación que respalde esto, fue una conclusión a la que llegué después de muchas pruebas. ¿Quizás alguien más tiene alguna información sobre eso?

Finalmente encontré una versión de trabajo para Firefox, Chrome y navegador predeterminado en Android (4.2 probado solamente):

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

El segundo parámetro pasado a Geolocation.getCurrentPosition()es la función que desea manejar cualquier error de geolocalización. La propia función del controlador de errores recibe un PositionErrorobjeto con detalles sobre por qué falló el intento de geolocalización. Recomiendo enviar el error a la consola si tiene algún problema:

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

Hacer esto en mi código reveló el mensaje "Proveedor de ubicación de red en ' https://www.googleapis.com/ ': Código de error devuelto 400". Resulta que Google Chrome utiliza las API de Google para obtener una ubicación en dispositivos que no tienen GPS incorporado (por ejemplo, la mayoría de las computadoras de escritorio). Google devuelve una latitud / longitud aproximada basada en la dirección IP del usuario. Sin embargo , en las compilaciones de desarrollador de Chrome (como Chromium en Ubuntu) no se incluye una clave de acceso a la API en la compilación del navegador. Esto hace que la solicitud de la API falle silenciosamente. Consulte el problema 179686 de Chromium: Geolocalización que da un error 403 para más detalles.

Tengo este problema en Mozilla. Todo el tiempo: Error : Error desconocido al adquirir la posición .

Ahora estoy usando 47 Mozilla. He intentado todo, pero todo este tiempo este problema. PERO luego abro sobre: ​​config en mi barra de direcciones, vaya geo.wifi.ui y cambié su valor a " https://location.services.mozilla.com/v1/geolocate?key=test ". ¡trabajos!

Si tiene un error de tiempo de espera de adquisición de posición , intente aumentar el valor de tiempo de espera:

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

Puede ser una buena idea utilizar un servicio de ubicación geográfica de direcciones IP como método alternativo cuando getCurrentPositionfalla. Por ejemplo con nuestra api https://ip-api.io

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

En nuestro caso, siempre funciona la primera vez, pero al volver a ejecutar la función más de 3-4 veces, falla.

Solución simple: almacene su valor en LocalStorage.

Antes de:

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

Después:

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

Noté este problema recientemente, y no estoy seguro de cómo se produce, pero parece que a veces Firefox se atasca en algo cargado en la memoria caché. Después de borrar el caché y reiniciar Firefox, parece funcionar nuevamente.

Esta biblioteca agrega una opción deseada de precisión y maxWait a las llamadas de geolocalización, lo que significa que seguirá tratando de obtener una posición hasta que la precisión esté dentro de un rango específico.

Gracias a todos por sus comentarios, esto me ayudó.

Además de tener que usar watchPosition () en lugar de getCurrentPosition (), también descubrí que necesitaba mover la llamada desde document.ready () a la cabeza.

Esto me sucedió cuando usé el modo de diseño receptivo de Firefox. Se ha presentado un informe de error . Por ahora, simplemente no use el modo de diseño receptivo mientras usa la API de geolocalización.

Puede ser que ayude a alguien, en Android tuve el mismo problema, pero lo resolví usando setTimeout adentro, document.ready por lo que funcionó para mí en segundo lugar, debe aumentar el tiempo de espera solo en caso de que el usuario permita su ubicación después de unos segundos, así que lo mantuve en 60000 mili segundos (1 minuto) permitiendo que mi función de éxito llame si el usuario hace clic en el botón de permiso dentro de 1 minuto.