navigator.geolocation.getCurrentPosition fonctionne parfois parfois non

J'ai donc un peu assez simple de JS utilisant le 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

Fondamentalement, ce qui se passe ici, c'est que nous obtenons la position actuelle, si elle est obtenue, deux "filigranes" sont placés dans deux champs qui disent "Position actuelle" et deux champs cachés sont créés avec les données lat comme valeur (ils sont supprimés au début afin qu'ils ne soient pas dupliqués à chaque fois). Il y a également deux boutons qui ont une fonction de clic qui leur est liée et qui font la même chose. Malheureusement, une fois sur trois environ, cela fonctionne. Quel est le problème ici ???

J'ai eu exactement le même problème et je n'ai trouvé presque aucune information en ligne à ce sujet. Rien du tout dans les livres. Enfin, j'ai trouvé cette interrogation sobre sur stackoverflow et (ha!), C'était l'impulsion finale dont j'avais besoin pour créer un compte ici.

Et j'ai une réponse partielle, mais hélas pas complète.

Tout d'abord, sachez que le délai d' expiration par défaut pour getCurrentPosition est infini (!). Cela signifie que votre gestionnaire d'erreurs ne sera jamais appelé si getCurrentPosition se bloque quelque part à l'arrière.

Pour vous assurer d'obtenir un délai d'expiration, ajoutez le troisième paramètre facultatif à votre appel à getCurrentPosition, par exemple, si vous voulez que l'utilisateur n'attende pas plus de 10 secondes avant de lui donner un indice de ce qui se passe, utilisez:

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

Deuxièmement, j'ai connu une fiabilité assez différente dans différents contextes. Ici à la maison, je reçois un rappel dans une seconde ou deux, bien que la précision soit médiocre.

Au travail cependant, j'éprouve des variations de comportement assez bizarres: la géolocalisation fonctionne tout le temps sur certains ordinateurs (sauf IE, bien sûr), d'autres ne fonctionnent qu'en chrome et safari mais pas en firefox (problème gecko?), D'autres fonctionnent une fois, puis par la suite échouer - et le modèle change d'heure en heure, de jour en jour. Parfois, vous avez un ordinateur «chanceux», parfois non. Peut-être que l'abattage des chèvres à la pleine lune serait utile?

Je n'ai pas pu comprendre cela, mais je soupçonne que l'infrastructure principale est plus inégale que celle annoncée dans les divers livres et sites Web de Gung-ho qui poussent cette fonctionnalité. Je souhaite vraiment qu'ils soient un peu plus précis sur la façon dont cette fonctionnalité est floconneuse et sur l'importance de ce paramètre de délai d'attente, si vous voulez que votre gestionnaire d'erreurs fonctionne correctement .

J'ai essayé d'enseigner ce genre de choses aux étudiants aujourd'hui et j'ai eu la situation embarrassante où mon propre ordinateur (sur le projecteur et plusieurs grands écrans) échouait silencieusement, alors qu'environ 80% des étudiants obtenaient un résultat presque instantanément (en utilisant le exactement le même réseau sans fil). Il est très difficile de résoudre ces problèmes lorsque mes élèves fabriquent également des fautes de frappe et d'autres gaffes, et lorsque mon propre ordinateur échoue également.

Quoi qu'il en soit, j'espère que cela aide certains d'entre vous. Merci pour le contrôle de santé mentale!

C'est la manière hacky que je contourne, au moins cela fonctionne dans tous les navigateurs actuels (sous Windows, je ne possède pas de 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();
}

Cela fonctionnera également si quelqu'un clique sur la fermeture ou choisit non ou choisit l'option Ne jamais partager sur Firefox.

Clunky, mais ça marche.

Cela fonctionne pour moi à chaque fois:

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

Bien que ce ne soit pas très précis. Ce qui est drôle, c'est que sur le même appareil, si je lance cela, cela me met à environ 100 mètres (à chaque fois), mais si je vais sur les cartes de Google, il trouve exactement ma position. Donc, bien que je pense que le enableHighAccuracy: true l'aide à fonctionner de manière cohérente, il ne semble pas le rendre plus précis ...

C'est déjà une vieille question, mais toutes les réponses n'ont pas résolu mon problème, alors ajoutons celle que j'ai finalement trouvée. Ça sent comme un hack (et c'est un), mais ça marche toujours dans ma situation. J'espère aussi dans votre situation.

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

Idem ici les gens, cela fonctionne parfaitement entre Chrome (stable, dev et canary) mais pas avec FF et Safari. Il fonctionne également parfaitement sur mon iPhone et iPad (Safari!). Cela peut être dû à la nouveauté relative de cette fonctionnalité (c'est-à-dire qu'il s'agit d'un bogue). J'y passe presque une semaine maintenant et je n'arrive pas à le faire fonctionner sur ces navigateurs

Voici ce que j'ai trouvé:

La première fois que vous appelez getCurrentPosition, cela fonctionne parfaitement. Tout appel ultérieur ne revient jamais, c'est-à-dire qu'il ne déclenche pas les fonctions successCallback ou errorCallback. J'ai ajouté quelques options de position à mon appel pour prouver mon point:

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

et il expire à chaque fois (après le premier appel réussi). Je pensais que je pouvais le réparer avec maximumAge, mais cela ne semble pas fonctionner car il est supposé fonctionner non plus:

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

cela devrait empêcher d'appeler réellement la fonction getCurrentPosition si vous l'appelez dans les 60 secondes, mais cela l'ignore (cependant, cela peut être dû au fait que j'actualise ma page pour déclencher le deuxième appel, je ne sais pas s'il s'agit d'un appel persistant)

btw, même les exemples de google échouent sur ces navigateurs, ce qui m'amène à croire qu'il s'agit bien de bogues de navigateur, essayez-le, chargez-le deux fois dans Safari et cela ne fonctionnera pas la deuxième fois.

Si quelqu'un trouve une solution à cela, VEUILLEZ m'en faire part :-)

À votre santé.

Vous n'obtenez pas de message d'erreur car il n'a pas de délai d'expiration par défaut (au moins je pense). J'ai eu le même problème avec firefox que pour moi firefox donne toujours un timeout. Vous pouvez définir vous-même un délai d'attente comme celui-ci.

Ma fonction fonctionne très bien dans Chrome mais j'obtiens un timeout à chaque fois dans Firefox.

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

Je recommande de surveiller attentivement vos erreurs. Soyez attendus pour tout. Ayez un plan de sauvegarde pour tout. J'utilise moi-même des valeurs par défaut ou des valeurs de ma base de données au cas où les géolocalisations google et les géolocalisations de navigateur échoueraient.

J'obtiens toujours des résultats inégaux en 2017, et j'ai une théorie: la documentation de l'API dit que l'appel n'est désormais disponible que "dans un contexte sécurisé", c'est-à-dire via HTTPS. J'ai du mal à obtenir un résultat dans mon environnement de développement (http sur localhost) et je crois que c'est pourquoi.

Je posterai ceci ici au cas où cela serait utile à n'importe qui…

Sur iOS Safari, les appels à navigator.geolocation.getCurrentPositionexpireraient si j'avais une navigator.geolocation.watchPositionfonction active en cours d'exécution.

Démarrer et arrêter watchPositioncorrectement l'utilisation clearWatch() comme décrit ici, a fonctionné: https://developer.mozilla.org/en-US/docs/Web/API/Geolocation/watchPosition

voici ma solution grâce à une fermeture:

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

Donc, je rencontrais la même chose. J'ai essayé la solution de délai d'attente qui a fonctionné mais pas de manière fiable. J'ai trouvé que si vous l'appelez simplement deux fois, l'emplacement est correctement rafraîchi

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

bien sûr, c'est un peu plus lent mais je ne l'ai pas fait me donner la mauvaise position une fois. Je l'ai fait frapper le timeout à quelques reprises et ne retourner rien d'autre que ça, ça marche très bien. Je sais que c'est encore un peu hacky et j'ai hâte que quelqu'un trouve la vraie solution.

Ou si vous voulez vous assurer qu'il continuera d'essayer jusqu'à ce que vous vouliez abandonner, vous pouvez essayer quelque chose comme ça.

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

J'ai probablement quelques fautes de frappe et quelques fautes d'orthographe ici, mais j'espère que vous avez compris l'idée. Faites-moi savoir si quelqu'un a des questions ou si quelqu'un trouve quelque chose de mieux.

Pour toute personne travaillant sur une application iPhone ...

Si votre code s'exécute dans une UIWebView sur iOS 9+, vous devez définir NSLocationWhenInUseUsageDescription dans le plist de votre application.

Si vous ne le définissez pas, il getCurrentPositionne rappellera jamais et l'utilisateur ne sera jamais invité.

J'ai trouvé que ça ne marche pas

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

Mais

cette façon fonctionne parfaitement

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 réponse de @ brennanyoung est excellente, mais si vous vous demandez quoi faire en cas d'échec, vous pouvez utiliser une API de géolocalisation IP telle que https://ipinfo.io (qui est mon service). Voici un exemple:

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

Voir https://ipinfo.io/developers/replacing-getcurrentposition pour plus de détails.

J'ai eu des problèmes similaires et j'ai étudié la possibilité que les navigateurs aient des limites sur la fréquence d'appel de getCurrentPosition. Il semble que je puisse souvent obtenir un emplacement, mais si je rafraîchis la page immédiatement, elle expirera. Si j'attends un peu, je peux généralement retrouver un emplacement. Cela se produit généralement avec FF. Dans Chrome et Safari, je n'ai pas encore remarqué de temporisation de getCurrentPosition. Juste une pensée...

Bien que je ne trouve aucune documentation à l'appui, c'est une conclusion à laquelle je suis parvenu après de nombreux tests. Peut-être que quelqu'un d'autre a des informations à ce sujet?

J'ai enfin trouvé une version de travail pour Firefox, Chrome et navigateur par défaut dans Android (4.2 testé uniquement):

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

Le deuxième paramètre transmis à Geolocation.getCurrentPosition()est la fonction à laquelle vous souhaitez gérer les erreurs de géolocalisation. La fonction de gestion des erreurs elle-même reçoit un PositionErrorobjet avec des détails sur les raisons de l'échec de la tentative de géolocalisation. Je recommande de générer l'erreur sur la console si vous rencontrez des problèmes:

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

Faire cela dans mon code a révélé le message "Fournisseur de localisation réseau sur ' https://www.googleapis.com/ ': Code d'erreur 400 renvoyé". Il s'avère que Google Chrome utilise les API Google pour obtenir un emplacement sur des appareils sans GPS intégré (par exemple, la plupart des ordinateurs de bureau). Google renvoie une latitude / longitude approximative en fonction de l'adresse IP de l'utilisateur. Cependant , dans les versions développeur de Chrome (telles que Chromium sur Ubuntu), aucune clé d'accès API n'est incluse dans la version du navigateur. Cela entraîne l'échec silencieux de la demande d'API. Voir Chromium Issue 179686: Géolocalisation donnant une erreur 403 pour plus de détails.

J'ai ce problème dans Mozilla. Tout le temps: Erreur Erreur inconnue lors de l'acquisition de la position .

J'utilise maintenant 47 Mozilla. J'ai tout essayé, mais tout le temps ce problème. MAIS alors j'ouvre sur: config dans ma barre d'adresse, allez sur geo.wifi.ui et changez sa valeur en " https://location.services.mozilla.com/v1/geolocate?key=test ". travaux!

Si vous avez une erreur de temporisation de l'acquisition de position , essayez d'augmenter la valeur du délai:

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

Il peut être judicieux d'utiliser un service de géolocalisation d'adresses IP comme méthode de secours en cas d' getCurrentPositionéchec. Par exemple avec notre api https://ip-api.io

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

Dans notre cas, il fonctionne toujours la première fois, mais en réexécutant la fonction plus de 3 à 4 fois, il échoue.

Solution simple: stockez sa valeur dans LocalStorage.

Avant:

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

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

J'ai moi-même remarqué ce problème récemment, et je ne sais pas comment il se produit, mais il semblerait que Firefox soit bloqué sur quelque chose chargé dans le cache. Après avoir effacé le cache et redémarré Firefox, il semble fonctionner à nouveau.

Cette bibliothèque ajoute une option souhaitéeAccuracy et maxWait aux appels de géolocalisation, ce qui signifie qu'elle continuera d'essayer d'obtenir une position jusqu'à ce que la précision se situe dans une plage spécifiée.

Merci à tous pour leur contribution, cela m'a aidé.

En plus d'avoir à utiliser watchPosition () au lieu de getCurrentPosition (), j'ai également constaté que je devais déplacer l'appel de document.ready () vers la tête.

Cela m'est arrivé lors de l'utilisation du mode de conception réactif de Firefox. Un rapport de bogue a été déposé. Pour l'instant, n'utilisez pas le mode de conception réactif lorsque vous utilisez l'API de géolocalisation.

Peut-être que cela aide quelqu'un, Sur Android, j'ai eu le même problème, mais je l'ai résolu en utilisant l' setTimeout intérieur, document.ready donc cela a fonctionné pour moi deuxièmement, vous devez augmenter le délai d'attente juste au cas où l'utilisateur autoriserait sa localisation après quelques secondes, donc je l'ai gardé à 60000 mili secondes (1 minute) permettant à ma fonction de réussite d'appeler si l'utilisateur clique sur le bouton Autoriser dans 1 minute.