navigator.geolocation.getCurrentPosition às vezes funciona às vezes não

Então, eu tenho um pouco de JS bastante simples usando o 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

Basicamente, o que está acontecendo aqui é que obtemos a posição atual; se obtida, duas "marcas d'água" são colocadas em dois campos que dizem "Posição atual" e dois campos ocultos são criados com os dados de longo prazo como valor (eles são removidos no começo para que não sejam duplicados toda vez). Há também dois botões que têm uma função de clique vinculada a eles que fazem a mesma coisa. Infelizmente, pela terceira vez, funciona. Qual é o problema aqui ???

Eu tenho exatamente o mesmo problema e quase não encontro informações on-line. Nada nos livros. Finalmente, encontrei essa consulta sóbria no stackoverflow e (ha!) Foi o impulso final necessário para configurar uma conta aqui.

E tenho uma resposta parcial, mas infelizmente não uma completa.

Antes de tudo, saiba que o tempo limite padrão para getCurrentPosition é infinito (!). Isso significa que seu manipulador de erros nunca será chamado se getCurrentPosition travar em algum lugar no back-end.

Para garantir que você tenha um tempo limite, adicione o terceiro parâmetro opcional à sua chamada para getCurrentPosition, por exemplo, se você quiser que o usuário espere não mais que 10 segundos antes de dar uma pista do que está acontecendo, use:

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

Em segundo lugar, experimentei confiabilidade bastante diferente em diferentes contextos. Aqui em casa, recebo um retorno de chamada dentro de um ou dois segundos, embora a precisão seja baixa.

No trabalho, no entanto, experimento variações bastante bizarras de comportamento: a geolocalização funciona em alguns computadores o tempo todo (exceto o IE, é claro), outros só funcionam no chrome e safari, mas não no firefox (questão de lagartixa?), Outros trabalham uma vez e depois posteriormente falha - e o padrão muda de hora em hora, de dia para dia. Às vezes você tem um computador 'sortudo', às vezes não. Talvez o abate de cabras na lua cheia ajudaria?

Não consegui entender isso, mas suspeito que a infraestrutura de back-end é mais desigual do que a anunciada nos vários livros e sites que estão impulsionando esse recurso. Eu realmente gostaria que eles fossem um pouco mais diretos sobre o quão flakey esse recurso é e o quão importante é essa configuração de tempo limite, se você quiser que seu manipulador de erros funcione corretamente .

Hoje tenho tentado ensinar essas coisas para os alunos e tive a situação embaraçosa em que meu próprio computador (no projetor e em várias telas grandes) falhou silenciosamente, enquanto cerca de 80% dos alunos obtiveram resultado quase instantaneamente (usando o mesma rede sem fio). É muito difícil resolver esses problemas quando meus alunos também estão cometendo erros de digitação e outros erros e quando meu computador também está falhando.

Enfim, espero que isso ajude alguns de vocês. Obrigado pela verificação de sanidade!

Esta é a maneira hacky que eu estou contornando isso, pelo menos funciona em todos os navegadores atuais (no Windows, eu não possuo um 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();
}

Isso também funcionará se alguém clicar no fechamento ou escolher não ou escolher a opção Nunca compartilhar no Firefox.

Desajeitado, mas funciona.

Isso funciona para mim sempre:

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

Embora não seja muito preciso. O engraçado é que, no mesmo dispositivo, se eu fizer isso, ele me deixa a cerca de 100 metros (todas as vezes), mas se eu for aos mapas do google, ele encontrará minha localização exatamente. Portanto, embora eu ache que o enableHighAccuracy: true o ajude a funcionar de maneira consistente, ele não parece torná-lo mais preciso ...

Essa já é uma pergunta antiga, mas todas as respostas não resolveram o meu problema, então vamos adicionar a que finalmente encontrei. Cheira a um hack (e é um), mas funciona sempre na minha situação. Espero também na sua situação.

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

Mesmo aqui, pessoal, isso funciona perfeitamente no Chrome (estável, dev e canary), mas não no FF e no Safari. Também funciona perfeitamente no meu iPhone e iPad (Safari!). Isso pode ser devido à relativa novidade desse recurso (ou seja, é um bug). Passo quase uma semana nisso agora e simplesmente não consigo fazê-lo funcionar nesses navegadores

Aqui está o que eu encontrei:

A primeira vez que você chama getCurrentPosition, ele funciona perfeitamente. Qualquer chamada subsequente nunca retorna, ou seja, não aciona as funções successCallback ou errorCallback. Adicionei algumas opções de posição à minha chamada para provar meu argumento:

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

e o tempo limite é excedido o tempo todo (após a primeira chamada bem-sucedida). Eu pensei que poderia corrigi-lo com maximumAge, mas isso não parece estar funcionando, pois deve funcionar:

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

isso deve impedir realmente chamar a função getCurrentPosition se você chamá-la dentro de 60 segundos, mas ignora isso (no entanto, isso pode ocorrer porque eu atualizo minha página para acionar a segunda chamada, não tenho certeza se isso é persistente entre as chamadas)

aliás, até os exemplos do google falham nesses navegadores, o que me leva a acreditar que esses são realmente erros do navegador. Experimente, carregue duas vezes no Safari e não funcionará na segunda vez.

Se alguém encontrar uma solução para isso, por favor me avise :-)

Felicidades.

Você não recebe uma mensagem de erro porque não tem tempo limite por padrão (pelo menos eu acho). Eu tive o mesmo problema com o Firefox apenas para mim, o Firefox sempre dá um tempo limite. Você pode definir um tempo limite dessa maneira.

Minha função funciona muito bem no chrome, mas sempre recebo um tempo limite no firefox.

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

Eu recomendo observar seus erros com cuidado. Seja esperado para tudo. Tenha um plano de backup para tudo. Eu mesmo uso alguns valores padrão ou valores do meu banco de dados, caso falhem as geolocalizações do google e as localizações do navegador.

Ainda estou obtendo resultados irregulares em 2017 e tenho uma teoria: a documentação da API diz que a chamada agora está disponível apenas "em um contexto seguro", ou seja, por HTTPS. Estou tendo problemas para obter um resultado no meu ambiente de desenvolvimento (http no localhost) e acredito que é por isso.

Vou postar aqui caso seja útil para qualquer pessoa…

No iOS Safari, as chamadas para navigator.geolocation.getCurrentPositionatingiriam o tempo limite se eu tivesse uma navigator.geolocation.watchPositionfunção ativa em execução.

Iniciando e parando o watchPositionuso correto, clearWatch() conforme descrito aqui, funcionou: https://developer.mozilla.org/en-US/docs/Web/API/Geolocation/watchPosition

aqui está a minha solução graças a um fechamento:

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

Então, eu estava correndo para a mesma coisa. Tentei a solução de tempo limite que funcionou, mas não de forma confiável. Descobri que se você chamar duas vezes, o local será atualizado corretamente

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

é claro que isso é um pouco mais lento, mas eu não tive uma posição errada uma vez. Eu tive que acertar o tempo limite algumas vezes e não retornar nada além de que ele funciona muito bem. Eu sei que isso ainda é um pouco hacky e estou ansioso para alguém encontrar a solução real.

Ou, se você quiser ter certeza de que continuará tentando até desistir, tente algo assim.

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

Provavelmente tenho alguns erros de digitação e ortografia aqui, mas espero que você entenda. Deixe-me saber se alguém tiver dúvidas ou se alguém encontrar algo melhor.

Para quem trabalha em um aplicativo para iPhone ...

Se seu código estiver sendo executado em um UIWebView no iOS 9 ou superior, você deverá definir NSLocationWhenInUseUsageDescription o plist do seu aplicativo.

Se você não o definir, getCurrentPositionnunca retornará a ligação e o usuário nunca será solicitado.

Eu descobri que desse jeito não funciona

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

Mas

desta maneira funciona perfeito

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

function errorHandler() {...}

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

A resposta de @ brennanyoung é ótima, mas se você estiver se perguntando o que fazer no caso de falha, poderá usar uma API de geolocalização IP, como https://ipinfo.io (que é o meu serviço). Aqui está um exemplo:

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 obter mais detalhes.

Eu tenho problemas semelhantes e tenho estudado a possibilidade de que os navegadores tenham limites para a frequência com que getCurrentPosition pode ser chamado. Parece que posso obter um local com frequência, mas se eu atualizar a página imediatamente, o tempo limite será excedido. Se eu esperar um pouco, geralmente consigo um local novamente. Isso geralmente acontece com FF. No Chrome e Safari, ainda não notei o tempo limite de getCurrentPosition. Apenas um pensamento...

Embora eu não consiga encontrar nenhuma documentação para apoiar isso, foi uma conclusão a que cheguei após muitos testes. Talvez alguém tenha alguma informação sobre isso?

Finalmente encontrei uma versão de trabalho para o Firefox, Chrome e Navegador Padrão no Android (apenas 4.2 testado):

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

O segundo parâmetro transmitido para Geolocation.getCurrentPosition()é a função que você deseja tratar de qualquer erro de localização geográfica. A própria função do manipulador de erros recebe um PositionErrorobjeto com detalhes sobre por que a tentativa de geolocalização falhou. Eu recomendo enviar o erro para o console se você tiver algum 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);
  }
}

Fazer isso no meu código revelou a mensagem "Provedor de localização de rede em ' https://www.googleapis.com/ ': código de erro retornado 400". Acontece que o Google Chrome usa as APIs do Google para obter um local em dispositivos que não possuem GPS incorporado (por exemplo, a maioria dos computadores de mesa). O Google retorna uma latitude / longitude aproximada com base no endereço IP do usuário. No entanto , nas versões do desenvolvedor do Chrome (como o Chromium no Ubuntu), não há chave de acesso à API incluída na versão do navegador. Isso faz com que a solicitação da API falhe silenciosamente. Consulte Chromium Issue 179686: Geolocalização dando erro 403 para obter detalhes.

Eu tenho esse problema no Mozilla. Desde sempre: Erro : Erro desconhecido ao adquirir posição .

Agora eu estou usando 47 Mozilla. Eu tentei de tudo, mas esse tempo todo esse problema. MAS então eu abro about: config na minha barra de endereços, geo.wifi.ui e alterei o valor para " https://location.services.mozilla.com/v1/geolocate?key=test ". trabalho!

Se você tiver um erro de tempo limite de aquisição de posição , tente aumentar o valor do tempo limite:

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

Pode ser uma boa ideia usar um serviço de localização geográfica de endereço IP como um método de fallback quando houver getCurrentPositionfalha. Por exemplo, com a nossa API https://ip-api.io

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

No nosso caso, ele sempre funciona na primeira vez, mas, ao executar novamente a função mais de 3-4 vezes, falha.

Solução simples: armazene seu valor no LocalStorage.

Antes:

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

Depois de:

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

Eu também notei esse problema recentemente, e não sei ao certo como isso ocorre, mas às vezes parece que o Firefox fica preso em algo carregado no cache. Após limpar o cache e reiniciar o Firefox, ele parece funcionar novamente.

Essa biblioteca adiciona uma opção desejada de Precisão e maxWait às chamadas de geolocalização, o que significa que continuará tentando obter uma posição até que a precisão esteja dentro de um intervalo especificado.

Obrigado a todos por sua contribuição, isso me ajudou.

Além de ter que usar watchPosition () em vez de getCurrentPosition (), também descobri que precisava mover a chamada de document.ready () para a cabeça.

Isso aconteceu comigo ao usar o modo de design responsivo do Firefox. Houve um relatório de bug arquivado. Por enquanto, apenas não use o modo de design responsivo enquanto estiver usando a API de localização geográfica.

Pode ser que ajude alguém, no Android eu tive o mesmo problema, mas eu descobri isso usando o setTimeout interior, document.ready então funcionou para mim em segundo lugar, você tem que aumentar o tempo limite apenas para o caso de o usuário permitir sua localização após alguns segundos, então eu o mantive em 60000 mili segundos (1 minuto), permitindo que minha função de sucesso chame se o usuário clicar no botão permitir dentro de 1 minuto.