@ acapop77 J'ai oublié de mentionner également que les autorisations sont activées en utilisant:

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />

J'ai le même problème sur RN 0.25.1, la différence est, pour moi, le problème persiste pour une précision élevée et faible. Enfin, j'ai trouvé quelque chose qui le fait fonctionner, mais ce n'est pas une solution.

Voici ce qui a fonctionné pour moi - en supposant que vous utilisez stock android avd - émulateur:

1. Dans le périphérique d'émulation Android, accédez à "Paramètres> Emplacement" (comme vous le feriez sur le périphérique réel) et réglez Mode sur Haute précision.
2. Revenez à l'application.
3. Appuyez sur le bouton "Contrôles étendus" (représenté par "..."). Ensuite, dans la section Emplacement, vous verrez les données des points de données GPS et le bouton «Envoyer» ci-dessous. Cliquez simplement sur "Envoyer" et fermez le menu des commandes étendues.
4. Recharger l'application.

Cela fonctionne pour moi - sur une «base unique». Chaque fois que je veux recharger l'application, je dois recommencer 3-4 étapes. Mais au moins de cette façon, je fais fonctionner la géolocalisation et je n'obtiens pas d'erreur de temporisation.

Je vis quelque chose de similaire en 0,24. Même si <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" /> est dans mon AndroidManifest.xml, je reçois l'erreur rouge indiquant:

"Il semble que l'application ne soit pas autorisée à accéder à la position. Ajoutez la ligne suivante ..."

Je n'utilise pas l'émulateur et je crée plutôt directement sur l'appareil.

Edit - cela se produit également dans 0.25.1

@ acapop77 @rossthedevigner Je construis également directement sur un appareil Samsung S6.

@Findiglay Même chose ici. J'ai même essayé de faire une installation manuelle de .apk et j'ai toujours reçu l'erreur.

J'essaie une solution de contournement où je boucle dans le manifeste des autorisations et vois si android.permission.ACCESS_FINE_LOCATION est activé.

Quelqu'un ayant navigator.geolocation == undefined?

Je rencontre actuellement ce problème sur mon appareil.

Plusieurs problèmes sont signalés ici. Je ne suis pas sûr que tous soient pertinents pour le problème spécifique avec enableHighAccuracy.

Je n'ai aucune expérience avec le développement Android, mais j'ai trouvé que si je modifie LocationModule.java pour coder en dur les LocationOptions boolean highAccuracy = true; et reconstruire, mon emplacement reviendra correctement. Je ne suis pas certain que les résultats soient différents ou non de ceux reçus avec le paramètre enableHighAccuracy: false dans l'API de géolocalisation React-Native, mais il devrait être prudent de supposer que cela fonctionne en mode haute précision.

Cela pourrait-il signifier que le bogue se produit dans le pont entre l'API de géolocalisation et le LocationModule?

Je rencontre le même problème. J'ai fait la même chose que @Findiglay m'a suggéré et

Une idée de la raison pour laquelle cela se produit sur de vrais appareils? :(

Avoir le même problème. J'exécute actuellement l'application sur de vrais appareils, en utilisant RN 0.25.1.

Je dois ajouter que j'ai déjà ajouté les autorisations Android nécessaires au manifeste des autorisations. Mais encore des délais d'attente.

comme solution de contournement, j'ai activé `` Autoriser les emplacements fictifs '' dans les paramètres Android et installé une application qui se moque du GPS (recherchez de faux GPS en magasin). Au moins jusqu'à ce que cela soit corrigé, le développement n'est pas bloqué

Je les gars,
J'étais confronté à la même erreur mais, après quelques tentatives avec mes collègues, nous remarquons quelque chose d'étrange (mais normal si vous pensez au GPS).

Si vous exécutez des tests «à l'intérieur de votre bureau» à l'aide d'un appareil physique, le localisateur GPS peut être dérangé par des éléments externes comme les murs, ou par la simple raison que vous essayez de faire cette opération «à l'intérieur» et, généralement, cela doit être exécuté à l'extérieur .

Eh bien, après cela, nous sortons de notre bureau, nous réexécutons les tests et l'appareil répond comme prévu (nous n'avons pas reçu l'erreur de délai d'expiration de la demande).

Ma suggestion est la suivante: essayez la géolocalisation en utilisant "enableHighAccuracy" défini sur true, si cela échoue (au bureau, cela peut échouer), réessayez avec false, cela devrait fonctionner, dans mon cas, c'est le cas.

J'espère que cela peut aider.

+1

Même problème ici si enableHighAccuracy est défini sur true ou false .
Il fonctionne sur les émulateurs GenyMotion mais pas sur de vrais appareils (testé sur Samsung, Nexus, Mi).
Autorisation activée dans AndroidManifest.xml
Code:

                navigator.geolocation.getCurrentPosition(
                    (position) => {
                        console.log(position);
                    },
                    (error) => console.log(new Date(), error),
                    {enableHighAccuracy: true, timeout: 10000, maximumAge: 3000}
                );  

définir enableHighAccuracy sur true ou false ne fonctionne pas pour moi.
omettre le 3ème argument pour getCurrentPosition pour utiliser les valeurs par défaut du module natif fonctionne pour moi.

Même problème ici avec LGE Nexus 5 (Android 6.0).
Sur Android 5.1.1 et 4.3, ce problème n'existe pas.
Dans l'émulateur avec Android 6.0, ce problème n'existe pas.
boolean highAccuracy = false; ne fonctionne pas.
RN 0,28,0.

Hé les gars, j'ai trouvé une solution temporaire - ce paquet https://github.com/lucasferreira/react-native-android-permissions

Des mises à jour ou un correctif pour cela? Tout fonctionne bien sur les appareils Simulator et pré-5.0, après ce seul délai, et j'ai désespérément besoin d'un correctif pour une application déjà disponible!

+1

Ce problème est affecté par le paramètre locationMode sur l'appareil. Lorsque le mode de localisation est défini sur Haute précision ou sur appareil uniquement, la géolocalisation expire. Il fonctionne correctement lorsque le mode de localisation est réglé sur économie de batterie

J'ai eu le même problème, j'ai pris un punt et enlevé le 3ème argument. Et ça marche maintenant.

navigator.geolocation.getCurrentPosition( (position) => { console.log(position); }, (error) => console.log(new Date(), error), {enableHighAccuracy: true, timeout: 10000, maximumAge: 3000} //removed this );

Je suppose que cela est lié à: https://productpains.com/post/react-native/add-android-m-permissions-model-support

droite?

Non, c'était pour le problème de délai d'expiration de l'emplacement

Oui, je venais de découvrir que la suppression du 3ème argument semble être une solution.

Nous n'avons pas encore entièrement testé l'appareil, mais il semble que la version Android 22, avec le mode de l'appareil réglé sur haute précision ou appareil uniquement, provoquera l'expiration de l'emplacement, lorsque le 3ème argument est inclus, quels que soient les paramètres. Cela ne semble pas affecter la version Android 23.

Même expérience de mon côté, sauf que la version Android 23 ne fonctionne qu'avec le 3ème argument lorsque enableHighAccuracy est défini sur false ( true entraîne l'expiration de l'emplacement). Testé également sur les versions android 22, 21, 20 & 19 et il semble que la présence du 3ème argument provoque un timeout dans tous les cas. La suppression de cet argument semble être la seule solution fiable.

La suppression du 3ème argument me fait simplement avoir la fenêtre contextuelle "La demande de localisation a expiré" instantanément au lieu d'attendre la fin du délai. Définir enableHighAccuracy sur false ne fonctionne pas non plus.

Sur mon émulateur, l'emplacement n'est disponible que lorsque j'ouvre les paramètres de l'émulateur et envoie un emplacement (vérifiez la capture d'écran).

Existe-t-il un moyen de l'obtenir automatiquement?

Dans mon cas, définir enableHighAccuracy à false résolu le problème.

Ayant le même problème ici, à la fois sur l'émulateur et sur l'appareil, et essayé avec true et false pour enableHighAccuracy

J'obtiens simplement "undefined n'est pas un objet (évaluation de 'navigator.geolocation.getCurrentPosition')"

J'ai essayé de vérifier si (navigateur), cela retournait vrai,
mais si (navigator.geolocation) a renvoyé false.

Aussi, faites cela sur un appareil sous Android 5.1 OnePlus One. Mode développeur activé, autorisations AndroidManifest incluses, emplacements simulés activés / désactivés, tout.

De plus, il n'a pas semblé me ​​demander des autorisations de localisation - malgré la suppression de l'application sur l'appareil et du dossier de sortie sur mon mac.

Je ne peux pas réellement déboguer à distance non plus puisque j'utilise React Realm et que cette chose a d'énormes problèmes qui vissent le débogueur à distance Chrome à l'envers.

J'ai un problème similaire, peut-être que l'application n'expire pas toujours, MAIS elle le fait souvent, lorsque d'autres applications de géolocalisation fonctionnent très bien chaque fois que celle avec RN a une géolocalisation très mauvaise.
J'utilise RN 0.32 mais j'ai eu le même problème avec chaque version, pour une raison quelconque, la géolocalisation dans RN est très étrange et médiocre (au moins sur Android)

Même problème ici, test sur un appareil réel.

Rencontrer ceci et c'est vraiment ennuyeux: /

J'ai le même problème sur Android 6.0.

+1

J'ai trouvé qu'une solution était de ne pas ajouter de 3ème paramètre et d'utiliser la bibliothèque liée ci-dessus (https://github.com/lucasferreira/react-native-android-permissions) sur la version Android> = 23 pour demander les autorisations android M.

Je viens de repérer PermissionsAndroid a maintenant été ajouté à RN. Alors utilisez ceci pour demander si sur android> = 23

https://facebook.github.io/react-native/docs/permissionsandroid.html

Mais j'ai Android 5.1.1 sur mon appareil. Sur ce v. D'Android, la géolocalisation doit fonctionner correctement, non?

23 est à partir de 6,0. J'ai également trouvé que je devais ne pas ajouter le 3ème paramètre pour qu'il fonctionne sur tout.

J'ai réussi à faire fonctionner cela, mais cela pourrait être différent pour vous. Les nouvelles versions de RN (la mienne est la 0.32.1) incluent un fichier appelé MainApplication.java (en plus de MainActivity.java). Le React Native Mapbox GL Docs indique que vous devez inclure le ReactNativeMapboxGLPackage dans MainActivity.java, mais vous devez le faire dans MainApplication.java pour que cela ressemble à ceci:

MainApplication.java

». . .

<strong i="8">@Override</strong>
protected List<ReactPackage> getPackages() {
  return Arrays.<ReactPackage>asList(
      new MainReactPackage(),
      new ReactNativeMapboxGLPackage()
  );
}

};
»

Et MainActivity.java resterait le même que d'habitude.

Ma version Android est 23, donc j'utilise toujours les autorisations du manifeste xml

Avec le GPS activé sur l'appareil, l'application renvoie la position bien, mais si je la désactive, la position retourne: error: No available location provider.

Comment puis-je forcer l'appareil à une position GPS active?

C'est exaspérant = /

J'ai eu getCurrentPosition travaillant sur mon émulateur Android Genymotion ces dernières semaines, mais maintenant, il échoue à nouveau.

J'utilise le widget GPS de Genymotion pour définir l'emplacement. J'ai installé Google Maps sur l'émulateur et Google Maps peut très bien lire ma position.

J'ai toutes les autorisations nécessaires, et j'utilise même le module PermissionsAndroid comme @sattaman l'a suggéré. Il semble que le comportement soit non déterministe, en ce sens qu'il fonctionne un jour et se brise le lendemain.

Je suis sur RN 0.31 et la suppression du troisième paramètre a fonctionné pour moi aussi! Appareil réel, Nexus 5X, Android 6.

J'ai le même problème sur RN 0.34.1, mais supprimer le troisième paramètre peut le résoudre
La définition de enableHighAccuracy sur false ne résout pas ce problème

Même problème avec moi sur RN 0.32, essayé avec Android 22 & 23,

enableHighAccuracy sur true ou false, ne fonctionne pas pour moi
la suppression du troisième paramètre entraîne un "délai d'expiration de la demande de localisation" immédiat
cependant le redémarrage de mon appareil fait son travail, mais sera cassé après un certain temps,

maintenant, pour obtenir l'emplacement des utilisateurs, j'utilise simplement ceci:
https://github.com/mauron85/react-native-background-geolocation

@acondense où

J'ai rencontré le même problème sur RN 0.35 avec Android 23 et 24, mais fonctionne bien avec Android 22.
Cela peut être lié au système d'autorisation d'exécution d'Android 6.0:
http://stackoverflow.com/questions/32224534/access-fine-location-permission-error-emulator-only

J'utilise cette bibliothèque pour éviter ce problème et cela fonctionne très bien!
https://github.com/yonahforst/react-native-permissions

La suppression du troisième paramètre l'a corrigé pour moi aussi 💯 💯 💯

La suppression du troisième paramètre a fonctionné 👍

Il n'était pas si clair dès le départ de quel paramètre tout le monde parlait, le paramètre de méthode ou le troisième paramètre de l'objet options.

Pour être précis, c'est le troisième paramètre de la méthode getCurrentPosition , qui ressemble à quelque chose comme ça à la fin:

navigator.geolocation.getCurrentPosition(
    (position) => {
       ...
    },
    (error) => alert(error.message)
)

Enfin, je suis venu avec la solution suivante (la même idée que celle décrite ci-dessus):

export const detectCurrentLocation = (successCallback, errorCallback) => {
    let navigatorOptions = {}
    if (Platform.OS === 'android' && Platform.Version === 23) {
        navigatorOptions = {
            enableHighAccuracy: false,
            timeout: 10000,
            maximumAge: 0
        }
    }

    navigator.geolocation.getCurrentPosition(
        position => successCallback(detectedLocation),
        error => errorCallback(error),
        navigatorOptions
    )
}

Il fonctionne sur les appareils (testé sur Android 21, 22 et 23), mais pour Android 23, il est extrêmement lent: 5 à 10 secondes.

Quelqu'un a-t-il utilisé LocationServices.FusedLocationApi comme solution de contournement à cette fin en react-native (implémentation native, en code Java pour Android)?

enableHighAccuracy: true ne fonctionne pas du tout sur Android

J'utilise ce code pour vérifier l'autorisation de localisation sur Android 6

requestLocationPermission = async () => {
    try {
      const granted = await PermissionsAndroid.requestPermission(
        PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION,
        {
          'title': 'Enable location',
          'message': 'Location is good \o/',
        },
      );

      if (granted) {
        console.log('You can use the location');
        this.getLocation();
      } else {
        console.log('Location permission denied');
      }
    } catch (err) {
      console.warn(err);
    }
  };

@sibelius Cela évite Location request timed out erreur

utiliser mon extrait et celui-ci également https://github.com/facebook/react-native/issues/7495#issuecomment -259753488

N'y a-t-il toujours pas de solution à ce problème? J'ai absolument tout essayé sur ce fil et rien ne fonctionne pour moi, c'est toujours une erreur de temporisation, que ce soit instantanément ou après quelques secondes.

Même chose ici, le commentaire @sattaman l'a corrigé pour mon appareil (réglage du mode de localisation sur économie de batterie), mais comment dire aux utilisateurs de l'application de faire une telle chose!

Soit la désactivation de enableHighAccuracy soit la désactivation du 3ème paramètre fonctionne pour moi. L'emplacement semble toujours assez précis, cependant.
Aucun problème sur iOS. (RN 0,39)

RN 0.40 même problème. La suppression du 3ème paramètre le résout.
(Mais vous n'obtenez pas une grande précision)

même problème, la suppression du 3ème paramètre le résout.

Sur un émulateur, je dois définir enableHighAccuracy: true et m'assurer que le mode de localisation a été défini sur Haute précision. Sinon, il expire. Je ne peux pas faire fonctionner l'économie de batterie sur un émulateur en aucune circonstance.

Sur un appareil, je ne transmets aucune option. Si vous avez du mal avec cela comme moi, je suggère de l'essayer sur de vrais appareils. J'ai testé sur un Pixel C (Android 7.1) et Note 4 (Android 6.0.1)

Sur iOS, j'ai dû définir High Accuracy sur True. Vous pouvez imaginer ma fonction de localisation à ce stade ...

Je travaille sur RN 0.40 et j'utilise un appareil réel (Nexus 5) et j'ai toujours le problème.

J'ai essayé n'importe quoi de tous les commentaires de ce numéro.

Quelqu'un a-t-il résolu le problème d'une autre manière, non mentionnée ici?

// METTRE À JOUR:

Il semble que navigator.geolocation.watchPosition fonctionne. Donc, l'utiliser pourrait être la solution de contournement jusqu'à ce que navigator.geolocation.getCurrentPosition soit corrigé.

Pour l'instant, je vais écrire un module natif et parler directement aux API natives, car l'utilisation d'une haute précision est importante pour moi.
L'API de géolocalisation de RN semble instable pour l'instant.

Dans mon projet, je découvre quelques règles.

1. le paramètre de l'appareil Android - L'emplacement est uniquement l'appareil, vous ne devez PAS définir enableHighAccuracy: true pour getCurrentPosition
2. le réglage - L' emplacement est grande précision, vous devez définir enableHighAccuracy: true à getCurrentPosition

Conformément à ces deux règles, tout fonctionne bien dans mon projet

@kimochg quelle est votre configuration de test?

Lors de mes tests, définir le paramètre de l'appareil pour Emplacement sur Appareil uniquement entraînera un timeOut à chaque fois, quelle que soit la géolocalisation enableHighAccuracy .

Définir le paramètre de l'appareil sur Haute précision me donnera un emplacement valide quel que soit le paramètre enableHighAccuracy .

ÉDITER
Il semble que pour moi, la géolocalisation ne récupérera un nouvel emplacement que si je définis enableHighAccuracy: false et le paramètre de localisation de l'appareil sur Haute précision. Avec enableHighAccuracy: true il récupérera un emplacement mis en cache mais une nouvelle récupération expirera.

Ceci est sur React Native 0.40, test sur Nexus 5X exécutant Android 7.1.1

@kulmajaba some as you React Native 0.40, test sur Nexus 5X sous Android 7.1.1
mais l'émulateur Android ici, pas un vrai appareil Android

si vous utilisez un émulateur,
cliquez-vous sur le bouton «Contrôles étendus» sur la barre droite de l'émulateur et envoyez-vous des données GPS?
(le bouton)

@kimochg Ok. J'utilise un vrai appareil pour tester, je devrai comparer le comportement de l'émulateur à celui-ci la prochaine fois que je travaillerai sur le projet.

@Ascendance @ Daniel-ltw J'ai suivi toutes les solutions de ce fil et je n'ai pas pu ébranler les redoutables problèmes de navigator.geolocation non définis. Puis j'ai connecté navigator .

Voici ce que j'ai récupéré:

ProxyComponent
_attachGesture
_cleanScenesPastIndex
_clearTransformations
_completeTransition
_deltaForGestureAction
_detachGesture
_disableScene
_disableTVEventHandler
_doesGestureOverswipe
_eligibleGestures
...

Puis j'ai réalisé que cela provenait du composant Navigator. Il utilise (route, navigator) lors du rendu des routes. Effectivement, la suppression de la variable du navigateur et la consignation à nouveau ont donné:

WorkerNavigator
appCodeName
appName
appVersion
geolocation (...)
get geolocation
getValue()
set geolocation
setValue(newValue)
hardwareConcurrency

J'espère que cela aide quelqu'un d'autre - cela m'a pris un temps triste pour comprendre quel était le problème. : /

@kulmajaba le maximumAge corrigé tous les problèmes de mise en cache pour moi. Le mettre à 0 le forcera à toujours obtenir une nouvelle position.

Pour toute autre personne aux prises avec le problème du délai d'expiration, j'ai lu que parfois les appels GPS de haute précision peuvent prendre un certain temps (plus d'une minute), en particulier à l'intérieur - comme @RoBYCoNTe l'a souligné ci-dessus.

S'appuyer sur un appel de haute précision dès le départ n'est peut-être pas la meilleure solution, peut-être obtenir d'abord un appel de faible précision et lancer un appel de haute précision en arrière-plan serait une meilleure approche. Cela dépend bien sûr de vos besoins, attendre une minute + pour un appel n'est pas pour tout le monde :)

Étant donné que RN étend également les spécifications Web pour la géolocalisation, vous pouvez trouver des réponses y relatives sur le Web, comme le bien nommé http://stackoverflow.com/questions/3752383/geolocation-is-so-slow-what-im- faire mal

Quelqu'un at-il une solution solide? Certains utilisateurs ne peuvent même pas s'inscrire à mon application en raison d'une partie de l'inscription les obligeant à définir leur géolocalisation. Le problème ne se produit que sur certains appareils Android et je n'utilise pas le 3ème paramètre. Me rend fou. Les gens donnent automatiquement des avis 1 étoile à mon application parce qu'ils ne peuvent pas définir leur géolocalisation, hahaha. >.>

@booboothefool essayez d'utiliser le paramètre options et passez highAccuracy comme
faux. Les résultats sont beaucoup plus rapides de cette façon.

Le lun 20 février 2017 09:50 booboothefool [email protected]
a écrit:

Quelqu'un at-il une solution solide? Certains utilisateurs ne peuvent même pas s'inscrire à mon
application en raison d'une partie de l'inscription les obligeant à définir leur géolocalisation.
Le problème ne se produit que sur certains appareils Android, et je n'ai pas
en utilisant le 3ème paramètre. Me rend fou.

-
Vous recevez ceci parce que vous avez commenté.
Répondez directement à cet e-mail, affichez-le sur GitHub
https://github.com/facebook/react-native/issues/7495#issuecomment-281142941 ,
ou couper le fil
https://github.com/notifications/unsubscribe-auth/ADJE_BC-osVA45bcpejEI_paDEBykBs1ks5redJtgaJpZM4Ibete
.

@greyvugrin D'accord, je vais

Également basé sur ceci: https://developer.mozilla.org/en-US/docs/Web/API/PositionOptions

Il semble que ce soient les options par défaut. enableHighAccuracy: false avec timeout: Infinity , alors ne devrait-il pas déjà le faire si je ne fournis pas le 3ème paramètre?

@booboothefool vous avez raison, ce fil est déroutant. D'après ce que je peux dire, les personnes qui omettent le paramètre d'options ont peut-être résolu leur problème parce que quelque chose d'autre dans les paramètres affectait les choses.

définir enableHighAccuracy sur true ou false ne fonctionne pas pour moi.
omettre le 3ème argument pour getCurrentPosition pour utiliser les valeurs par défaut du module natif fonctionne pour moi.

Donc, le problème était peut-être avec timeout . Il y a beaucoup de facteurs qui entrent en jeu dans la géolocalisation, obtenir autant d'informations que possible des personnes qui plantent aidera.

Si vous avez déjà supprimé les options et que RN utilise par défaut les mêmes paramètres que Web, les choses devraient bien fonctionner. Si vous rencontrez toujours des problèmes, voyez peut-être si les utilisateurs ont des autorisations activées pour l'emplacement (et vous le vérifiez dans votre application).

Salut @greyvugrin ,

Merci pour le gros conseil sur les autorisations. Je pense que c'est ce qui me manquait. Après avoir implémenté https://github.com/lucasferreira/react-native-android-permissions (je préfère cette API à https://facebook.github.io/react-native/docs/permissionsandroid.html), en spécifiant enableHighAccuracy: false , et en définissant un timeout , cela semble fonctionner pour tout le monde maintenant.

Mon application est passée de 1 étoile sur le Google Play Store, tout le monde la détruisant pour les problèmes de géolocalisation à 3,6 étoiles, hahaha! 👍

@booboothefool c'est une si bonne nouvelle, content de l'entendre !!!

J'ai essayé toutes les approches suggérées ici. Impossible d'obtenir quoi que ce soit de getCurrentPosition mais des délais d'expiration sur le simulateur ou l'appareil sur Android. watchPosition fonctionne mais n'offre pas vraiment le meilleur UX pour l'utilisateur, je n'ai besoin de l'emplacement des utilisateurs qu'une seule fois, je n'ai pas besoin de garder le GPS pour gaspiller leur batterie.

J'ai essayé:

• enableHighAccuracy: faux
• suppression de l'argument d'options
• vérifier et demander la permission android> = 23
• Les deux FINE & COARSE en manifeste.

Aucun ne modifie les délais pour getCurrentPosition

C'est juste quelque chose que les développeurs d'Android Studio Emulator devront corriger / implémenter à l'avenir lorsqu'ils en auront l'occasion.

Cependant, en attendant ... Vous pouvez importer un gros fichier de trace GPX et le laisser jouer à une vitesse "1x". J'ai attrapé un GPX d'ici ... ExpertGPS.com -> ca-trails.gpx
... ce fichier a duré environ 8 minutes à une vitesse "5x", donc à une vitesse "1x", il DEVRAIT durer environ 40 minutes.

Chargez-le (ou un autre fichier GPX éventuellement plus gros) dans [...] Options étendues-> Emplacement (bouton Charger GPS / KML en bas à droite), appuyez sur le bouton de lecture, puis fermez la fenêtre ... il continuera à jouer jusqu'à ce qu'il touche la fin. Dommage qu'il n'y ait pas de répétition automatique - une autre demande de fonctionnalité pour les programmeurs Android Studio. :-)

Ce n'est pas vrai. J'obtiens les mêmes délais d'expiration sur de vrais appareils.
getCurrentPosition expire toujours. La montre fonctionne bien. Test du Z5, du Nexus 5X
& Pixel, tout le délai d'expiration lors de l'appel initial à getCurrentPosition.

Le samedi 4 mars 2017, 19:49 Deen Foxx, [email protected] a écrit:

C'est juste quelque chose que les développeurs d'Android Studio Emulator vont faire
doivent réparer / mettre en œuvre à l'avenir quand ils en auront l'occasion.

Cependant, en attendant ... vous pouvez importer un gros fichier de trace GPX et laisser
il est lu à une vitesse "1x". J'ai attrapé un GPX d'ici ... ExpertGPS.com ->
ca-trails.gpx
https://www.expertgps.com/data/downloading.asp?file=ca/ca-trails.gpx
... ce fichier a duré environ 8 minutes à une vitesse "5x", donc à une vitesse "1x"
DEVRAIT durer environ 40 minutes.

Chargez-le (ou un autre fichier GPX éventuellement plus volumineux) dans [...] Extended
Options-> Localisation (bouton Charger GPS / KML en bas à droite), appuyez sur la lecture
bouton, puis fermez la fenêtre ... il continuera à jouer jusqu'à ce qu'il touche le
fin. Dommage qu'il n'y ait pas de répétition automatique - une autre demande de fonctionnalité pour Android
Programmeurs de studio. :-)

-
Vous recevez ceci parce que vous avez commenté.
Répondez directement à cet e-mail, affichez-le sur GitHub
https://github.com/facebook/react-native/issues/7495#issuecomment-284172310 ,
ou couper le fil
https://github.com/notifications/unsubscribe-auth/AACQ6AoZYXJ02DCmevcLmmF3tuOdg_SEks5ribJHgaJpZM4Ibete
.

La suppression du troisième paramètre de getCurrentLocation a fonctionné pour moi sur l'émulateur.

{
   timeout: 20000,
    maximumAge: 1000
}

Je viens de coder une possibilité à trois passes. Peut-être un peu exagéré, mais bon. Voici l'extrait de code (avec des commentaires) ...

class FindNearMe extends Component {

  constructor(props) {
    super(props);

    this.state = {
      prevLatitude: 0.0,
      prevLongitude: 0.0,
      gotLocation: false,
      locating: false,
      loading: false
    };
  }

  handleGeolocationSuccess = (position) => {

    // Get a response, say we are done locating, even if it is still looking for a fine result.
    this.setState({ locating: false });

    // If we previously failed, we can clear the error if it just happens to still be visible.
    if (!this.state.gotLocation) {
      this.props.navigator.hideLocalAlert();  // Hide possibly open alert.
      this.setState({ gotLocation: true });  // Remove the previous failure state.
    }

    // Only proceed if there is an actual change in location.
    if (this.state.prevLatitude != position.coords.latitude ||
        this.state.prevLongitude != position.coords.longitude) {

      // Overwrite the old location with the new location.
      this.setState({
        prevLatitude: position.coords.latitude,
        prevLongitude: position.coords.longitude,
        loading: true // Only needed if you plan to get content from server.
      });

      // ... DO SOMETHING WITH THE UPDATED LOCATION ...
      // If you used a callback function (success or failure) be sure to include this...
      this.setState({ loading: false });
 };

  // This first, RoughError, means the "enableHighAccuracy: false" time-out occurred.
  handleGeolocationRoughError = (error) => {
    this.props.navigator.showLocalAlert('Attempting to pinpoint your location...', config.errorStyles);
    // Invalidate our current location
    this.setState({ gotLocation: false });
  };

  // This second, FineError, means the "enableHighAccuracy: true" time-out occurred.
  handleGeolocationFineError = (error) => {
    // If we got Rough location, I'm ignoring this. But, if neither rough nor fine succeeded...
    if (!this.state.gotLocation) {
      // ...try once more without the options.
      navigator.geolocation.getCurrentPosition(
        this.handleGeolocationSuccess,
        this.handleGeolocationFinalError
      );
    }
  };

  // This last, FinalError, means nothing worked and we're giving up.
  handleGeolocationFinalError = (error) => {
    if (!this.state.gotLocation) {
      this.props.navigator.showLocalAlert('Could not determine your location, sorry!', config.errorStyles);

      // Let our app know that we are not trying anymore.
      this.setState({ locating: false });
    }
  };

  goToNearMe = () => {
      // Track when we are attempting to get a location update.
      this.setState({ locating: true });

      // Try to get the rough location quickly.
      navigator.geolocation.getCurrentPosition(
        this.handleGeolocationSuccess,
        this.handleGeolocationRoughError,
        {
          enableHighAccuracy: false,
          timeout: 500,  // I have this set for half-second before popping up the alert.
          maximumAge: 0
        }
      );

      // But, also, simultaneously try to get the fine location.
      navigator.geolocation.getCurrentPosition(
        this.handleGeolocationSuccess,
        this.handleGeolocationFineError,
        {
          enableHighAccuracy: true,
          timeout: 7500,  // I have this set for 7.5 seconds, about the length of the first alert's visibility.
          maximumAge: 0
        }
      );
  };

  render() {
    return (
        <Container>
          <LocateMeButton
              onPress={this.goToNearMe}
              loading={this.state.loading || this.state.locating}
          />
          <Header>
            Use Current Location
          </Header>
        </Container>
    );
  }
}

export default FindNearMe;

Je n'ai testé cela que sur des émulateurs de développement locaux, pas en production. Faites-moi savoir si cela vous a été utile.

Je pensais juste ... cela fonctionnerait probablement parfaitement en deux passes si votre appel roughError utilise simplement la version sans option ...

  goToNearMe = () => {
      // Track when we are attempting to get a location update.
      this.setState({ locating: true });

      // Try to get the rough location quickly.
      navigator.geolocation.getCurrentPosition(
        this.handleGeolocationSuccess,
        this.handleGeolocationRoughError,
// Just leave this off entirely (but default timeout is Infinity, so you'd never get the first alert!)...
//        {
//          enableHighAccuracy: false,
//          timeout: 500,  // I have this set for half-second before popping up the alert.
//          maximumAge: 0
//        }
// ...or try ujwal-setlur's method of leaving off the enableHighAccuracy portion...
        {
          timeout: 500,
          maximumAge: 0
        }
// NOTE: ujwal-setlur's method did NOT work for my Android emulator.
//             I had to comment out the options object completely for it to not time-out.
      );

      // But, also, simultaneously try to get the fine location.
      navigator.geolocation.getCurrentPosition(
        this.handleGeolocationSuccess,
//        this.handleGeolocationFineError,  // Wouldn't need this, make it your FinalError instead.
        this.handleGeolocationFinalError,
        {
          enableHighAccuracy: true,
          timeout: 7500,  // I have this set for 7.5 seconds, about the length of the first alert's visibility.
          maximumAge: 0
        }
      );
  };

Cela ferait en sorte que les téléphones Android avec des problèmes n'aient plus de retard, tout en essayant toujours la haute précision. Vous n'auriez alors plus besoin du tout de FineError, ce code peut être supprimé.

• Oui, je sais qu'il y a une légère possibilité que la tentative "enableHighAccuracy: true" revienne avant les autres résultats asynchrones "bruts" (surtout si timeout est Infinity) et se perd / soit ainsi écrasée ... mais j'en doute. Si vous voulez vraiment être aussi prudent, vous pouvez modifier le code pour tester ce cas particulier.

Des progrès à ce sujet?

Alex, il y a quelques solutions sur ce fil. Qu'avez-vous essayé? Il
peut également valoir la peine de créer un nouveau ticket une fois que vous aurez plus de détails depuis
ce fil est si long, si aucune des solutions ci-dessus ne fonctionne.

Le ven 17 mars 2017, 10:29 Alex Sinelnikov [email protected]
a écrit:

Des progrès à ce sujet?

-
Vous recevez cela parce que vous avez été mentionné.
Répondez directement à cet e-mail, affichez-le sur GitHub
https://github.com/facebook/react-native/issues/7495#issuecomment-287419487 ,
ou couper le fil
https://github.com/notifications/unsubscribe-auth/ADJE_HLDGQEplAduqm3Zx5L74dv99mnhks5rmsLjgaJpZM4Ibete
.

Comme toi. Aucune des suggestions ci-dessus ne fonctionne. La seule solution pour moi de
obtenir un emplacement sur Android était d'utiliser une montre et de mettre à jour l'interface utilisateur pour informer
l'utilisateur que se passe-t-il si les fonctions de vos applications répondent sur place. Ne pas
déranger avec getCurrentPosition cela ne fonctionne sur aucun des 10 vrais tests
appareils que nous avons exécutant différentes versions d'Android 4+

Le vendredi 17 mars 2017, 17:48 Gray Vugrin, [email protected] a écrit:

Alex, il y a quelques solutions sur ce fil. Qu'avez-vous essayé? Il
peut également valoir la peine de créer un nouveau ticket une fois que vous aurez plus de détails depuis
ce fil est si long, si aucune des solutions ci-dessus ne fonctionne.

Le ven 17 mars 2017, 10:29 Alex Sinelnikov [email protected]
a écrit:

Des progrès à ce sujet?

-
Vous recevez cela parce que vous avez été mentionné.
Répondez directement à cet e-mail, affichez-le sur GitHub
<
https://github.com/facebook/react-native/issues/7495#issuecomment -287419487
,
ou couper le fil
<
https://github.com/notifications/unsubscribe-auth/ADJE_HLDGQEplAduqm3Zx5L74dv99mnhks5rmsLjgaJpZM4Ibete

.

-
Vous recevez ceci parce que vous avez commenté.
Répondez directement à cet e-mail, affichez-le sur GitHub
https://github.com/facebook/react-native/issues/7495#issuecomment-287424598 ,
ou couper le fil
https://github.com/notifications/unsubscribe-auth/AACQ6DgWuUzw4hj7rmr8LDzcRHjEheIcks5rmsdSgaJpZM4Ibete
.

Parfois ça marche, d'autres pas. J'ai essayé TOUTES les solutions ci-dessus et aucune solution fiable jusqu'à présent. Cela me rend vraiment fou :(

Existe-t-il un module natif qui réplique une fonction comme getCurrentPosition? Je cherche un autre dépôt car je ne peux pas écrire de code java.

watchPosition a un problème lorsque la localisation n'est pas activée. Il ne jette jamais de timeout bien que j'aie défini timeout = 1000

Sur «getCurrentPosition», il lancera un délai d'attente, donc je peux déclencher la boîte de dialogue de localisation pour activer le GPS. Mais maintenant je passe de 'getCurrentPosition'

ÉDITER:
J'ai essayé toutes les variantes et maintenant je sais où est le problème. Je peux le faire fonctionner en supprimant les troisièmes paramètres ET en définissant le mode de localisation sur Haute précision ou sur Économie de batterie. Sinon, ça ne marche pas. Je ne sais pas comment dire à l'utilisateur de choisir Haute précision ou Économie de batterie au lieu de Périphérique uniquement, car il a une manière différente d'accéder à ce menu pour chaque fournisseur.

Il y a un commentaire ci-dessus pour ajouter enableHighAccuracy: false dans les troisièmes paramètres, mais cela ne fonctionnait pas pour les options Haute précision, Économie de batterie ou Appareil uniquement. Je pense que les troisièmes paramètres de géolocalisation sont inutiles pour un appareil réel.

Dans mon cas, supprimer maximumAge a résolu le problème.

La suppression de maximumAge fonctionne, mais il s'agit d'une solution temporaire. A bien fonctionné dans la plupart des cas, mais a rencontré des problèmes de production où sur une carte, l'emplacement actuel de l'utilisateur serait complètement désactivé en raison de l'utilisation de coordonnées obsolètes. Passé à une implémentation native à la place.

@nigelnindo que voulez-vous dire Implémentation native? au sein de RN ou le faire directement dans Android?

@ L3V147H4N directement dans Android. Il existe quelques bibliothèques que vous pouvez utiliser pour cela, mais j'ai vu que la plupart ne sont pas compatibles avec les dernières versions de RN. S'il y a suffisamment d'intérêt pour cela, cela ne me dérange pas de passer du temps à créer un module simple pour aider à résoudre les problèmes de géolocalisation sur Android décrits dans ce fil.

Peut-être que vous pouvez vérifier https://github.com/mauron85/react-native-background-geolocation#getlocationssuccess -fail

C'est une implémentation native et ça marche bien pour moi.

Je pense que presque tout le monde sur ce fil serait très reconnaissant @nigelnindo
https://github.com/nigelnindo

Le lundi 3 avril 2017 à 17:34 Nigel Nindo [email protected] a écrit:

@ L3V147H4N https://github.com/L3V147H4N directement dans Android. Il y a
quelques bibliothèques que vous pouvez utiliser pour cela, mais j'ai vu que la plupart
ne sont pas compatibles avec les dernières versions de RN. S'il y en a assez
intérêt pour cela, cela ne me dérange pas de passer du temps à créer un module simple
pour aider à résoudre les problèmes de géolocalisation sur Android décrits sur ce fil.

-
Vous recevez ceci parce que vous avez commenté.
Répondez directement à cet e-mail, affichez-le sur GitHub
https://github.com/facebook/react-native/issues/7495#issuecomment-291198134 ,
ou couper le fil
https://github.com/notifications/unsubscribe-auth/AACQ6BwArzmfCk3TXfiRMp7kpdwMLM81ks5rsR-hgaJpZM4Ibete
.

La frustration ... J'essaye d'utiliser navigator.geolocation.getCurrentPosition mais j'obtiens toujours l'erreur:
La demande de localisation a expiré. Pour Android, iOS fonctionne bien.
J'ai essayé de définir enableHighAccuracy sur True / False, en supprimant le 3ème argument, j'ai ajouté les autorisations de localisation COURSE et FINE dans AndroidManifest.

SDK Android 23, outils de création 25.0.0
Réagir 16.0.0-alpha.6
RN 0,43,3

Merci de votre aide!

Bienvenue sur le fil Douglas, malheureusement getCurrentPosition n'est pas
fiable sur Android comme vous l'avez découvert.
Jetez un œil à certaines des solutions plus tôt dans le fil en utilisant
watchPosition place

Merci @raldred.
watchPosition semble fonctionner, appréciez l'aide!

@douglaswissett vous êtes les bienvenus. Espérons qu'il y aura bientôt une solution robuste pour getCurrentPosition .

Puis-je utiliser watchPosition puis clearWatch immédiatement après avoir obtenu la position géographique? J'ai du mal à faire cela, car clearWatch ne peut être appelé que sur componentDidMount

@pewh oui. C'est ce que je fais.
De plus, navigator.geolocation.clearWatch peut être appelé à tout moment.
Gardez simplement une référence au watchID sur votre composant qui est retourné par l'appelé à watchPosition

D'après les documents que j'ai lus sur https://facebook.github.io/react-native/docs/geolocation.html , je n'ai aucune idée de comment obtenir this.watchID intérieur de watchPosition callback. Mon cas d'utilisation est de déclencher clearWatch immédiatement après avoir reçu une nouvelle valeur.

@pewh voici ma mise en œuvre. Ce n'est pas parfait mais ça marche.
https://gist.github.com/raldred/b08cf60712eb87d81f05437444dff4ae

@raldred a essayé votre solution et celle de tous les autres, rien ne fonctionne

Des solutions à ce sujet? essayez tout ici et rien ne semble fonctionner, aidez s'il vous plaît! si vous pouvez partager des extraits ou quelque chose

@ gerard0315 vous réussissez à résoudre ce problème?

Cela semble fonctionner sur un vrai téléphone Android pour moi

Obtenez Outlook pour iOS https://aka.ms/o0ukef

De: Jorge Almonacid [email protected]
Envoyé: mardi 9 mai 2017 14:29:56
À: facebook / react-native
Cc: Ujwal Setlur; Commentaire
Objet: Re: [facebook / react-native] La géolocalisation «enableHighAccuracy» sur Android expire toujours (# 7495)

Des solutions à ce sujet? essayez tout ici et rien ne semble fonctionner, aidez s'il vous plaît! si vous pouvez partager des extraits ou quelque chose

-
Vous recevez ceci parce que vous avez commenté.
Répondez directement à cet e-mail, affichez-le sur GitHub https://github.com/facebook/react-native/issues/7495#issuecomment-300307037 , ou désactivez le fil https://github.com/notifications/unsubscribe-auth/ AFkMXWcokXoYDpsw28UaiUSDtCvRpE3Rks5r4NrUgaJpZM4Ibete .

J'ai déjà partagé mes extraits qui fonctionnent sur de vrais appareils fonctionnant
Android 4-7.

Le mar 9 mai 2017, 22:29 Jorge Almonacid, [email protected] a écrit:

Des solutions à ce sujet? essayez tout ici et rien ne semble fonctionner,
s'il vous plaît aidez! si vous pouvez partager des extraits ou quelque chose

-
Vous recevez cela parce que vous avez été mentionné.
Répondez directement à cet e-mail, affichez-le sur GitHub
https://github.com/facebook/react-native/issues/7495#issuecomment-300307037 ,
ou couper le fil
https://github.com/notifications/unsubscribe-auth/AACQ6HSlN8YS_jE6NY9w2vuk7Hv4Wjwfks5r4NrSgaJpZM4Ibete
.

Actuellement, il est possible d'obtenir une mise à jour (dans l'émulateur Android) uniquement si vous modifiez tous les paramètres (Longitude, Latitude, Altitude) en même temps. Si vous n'en modifiez qu'un ou deux - nothing works .

Il y a un défaut inné dans la façon dont React-Native gère l'emplacement sur Android. (iOS semble manquer de ce problème, iirc)

String provider = highAccuracy ? LocationManager.GPS_PROVIDER : LocationManager.NETWORK_PROVIDER;

LocationManager.GPS_PROVIDER is best for outdoors when you have a clear view of the sky

tandis que

LocationManager.NETWORK_PROVIDER is best for indoors, since it uses networks (and cell towers?)

En réalité, vous avez besoin des deux / de tous les fournisseurs si vous voulez une localisation ultra précise. Ensuite, vous souhaitez comparer la précision, l'horodatage et accepter l'emplacement le plus précis et le plus récent.

Il y a deux façons de procéder:

En réaction:

Configurez deux variables watchID -> watchIDGPS et watchIDNetwork . Ensuite, configurez deux observateurs, l'un avec enableHighAccuracy=true et enableHighAccuracy=false cela renverra à la fois le fournisseur de GPS et le fournisseur de réseau (le réseau sera plus précis à l'intérieur)

Le problème avec la méthode React est qu'elle fait cela sur le thread JS; Cela pourrait geler votre application sur des appareils dépourvus de ressources. Néanmoins, cela fonctionne.

En natif:

Vous voudrez réécrire le LocationModule.java tant que module personnalisé pour gérer les fournisseurs de votre choix et signaler l'emplacement au mLocationListener quel que soit le fournisseur. Jusqu'à ce que React-Native corrige ce "problème".

@ralred , Merci pour l'extrait mais quel est l'objet AndroidPermissions ?

J'ai essayé toutes les solutions, toutes ont échoué ...
Je me suis soudainement souvenu que mon application avait un module de carte, la carte de baidu, une carte chinoise (map.baidu.com) comme google map, elle peut obtenir des marqueurs et l'emplacement actuel !!! Enfin je l'ai fait ~

vous pouvez le rechercher par github, react-native-baidu-map

importer {
MapView, // la vue de la carte (je n'en ai pas besoin)
MapTypes, // tapez en 2D ou 3D (je n'ai pas besoin)
Géolocalisation // api à propos de l'emplacement (j'ai besoin)
} de 'react-native-baidu-map';

componentDidMount () {
Geolocation.getCurrentPosition ()
.then (données => {
Alert.alert (JSON.stringify (data.latitude), JSON.stringify (data.longitude))
})
}

Je ne sais pas si cela peut fonctionner dans un autre pays, juste une réflexion en utilisant certaines applications de carte, vous pouvez essayer des cartes react-native-maps ou d'autres cartes ...

Rien ne fonctionne, watchPosition ne sera même pas appelé sur Android, iOS fonctionne parfaitement. C'est déjà RN v0.45.0 (je suis actuellement sur 0.44.0) et ce n'est toujours pas résolu? Allons!

@rexlow
Rien ne fonctionne aussi bien, j'utilise la version 0.44. avez-vous essayé de mettre à jour vers la v0.45?

@VietDucPhan Cela a juste fonctionné maintenant, totalement aléatoire 😓. Toujours à 0.44.0

@rexlow Oh tant mieux pour vous. Maintenant, je n'ai besoin que de ma chance pour me frapper.

Avez-vous simplement essayé de supprimer la structure des options? C'est la seule chose qui a fonctionné pour moi.

Obtenez Outlook pour iOS https://aka.ms/o0ukef

De: viet_duc_phan [email protected]
Envoyé: dimanche 18 juin 2017 23:26:15
À: facebook / react-native
Cc: Ujwal Setlur; Commentaire
Objet: Re: [facebook / react-native] La géolocalisation «enableHighAccuracy» sur Android expire toujours (# 7495)

@rexlow https://github.com/rexlow Oh tant mieux pour vous. Maintenant, je n'ai besoin que de ma chance pour me frapper.

-
Vous recevez ceci parce que vous avez commenté.
Répondez directement à cet e-mail, affichez-le sur GitHub https://github.com/facebook/react-native/issues/7495#issuecomment-309349488 , ou désactivez le fil https://github.com/notifications/unsubscribe-auth/ AFkMXYI2vukJgcTLkBeNdXdclgFbgo1sks5sFhSHgaJpZM4Ibete .

@rexlow @ ujwal-setlur Je veux juste vous faire savoir que la chance me frappe. cela fonctionne et totalement aléatoire. Je n'ai rien changé.

Avez-vous essayé un vrai appareil?

Le mar 20 juin 2017, 19:18 viet_duc_phan, [email protected] a écrit:

@rexlow https://github.com/rexlow @ ujwal-setlur
https://github.com/ujwal-setlur Je veux juste vous faire savoir que
la chance me frappe. cela fonctionne et totalement aléatoire. Je n'ai pas changé
n'importe quoi.

-
Vous recevez cela parce que vous avez été mentionné.
Répondez directement à cet e-mail, affichez-le sur GitHub
https://github.com/facebook/react-native/issues/7495#issuecomment-309843462 ,
ou couper le fil
https://github.com/notifications/unsubscribe-auth/AACQ6OVyeCsOgd-qevP9CrP9XJMhwaxsks5sGAz3gaJpZM4Ibete
.

@raldred Toujours testé sur de vrais appareils.

@VietDucPhan pouvez-vous configurer un exemple qui reproduit le problème?

Le mar 20 juin 2017, 20:52 viet_duc_phan, [email protected] a écrit:

@raldred https://github.com/raldred Toujours testé sur de vrais appareils.

-
Vous recevez cela parce que vous avez été mentionné.
Répondez directement à cet e-mail, affichez-le sur GitHub
https://github.com/facebook/react-native/issues/7495#issuecomment-309870269 ,
ou couper le fil
https://github.com/notifications/unsubscribe-auth/AACQ6N5SVbYeDEeY9FRnTQSrvpLwKL5aks5sGCLmgaJpZM4Ibete
.

@raldred le rapport d'origine de cette chaîne contient un extrait de code:

navigator.geolocation.getCurrentPosition(
      (position) => {
        console.log(position);
       },
       (error) => {
        console.log(error)
      },
      {enableHighAccuracy: true, timeout: 20000, maximumAge: 10000}
);

Cela échoue aussi pour moi. Le seul moyen de le résoudre semble ne pas inclure l'argument options:

navigator.geolocation.getCurrentPosition(
      (position) => {
        console.log(position);
       },
       (error) => {
        console.log(error)
      }
);

@dreallday a raison, réagit mal la localisation Android. Cependant, plutôt que de gérer manuellement les deux fournisseurs, il serait préférable d'utiliser l' API Fused qui combine les informations des fournisseurs avec la magie.

J'ai trouvé que React-Native-Fused-Location était vraiment utile pour faire des demandes de localisation sur Android.

@raldred Salut désolé, Je n'ai pas vérifié

@ derman232 Est-ce que

@rexlow désolé je ne connais pas la réponse à cela, pas une fonctionnalité dont j'ai besoin pour mon application.

Juste en donnant mon avis sur la façon dont j'ai résolu ce problème:

• Le problème est qu'android> = 6.0 nécessite que des autorisations soient accordées pendant l'exécution
• Cette question stackoverflow a plus de détails: question
• J'ai utilisé le module PermissionsAndroid de React Native pour obtenir les autorisations

Maintenant, tout fonctionne.

Salut,
Rien ne fonctionne. J'ai tout essayé.
S'il vous plaît donnez votre avis.
THX

Je voudrais vraiment aider à résoudre ce problème pour les gens.
Nous avons 3 applications natives de réaction qui utilisent la localisation en direct. Contrôle qualité sur plus de 30 appareils Android réels exécutant Gingerbread jusqu'à Nougat.
Tout fonctionne bien tout au long des tests utilisateur, nous n'avons depuis eu aucun rapport de problèmes d'utilisateurs en direct.

@adriancuco pourriez-vous partager votre implémentation et votre manifeste afin que nous puissions essayer de vous aider davantage.

• Version de RN?
• Avec quelles versions d'Android rencontrez-vous des problèmes?
• Avec quels appareils rencontrez-vous des problèmes?

Il y aura une complexité avec votre implémentation ou la configuration de votre appareil, il s'agit de savoir ce que c'est.

raldred,

Désolé. Ma faute!
Avant de me tuer, j'ai décidé de vérifier les paramètres de localisation sur mon téléphone, comme je l'ai lu il y a quelques jours, et le GPS était juste activé. ; (
J'ai donc activé le GPS, le Wifi, etc. et tout et maintenant cela fonctionne bien.
J'apprécie beaucoup.
Merci beaucoup

Une mise à jour concernant ce problème?

Toujours pas de solution.

De: adriancuco [email protected]
Envoyé: mardi 4 juillet 2017 14:44:28
À: facebook / react-native
Cc: Marouen SAYARI; Commentaire
Objet: Re: [facebook / react-native] La géolocalisation «enableHighAccuracy» sur Android expire toujours (# 7495)

raldred,

Désolé. Ma faute!
Avant de me tuer, j'ai décidé de vérifier les paramètres de localisation sur mon téléphone, comme je l'ai lu il y a quelques jours, et le GPS était juste activé. ; (
J'ai donc activé le GPS, le Wifi, etc. et tout et maintenant cela fonctionne bien.
J'apprécie beaucoup.
Merci beaucoup

-
Vous recevez ceci parce que vous avez commenté.
Répondez directement à cet e-mail, visualisez-le sur GitHub https://github.com/facebook/react-native/issues/7495#issuecomment-312881724 , ou désactivez le fil https://github.com/notifications/unsubscribe-auth/ AD79YGcm507EtBxrFHHJkEc-OBvRsjKmks5sKkG7gaJpZM4Ibete .

@ m-sayari vous allez nous donner un peu plus d'informations pour nous aider.

• Version RN
• Version cible Android Build
• Version de l'appareil Android
• Appareils sur lesquels vous rencontrez ce problème.

Ce sera quelque chose de spécifique à votre implémentation / configuration à l'origine du problème. Comme indiqué précédemment, nous l'avons fait fonctionner sans problème sur plusieurs applications en direct.

Résolu ici! RN 0.45.1 utilisant un Redmi 4A avec Android 6.

J'ai eu ce problème en appelant navigator.geolocation.getCurrentPosition () à l'intérieur de componentDidMount ()
Au lieu de getCurrentPosition, appelez simplement watchPosition () avec les mêmes paramètres.

@raldred
Version RN
0,46
Version cible Android Build
api 22
Version de l'appareil Android
6.0.1
Appareils sur lesquels vous rencontrez ce problème.
lien 5

L'appel de getCurrentLocation sans le troisième paramètre «options» résout mon problème. Cela ne fonctionne pas pour moi si le paramètre "enableHighAccuracy" est défini sur false

Bonjour @raldred , même problème que d'autres ont signalé sur RN 0.47.

• Version RN: 0.47
• Version cible Android Build laissée sur les valeurs par défaut RN:

    compileSdkVersion 23
    buildToolsVersion "23.0.1"

    defaultConfig {
        minSdkVersion 16
        targetSdkVersion 22

• Version de l'appareil Android: 6.0.1, 7.0
• Appareils sur lesquels vous rencontrez ce problème:
  
  
  
  • Nexus 5 avec Android 6.0.1
  
  
  • Xiaomi Redmi 3S avec Android 6.0.1
  
  
  • Émulateur Android avec Android 7.0
  
  

getCurrentPosition fonctionne très bien lorsque je règle le mode de localisation "Appareil uniquement" dans les paramètres de l'appareil, mais cesse de fonctionner ( Location request timed out ) lorsque le mode est réglé sur "Haute précision".

Je dois omettre le troisième paramètre pour que getCurrentPosition fonctionne au moins en mode Appareil uniquement:

    navigator.geolocation.getCurrentPosition(setLocation);

J'ai supposé cela et cela a fonctionné pour moi, je n'ai pas testé avec un cas différent.
Donc, en regardant mes options, j'ai compris qu'il y avait deux éléments qui se contredisaient maximumAge et enableHighAccuracy , je pense que ces deux options sont les mêmes d'une manière légèrement différente, tandis que l'âge maximum vous garantit obtenir la dernière géolocalisation en fonction de vos paramètres même si la précision est faible, enableHighAccuracy s'assure que vous obtenez l'emplacement le plus actuel et le plus précis, j'avais le même problème avec les options suivantes.
{enableHighAccuracy: true, timeout: 20000, maximumAge: 60000} jusqu'à ce que je supprime l'âge maximum et que je laisse enableHighAccuracy j'espère que cela aidera quelqu'un.

Je viens de créer react-native à partir de master pour essayer de savoir si commit 7e11bad86fd21ce1a8408218e66ce85993d9db69 résout ce problème. Malheureusement, j'obtiens toujours la même erreur qu'avant.

@olieidel Watch position fonctionne réellement, assurez-vous également que votre appareil a accordé l'accès de localisation à l'application et que votre service de localisation est activé.

@olieidel Vous pouvez vérifier si votre application a accès aux autorisations de localisation avec l'API suivante, PermissionsAndroid , vous devez d'abord vérifier puis demander si elle n'est pas accordée.

@mrbarde merci pour la réponse rapide!

Ah, après une journée entière de débogage, voici mes conclusions et une solution de contournement pertinente:
RN 0.46.4, appareil: Nexus 5X, API 25

Mode de localisation: appareil uniquement

• getCurrentPosition , enableHighAccuracy: true : fonctionne lorsque le signal GPS est disponible, sinon timeout
• getCurrentPosition , enableHighAccuracy: false : ne fonctionne pas (timeout). a probablement besoin de services de localisation (mode de localisation! = appareil uniquement).
• watchPosition , enableHighAccuracy: true : fonctionne lorsque le signal GPS est disponible, sinon timeout
• watchPosition , enableHighAccuracy: false : ne fonctionne pas

Mode de localisation: haute précision

• getCurrentPosition , enableHighAccuracy: true : fonctionne quand le signal GPS est disponible, sinon timeout. Peut renvoyer un emplacement plus ancien, selon votre paramètre maximumAge .
• getCurrentPosition , enableHighAccuracy: false : fonctionne après 5-6s (comme indiqué déjà).
• watchPosition , enableHighAccuracy: true : fonctionne lorsque le signal GPS est disponible, sinon timeout
• watchPosition , enableHighAccuracy: false : fonctionne

Sommaire
Si votre mode de localisation est Appareil uniquement, vous devez vous attendre à toujours avoir un signal GPS. Dans tous les autres cas, vous avez besoin de services de localisation (mode de localisation! = Appareil uniquement).
Je suppose que tout cela est le comportement attendu de l'API Location et je viens de découvrir l'équivalent du fait que la terre n'est pas plate, cependant, c'est un enfer à déboguer si vous avez un appareil configuré avec le mode Location == Device only (un émulateur, un appareil nouvellement configuré) et vous êtes assis dans une pièce sans signal GPS disponible. Dans ce cas, vous n'aurez que des délais d'expiration.

solution de contournement
Comme déjà décrit dans ce fil, j'ai également utilisé deux écouteurs watchPosition avec des valeurs différentes pour enableHighAccuracy et prenez simplement la première valeur des deux, puis supprimez-les. En jouant avec cette approche, j'ai eu l'impression que les deux auditeurs retournent effectivement aux mêmes endroits, mais ma tolérance de débogage pour la journée est épuisée ...
Cela suppose que votre mode de localisation n'est pas uniquement un appareil.

@olieidel Bien sûr, et je me demande pourquoi personne n'utilise directement l'API de géolocalisation native react.Si ce n'est pas utile ou ne fonctionne tout simplement pas, je pense qu'une chose appropriée serait de le remplacer par navigator.geolocation puisque cela fonctionne le se demande, essayez de faire une pull request avec votre solution de contournement pour voir si Facebook l'aimera. Et merci d'avoir fait un effort supplémentaire pour creuser plus profondément.

Il m'a fallu un certain temps pour reproduire systématiquement ce problème.

Je rencontre ce problème uniquement sur les téléphones Samsung équipés d'Android 5.1 et 6.0 lorsque le mode de localisation est réglé sur "Haute précision" et en utilisant l'API de position actuelle tout en étant à l'intérieur sans signal GPS. Cela fonctionne bien sur les téléphones Oppo ou à l'extérieur avec un signal GPS clair, même avec le mode «Haute précision» activé.

Je vais tester quelques-unes des solutions suggérées dans ce fil sous peu.

@mrbarde juste pour clarifier: j'utilisais navigator.geolocation . :)

@olieidel Je sais, juste en disant que la documentation doit refléter navigator.geolocation et non l'API de géolocalisation.

Salut les gars, j'ai réalisé que sur Android, vous pouvez avoir l'autorisation d'accéder à l'emplacement, mais l'utilisateur a désactivé l'emplacement à partir des paramètres du système d'exploitation. Donc, appeler navigator.getCurrentPosition() expirera toujours.

Voici un extrait de code Java avec deux méthodes. checkIfLocationAvailable qui vérifie si la localisation de l'utilisateur est activée ou non dans les paramètres. requestUserToActivateLocation invitera l'utilisateur à activer la localisation.

package location;

import android.Manifest;
import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.Intent;
import android.content.IntentSender;
import android.content.pm.PackageManager;
import android.location.Location;
import android.os.Build;
import android.os.Bundle;
import android.provider.Settings;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.v4.content.ContextCompat;
import android.text.TextUtils;
import android.util.Log;

import com.facebook.react.bridge.Promise;
import com.facebook.react.bridge.ReactApplicationContext;
import com.facebook.react.bridge.ReactContextBaseJavaModule;
import com.facebook.react.bridge.ReactMethod;
import com.google.android.gms.common.ConnectionResult;
import com.google.android.gms.common.api.GoogleApiClient;
import com.google.android.gms.common.api.PendingResult;
import com.google.android.gms.common.api.ResultCallback;
import com.google.android.gms.common.api.Status;
import com.google.android.gms.location.LocationRequest;
import com.google.android.gms.location.LocationServices;
import com.google.android.gms.location.LocationSettingsRequest;
import com.google.android.gms.location.LocationSettingsResult;
import com.google.android.gms.location.LocationSettingsStates;
import com.google.android.gms.location.LocationSettingsStatusCodes;



/**
 * Created by nigelnindo on 11/28/16.
 */
public class LocationBridge extends ReactContextBaseJavaModule implements GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener {
    public LocationBridge(ReactApplicationContext reactContext) {
        super(reactContext);
    }

    public GoogleApiClient googleApiClient;

    <strong i="10">@Override</strong>
    public String getName() {
        return "LocationBridge";
    }

    <strong i="11">@ReactMethod</strong>
    public void checkIfLocationAvailable(final Promise promise){

        int locationMode = 0;
        String locationProviders;
        boolean isAvailable = false;

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT){
            try {
                locationMode = Settings.Secure.getInt(getReactApplicationContext().getContentResolver(), Settings.Secure.LOCATION_MODE);
            } catch (Settings.SettingNotFoundException e) {
                e.printStackTrace();
            }

            isAvailable = (locationMode != Settings.Secure.LOCATION_MODE_OFF);
        } else {
            locationProviders = Settings.Secure.getString(getReactApplicationContext().getContentResolver(), Settings.Secure.LOCATION_PROVIDERS_ALLOWED);
            isAvailable = !TextUtils.isEmpty(locationProviders);
        }

        boolean coarsePermissionCheck = (ContextCompat.checkSelfPermission(getReactApplicationContext(), Manifest.permission.ACCESS_COARSE_LOCATION) == PackageManager.PERMISSION_GRANTED);
        boolean finePermissionCheck = (ContextCompat.checkSelfPermission(getReactApplicationContext(), Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED);

        boolean finalResult = (isAvailable && (coarsePermissionCheck || finePermissionCheck));

        Log.e("FINAL RESULT", Boolean.toString(finalResult));

        promise.resolve(Boolean.toString(finalResult));

    }

    <strong i="12">@ReactMethod</strong>
    public void requestUserToActivateLocation(final Promise promise){

        Log.e("LOCATION_BRIDGE:", "called activate location function");

        if (googleApiClient == null) {
            Log.e("LOCATION_BRIDGE: ", "googleApiClient is null");
            googleApiClient = new GoogleApiClient.Builder(getReactApplicationContext())
                    .addApi(LocationServices.API)
                    .addConnectionCallbacks(this)
                    .addOnConnectionFailedListener(this).build();
            googleApiClient.connect();
        }

        LocationRequest locationRequest = LocationRequest.create();
        locationRequest.setPriority(LocationRequest.PRIORITY_BALANCED_POWER_ACCURACY);
        locationRequest.setInterval(30 * 1000);
        locationRequest.setFastestInterval(5 * 1000);
        LocationSettingsRequest.Builder builder = new LocationSettingsRequest.Builder()
                .addLocationRequest(locationRequest);

        //**************************
        builder.setAlwaysShow(true); //this is the key ingredient
        //**************************

        Log.e("LOCATION_BRIDGE", "Created builder");

        PendingResult<LocationSettingsResult> result =
                LocationServices.SettingsApi.checkLocationSettings(googleApiClient, builder.build());
        result.setResultCallback(new ResultCallback<LocationSettingsResult>() {
            <strong i="13">@Override</strong>
            public void onResult(LocationSettingsResult result) {
                Log.e("LOCATION_BRIDGE: ", "onResult callback invoked");
                final Status status = result.getStatus();
                final LocationSettingsStates state = result.getLocationSettingsStates();
                switch (status.getStatusCode()) {
                    case LocationSettingsStatusCodes.SUCCESS:
                        Log.e("LOCATION_BRIDGE: ", "Location settings satisfied");
                        // All location settings are satisfied. The client can initialize location
                        // requests here.
                        promise.resolve("true");
                        break;
                    case LocationSettingsStatusCodes.RESOLUTION_REQUIRED:
                        Log.e("LOCATION_BRIDGE", "Location resolution required");
                        // Location settings are not satisfied. But could be fixed by showing the user
                        // a dialog.
                        try {
                            // Show the dialog by calling startResolutionForResult(),
                            // and check the result in onActivityResult().
                            status.startResolutionForResult(
                                    getCurrentActivity(), 1000);
                            promise.resolve("awaiting");
                        } catch (IntentSender.SendIntentException e) {
                            Log.e("LOCATION_BRIDGE", "could not send intent");
                            promise.reject("LOCATION_BRIDGE", "could not send intent");
                        }
                        break;
                    case LocationSettingsStatusCodes.SETTINGS_CHANGE_UNAVAILABLE:
                        Log.e("LOCATION_BRIDGE", "location settings are unavailable");
                        // Location settings are not satisfied. However, we have no way to fix the
                        // settings so we won't show the dialog.
                        promise.reject("LOCATION_BRIDGE", "settings change is not available");
                        break;
                }
            }
        });

    }

    <strong i="14">@Override</strong>
    public void onConnected(<strong i="15">@Nullable</strong> Bundle bundle) {
        Log.e("LOCATION_BRIDGE", "CONNECTED");
    }

    <strong i="16">@Override</strong>
    public void onConnectionSuspended(int i) {
        Log.e("LOCATION_BRIDGE", "SUSPENDED");
    }

    <strong i="17">@Override</strong>
    public void onConnectionFailed(<strong i="18">@NonNull</strong> ConnectionResult connectionResult) {
        Log.e("LOCATION_BRIDGE", "CONNECTION FAILED");
        Log.e("LOCATION_BRIDGE", connectionResult.toString());
        if (connectionResult.hasResolution()){
            try {
                connectionResult.startResolutionForResult(getCurrentActivity(), 1);
            } catch (IntentSender.SendIntentException e) {
                e.printStackTrace();
            }
        }
        else{
            Log.e("LOCATION_BRIDGE","CONNECTION FAILURE HAS NO RESOLUTION");
        }
    }
}

Depuis que j'ai commencé à l'utiliser, je n'ai pas eu de problèmes de localisation avec Android. J'espère que cela aidera quelqu'un.

Bien sûr, vous devrez ajouter compile 'com.google.android.gms:play-services-location:x.x.x' à votre app/build.gradle , et créer un module natif comme décrit ici . Je ne sais pas si cette fonctionnalité est suffisante pour créer une bibliothèque npm autonome.

Salut @nigelnindo, il y a en fait une API native React pour celle appelée PermissionsAndroid ,
vous pouvez vérifier que l'utilisateur a activé l'autorisation de localisation pour l'application
J'ai eu le même problème que vous avez signalé, alors ce que j'ai fait pour le résoudre était le suivant.

J'ai d'abord vérifié si l'utilisateur a autorisé l'application à accéder à l'emplacement des appareils

PermissionsAndroid
.check("android.permission.ACCESS_FINE_LOCATION")
.then((granted) => {
    if(granted){
        // do something
        return;
    }
    // do something else
}).catch((err) => {
    // handle error
});

Et puis déclenché une fonction avec le code ci-dessous, cela demandera à l'utilisateur de
accorder l'accès à la localisation à l'application.

PermissionsAndroid
.request("android.permission.ACCESS_FINE_LOCATION")
.then((resp) => {
    if(resp == "granted"){
        _self._watchLocation();
    }else{
        this.props.watchLocSuccess();
    }
    // set state
    _self.setState({
        requestLocation: false
    });
    // 
}).then((err) => {
    // handle error
});

Cela a fait l'affaire pour moi et maintenant je n'ai aucun problème de localisation, j'espère que cela aidera quelqu'un là-bas.

Salut @mrbarde , juste pour ajouter, j'utilise la bibliothèque PermissionsAndroid en plus de l'extrait ci-dessus. Comme je l'ai mentionné précédemment:

Salut les gars, j'ai réalisé que sur Android, vous pouvez avoir l'autorisation d'accéder à l'emplacement, mais l'utilisateur a désactivé l'emplacement à partir des paramètres du système d'exploitation.

En d'autres termes, votre application peut avoir l'autorisation d'accéder à l'emplacement obtenu avec PermissionsAndroid , mais si l'utilisateur a désactivé l'emplacement soit à partir de ses raccourcis dans la barre d'état, soit en accédant à Settings -> Location -> Off le getCurrentPosition() call expirera toujours. Cela aide avec ce cas de pointe.

@nigelnindo yh dans ce cas, alors je vais vraiment suggérer votre solution, est-il possible pour vous de faire un PR avec ça? Je veux dire que cela pourrait vraiment gagner beaucoup de temps, j'utilise un package externe pour gérer cela car je ne peux pas écrire Java, même si j'aurais vraiment aimé avoir le temps de l'apprendre. Si c'était officiellement dans React, je préférerais cela, je suis sceptique quant au fait de compter sur des bibliothèques tierces pour des choses vraiment essentielles comme celle-ci, je m'inquiète pour la cohérence.

essayez de changer (Android) TargetSdkVersion sur build.gradle (app) sous 23 (16-22) . et cela fonctionnera!

car nous avons besoin de l'autorisation d'utilisation du fichier AndroidManifest. et le fichier AndroidManifest juste appelé au SDK sous 23 (16-22).

et n'oubliez pas d'ajouter:

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />

Ne supprimez pas le paramètre maxAge!

Si vous le faites, le module GPS renverra le dernier résultat mis en cache jusqu'à obtenir la position réelle des satellites. Il peut être placé en cache dans une autre application loin de votre position réelle. Et si vous essayez d'enregistrer une trace, vos premiers points peuvent afficher une position éloignée de votre position réelle.

@pavelpashkovsky Pouvez-vous montrer des faits ou des documents officiels pour étayer votre affirmation?

@rexlow Je viens de décrire le résultat de mes tests, car il y a environ 1 semaine, j'ai rencontré le même problème et j'ai trouvé ce sujet.

J'ai eu environ 30 tests. Et j'ai eu 3-4 cas avec une mauvaise position dans les premières 1 à 5 secondes (jusqu'à ce que le GPS trouve le signal des satellites)

@pavelpashkovsky Je suis maintenant confronté au même problème. Bien que j'ai maximumAge: 1000 dans ma configuration. Cela ressemble à sa mise en cache de l'emplacement précédent comme vous l'avez dit.

@rexlow Vous avez raison. Dans votre cas, le GPS garde la position pendant 1 seconde.

Mais le meilleur résultat que j'ai obtenu avec maximumAge: 0 lorsque le GPS n'enregistre aucun résultat et essaie toujours d'obtenir la position réelle (ou une erreur si vous ne pouvez pas obtenir la position des satellites).

Je peux confirmer que la suppression de maximumage peut également causer des problèmes sur le téléphone Oppo que j'ai testé. Il utilisera un très ancien cache.

Cela m'arrivait depuis le début. Il s'avère que mon autorisation de géolocalisation a été désactivée dans Informations sur l'application -> Autorisations. Je me demande pourquoi cela s'est produit, mais il semble que ces autorisations remplacent celles que nous demandons lors de l'exécution. Peut-être que quelqu'un d'autre a aussi ce problème

salut (désolé pour mon anglais).
Je pense que l'augmentation de maximumAge résoudra le problème.

RN 0.48 Doc de géolocalisation:
L'API de géolocalisation étend la spécification Web: https://developer.mozilla.org/en-US/docs/Web/API/Geolocation

et par selon:
https://developer.mozilla.org/en-US/docs/Web/API/PositionOptions/enableHighAccuracy
&
https://developer.mozilla.org/en-US/docs/Web/API/PositionOptions/timeout
& spécialement :
https://developer.mozilla.org/en-US/docs/Web/API/PositionOptions/maximumAge

dans un scénario avec ces options:
{enableHighAccuracy: true, timeout: 10000, maximumAge: 30000}

la puce GPS de l'appareil tente de se connecter aux satellites. si la connexion établie dans le délai d'expiration (10000 ms), la latitude et la longitude seront renvoyées sans aucune erreur comme @RoBYCoNTe l'a dit: issueecomment-220580494 mais si la connexion GPS a échoué ou a expiré, l'appareil essaie de renvoyer une latitude et une longitude en cache avec un âge maximum qui définit dans options (30000 ms). si quelque chose existe, le code d'erreur 3 est renvoyé avec une erreur de délai d'expiration dans le sujet.

Je pense que l'augmentation du délai d'attente (au moins 25000 ms) pour la connexion et en particulier l'augmentation de maximumAge (au moins 3600000 ms = 1 heure) est la meilleure solution!

{enableHighAccuracy: true, timeout: 25000, maximumAge: 3600000} travaillé pour moi

_emulator config_: pendant la période de temporisation, vous devez envoyer des informations de localisation virtuelle (latitude et longitude) via le menu Location dans les paramètres de l' émulateur. (cela émulera la connexion satellite)

{ enableHighAccuracy: true, timeout: 60000, maximumAge: 1200 } fonctionné pour moi. Pour moi, ce n'était pas l'âge maximum, c'était le temps que j'étais prêt à attendre.

(Android uniquement)
Ce problème n'est pas un bug à mon avis.
Dans React Native, la géolocalisation fonctionne comme suit:

• haute précision signifie localisation GPS
• Lorsqu'il est désactivé, il récupère l'emplacement du fournisseur de réseau
• maximumAge vous permet de ne pas récupérer une nouvelle position à chaque fois (ce qui prend beaucoup de temps et de batterie) mais de vous fier à une position en cache

Fondamentalement, le fournisseur de GPS est plus lent que le fournisseur de réseau et ne fonctionnera pas toujours en fonction de votre emplacement (si le GPS ne peut pas atteindre le téléphone, vous obtiendrez un délai d'expiration). Le fournisseur de réseau est plus rapide, plus accessible, mais en tant que compromis, la précision est faible (le pire que j'ai eu était de 2000 mètres).

Si vous avez un délai d'expiration avec highAccuracy, cela signifie que vous ne pouvez pas être atteint par le GPS.
Dans ce cas, envisagez de le désactiver par défaut et mettez à jour l'emplacement à mesure qu'il devient de plus en plus précis. Vos utilisateurs n'attendront pas dans ce cas.

Dans mon cas, j'ai implémenté mes propres observateurs, en comparant l'emplacement et en renvoyant toujours le plus précis. Le problème avec l'implémentation RN par défaut est qu'elle s'appuie soit sur le fournisseur de GPS soit sur le fournisseur de réseau, mais ne renvoie pas un compromis entre les deux. Vous devrez probablement le résoudre soit sur JS soit sur Native.

J'espère que cela a aidé.

Testé sur Android uniquement.

J'ai réussi à le faire fonctionner avec les cas suivants et à m'assurer que la localisation est activée:

• Si vous exécutez votre application via Android Emulator, vous devez mettre des options, sinon cela échouera.

navigator.geolocation.getCurrentPosition(
    (position) => {
        this.setState({currentLocation: {lat: position.coords.latitude, lng: position.coords.longitude}})
    }, (error) => {
        alert("Geolocation error: "+error.message);
    },
    {enableHighAccuracy: true, timeout: 20000, maximumAge: 0}
);

J'utilise simplement des contrôles étendus pour envoyer la position souhaitée à l'application.

• Si vous exécutez votre application sur de vrais téléphones mobiles, vous devez omettre les options, sinon cela échouera.

navigator.geolocation.getCurrentPosition(
    (position) => {
        this.setState({currentLocation: {lat: position.coords.latitude, lng: position.coords.longitude}})
    }, (error) => {
        alert("Geolocation error: "+error.message);
    }
);

Cela obtiendra votre position actuelle

Nous rencontrons le même problème!

Un correctif à ce problème sera-t-il disponible dans une prochaine version?

J'ai essayé certaines des solutions proposées ( exemple , exemple , exemple et exemple ) et aucune n'a résolu le problème. Mais je dois dire que je n'ai trouvé aucune référence pour le scénario suivant:

App

• Android 6.x
• Réagir 16.1.0
• React-Native 16.50.3

Scénario d'utilisation

• le téléphone Android n'a pas de carte SIM, ils appartiennent à l' entreprise et sont simplement autorisés à se connecter au WIFI.

J'obtiens toujours l'erreur Geolocation timed out, code 3 ...

Quelqu'un a résolu ça?

_Mise à jour_ (13/11/2017):

Je l'ai résolu (au moins temporairement) en définissant Settings >> Privacy >> Location >> Mode sur High accuracy

Salut.
J'ai trouvé une bonne solution!
Veuillez d'abord lire mon commentaire précédent sur ce problème: # issuecomment-331830285

Solution:
Premier appel navigator.geolocation.getCurrentPosition avec: {enableHighAccuracy: true, timeout: 60000, maximumAge: 0} as PositionOptions , cela retournera la position actuelle réelle.
si la requête précédente expirait, appelez navigator.geolocation.getCurrentPosition avec: {enableHighAccuracy: false, timeout: 30000, maximumAge: 3600000} as PositionOptions , cela renverra la position solution de secours et _ (je pense) _ jamais expiré!
exemple de code:

const GeoHightAccuracy = () => {
  return new Promise((resolve, reject) => {
    navigator.geolocation.getCurrentPosition(
      (locHightAccuracy)=>{
        resolve(locHightAccuracy)
      },
      (error)=>{
        GeoLowAccuracy()
        .then((locLowAccuracy)=>{resolve(locLowAccuracy)})
        .catch((err)=>{reject(err)});
      },
      {enableHighAccuracy: true, timeout: 60000, maximumAge: 0}
    )
  });
};

const GeoLowAccuracy = () => {
  return new Promise((resolve, reject) => {
    navigator.geolocation.getCurrentPosition(
      (locLowAccuracy)=>{
        resolve(locLowAccuracy)
      },
      (error)=>{
        reject(error)
      },
      {enableHighAccuracy: false, timeout: 15000, maximumAge: 3600000}
    )
  });
};



md5-4cb745c8e66bae2435e8bf78ce42a9c0



GeoHightAccuracy()
.then(locationData => console.log(locationData))
.catch(error => console.log(error));

J'espère être utile.

J'ai le même problème ici!
Je n'arrive pas à faire fonctionner navigator.geolocation sur mon vrai appareil Android.

Je crois qu'il n'y a rien à régler ici, la géolocalisation fonctionne comme prévu. Lisez mon message ci-dessus.

@Rewieer , merci pour votre réponse!

J'utilise ce code pour tester navigator.geolocation sur mon application.

var options = {
  enableHighAccuracy: true,
  timeout: 5000,
  maximumAge: 5000
};

function success(pos) {
  var crd = pos.coords;
  alert(crd.latitude + " " + crd.longitude);
};

function error(err) {
  alert('ERROR(' + err.code + '): ' + err.message);
};

navigator.geolocation.getCurrentPosition(success, error, options);

Je reçois toujours ERROR(3): Location request timed out .
en utilisant toutes les combinaisons d'options.
Je peux voir le point bleu de ma position sur la carte et le GPS fonctionne bien, mais je ne peux pas obtenir de position ou faire fonctionner navigator.geolocation par programme.

Les problèmes possibles sont:

• mauvaise configuration du simulateur / téléphone
• pas dans une zone couverte par GPS (fonctionne mal dans les bâtiments ou dans la rue avec de grands bâtiments par exemple)
• temps morts trop tôt

L'utilisation de la localisation réseau semble mieux fonctionner dans ces cas. Avez-vous essayé de récupérer la position actuelle sans options? (qui utiliserait l'infrastructure liée au réseau pour obtenir le poste)

J'utilise un vrai appareil Android (version 5.1)
Je suis en mesure de déterminer ma position à l'aide de react-native-maps (position correcte du point bleu sur la carte dans mon application) + Je peux utiliser l'application google maps et accéder à ma position (le GPS fonctionne).
J'utilise un grand délai d'attente, basculant enableHighAccuracy sur true et false, supprimez les options ... etc. tous n'ont pas réussi à obtenir navigator.geolocation pour obtenir des données.

Avez-vous mis la main à la pâte sur Android avec l'API native?

16/11/2017 15:19 GMT + 01: 00 Badis Merabet [email protected] :

J'utilise un vrai appareil Android (version 5.1)
Je suis capable de déterminer ma position à l'aide de React-Native-Maps (correct blue
position du point sur la carte dans mon application) + Je peux utiliser l'application google maps et
aller à ma position (le GPS fonctionne).
J'utilise un grand délai d'attente, en basculant enableHighAccuracy sur true et false,
supprimer des options ... etc. tous n'ont pas réussi à obtenir navigator.geolocation pour obtenir
Les données.

-
Vous recevez cela parce que vous avez été mentionné.
Répondez directement à cet e-mail, affichez-le sur GitHub
https://github.com/facebook/react-native/issues/7495#issuecomment-344935653 ,
ou couper le fil
https://github.com/notifications/unsubscribe-auth/ALuPm5XL1tNLCniOMR4YAMI4ZC2fKxrsks5s3ESBgaJpZM4Ibete
.

Oui @Rewieer , je suis d'accord, la cause des erreurs est de mauvaises configurations.

Dans l'émulateur, nous devons envoyer la latitude et la longitude via le paramètre de l'émulateur avant le délai d'expiration!

Ma solution # issuecomment-331830285 essaie d'abord d'obtenir la position actuelle réelle via la connexion GPS et satellite et si la demande expire (ou sur toute autre erreur) essaie d'utiliser l'infrastructure liée au réseau pour obtenir la position LowAccuracy .

@Rewieer Je n'ai jamais travaillé avec l'API native Android. Je ne fais que du développement JavaScript.

@badis veuillez envoyer votre code et votre journal des erreurs.

@badis
Doc RN:
Pour demander l'accès à l'emplacement, vous devez ajouter la ligne suivante à AndroidManifest.xml de votre application:

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />

En travaillant avec React-Native, vous devez en savoir plus sur l'environnement natif sous-jacent, car de tels problèmes me surviennent souvent lorsque je travaille avec React-Native.
Le meilleur moyen (du point de vue de l'utilisateur) est de récupérer une approximation au début et de la corriger au fur et à mesure, car le GPS peut prendre un certain temps en fonction de votre position et de la position des satellites à proximité. Je sais que l'emplacement du réseau peut sembler très difficile, mais je suppose que tout le monde ne vit pas à San Francisco :)

@Rewieer @hoorsa
Voici un code de démonstration où je teste les fonctionnalités: https://github.com/badis/mobile-react-native
Jetez un œil à la page Carte.
Je veux juste savoir si le code est correct et fonctionne pour quelqu'un d'autre.
Après cela, je vais essayer de mon côté pour voir si le problème réside dans les paramètres et l'emplacement de mon appareil.

Merci à tous !

@badis avez-vous ajouté <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" /> à AndroidManifest.xml de votre application?

Oui, hier.
https://github.com/badis/mobile-react-native/blob/master/android/app/src/main/AndroidManifest.xml

@badis J'ai eu le même problème hier. Cela fonctionne si vous supprimez simplement le dernier argument (je comprends que ce n'est pas idéal) comme suggéré dans https://github.com/facebook/react-native/issues/7495#issuecomment -228730196

Quelles sont les options par défaut pour Android? peut-être que cela pourrait aider à résoudre celui-ci

Je pense que nous utilisons ces valeurs par défaut (en inspectant LocationModule.java):

{
enableHighAccuracy: false, // Ne pas utiliser le GPS
maximumAge: Double.POSITIVE_INFINITY, // Accepte tout emplacement mis en cache
timeout: Long.MAX_VALUE,
distanceFiltre: 100
}

Nous rencontrons également la même erreur de localisation, la désactivation du troisième paramètre d'option fonctionne pour les modes `` Haute précision '' et `` Économie de batterie ''. Pourtant, seul l'appareil échoue à chaque fois. enableHighAccuracy sur true échoue quel que soit le mode sur lequel nous avons défini le périphérique.

Est-ce que cette chose utilise même FusedLocationProviderClient , comme le site Android Dev suggère de le faire?

La désactivation du troisième paramètre d'option fonctionne pour les modes «Haute précision» et «Économie de batterie».

@mkpietrzyk si omettant options résolu pour vous dans ces deux modes?

@natterstefan

oui, pour Android, j'ai utilisé les paramètres par défaut ... mais avoir un timeout et un maximumAge presque infinis pour mon application est un peu un appkiller car j'ai besoin de savoir où sont mes utilisateurs pour vérifier certaines conditions.

en utilisant une solution @hoorsa ici vérification GPS comme fonctionne bien. Pourtant, il est de toute façon très délicat pour le GPS et ne répond parfois pas à une précision élevée ... c'est pourquoi je ne considère pas que cela fonctionne très bien, mais bon, ça marche un peu.

J'ai le même problème, où je dois définir le délai d'expiration comme une durée ridiculement élevée pour que cela fonctionne, mais les utilisateurs devront accéder aux informations plus tôt. Lors de la première création de l'application, je peux enregistrer en une demi-seconde que les autorisations pour accéder à un emplacement précis sont valides. La mise en œuvre de la localisation précise ne fonctionne tout simplement pas correctement sur Android.
Pour référence, je l'ai essayé avec / sans aucun paramètre. Même sans aucune option supplémentaire, il échouera toujours à charger l'emplacement parfois. Les tests ont été effectués sur un One Plus One

J'ai également ce problème de délai d'attente.

RN .50,3

Essayé, appel de l'API avec et sans le paramètre maximumAge:

{enableHighAccuracy: true, timeout: 10000},

J'emballe également cet appel avec une demande d'autorisation afin que ce ne soit pas un problème:

PermissionsAndroid.request (
PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION,

Le mode haute précision est activé sur l'appareil.
Le manifeste a les autorisations correctes.

Sur mon Galaxy S7 - il résout un emplacement bien.
Sur mon Pixel 2 - il expire après le délai de 10 secondes dans un endroit qui n'a pas de signal GPS.
Sur l'émulateur - il expire après le délai de 10 secondes, À MOINS QUE j'aille dans l'onglet d'emplacement sur les contrôles étendus et clique sur ENVOYER pour envoyer un emplacement.

Il semble que navigator.geolocation.getCurrentPosition ne fonctionne PAS lorsqu'il n'y a pas de signal GPS, même s'il existe un emplacement plus ancien mis en cache à partir d'une autre application qui avait précédemment utilisé l'emplacement.

Je vais contourner ce problème en essayant une haute précision, puis en @olieidel l' a fait.

J'ai le même problème que @jacksontbryan, mais getCurrentPosition n'utilise un emplacement mis en cache si maximumAge est omis.

Cela semble fonctionner correctement sur un Galaxy S7, mais pas sur mon LG G6. Sur le LG, il expire presque tout le temps, si maximumAge est défini. Si maximumAge n'est pas défini, il utilise un ancien emplacement.

Edit: On dirait que l'omission de l'argument d'options fonctionne complètement.

Je recommande à tout le monde d'utiliser sa propre implémentation de module natif sur Android pour obtenir des résultats stables. C'est assez facile à mettre en œuvre, vous aurez beaucoup plus de contrôle sur le GPS et vous n'aurez pas à vous soucier du fait que votre application ne fonctionne pas sur certains appareils.

    public Location getBestLastKnownPosition(Context context) {
        LocationManager locationManager = (LocationManager)context.getSystemService(Context.LOCATION_SERVICE);
        List<String> providers = locationManager.getProviders(true);
        Location bestLocation = null;
        for (String provider : providers) {
            Location l = locationManager.getLastKnownLocation(provider);
            if (l == null) {
                continue;
            }
            if (bestLocation == null || l.getAccuracy() < bestLocation.getAccuracy()) {
                // Found best last known location: %s", l);
                bestLocation = l;
            }
        }

        if (bestLocation == null) {
            locationManager.requestSingleUpdate(new Criteria(), this, null);
        }
        return bestLocation;
    }

    private static WritableMap locationToMap(Location location) {
        WritableMap map = Arguments.createMap();
        WritableMap coords = Arguments.createMap();
        coords.putDouble("latitude", location.getLatitude());
        coords.putDouble("longitude", location.getLongitude());
        coords.putDouble("altitude", location.getAltitude());
        coords.putDouble("accuracy", location.getAccuracy());
        coords.putDouble("heading", location.getBearing());
        coords.putDouble("speed", location.getSpeed());
        map.putMap("coords", coords);
        map.putDouble("timestamp", location.getTime());
        map.putString("provider", location.getProvider());

        if (android.os.Build.VERSION.SDK_INT >= 18) {
            map.putBoolean("mocked", location.isFromMockProvider());
        }

        return map;
    }

    <strong i="6">@ReactMethod</strong>
    public void getCurrentPosition(Callback successCallback, Callback errorCallback){
        Location l = getBestLastKnownPosition(this.getReactApplicationContext());
        if (l == null){
            errorCallback.invoke("Failed to retrieve current location");
            return;
        }
        successCallback.invoke(locationToMap(l));
    }

    private static class LocationOptions {
        private final long timeout;
        private final double maximumAge;
        private final boolean highAccuracy;
        private final float distanceFilter;

        private LocationOptions(
                long timeout,
                double maximumAge,
                boolean highAccuracy,
                float distanceFilter) {
            this.timeout = timeout;
            this.maximumAge = maximumAge;
            this.highAccuracy = highAccuracy;
            this.distanceFilter = distanceFilter;
        }

        private static LocationOptions fromReactMap(ReadableMap map) {
            // precision might be dropped on timeout (double -> int conversion), but that's OK
            long timeout =
                    map.hasKey("timeout") ? (long) map.getDouble("timeout") : Long.MAX_VALUE;
            double maximumAge =
                    map.hasKey("maximumAge") ? map.getDouble("maximumAge") : Double.POSITIVE_INFINITY;
            boolean highAccuracy =
                    map.hasKey("enableHighAccuracy") && map.getBoolean("enableHighAccuracy");
            float distanceFilter = map.hasKey("distanceFilter") ?
                    (float) map.getDouble("distanceFilter") :
                    10;

            return new LocationOptions(timeout, maximumAge, highAccuracy, distanceFilter);
        }
    }

    <strong i="7">@ReactMethod</strong>
    public void watchPosition(ReadableMap options, Callback successCallback, Callback errorCallback){
        LocationOptions opts = LocationOptions.fromReactMap(options);
        LocationManager locationManager = (LocationManager)this.getReactApplicationContext().getSystemService(Context.LOCATION_SERVICE);
        Criteria criteria = new Criteria();
        if (opts.highAccuracy) {
            criteria.setAccuracy(Criteria.ACCURACY_FINE);
        }
        String bestProvider = locationManager.getBestProvider(criteria, true);

        locationManager.requestLocationUpdates(bestProvider, 1000, opts.distanceFilter, this);
    }

    <strong i="8">@Override</strong>
    public void onLocationChanged(Location location) {
        if (location == null) return;

        this.getReactApplicationContext()
                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
                .emit("locationChanged", locationToMap(location));
    }

@Buthrakaur J'essaie de créer un module natif pour votre extrait de code, mais je ne peux pas le faire fonctionner car il a échoué lors de la compilation. J'ai posté mon essence https://gist.github.com/pewh/1fd64c8f0b3797ef2b7a7046b5a5f974 et j'espère que quelqu'un fera une révision sur mon essence. Merci beaucoup et joyeux Noël!

L'appel de navigator.geolocation.getCurrentPosition sans aucune option a résolu le problème pour moi. Je transmets uniquement les rappels de succès et d'erreur.

Testé sur un vrai appareil avec Android 5.1.

@ginex Êtes-vous sûr que les données sont nouvelles? Quand je fais cela, j'obtiens parfois des données d'une heure. (Il dit que je suis là où j'étais il y a une heure).

Cela doit vraiment être corrigé!

salut

Je suis également confronté au même problème. Je reçois une erreur de temporisation sur certains appareils. J'ai augmenté le délai d'expiration de 2 secondes à 10 minutes mais sans attendre 10 minutes, cela me lance juste l'erreur.

J'ai également essayé avec enableHighAccuracy: false. Dans ce cas, je suis capable d'obtenir l'emplacement (sauf en mode appareil).

J'ai aussi essayé sans passer les paramètres. Je suis en mesure d'obtenir l'emplacement dans ce cas également, mais sauf le mode appareil.

J'ai également essayé de passer maximumAge mais aucun résultat.
Ceci est mon code-

getCurrentPosition () {
navigator.geolocation.getCurrentPosition (
(position) => {
console.log ('obtenir la position');
this.location = {
longitude: position.coords.longitude,
latitude: position.coords.latitude,
erreur: nulle,
};
},
(erreur) => {
console.log ('obtenir une erreur de position', erreur);
this.location = {
longitude: nulle,
latitude: nulle,
erreur: error.message,
};
},
{
enableHighAccuracy: vrai,
délai d'expiration: 600000
},
);
}

Si l'un d'entre vous utilise skipPermissionsRequest et que la géolocalisation expire - voir # 17487

salut

@ngandhy - Non, je n'utilise pas 'skipPermissionRequests': true. et minSdkVersion vaut 16

J'ai les mêmes problèmes que vous tous, j'ai essayé toutes les combinaisons que les gens mentionnent pour Android et résolvez-les avec cette géolocalisation de fond natif et nous pouvons obtenir des emplacements enregistrés et même des emplacements GPS et ces emplacements seront extrêmement précis.

@badis
Votre solution a fonctionné pour moi - merci!

Ma méthode avant la correction:

getUserLocationHandler() { navigator.geolocation.getCurrentPosition(position => { console.log(position.coords.latitude, position.coords.longitude); }, err => { console.log(err); } }

Ma méthode après votre correction:

getUserLocationHandler() { navigator.geolocation.getCurrentPosition(position => { console.log(position.coords.latitude, position.coords.longitude); }, err => { console.log(err); }, {enableHighAccuracy: false, timeout: 15000, maximumAge: 3600000}); }

Je viens de tester ce code et cela pourrait être une solution:
https://www.abidibo.net/blog/2017/11/23/geolocation-react-native/

Avez-vous ce problème aussi, quelqu'un a-t-il une solution?

Je rencontre ce problème depuis un certain temps et la seule «solution» qui fonctionne de manière cohérente est de désactiver «enableHighAccuracy». Le problème avec cela est qu'il utilise ensuite votre réseau au lieu du GPS pour déterminer votre position, ce qui perd une tonne de précision.

La plupart des autres solutions semblent fonctionner au début, mais j'ai trouvé que cela était généralement dû à l'utilisation d'une position en cache et que si vous redémarrez votre téléphone et lancez votre application, cela échouerait toujours.

Aujourd'hui, j'ai trouvé ce package qui utilise l'API des emplacements fusionnés de Google pour les emplacements Android et revient à l'implémentation React Native par défaut pour iOS (je ne suis pas l'auteur de ce package, mais bravo à lui pour l'avoir créé):

https://www.npmjs.com/package/react-native-geolocation-service

Je l'ai seulement testé un peu jusqu'à présent, mais il semble bien fonctionner.

@globetro Merci! J'ai vérifié cela aussi et semble fonctionner correctement!

@globetro Merci.
react-native-geolocation-service est la meilleure solution.

@globetro J'ai également eu du succès avec ce plugin. Cela devrait être fusionné pour réagir natif en tant que fonctionnalité de géolocalisation par défaut!

react-native-geolocation-service ne m'aide pas :(

Merci @globetro, le package * react -native-geolocation-service * a parfaitement fonctionné, il serait bien de l'ajouter en tant que composant de base sur react native.

Vous voulez vraiment avoir deux écouteurs de localisation (ce qui coûte cher), l'un qui fait une haute précision et l'autre qui ne le fait pas.

alors vous voulez comparer ce qui est plus précis et plus récent que votre emplacement «actuel».

C'est une solution «temporaire», cela devrait vraiment être implémenté du côté RN afin qu'il utilise à la fois les autorisations COARSE et FINE si highAccuracy est activé.

J'ai corrigé ce problème, voici le composant que j'ai créé à l'aide d'une promesse:
https://gist.github.com/a3diti/5466f7309752cbb2e63ecefff6365bb9
Dans Android, j'ai supprimé maximumAge , j'ai conservé enableHighAccuracy à true , et j'ai ajouté un contrôle d'autorisation du composant RN PermissionsAndroid .

@ a3diti L' avez-vous testé dans le monde réel? L'emplacement peut être mis en cache.

@ a3diti À moins qu'ils ne

Pourquoi ne pas fusionner le code utilisé ici https://www.npmjs.com/package/react-native-geolocation-service dans core?

Je fais face au même "problème de délai de demande", après R & D, j'essaye de "redémarrer" l'appareil, puis après avoir obtenu l'emplacement et son fonctionnement.

Veuillez vérifier mon code.

componentDidMount = () => {
navigator.geolocation.getCurrentPosition (
(position) => {
const initialPosition = JSON.stringify (position);
this.setState ({position initiale});
},
(erreur) => alerte (error.message),
{enableHighAccuracy: false, timeout: 20000, maximumAge: 1000, distanceFilter: 1}

  );
  this.watchID = navigator.geolocation.watchPosition((position) => {
     const lastPosition = JSON.stringify(position);
     this.setState({ lastPosition });
     Alert.alert("Location change",lastPosition);

  });

}

Toute raison pour laquelle les gens ont encore du mal avec cela et n'utilisent pas

https://www.npmjs.com/package/react-native-geolocation-service

comme suggéré précédemment? Cela fonctionne parfaitement pour moi.

Cela ne fonctionne-t-il pas pour les autres?

Ajouté ceci au fichier AndroidManifest.xml et cela fonctionne!

  <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
  <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />

Salut les gars,

J'ai essayé d'utiliser le service react -native-geolocation-service comme suggéré par @globetro mais cela fait planter mon application instantanément. Des idées?

@ Patrick-Bayer Je l'utilise sur mon application sur Google Play où cela fonctionne, mais ma version de développement plante maintenant instantanément pour une raison inconnue. Il semble que ce soit le service de géolocalisation natif qui cause le crash pour moi également.

Fatal Exception: java.lang.VerifyError: Verifier rejected class com.google.android.gms.location.FusedLocationProviderClient: void com.google.android.gms.location.FusedLocationProviderClient.<init>(android.app.Activity) failed to verify: void com.google.android.gms.location.FusedLocationProviderClient.<init>(android.app.Activity): [0x8] register v2 has type Precise Reference: com.google.android.gms.common.api.internal.zzg but expected Precise Reference: com.google.android.gms.common.api.internal.zzcz

Dites moi si vous trouvez une solution.

@oakis Les étapes suivantes ont fonctionné pour moi:

1. Mettez à jour Gradle et changez la version dans

dependencies {
        classpath 'com.android.tools.build:gradle:3.1.0'

        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }

1. Ajoutez "google ()" aux référentiels dans votre android / build.gradle

Parfois, même après avoir ajouté <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" /> à votre AndroidManifest.xml, cela peut toujours ne pas fonctionner.
Solution de contournement rapide

1. Vous pouvez demander explicitement les informations de localisation de l'utilisateur lorsqu'il monte le premier écran de votre application comme ceci
   try { const granted = await PermissionsAndroid.request( PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION ) if (granted == PermissionsAndroid.RESULTS.GRANTED) { // WHATEVER WAY YOU WANT THEM TO KNOW THAT THEY HAVE GRANTED THE PERMISSION //MAY BE USING BASIC ALERT OR TOASTANDROID } else { //SAME AS ABOVE } } catch (error) { //catch the error alert(error); }
2. Ne définissez jamais enableHighAccuracy comme étant faux, supprimez plutôt maximumAge et augmentez votre timeOut . Quelque chose comme {enableHighAccuracy: true, timeout: 100000,} ferait l'affaire.

J'espère que cela aidera quelqu'un.

Pour moi, définir enableHighAccuracy sur true fonctionne sur l'API 23, bien que je doive définir sur false sur l'API 26.
(ce sont les seuls sur lesquels je teste)

EDIT: J'ai fini par installer le service react

Salut,

J'ai eu le même problème et voici une autre solution.

J'ai ajouté la balise uses-feature ci-dessous dans AndroidManifest.xml et il semble que l'application fonctionne bien avec highAccuracy: true

<uses-feature android:name="android.hardware.location.gps" />

Il semble que si vous définissez highAccuracy: high , le React Native utilise GPS_PROVIDER au lieu de NETWORK_PROVIDER. Et comme l'indique le document des développeurs Android, une application ciblant l'API 21 ou une version ultérieure doit inclure cette balise dans AndroidManifest.xml pour utiliser GPS_PROVIDER.

Attention: si votre application cible Android 5.0 (niveau d'API 21) ou supérieur, vous devez déclarer que votre application utilise la fonctionnalité matérielle android.hardware.location.network ou android.hardware.location.gps dans le fichier manifeste, selon que votre L'application reçoit des mises à jour de localisation de NETWORK_PROVIDER ou de GPS_PROVIDER. Si votre application reçoit des informations de localisation de l'une de ces sources de fournisseur de localisation, vous devez déclarer que l'application utilise ces fonctionnalités matérielles dans votre manifeste d'application. Sur les appareils exécutant des versions antérieures à Android 5.0 (API 21), la demande de l'autorisation ACCESS_FINE_LOCATION ou ACCESS_COARSE_LOCATION comprend une demande implicite de fonctionnalités matérielles de localisation. Cependant, la demande de ces autorisations ne demande pas automatiquement les fonctionnalités matérielles de localisation sur Android 5.0 (niveau d'API 21) et supérieur.

https://developer.android.com/guide/topics/location/strategies#Permission

Je ne sais pas pourquoi vous n'avez pas besoin d'inclure android.hardware.location.network dans AndroidManifest.xml lors de la définition de highAccuracy: false ce qui implique que LocationManager utilise NETWORK_PROVIDER et que la balise est donc requise selon le document.

J'espère que cette solution fonctionne pour vous.

J'ai fait quelques expériences et il semble que le délai d'expiration soit lié à l'activation des services de localisation de Google sur l'appareil.
J'ai remarqué que lorsque j'active les services de localisation sur l'appareil, une boîte d'alerte vous demande "Améliorer la précision de la localisation?" avec un texte expliquant que les services de localisation de Google fonctionneront en arrière-plan et enverront également des données de localisation à Google. Cela se produit généralement sur un nouvel appareil ou un émulateur, car la plupart d'entre nous l'ont déjà activé sur nos appareils habituels.

Lorsque cela n'est pas activé, l'appareil doit obtenir un nouvel emplacement presque chaque fois que vous le demandez (contrôlé par les paramètres maximumAge ). Si vous n'avez pas demandé l'emplacement depuis un certain temps et que la timeout n'est pas suffisante pour obtenir un nouvel emplacement, le navigator.geolocation.getCurrentPosition renverra simplement un timeout.

J'ai également vu cela se résoudre en ouvrant une fois Google Maps sur l'appareil (qui obtient à nouveau un nouvel emplacement).

Encore une fois, sans prétendre que c'est la bonne explication / solution, il suffit d'ajouter mes observations à ce fil

Je n'ai pu surveiller les changements d'emplacement que sur Android avec react-native-fused-location

Y a-t-il quelqu'un qui souhaite intégrer les changements de l'un des modules suggérés au noyau?

Il y a quelques jours, j'ai publié react-native-cross-geolocation qui est compatible avec le module de géolocalisation RN, mais utilise l'API de localisation Google la plus efficace pour Android. Pour cette raison, je ne pense pas que mon module soit un candidat pour l'intégrer dans le noyau RN, mais il est disponible pour tous ceux qui souhaitent l'utiliser.

react-native-geolocation-service Ce paquet utilise l'API de localisation fusionnée et fonctionne très bien pour obtenir la position ou même pour regarder la position. @hramos et @reyalpsirc, veuillez essayer.

L' emplacement fusionné

J'ai presque tout essayé et il s'avère que c'est incohérent. J'ai trouvé quelque chose qui pourrait être utile.

Permettre une haute précision signifie trouver la localisation via le réseau gps + (services de l'opérateur). Après avoir vérifié les autorisations au niveau de l'application, les autorisations de localisation des services de l'opérateur étaient désactivées sur mon appareil. L'activer et supprimer le troisième paramètre de navigator.geolocation.getCurrentPosition () fonctionne pour moi.
Essayer
-Accédez aux paramètres de votre appareil -> Sécurité et emplacement -> Emplacement -> Autorisations au niveau de l'application
-Activer l'autorisation de localisation pour les services de l'opérateur
-Supprimer la configuration de l'emplacement (troisième paramètre) de getCurrentPosition
-Redémarrez votre appareil

J'espère que cela t'aides!

Je ne sais pas si c'est pertinent. Mais un exemple de https://snack.expo.io/SkJqg8gYm. Après avoir personnalisé le code, le code a touché le bloc catch tout le temps. Ensuite, j'ai découvert que chaque fois qu'une exception javascript se produit, elle est lancée en silence. En raison de ce bloc catch a été exécuté. Ensuite, je me suis assuré qu'aucune erreur ne se produirait lors de l'appel de cette fonction. Je suppose que le dactylographie doit être appliqué dans des cas comme celui-ci pour éviter les erreurs d'exécution.

{enableHighAccuracy: true, timeout: 10000, maximumAge: 0}
ce que j'ai trouvé si sauter le deuxième paramètre ou donner moins de 10000 valeurs cela donne l'erreur

essayer de donner les trois paramètres comme ci-dessus résoudra mon problème au moins dans l'émulateur

Essayez d'ajouter ces autorisations sur votre _AndroidManifest.xml_ :

<_uses-permission i = "6" />
<_uses-permission i = "8" />
<_permission_ i = "10" /> _android: name = "android.permission.ACCESS_COARSE_LOCATION" _
_android: protectionLevel = "signature" _ />
<_permission_ i = "13" /> _android: name = "android.permission.ACCESS_FINE_LOCATION" _
_android: protectionLevel = "signature" _ />

Salut, je faisais face au même problème "timeout de la demande". J'ai essayé toutes les solutions possibles, comme indiqué ci-dessus, celles-ci ne pouvaient pas fonctionner pour moi, mais récemment, j'ai trouvé un module qui surmonte ce problème.
https://www.npmjs.com/package/react-native-geolocation-service
Cela a fonctionné pour moi .....

@vishalTechnoFreek , existe également une géolocalisation croisée native de réaction .

Il est entièrement compatible avec la géolocalisation RN actuelle, mais en utilisant la nouvelle API Google. Avec cette API, vous ne vous inquiétez pas du mode à utiliser, le service détecte automatiquement la meilleure option.

Un autre avantage est que, lorsque RN corrige ce problème, vous pouvez le supprimer sans affecter votre application, si vous le souhaitez.

Pour mon cas, ce qui a mentionné @manurana concernant (le téléchargement et) l'ouverture de l'application Google Maps, puis le retour à Expo, a fait l'affaire.

Je travaille avec Genymotion et Android 5.

De plus, pour les utilisateurs de Genymotion, pour lire correctement la position, la fenêtre de carte de Genymotion doit être ouverte; sinon cela fonctionnera mais avec l'emplacement de Geny par défaut

définir enableHighAccuracy sur true ou false ne fonctionne pas pour moi.
omettre le 3ème argument pour getCurrentPosition pour utiliser les valeurs par défaut du module natif fonctionne pour moi.

bouée de sauvetage 👍 cela a fonctionné pour moi.

Je les gars,
J'étais confronté à la même erreur mais, après quelques tentatives avec mes collègues, nous remarquons quelque chose d'étrange (mais normal si vous pensez au GPS).

Si vous exécutez des tests «à l'intérieur de votre bureau» à l'aide d'un appareil physique, le localisateur GPS peut être dérangé par des éléments externes comme les murs, ou par la simple raison que vous essayez de faire cette opération «à l'intérieur» et, généralement, cela doit être exécuté à l'extérieur .

Eh bien, après cela, nous sortons de notre bureau, nous réexécutons les tests et l'appareil répond comme prévu (nous n'avons pas reçu l'erreur de délai d'expiration de la demande).

Ma suggestion est la suivante: essayez la géolocalisation en utilisant "enableHighAccuracy" défini sur true, si cela échoue (au bureau, cela peut échouer), réessayez avec false, cela devrait fonctionner, dans mon cas, c'est le cas.

J'espère que cela peut aider.

Je suis confronté au même problème, mais définir enableHighAccuracy sur false ne fonctionne pas pour moi. Donc, cette solution qui semble parfaite ne fonctionne pas pour moi.

J'ai rencontré un problème similaire avec plusieurs demandes (sélection continue d'utiliser l'emplacement actuel) J'ai ajouté une nouvelle tentative pour la demande de localisation. pas le problème exact, mais peut être aidera quelqu'un.

import retry from 'retry'

if (granted === PermissionsAndroid.RESULTS.GRANTED) {
  const operation = retry.operation({ retries: 2 });
  operation.attempt(() => {
    navigator.geolocation.getCurrentPosition(
      (response) => { resolve(response) },
      (error) => {
        if (operation.retry(error)) {
          return;
        }
        reject(error)
     },
     { timeout: 2000, enableHighAccuracy: true, maximumAge: 100 },
   );
 })
} else {
  reject(new Error('Location access denied'))
}

https://www.npmjs.com/package/react-native-geolocation-service
Ce package a résolu le problème pour moi.
Presque toutes les suggestions ci-dessus n'ont pas fonctionné pour moi.

Salut, Invité, je résous le problème, ce qui s'est passé, c'est que lorsque nous demandons l'emplacement pour la première fois et que nous utilisons "maximunAge", nous n'avons pas un emplacement précédent mis en cache donc, il y a un bogue, assurez-vous que la toute première fois lorsque vous demandez l'emplacement est sans "maximunAge"

la réponse simple est de sortir de là où vous êtes et d'aller dans un espace ouvert, puis de réessayer.

C'est une science simple.

Les services GPS sont affectés par les murs épais et les voitures.

Cela a fonctionné pour moi. Pas besoin de modifier quoi que ce soit !!!

Dans mon cas, supprimer maximumAge a résolu le problème.

Merci beaucoup! Travail!

Salut,
Aucune des solutions ne fonctionne pour moi.
J'utilise navigator.geolocation, en utilisant uniquement {enableHighAccuracy: false} comme troisième paramètre.
Sous iOS, cela fonctionne bien et sous Android, cela ne fonctionne pas sur certains appareils.
J'ai vérifié dans Android 7, 8, 9. Il ne fonctionne pas dans les téléphones Lenovo avec Android 7. Mais fonctionne avec d'autres appareils avec Android 7.

Quelqu'un a-t-il une solution de contournement pour résoudre ce problème.
Toute suggestion est appréciable.

Merci

@akhilsanker peut peut-être essayer une bibliothèque comme -native-fused-location

Salut @reyalpsirc ,

Merci pour la réponse. Vraiment apprécier pour votre temps.
Il n'y a pas de problème sous iOS et fonctionne correctement dans la plupart des appareils Android. J'ai peu de temps et il sera difficile d'utiliser une nouvelle bibliothèque, comme vous l'avez suggéré.
Avez-vous une autre solution de contournement pour résoudre ce problème?
Merci pour votre temps.

Je vous remercie.

Désolé @akhilsanker , tout ce que j'ai fait était d'utiliser la géolocalisation de react native pour iOS et FusedLocation pour Android.

le réglage maximumAge:0 fonctionné pour moi:
{ enableHighAccuracy: true, timeout: 60000, maximumAge:0 }
peut-être que @GersonM a raison ...

Le module de géolocalisation est supprimé de RN en maître et ne sera pas disponible dans la version 0.60. Veuillez utiliser https://github.com/react-native-community/react-native-geolocation et signaler les problèmes là-bas. Je vous remercie

Nous sommes en 2019, j'ai essayé 3 bibliothèques de localisation différentes, aucune d'entre elles ne fonctionne pour Android. Incroyable.

Nous sommes en 2019, j'ai essayé 3 bibliothèques de localisation différentes, aucune d'entre elles ne fonctionne pour Android. Incroyable.

react-native-geolocation-service fonctionne correctement.

Si un package ne fonctionne pas, créez un ticket de problème sur ce dépôt. Les problèmes ne se résoudront pas, rejoignez la communauté.

voir le commentaire <permission> __ et__ <uses-permission>

https://www.npmjs.com/package/react-native-geolocation-service
Ce package a résolu le problème pour moi.
Presque toutes les suggestions ci-dessus n'ont pas fonctionné pour moi.

Je vous remercie!