@ acapop77 Esqueci de mencionar também que as permissões são ativadas usando:

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

Tenho o mesmo problema no RN 0.25.1, a diferença é, para mim o problema persiste para alta e baixa precisão. Finalmente encontrei algo que faz funcionar, mas não é uma solução.

Aqui está o que funcionou para mim - supondo que você use stock android avd - emulator:

1. No dispositivo do emulador Android, vá para "Configurações> Localização" (como você faria no dispositivo real) e defina o Modo como Alta precisão.
2. Volte para o aplicativo.
3. Pressione o botão "Controles estendidos" (representado por "..."). Em seguida, na seção Localização, você verá os dados do ponto de dados GPS e o botão "Enviar" abaixo. Basta clicar em "Enviar" e fechar o menu de controles estendidos.
4. Recarregue o aplicativo.

Isso funciona para mim - em 'base única'. Cada vez que eu quiser recarregar o aplicativo, preciso fazer 3-4 etapas novamente. Mas pelo menos assim consigo fazer o Geolocation funcionar e não obtenho erro de tempo limite.

Estou experimentando algo semelhante no 0.24. Mesmo que <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" /> esteja em meu AndroidManifest.xml, recebo o erro em vermelho informando:

"Parece que o aplicativo não tem permissão para acessar a localização. Adicione a seguinte linha ..."

Não estou usando o emulador, mas sim compilando diretamente no dispositivo.

Editar - isso também acontece no 0.25.1

@ acapop77 @rossthedevigner Também estou construindo diretamente para um dispositivo Samsung S6.

@Findiglay O mesmo aqui. Eu até tentei fazer uma instalação manual do .apk e ainda recebi o erro.

Estou tentando uma solução alternativa em que percorro o manifesto de permissões e vejo se android.permission.ACCESS_FINE_LOCATION está habilitado.

Alguém tendo navigator.geolocation == undefined?

No momento, estou tendo esse problema no meu dispositivo.

Existem vários problemas sendo relatados aqui. Não tenho certeza se todos são relevantes para o problema específico com enableHighAccuracy.

Não tenho nenhuma experiência com desenvolvimento de Android, mas descobri que se eu editar LocationModule.java para codificar o LocationOptions boolean highAccuracy = true; e reconstruir, então meu local retornará corretamente. Não tenho certeza se os resultados são ou não diferentes daqueles recebidos com a configuração enableHighAccuracy: false na API de geolocalização React-Native, mas deve ser seguro assumir que está operando no modo de alta precisão.

Isso poderia significar que o bug está acontecendo na ponte entre a API de geolocalização e o LocationModule?

Eu estou passando pelo mesmo problema. Fiz o mesmo que @Findiglay sugeriu e trabalhei algumas vezes, mas depois obtive apenas tempos limite.

Alguma ideia de por que isso acontece em dispositivos reais? :(

Tendo o mesmo problema. Atualmente estou executando o aplicativo em dispositivos reais, usando RN 0.25.1.

Devo acrescentar que já adicionei as permissões necessárias do Android ao manifesto de permissões. Mas ainda assim o tempo limite.

como solução alternativa, habilitei 'Permitir locais fictícios' nas configurações do Android e instalei um aplicativo que simula o GPS (procure por GPS falso na loja). Pelo menos até que isso seja corrigido, o desenvolvimento não é bloqueado

Eu pessoal,
Estava enfrentando o mesmo erro mas, após algumas tentativas com meus colegas, notamos algo estranho (mas normal se você pensa em GPS).

Se você executar testes "dentro do seu escritório" usando um dispositivo físico, o localizador GPS pode ser perturbado por coisas externas como paredes, ou pelo simples motivo de que você está tentando fazer esta operação "interna" e, geralmente, deve ser executada ao ar livre .

Bem, depois disso saímos de nosso escritório, reexecutamos os testes e o dispositivo responde conforme planejado (não recebemos o erro de tempo limite de solicitação).

Minha sugestão é: tente geolocalização usando "enableHighAccuracy" definido como true, se falhar (no escritório isso pode falhar), tente novamente com false, isso deve funcionar, no meu caso funcionou.

Espero que isso possa ajudar.

+1

O mesmo problema aqui se enableHighAccuracy está definido como true ou false .
Ele funciona em emuladores GenyMotion, mas não em qualquer dispositivo real (testado em Samsung, Nexus, Mi).
Permissão ativada em AndroidManifest.xml
Código:

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

definir enableHighAccuracy como true ou false não funciona para mim.
omitir o terceiro argumento para getCurrentPosition para usar os valores padrão do módulo nativo funciona para mim.

O mesmo problema aqui com LGE Nexus 5 (Android 6.0).
No Android 5.1.1 e 4.3 não existe esse problema.
No emulador com Android 6.0 não existe esse problema.
boolean highAccuracy = false; não funciona.
RN 0.28.0.

Olá pessoal, encontrei uma correção temporária - este pacote https://github.com/lucasferreira/react-native-android-permissions

Alguma atualização ou correção para isso? Tudo funciona bem no Simulador e dispositivos anteriores ao 5.0, depois disso apenas o tempo limite, e eu preciso desesperadamente de uma correção para um aplicativo já disponível!

+1

Esse problema é afetado pela configuração de locationMode no dispositivo. Quando o modo de localização é definido para alta precisão ou somente dispositivo, o tempo de geolocalização se esgota. Funciona corretamente quando o modo de localização está configurado para economizar bateria

Eu tive o mesmo problema, peguei um punt e retirei o terceiro argumento. E agora está funcionando.

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

Presumo que esteja relacionado a: https://productpains.com/post/react-native/add-android-m-permissions-model-support

direito?

Não, isso foi devido ao problema de tempo limite de localização

Sim, acabei de descobrir que remover o terceiro argumento parece ser uma solução.

Ainda não testamos totalmente o dispositivo, mas parece que a versão 22 do Android, com o modo de dispositivo definido para alta precisão ou somente dispositivo, fará com que o local atinja o tempo limite, quando o terceiro argumento for incluído, independentemente das configurações. Parece não afetar a versão 23 do Android.

A mesma experiência do meu lado, exceto que a versão 23 do Android só funciona com o terceiro argumento quando enableHighAccuracy está definido como false ( true faz com que a localização expire). Também testado na versão 22, 21, 20 e 19 do Android e parece que a presença do 3º argumento causa um tempo limite em todos os casos. Remover esse argumento parece ser a única solução confiável.

Remover o terceiro argumento apenas me faz ter o pop-up de "O tempo limite da solicitação expirou" instantaneamente em vez de esperar até que o tempo limite seja concluído. Definir enableHighAccuracy como falso também não funciona.

No meu emulador, o local está disponível apenas quando eu abro as configurações do emulador e envio um local (verifique a imagem).

Existe uma maneira de obtê-lo automaticamente?

No meu caso, definir enableHighAccuracy como false resolveu o problema.

Tendo o mesmo problema aqui, tanto no emulador quanto no dispositivo, e tentei com true e false para enableHighAccuracy

Acabei de receber "undefined não é um objeto (avaliando 'navigator.geolocation.getCurrentPosition')"

Tentei verificar se (navegador), retornou verdadeiro,
mas se (navigator.geolocation) retornasse falso.

Além disso, fazer isso no dispositivo Android 5.1 OnePlus One. Modo de desenvolvedor habilitado, permissões AndroidManifest incluídas, locais fictícios ativado / desativado, tudo.

além disso, não parecia me pedir permissões de localização, apesar de eu ter excluído o aplicativo no dispositivo e a pasta de saída no meu mac.

Também não posso depurar remotamente porque estou usando React Realm e essa coisa tem ENORMES problemas que estragam o depurador remoto do Chrome de dentro para fora.

Eu tenho um problema semelhante, talvez o aplicativo nem sempre expire, mas ele faz isso muito, quando outros aplicativos de geolocalização funcionam bem sempre que aquele com RN tem geolocalização muito pobre.
Estou usando RN 0,32, mas tive o mesmo problema com todas as versões, por algum motivo geolocalização no RN é muito estranho e ruim (pelo menos no Android)

O mesmo problema aqui, testando em um dispositivo real.

Encontrar isso e isso é realmente irritante: /

Estou tendo o mesmo problema no Android 6.0.

+1

Eu encontrei uma solução para não adicionar um terceiro parâmetro, e usar a biblioteca vinculada acima (https://github.com/lucasferreira/react-native-android-permissions) na versão do Android> = 23 para solicitar permissões M do Android.

PermissõesAndroid apenas manchadas agora foi adicionado ao RN. Portanto, use para solicitar se no Android> = 23

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

Mas eu tenho Android 5.1.1 no meu dispositivo. Neste v. De android, a geolocalização deve funcionar bem, não?

23 é 6.0 em diante. Também descobri que precisava não adicionar o terceiro parâmetro para que funcionasse em tudo.

Consegui fazer funcionar, mas pode ser diferente para você. As versões mais recentes do RN (o meu é 0.32.1) incluem um arquivo chamado MainApplication.java (além de MainActivity.java). O React Native Mapbox GL Docs diz que você deve incluir o ReactNativeMapboxGLPackage em MainActivity.java, mas você deve fazer isso em MainApplication.java para que se pareça com isto:

MainApplication.java

`. . .

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

};
`

E MainActivity.java permaneceria o mesmo de sempre.

Minha versão do Android é 23, então ainda estou usando as permissões do manifesto xml

Com o GPS ativado no dispositivo, o aplicativo retorna a localização corretamente, mas se eu desligá-lo, retorna a localização: error: No available location provider.

Como posso forçar o dispositivo a ativar a localização GPS?

Isso é enlouquecedor = /

Eu tinha getCurrentPosition trabalhando em meu emulador Genymotion Android nas últimas semanas, mas agora ele está falhando novamente.

Estou usando o widget GPS do Genymotion para definir a localização. Eu instalei o Google Maps no emulador e o Google Maps pode ler minha localização muito bem.

Tenho todas as permissões necessárias e até mesmo estou usando o módulo PermissionsAndroid como @sattaman sugeriu. Parece que o comportamento é não determinístico, pois funciona um dia e é quebrado no outro.

Estou no RN 0,31 e remover o terceiro parâmetro funcionou para mim também! Dispositivo real, Nexus 5X, Android 6.

Tenho o mesmo problema no RN 0.34.1, mas remover o terceiro parâmetro pode corrigi-lo
Definir enableHighAccuracy como false não resolve este problema

O mesmo problema comigo em RN 0,32, tentei com Android 22 e 23,

enableHighAccuracy para true ou false, não funciona para mim
remover o terceiro parâmetro causa "tempo limite de solicitação de localização" imediato
no entanto, reiniciar meu dispositivo funciona, mas será interrompido depois de algum tempo,

agora, para obter a localização dos usuários, eu apenas uso isto:
https://github.com/mauron85/react-native-background-geolocation

@acondense onde você define o código para geolocalização em segundo plano, porque não parece estar executando a função de localização

Encontrei o mesmo problema no RN 0,35 com Android 23 e 24, porém funciona bem com Android 22.
Pode estar relacionado ao sistema de permissão de tempo de execução do Android 6.0:
http://stackoverflow.com/questions/32224534/access-fine-location-permission-error-emulator-only

Eu uso esta biblioteca para evitar este problema e funciona bem!
https://github.com/yonahforst/react-native-permissions

Remover o terceiro parâmetro também corrigiu para mim 💯 💯 💯

Removendo o terceiro parâmetro funcionou 👍

Não ficou tão claro desde o início qual parâmetro todos estavam falando, o parâmetro do método ou o terceiro parâmetro do objeto options.

Para ser preciso, é o terceiro parâmetro do método getCurrentPosition , que se parece com isso no final:

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

Finalmente, eu vim com a seguinte solução (a mesma ideia descrita acima):

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

Funciona em dispositivos (testados no Android 21, 22 e 23), mas no Android 23 é extremamente lento: 5 a 10 segundos.

Alguém usou LocationServices.FusedLocationApi como uma solução alternativa para essa finalidade em react-native (implementando nativamente, em código Java para Android)?

enableHighAccuracy: true não funcionam no Android de forma alguma

Estou usando este código para verificar a permissão de localização no 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 Isso evita o erro Location request timed out ?

use meu snippet e este também https://github.com/facebook/react-native/issues/7495#issuecomment -259753488

Ainda não há solução para isso? Eu tentei absolutamente tudo neste tópico e nada funciona para mim, é sempre um erro de tempo limite, seja instantaneamente ou após alguns segundos.

O mesmo aqui, o comentário de @sattaman corrigiu para o meu dispositivo (configurando o modo de localização para economia de bateria), porém como dizer aos usuários do aplicativo para fazer tal coisa!

Desativar enableHighAccuracy ou omitir o terceiro parâmetro funciona para mim. A localização ainda parece bastante precisa, no entanto.
Sem problemas no iOS. (RN 0,39)

RN 0,40 mesmo problema. Remover o terceiro parâmetro resolve isso.
(Mas você não obtém alta precisão)

mesmo problema, removendo o terceiro parâmetro resolvê-lo.

Em um emulador, tenho que definir enableHighAccuracy: true e garantir que o modo de localização esteja definido como Alta precisão. Caso contrário, o tempo limite será atingido. Não consigo fazer com que a economia de bateria de um emulador funcione em nenhuma circunstância.

Em um dispositivo, não passo nenhuma opção. Se você está lutando com isso como eu - sugiro tentar em dispositivos reais. Testei em um Pixel C (Android 7.1) e Note 4 (Android 6.0.1)

No iOS, tive que definir Alta precisão como Verdadeiro. Você pode imaginar minha função de obtenção de localização neste ponto ...

Estou trabalhando no RN 0.40 e usando um dispositivo real (Nexus 5) e ainda estou com o problema.

Tentei tudo de todos os comentários nesta edição.

Alguém resolveu o problema de alguma outra forma, não mencionada aqui?

// ATUALIZAÇÃO:

Parece que navigator.geolocation.watchPosition funciona. Portanto, usá-lo pode ser a solução alternativa até que navigator.geolocation.getCurrentPosition seja corrigido.

Por enquanto, vou escrever um módulo nativo e falar diretamente com APIs nativas, porque usar alta precisão é importante para mim.
A API de geolocalização da RN parece instável por enquanto.

No meu projeto, descobri algumas regras.

1. a configuração do dispositivo Android - a localização é apenas do dispositivo, você NÃO deve definir enableHighAccuracy: true para getCurrentPosition
2. a configuração - a localização é de alta precisão, você deve definir enableHighAccuracy: true para getCurrentPosition

De acordo com essas duas regras, as coisas funcionam bem no meu projeto

@kimochg qual é a sua configuração de teste?

Em meus testes, definir a configuração do dispositivo para Local para dispositivo apenas resultará em um timeOut todas as vezes, independentemente de qual localização enableHighAccuracy seja.

Definir a configuração do dispositivo como Alta precisão me dará um local válido, independentemente de como enableHighAccuracy está definido.

EDITAR
Parece que, para mim, a geolocalização só buscará um novo local se eu definir enableHighAccuracy: false e a configuração de localização do dispositivo como Alta precisão. Com enableHighAccuracy: true ele irá buscar um local em cache, mas uma nova busca atingirá o tempo limite.

Este é o React Native 0.40, testando no Nexus 5X com Android 7.1.1

@kulmajaba some as you React Native 0.40, testando no Nexus 5X rodando Android 7.1.1
mas o emulador de Android aqui, não um dispositivo Android real

se você estiver usando emulador,
você clica no botão 'Controles estendidos' na barra direita do emulador e envia dados GPS?
(o botão)

@kimochg Ok. Estou usando um dispositivo real para teste, precisarei comparar o comportamento do emulador com aquele na próxima vez que trabalhar no projeto.

@Ascendance @ Daniel-ltw Segui todas as soluções neste tópico e não consegui evitar os temidos problemas indefinidos do navigator.geolocation. Então eu loguei navigator .

Aqui está o que recebi de volta:

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

Então percebi que isso vinha do componente Navigator. Ele usa (route, navigator) ao renderizar rotas. Com certeza, remover a variável do navegador e registrar novamente resultou:

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

Espero que isso ajude outra pessoa. Levei muito tempo para perceber qual era o problema. : /

@kulmajaba o maximumAge corrigiu quaisquer problemas de cache para mim. Definir como 0 o forçará a sempre obter uma nova posição.

Para qualquer pessoa que esteja lutando com o problema de tempo limite, li que às vezes chamadas de GPS de alta precisão podem demorar um pouco (mais de um minuto), especialmente em ambientes fechados - como @RoBYCoNTe apontou acima.

Contar com uma chamada de alta precisão desde o início pode não ser o melhor, talvez obter uma de baixa precisão primeiro e iniciar uma chamada de alta precisão em segundo plano seria uma abordagem melhor. Isso depende das suas necessidades, claro, esperar um minuto + por uma chamada não é para todos :)

Além disso, considerando que a RN estende a especificação da web para geolocalização, você pode encontrar respostas relacionadas a ela na web, como o apropriadamente chamado http://stackoverflow.com/questions/3752383/geolocation-is-so-slow-what-im- fazendo errado

Alguém tem uma solução sólida? Alguns usuários nem conseguem se registrar no meu aplicativo devido a parte do registro que exige que eles definam sua geolocalização. O problema está acontecendo apenas em alguns dispositivos Android e não estou usando o terceiro parâmetro. Me deixando louco. As pessoas dão automaticamente avaliações de 1 estrela ao meu aplicativo porque não conseguem definir a geolocalização, hahaha. >.>

@booboothefool tente usar o parâmetro options e passar highAccuracy como
falso. Os resultados são muito mais rápidos dessa forma.

Na segunda-feira, 20 de fevereiro de 2017, 9h50 booboothefool [email protected]
escrevi:

Alguém tem uma solução sólida? Alguns usuários não podem nem mesmo se registrar para o meu
aplicativo devido a parte do registro que exige que eles definam sua geolocalização.
O problema está acontecendo apenas em alguns dispositivos Android, e não estou
usando o terceiro parâmetro. Me deixando louco.

-
Você está recebendo isso porque comentou.
Responda a este e-mail diretamente, visualize-o no GitHub
https://github.com/facebook/react-native/issues/7495#issuecomment-281142941 ,
ou silenciar o tópico
https://github.com/notifications/unsubscribe-auth/ADJE_BC-osVA45bcpejEI_paDEBykBs1ks5redJtgaJpZM4Ibete
.

@greyvugrin Ok, vou tentar. Por que metade das pessoas está relatando que "você precisa remover o terceiro parâmetro, apenas definir para enableHighAccuracy como false não funciona"? Parece que todo mundo está dizendo algo diferente.

Também com base nisso: https://developer.mozilla.org/en-US/docs/Web/API/PositionOptions

Parece que essas são as opções padrão. enableHighAccuracy: false com timeout: Infinity , então já não deveria estar fazendo isso se eu não fornecer o terceiro parâmetro?

@booboothefool você está certo sobre este tópico ser confuso. Pelo que posso dizer, as pessoas que estão omitindo o parâmetro de opções podem ter resolvido o problema porque algo mais nas configurações estava afetando as coisas.

definir enableHighAccuracy para true ou false não funciona para mim.
omitir o terceiro argumento para getCurrentPosition para usar os valores padrão do módulo nativo funciona para mim.

Portanto, o problema pode ter sido timeout . Existem muitos fatores relacionados à geolocalização, e obter o máximo de informações possível das pessoas que estão travando ajudará.

Se você já teve as opções removidas e o RN de fato assume os mesmos parâmetros da web, as coisas devem estar funcionando bem. Se você ainda estiver tendo problemas, talvez veja se os usuários têm permissões habilitadas para localização (e você está verificando isso em seu aplicativo).

Ei @greyvugrin ,

Obrigado pela grande dica sobre as permissões. Acho que é isso que estava faltando. Depois de implementar https://github.com/lucasferreira/react-native-android-permissions (eu prefiro esta API em vez de https://facebook.github.io/react-native/docs/permissionsandroid.html), junto com a especificação de enableHighAccuracy: false , e definindo timeout , parece funcionar para todos agora.

Meu aplicativo passou de 1 estrela na Google Play Store, com todos destruindo-o por questões de geolocalização, para 3,6 estrelas, hahaha! 👍

@booboothefool que notícia ótima, fico feliz em saber disso !!!

Tentei todas as abordagens sugeridas aqui. Não é possível obter nada de getCurrentPosition, mas tempos limite no simulador ou dispositivo no Android. watchPosition funciona, mas realmente não oferece a melhor experiência do usuário para o usuário, eu só preciso da localização do usuário uma vez, não há necessidade de manter o GPS ligado, desperdiçando bateria.

Eu tentei:

• enableHighAccuracy: false
• removendo o argumento de opções
• verificando e pedindo permissão android> = 23
• FINE e GROSSO no manifesto.

Nenhum altera os tempos limite de getCurrentPosition

Isso é apenas algo que os desenvolvedores do Android Studio Emulator terão que consertar / implementar no futuro, quando tiverem uma chance.

No entanto, enquanto isso ... Você pode importar um grande arquivo de trilha GPX e deixá-lo reproduzir na velocidade "1x". Peguei um GPX daqui ... ExpertGPS.com -> ca-trail.gpx
... este arquivo durou cerca de 8 minutos na velocidade "5x", então na velocidade "1x" ele DEVE durar cerca de 40 minutos.

Carregue-o (ou outro arquivo GPX possivelmente maior) nas [...] Opções estendidas-> Localização (botão Carregar GPS / KML no canto inferior direito), aperte o botão reproduzir e feche a janela ... ele continuará reproduzindo até chegar ao fim. Pena que não há repetição automática - outra solicitação de recurso para programadores do Android Studio. :-)

Isso não é verdade. Estou obtendo os mesmos tempos limite em dispositivos reais.
getCurrentPosition sempre atinge o tempo limite. O relógio funciona bem. Testando Z5, Nexus 5X
& Pixel, Tempo limite total na chamada inicial para getCurrentPosition.

No sábado, 4 de março de 2017, 19:49, Deen Foxx, [email protected] escreveu:

Isso é algo que os desenvolvedores do Android Studio Emulator irão
precisam consertar / implementar no futuro, quando tiverem uma chance.

No entanto, enquanto isso ... Você pode importar um grande arquivo de trilha GPX e deixar
ele reproduz na velocidade "1x". Peguei um GPX daqui ... ExpertGPS.com ->
ca-trilhas.gpx
https://www.expertgps.com/data/downloading.asp?file=ca/ca-trails.gpx
... este arquivo durou cerca de 8 minutos na velocidade "5x", então na velocidade "1x" ele
DEVE durar cerca de 40 minutos.

Carregue-o (ou outro arquivo GPX possivelmente maior) no [...] Extended
Opções-> Localização (botão Carregar GPS / KML no canto inferior direito), acesse o jogo
botão e, em seguida, feche a janela ... ele continuará tocando até atingir o
fim. Que pena que não há repetição automática - outra solicitação de recurso para Android
Programadores de estúdio. :-)

-
Você está recebendo isso porque comentou.
Responda a este e-mail diretamente, visualize-o no GitHub
https://github.com/facebook/react-native/issues/7495#issuecomment-284172310 ,
ou silenciar o tópico
https://github.com/notifications/unsubscribe-auth/AACQ6AoZYXJ02DCmevcLmmF3tuOdg_SEks5ribJHgaJpZM4Ibete
.

Remover o terceiro parâmetro para getCurrentLocation funcionou para mim no emulador.

{
   timeout: 20000,
    maximumAge: 1000
}

Acabei de codificar uma possibilidade de três passagens. Talvez um pouco exagerado, mas tudo bem. Aqui está o snippet de código (com comentários) ...

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;

Eu só testei isso em emuladores de desenvolvedores locais, não em produção. Deixe-me saber se isso foi útil para você.

Eu estava pensando ... provavelmente funcionaria perfeitamente como um passe duplo se sua chamada de roughError apenas usasse a versão sem opções ...

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

Isso faria com que os telefones Android com problemas não tivessem mais atrasos, mas ainda tentassem a alta precisão. Então você não precisaria mais do FineError, esse código pode ser removido.

• Sim, eu sei que há uma pequena possibilidade de a tentativa "enableHighAccuracy: true" retornar antes dos outros resultados "brutos" assíncronos (especialmente se o tempo limite for Infinity) e, portanto, ser perdida / sobrescrita ... mas eu duvido. Se você realmente deseja ser tão cauteloso, pode alterar o código para testar esse caso específico.

Algum progresso nisso?

Alex, existem algumas soluções neste tópico. O que você tentou? isto
também pode valer a pena criar um novo tíquete, uma vez que você tenha mais detalhes desde
este tópico é tão longo, se nenhuma das soluções acima funcionar.

Na sexta-feira, 17 de março de 2017, 10:29 Alex Sinelnikov [email protected]
escrevi:

Algum progresso nisso?

-
Você está recebendo isso porque foi mencionado.
Responda a este e-mail diretamente, visualize-o no GitHub
https://github.com/facebook/react-native/issues/7495#issuecomment-287419487 ,
ou silenciar o tópico
https://github.com/notifications/unsubscribe-auth/ADJE_HLDGQEplAduqm3Zx5L74dv99mnhks5rmsLjgaJpZM4Ibete
.

Gosto de voce. Nenhuma das sugestões acima funciona. A única solução para mim
obter uma localização no Android era usar um relógio e atualizar a IU para informar
o usuário o que está acontecendo se as funções do seu aplicativo responderem no local. Não
incomodar com getCurrentPosition, ele não funciona em nenhum dos 10 testes reais
dispositivos que executam várias versões do Android 4+

Na sexta-feira, 17 de março de 2017, 17:48 Gray Vugrin, [email protected] escreveu:

Alex, existem algumas soluções neste tópico. O que você tentou? isto
também pode valer a pena criar um novo tíquete, uma vez que você tenha mais detalhes desde
este tópico é tão longo, se nenhuma das soluções acima funcionar.

Na sexta-feira, 17 de março de 2017, 10:29 Alex Sinelnikov [email protected]
escrevi:

Algum progresso nisso?

-
Você está recebendo isso porque foi mencionado.
Responda a este e-mail diretamente, visualize-o no GitHub
<
https://github.com/facebook/react-native/issues/7495#issuecomment -287419487
,
ou silenciar o tópico
<
https://github.com/notifications/unsubscribe-auth/ADJE_HLDGQEplAduqm3Zx5L74dv99mnhks5rmsLjgaJpZM4Ibete

.

-
Você está recebendo isso porque comentou.
Responda a este e-mail diretamente, visualize-o no GitHub
https://github.com/facebook/react-native/issues/7495#issuecomment-287424598 ,
ou silenciar o tópico
https://github.com/notifications/unsubscribe-auth/AACQ6DgWuUzw4hj7rmr8LDzcRHjEheIcks5rmsdSgaJpZM4Ibete
.

Às vezes funciona, outras não. Tentei TODAS as soluções acima e nenhuma solução confiável até agora. Isso realmente me deixa louco :(

Existe algum módulo nativo que replica a função como getCurrentPosition? Estou procurando outro repo porque não consigo escrever código java.

watchPosition tem um problema quando a localização não está habilitada. Nunca lança o tempo limite, embora eu defina o tempo limite = 1000

Em 'getCurrentPosition', o tempo limite será atingido, então posso acionar a caixa de diálogo Localização para habilitar o GPS. Mas agora eu mudo de 'getCurrentPosition'

EDITAR:
Eu tentei todas as variações e agora sei onde está o problema. Posso fazê-lo funcionar se remover o terceiro parâmetro E definir o modo de localização para Alta precisão ou Economia de bateria. Caso contrário, não está funcionando. Não sei como dizer ao usuário para escolher High Accuracy ou Battery Saving em vez de Device Only, porque tem uma maneira diferente de acessar este menu para cada fornecedor.

Há um comentário acima para adicionar enableHighAccuracy: false em terceiros parâmetros, mas não funcionou para as opções Alta precisão, Economia de bateria ou Somente dispositivo. Acho que o terceiro parâmetro na geolocalização é inútil para um dispositivo real.

No meu caso, remover o maximumAge resolveu o problema.

Remover o maximumAge funciona, mas esta é uma solução temporária. Funcionou bem na maioria dos casos, mas teve alguns problemas na produção em que, em um mapa, a localização atual do usuário estaria completamente errada devido ao uso de coordenadas obsoletas. Em vez disso, mudou para uma implementação nativa.

@nigelnindo, o que você quer dizer com implementação nativa? dentro da RN ou fazendo isso diretamente no Android?

@ L3V147H4N diretamente no Android. Existem algumas bibliotecas que você pode usar para isso, mas eu vi que a maioria não é compatível com as versões mais recentes do RN. Se houver interesse suficiente nisso, não me importo de gastar algum tempo criando um módulo simples para ajudar a resolver os problemas de geolocalização no Android descritos neste tópico.

Talvez você possa verificar https://github.com/mauron85/react-native-background-geolocation#getlocationssuccess -fail

É uma implementação nativa e está funcionando bem para mim.

Acho que quase todos neste tópico ficariam muito gratos @nigelnindo
https://github.com/nigelnindo

Na segunda-feira, 3 de abril de 2017 às 17:34, Nigel Nindo [email protected] escreveu:

@ L3V147H4N https://github.com/L3V147H4N diretamente no Android. tem
algumas bibliotecas que você pode usar para isso, mas já vi que a maioria
não são compatíveis com as versões mais recentes do RN. Se houver o suficiente
interesse nisso, não me importo em gastar algum tempo criando um módulo simples
para ajudar a resolver os problemas de geolocalização no Android descritos neste tópico.

-
Você está recebendo isso porque comentou.
Responda a este e-mail diretamente, visualize-o no GitHub
https://github.com/facebook/react-native/issues/7495#issuecomment-291198134 ,
ou silenciar o tópico
https://github.com/notifications/unsubscribe-auth/AACQ6BwArzmfCk3TXfiRMp7kpdwMLM81ks5rsR-hgaJpZM4Ibete
.

A frustração ... Estou tentando usar navigator.geolocation.getCurrentPosition, mas continuo recebendo o erro:
A solicitação de local expirou. Para Android, o iOS funciona bem.
Tentei definir enableHighAccuracy como True / False, removendo o terceiro argumento, adicionei as permissões de localização COURSE e FINE no AndroidManifest.

Android SDK 23, Build tools 25.0.0
React 16.0.0-alpha.6
RN 0.43.3

Obrigado pela ajuda!

Bem-vindo ao tópico Douglas, infelizmente getCurrentPosition não é
confiável no Android, como você descobriu.
Dê uma olhada em algumas das soluções anteriores no tópico usando
watchPosition vez disso

Obrigado @raldred.
watchPosition parece estar funcionando, agradeço a ajuda!

@douglaswissett de nada. Esperançosamente, haverá uma solução robusta para getCurrentPosition breve.

Posso usar watchPosition e clearWatch imediatamente após obter a posição geográfica? Tenho problemas para fazer isso, porque clearWatch só pode ser chamado em componentDidMount

@pewh sim. Isto é o que eu faço.
Além disso, navigator.geolocation.clearWatch pode ser chamado a qualquer momento.
Basta manter uma referência ao watchID em seu componente que é retornado pelo chamado para watchPosition

Dos documentos que li em https://facebook.github.io/react-native/docs/geolocation.html , não tenho ideia de como obter this.watchID dentro de watchPosition callback. Meu caso de uso é acionar clearWatch imediatamente após receber o novo valor.

@pewh aqui está minha implementação. Não é perfeito, mas funciona.
https://gist.github.com/raldred/b08cf60712eb87d81f05437444dff4ae

@raldred tentou a sua solução e a de todo mundo, nada funcionou

Alguma solução sobre isso? tente tudo aqui e nada parece funcionar, por favor me ajude! se você pode compartilhar alguns trechos ou algo

@ gerard0315 você obteve algum sucesso ao resolver isso?

Parece funcionar em um telefone Android real para mim

Obtenha o Outlook para iOS https://aka.ms/o0ukef

De: Jorge Almonacid [email protected]
Enviado: terça-feira, 9 de maio de 2017 14h29:56
Para: facebook / react-native
Cc: Ujwal Setlur; Comente
Assunto: Re: [facebook / react-native] A geolocalização 'enableHighAccuracy' no Android sempre atinge o tempo limite (# 7495)

Alguma solução sobre isso? tente tudo aqui e nada parece funcionar, por favor me ajude! se você pode compartilhar alguns trechos ou algo

-
Você está recebendo isso porque comentou.
Responda a este e-mail diretamente, visualize-o no GitHub https://github.com/facebook/react-native/issues/7495#issuecomment-300307037 ou ignore o tópico https://github.com/notifications/unsubscribe-auth/ AFkMXWcokXoYDpsw28UaiUSDtCvRpE3Rks5r4NrUgaJpZM4Ibete .

Já compartilhei meus trechos que funcionam em dispositivos reais rodando
Android 4-7.

Na terça-feira, 9 de maio de 2017, 22:29 Jorge Almonacid, [email protected] escreveu:

Alguma solução sobre isso? tente tudo aqui e nada parece funcionar,
por favor ajude! se você pode compartilhar alguns trechos ou algo

-
Você está recebendo isso porque foi mencionado.
Responda a este e-mail diretamente, visualize-o no GitHub
https://github.com/facebook/react-native/issues/7495#issuecomment-300307037 ,
ou silenciar o tópico
https://github.com/notifications/unsubscribe-auth/AACQ6HSlN8YS_jE6NY9w2vuk7Hv4Wjwfks5r4NrSgaJpZM4Ibete
.

Atualmente é possível obter atualização (no emulador do Android) apenas se você alterar todos os parâmetros (Longitude, Latitude, Altitude) ao mesmo tempo. Se você alterar apenas um ou dois - nothing works .

Há uma falha inata na maneira como o React-Native lida com a localização no Android. (iOS parece não ter esse problema, 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

enquanto

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

Na realidade, você precisa de ambos / todos os provedores se quiser uma localização superprecisa. Em seguida, você deseja comparar a precisão, o carimbo de data / hora e aceitar a localização mais precisa e atual.

Existem duas maneiras de fazer isso:

Em reação:

Configure duas variáveis watchID -> watchIDGPS e watchIDNetwork . Em seguida, configure dois observadores, um com enableHighAccuracy=true e enableHighAccuracy=false Isso retornará o provedor de GPS e o provedor de rede (a rede será mais precisa em ambientes fechados)

O problema com a maneira React é que ela está fazendo isso no encadeamento JS; Isso pode congelar seu aplicativo em dispositivos com poucos recursos. No entanto, funciona.

Em nativo:

Você vai querer reescrever LocationModule.java como um módulo personalizado para lidar com provedores de sua escolha e relatar a localização de volta para mLocationListener independentemente de qual provedor seja. Até que o React-Native resolva esse "problema".

@ralred , Obrigado pelo snippet, mas qual é o objeto AndroidPermissions ?

Tentei todas as soluções, todas falharam ....
de repente lembrei que meu aplicativo tem um módulo de mapa, o mapa baidu, um mapa chinês (map.baidu.com) como o google map, ele pode obter marcadores e localização atual !!! Finalmente consegui ~

você pode pesquisar por github, react-native-baidu-map

import {
MapView, // a visualização do mapa (não preciso)
MapTypes, // digite como 2D ou 3D (não preciso)
Geolocalização // api sobre localização (preciso)
} de 'react-native-baidu-map';

componentDidMount () {
Geolocation.getCurrentPosition ()
.então (dados => {
Alert.alert (JSON.stringify (data.latitude), JSON.stringify (data.longitude))
})
}

Não sei se pode funcionar em outro país, apenas pensando usando alguns aplicativos de mapas, você pode tentar react-native-maps ou outros mapas ...

Nada funciona, watchPosition nem será chamado no Android, iOS funciona perfeitamente. Já é RN v0.45.0 (estou atualmente em 0.44.0) e ainda não está resolvido? Vamos!

@rexlow
Nada funciona tão bem, estou usando a versão 0.44. você tentou atualizar para v0.45?

@VietDucPhan Acabou de funcionar, totalmente aleatório 😓. Ainda em 0.44.0

@rexlow Oh bom para você. Agora, só preciso da sorte para me atingir.

Você já tentou apenas remover a estrutura de opções? Essa é a única coisa que funcionou para mim.

Obtenha o Outlook para iOS https://aka.ms/o0ukef

De: viet_duc_phan notificaçõ[email protected]
Enviado: Domingo, 18 de junho de 2017 23:26:15
Para: facebook / react-native
Cc: Ujwal Setlur; Comente
Assunto: Re: [facebook / react-native] A geolocalização 'enableHighAccuracy' no Android sempre atinge o tempo limite (# 7495)

@rexlow https://github.com/rexlow Que bom para você. Agora, só preciso da sorte para me atingir.

-
Você está recebendo isso porque comentou.
Responda a este e-mail diretamente, visualize-o no GitHub https://github.com/facebook/react-native/issues/7495#issuecomment-309349488 ou ignore o tópico https://github.com/notifications/unsubscribe-auth/ AFkMXYI2vukJgcTLkBeNdXdclgFbgo1sks5sFhSHgaJpZM4Ibete .

@rexlow @ ujwal-setlur Só quero que vocês saibam que a sorte me atingiu. está funcionando e totalmente aleatório. Eu não mudei nada.

Você experimentou em um dispositivo real?

Em terça-feira, 20 de junho de 2017, 19:18 viet_duc_phan, notificaçõ[email protected] escreveu:

@rexlow https://github.com/rexlow @ ujwal-setlur
https://github.com/ujwal-setlur Só quero que vocês saibam disso
sorte bate em mim. está funcionando e totalmente aleatório. eu não mudei
qualquer coisa.

-
Você está recebendo isso porque foi mencionado.
Responda a este e-mail diretamente, visualize-o no GitHub
https://github.com/facebook/react-native/issues/7495#issuecomment-309843462 ,
ou silenciar o tópico
https://github.com/notifications/unsubscribe-auth/AACQ6OVyeCsOgd-qevP9CrP9XJMhwaxsks5sGAz3gaJpZM4Ibete
.

@raldred Sempre testado em dispositivos reais.

@VietDucPhan você pode configurar um exemplo que reproduza o problema?

Em terça-feira, 20 de junho de 2017, 20:52 viet_duc_phan, notificaçõ[email protected] escreveu:

@raldred https://github.com/raldred Sempre testado em dispositivos reais.

-
Você está recebendo isso porque foi mencionado.
Responda a este e-mail diretamente, visualize-o no GitHub
https://github.com/facebook/react-native/issues/7495#issuecomment-309870269 ,
ou silenciar o tópico
https://github.com/notifications/unsubscribe-auth/AACQ6N5SVbYeDEeY9FRnTQSrvpLwKL5aks5sGCLmgaJpZM4Ibete
.

@raldred o relatório original nesta cadeia tem um snippet de código:

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

Isso também falha para mim. A única maneira de resolver isso parece não incluir o argumento options:

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

@dreallday está certo, o API Fused, que combina as informações dos provedores com magia.

Achei o react-native-fused-location muito útil para fazer solicitações de localização no Android.

@raldred Olá, desculpe, não verifiquei o e-mail recentemente, mas não está funcionando novamente.

@ derman232 O react -native- colocado em segundo plano?

@rexlow, desculpe, não sei a resposta para isso, não é um recurso que preciso para meu aplicativo.

Estou apenas dando minha opinião sobre como resolvi esse problema:

• O problema é que android> = 6.0 requer que as permissões sejam concedidas durante o tempo de execução
• Esta questão stackoverflow tem mais detalhes: question
• Usei o módulo PermissionsAndroid do React Native para obter as permissões

Agora tudo funciona.

Oi,
Nada funciona. Eu tentei de tudo.
Por favor informar.
THX

Eu realmente gostaria de ajudar a resolver isso para as pessoas.
Temos 3 apps nativos react que usam localização ao vivo. Controle de qualidade em mais de 30 dispositivos Android reais executando o Gingerbread até o Nougat.
Todos funcionam bem durante os testes de usuário, desde então não recebemos relatórios de problemas de usuários ativos.

@adriancuco poderia compartilhar sua implementação e manifesto para que possamos tentar ajudar mais.

• Versão do RN?
• Com quais versões do Android você está tendo problemas?
• Com quais dispositivos você está tendo problemas?

Haverá uma complexidade com sua implementação ou configuração de dispositivo, é uma questão de descobrir o que é.

raldred,

Desculpa. Minha culpa!
Antes de me matar, decidi verificar as configurações de localização no meu telefone, como li alguns dias atrás, e estava apenas com o GPS habilitado. ; (
Então habilitei GPS, Wifi, etc e tudo e agora está funcionando bem.
Realmente aprecio isso.
Muito obrigado

Alguma atualização sobre este problema?

Ainda sem solução.

De: adriancuco [email protected]
Enviado: terça-feira, 4 de julho de 2017 14h44:28
Para: facebook / react-native
Cc: Marouen SAYARI; Comente
Assunto: Re: [facebook / react-native] A geolocalização 'enableHighAccuracy' no Android sempre atinge o tempo limite (# 7495)

raldred,

Desculpa. Minha culpa!
Antes de me matar, decidi verificar as configurações de localização no meu telefone, como li alguns dias atrás, e estava apenas com o GPS habilitado. ; (
Então habilitei GPS, Wifi, etc e tudo e agora está funcionando bem.
Realmente aprecio isso.
Muito obrigado

-
Você está recebendo isso porque comentou.
Responda a este e-mail diretamente, visualize-o no GitHub https://github.com/facebook/react-native/issues/7495#issuecomment-312881724 ou ignore o tópico https://github.com/notifications/unsubscribe-auth/ AD79YGcm507EtBxrFHHJkEc-OBvRsjKmks5sKkG7gaJpZM4Ibete .

@ m-sayari, você vai nos dar mais algumas informações para ajudar.

• Versão RN
• Versão de destino da versão Android
• Versão do dispositivo Android
• Dispositivos em que você está tendo esse problema.

Eles serão algo específico para sua implementação / configuração que está causando o problema. De acordo com meu anterior, ele está funcionando sem problemas em vários aplicativos ativos.

Resolvido aqui! RN 0.45.1 usando um Redmi 4A com Android 6.

Tive este problema ao chamar navigator.geolocation.getCurrentPosition () dentro de componentDidMount ()
Em vez de getCurrentPosition, apenas chame watchPosition () com os mesmos parâmetros.

@raldred
Versão RN
0,46
Versão de destino da versão Android
api 22
Versão do dispositivo Android
6.0.1
Dispositivos em que você está tendo esse problema.
Nexus 5

Chamar getCurrentLocation sem o terceiro parâmetro 'options' resolve meu problema. Não funciona para mim definir 'enableHighAccuracy' como falso

Olá @raldred , mesmo problema relatado por outros no RN 0.47.

• Versão RN: 0,47
• Versão de destino da versão Android deixada nos padrões RN:

    compileSdkVersion 23
    buildToolsVersion "23.0.1"

    defaultConfig {
        minSdkVersion 16
        targetSdkVersion 22

• Versão do dispositivo Android: 6.0.1, 7.0
• Dispositivos em que você está tendo esse problema:
  
  
  
  • Nexus 5 com Android 6.0.1
  
  
  • Xiaomi Redmi 3S com Android 6.0.1
  
  
  • Emulador Android com Android 7.0
  
  

getCurrentPosition funciona perfeitamente quando defino o modo de localização "Somente dispositivo" nas configurações do dispositivo, mas para de funcionar ( Location request timed out ) quando o modo está definido como "Alta precisão".

Preciso omitir o terceiro parâmetro para que getCurrentPosition funcione pelo menos no modo Somente dispositivo:

    navigator.geolocation.getCurrentPosition(setLocation);

Eu assumi isso e funcionou para mim, embora não testei com um caso diferente.
Então, olhando minhas opções, descobri que havia dois itens que conflitavam entre si maximumAge e enableHighAccuracy , acho que essas duas opções são as mesmas de uma maneira ligeiramente diferente, enquanto a idade máxima garante que você obter a geolocalização mais recente com base em suas configurações, embora a precisão seja baixa, enableHighAccuracy garante que você obtenha a localização mais atual e precisa. Eu estava tendo o mesmo problema com as seguintes opções.
{enableHighAccuracy: true, timeout: 20000, maximumAge: 60000} até que eu removesse a idade máxima e deixasse enableHighAccuracy espero que isso ajude alguém.

Acabei de compilar o react-native do master para testar se o commit 7e11bad86fd21ce1a8408218e66ce85993d9db69 corrige esse problema. Infelizmente, ainda estou recebendo o mesmo erro de antes.

A posição do relógio

@olieidel Você pode verificar se seu aplicativo tem acesso às permissões de localização com a seguinte API, PermissionsAndroid , primeiro verifique e depois pergunte se não foi concedida.

@mrbarde obrigado pela resposta rápida!

Ah, depois de um dia inteiro de depuração, aqui estão minhas descobertas e uma solução alternativa relevante:
RN 0.46.4, Dispositivo: Nexus 5X, API 25

Modo de localização: apenas dispositivo

• getCurrentPosition , enableHighAccuracy: true : funciona quando o sinal de GPS está disponível, senão o tempo limite
• getCurrentPosition , enableHighAccuracy: false : não funciona (tempo limite). provavelmente precisa de serviços de localização (modo de localização! = dispositivo apenas).
• watchPosition , enableHighAccuracy: true : funciona quando o sinal de GPS está disponível, caso contrário, o tempo limite
• watchPosition , enableHighAccuracy: false : não funciona

Modo de localização: alta precisão

• getCurrentPosition , enableHighAccuracy: true : funciona quando o sinal GPS está disponível, caso contrário, o tempo limite. Pode retornar um local mais antigo, dependendo de sua configuração de maximumAge .
• getCurrentPosition , enableHighAccuracy: false : funciona após 5-6s (como já relatado).
• watchPosition , enableHighAccuracy: true : funciona quando o sinal GPS está disponível, senão o tempo limite
• watchPosition , enableHighAccuracy: false : funciona

Resumo
Se o seu modo de localização for Somente dispositivo, você deve sempre ter um sinal de GPS. Em todos os outros casos, você precisa de serviços de localização (modo de localização! = Somente dispositivo).
Suponho que esse seja o comportamento esperado da API de localização e acabei de descobrir o equivalente a terra não ser plana, no entanto, isso é um inferno para depurar se você tiver um dispositivo configurado com o modo Localização == Somente dispositivo (um emulador, um dispositivo recém-configurado) e você está sentado em uma sala sem sinal GPS disponível. Nesse caso, você só obterá tempos limite.

Gambiarra
Como já descrito neste tópico, eu também usei dois ouvintes watchPosition com valores diferentes para enableHighAccuracy e simplesmente peguei o primeiro valor de ambos e, em seguida, removi-os. Brincando com essa abordagem, tive a impressão de que os dois ouvintes realmente retornam os mesmos locais, mas minha tolerância de depuração para o dia se esgotou ...
Isso pressupõe que seu modo de localização não é apenas dispositivo.

@olieidel Claro, e eu me pergunto por que ninguém usa a API de geolocalização nativa reage diretamente. Se não é útil ou simplesmente não funciona, acho que uma coisa apropriada seria substituí-la por navigator.geolocation já que funciona maravilhas, tente fazer uma solicitação pull com sua solução alternativa para ver se o Facebook vai gostar. E obrigado por ir mais longe para cavar mais fundo.

Demorei um pouco para reproduzir esse problema de forma consistente.

Tenho esse problema apenas em telefones Samsung com Android 5.1 e 6.0 quando o modo de localização está definido como "Alta precisão" e usando a API de posição atual em ambientes internos sem sinal de GPS. Ele funciona bem em telefones Oppo ou em ambientes externos com sinal de GPS claro, mesmo com o modo "Alta precisão" ativado.

Vou testar algumas das soluções sugeridas neste tópico em breve.

@mrbarde só para esclarecer: eu estava usando navigator.geolocation . :)

@olieidel eu sei, apenas colocando por aí que a documentação deve refletir navigator.geolocation e não a Geolocalização Api.

Oi pessoal, percebi que no Android, você pode ter permissão para acessar a localização, mas o usuário desativou a localização nas configurações do sistema operacional. Portanto, chamar navigator.getCurrentPosition() ainda vai expirar.

Aqui está um snippet Java com dois métodos. checkIfLocationAvailable que verifica se o usuário tem a localização ativada nas configurações ou não. requestUserToActivateLocation solicitará que o usuário ative a localização.

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

Desde que comecei a usar isso, não tive problemas de localização com o Android. Espero que ajude alguém.

Claro, você precisará adicionar compile 'com.google.android.gms:play-services-location:x.x.x' ao seu app/build.gradle e criar um módulo nativo conforme descrito aqui . Não tenho certeza se isso é funcionalidade suficiente para criar uma biblioteca npm autônoma.

Olá @nigelnindo , na verdade há uma API React Native para isso chamada PermissionsAndroid ,
você pode verificar se o usuário ativou a permissão de localização para o aplicativo
Tive o mesmo problema que você apontou, então o que fiz para resolvê-lo foi o seguinte.

Primeiro verifiquei se o usuário concedeu ao aplicativo acesso à localização dos dispositivos

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

E então disparou uma função com o código abaixo, isso pedirá ao usuário para
conceder acesso de localização ao aplicativo.

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

Isso funcionou para mim e agora não tenho problemas de localização, espero que isso ajude alguém lá fora.

Olá @mrbarde , só para complementar, uso a biblioteca PermissionsAndroid além do trecho acima. Como eu mencionei antes:

Oi pessoal, percebi que no Android, você pode ter permissão para acessar a localização, mas o usuário desativou a localização nas configurações do sistema operacional.

Em outras palavras, seu aplicativo pode ter permissão para acessar a localização obtida com PermissionsAndroid , mas se o usuário desativou a localização nos atalhos da barra de status ou acessando Settings -> Location -> Off getCurrentPosition() call ainda expirará. Isso ajuda nesse caso extremo.

@nigelnindo yh nesse caso então vou realmente sugerir sua solução, é possível você fazer um PR com isso? Quer dizer, poderia realmente economizar muito tempo, eu uso um pacote externo para lidar com isso, já que não posso escrever Java, embora eu realmente desejasse ter tempo para aprendê-lo. Se fosse oficialmente no React, eu preferiria, fico cético em relação a depender de bibliotecas de terceiros para coisas realmente essenciais como essa, me preocupo com a consistência.

tente alterar (Android) TargetSdkVersion em build.gradle (app) em 23 (16-22) . e vai funcionar!

porque, precisamos usar a permissão do arquivo AndroidManifest. e o arquivo AndroidManifest apenas chamado no SDK em 23 (16-22).

e não se esqueça de adicionar:

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

Não exclua o parâmetro maxAge!

Se você fizer isso, o módulo GPS retornará o último resultado armazenado em cache até obter a posição real dos satélites. Ele pode ser posicionado em cache em outro aplicativo longe de sua posição real. E se você está tentando salvar alguma trilha, seus primeiros pontos podem mostrar uma posição distante de sua posição real.

@pavelpashkovsky Você pode mostrar alguns fatos ou documentos oficiais para apoiar sua reclamação?

@rexlow acabei de descrever o resultado dos meus testes, pois a cerca de 1 semana atrás eu enfrentei o mesmo problema e encontrei esse tópico.

Fiz cerca de 30 testes. E eu tenho 3-4 casos com posição errada primeiros 1-5 segundos (até que o GPS encontrou o sinal dos satélites)

@pavelpashkovsky Agora estou enfrentando o mesmo problema também. Embora eu tenha maximumAge: 1000 em minha configuração. Parece que está armazenando em cache o local anterior, como você disse.

@rexlow Você está certo. No seu caso, o GPS mantém a posição por 1 segundo.

Mas o melhor resultado que obtive com maximumAge: 0 quando o gps não salva nenhum resultado e sempre tenta obter a posição real (ou erro se não puder obter a posição dos satélites).

Posso confirmar que a remoção de maximumage pode causar problemas no telefone Oppo que testei também. Ele usará um cache muito antigo.

Isso estava acontecendo comigo o tempo todo. Acontece que minha permissão de geolocalização foi desativada em Informações do aplicativo -> Permissões. Eu me pergunto por que isso aconteceu, mas parece que essas permissões substituem as que solicitamos em tempo de execução. Talvez outra pessoa também tenha esse problema

oi (desculpe pelo meu inglês).
Acho que aumentar a maximumAge resolverá o problema.

RN 0.48 Geolocalização doc:
A API de geolocalização estende a especificação da web: https://developer.mozilla.org/en-US/docs/Web/API/Geolocation

e por de acordo com:
https://developer.mozilla.org/en-US/docs/Web/API/PositionOptions/enableHighAccuracy
E
https://developer.mozilla.org/en-US/docs/Web/API/PositionOptions/timeout
e especialmente :
https://developer.mozilla.org/en-US/docs/Web/API/PositionOptions/maximumAge

em um cenário com estas opções:
{enableHighAccuracy: true, timeout: 10000, maximumAge: 30000}

o chip GPS do dispositivo tenta se conectar aos satélites. se a conexão for estabelecida no período de tempo limite (10000 ms), a latitude e a longitude serão retornadas sem nenhum erro, como @RoBYCoNTe disse: issuecomment-220580494 mas se a conexão GPS falhou ou expirou o tempo, o dispositivo tenta retornar uma latitude e longitude em cache com a idade máxima definida em opções (30000 ms). se algo existir será retornado, senão o código de erro 3 retornará com erro de tempo limite no assunto.

Acho que aumentar o tempo limite (pelo menos 25.000 ms) para conexão e, especialmente, aumentar a idade máxima (pelo menos 3600000 ms = 1 hora) é a melhor solução!

{enableHighAccuracy: true, timeout: 25000, maximumAge: 3600000} funcionou para mim

_config_ do emulador: durante o período de tempo limite, você deve enviar informações de localização virtual (latitude e longitude) através do menu Localização nas configurações do emulador. (isso emulará a conexão via satélite)

{ enableHighAccuracy: true, timeout: 60000, maximumAge: 1200 } funcionou para mim. Para mim, não se tratava da idade máxima, mas do tempo que estava disposto a esperar.

(Apenas Android)
Este problema não é um bug na minha opinião.
No React Native, a geolocalização funciona da seguinte forma:

• alta precisão significa localização GPS
• Quando desativado, busca a localização do provedor de rede
• maximumAge permite que você não busque uma nova posição sempre (o que consome bateria e tempo), mas depende de uma posição em cache

Basicamente, o provedor de GPS é mais lento do que o provedor de rede e nem sempre funciona, dependendo da sua localização (se o GPS não conseguir alcançar o telefone, você terá um tempo limite). O provedor de rede é mais rápido, mais acessível, mas como compensação, a precisão é baixa (o pior que tive foram 2.000 metros).

Se você obteve um tempo limite usando alta precisão, significa que não pode ser alcançado por GPS.
Nesse caso, considere desativá-lo por padrão e atualizar o local à medida que se torna mais preciso. Seus usuários não vão esperar neste caso.

No meu caso implementei meus próprios vigilantes, comparando a localização e sempre retornando os mais precisos. O problema com a implementação RN padrão é que ela depende do provedor de GPS ou do provedor de rede, mas não retorna uma compensação de ambos. Você provavelmente terá que trabalhar em JS ou Native.

Espero que tenha ajudado.

Testado apenas em Android.

Consegui fazer funcionar com os seguintes casos e certifique-se de que a localização esteja habilitada:

• Se você estiver executando seu aplicativo através do Android Emulator, você deve colocar opções ou ele irá falhar.

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

Eu apenas uso os controles estendidos para enviar meu local desejado para o aplicativo.

• Se você estiver executando seu aplicativo em telefones celulares reais, deve omitir as opções ou ele irá falhar.

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

Isto irá obter a sua localização atual

Estamos enfrentando o mesmo problema!

Existe uma correção para isso em algum lançamento futuro próximo?

Tentei algumas das soluções propostas ( exemplo , exemplo , exemplo e exemplo ) e nenhuma delas resolveu o problema. Mas devo dizer que não encontrei nenhuma referência para o seguinte cenário:

Aplicativo

• Android 6.x
• React 16.1.0
• React-Native 16.50.3

Cenário de Uso

• o telefone Android tem _nenhum cartão SIM_, eles são _ propriedade da empresa _ e apenas podem se conectar ao WIFI.

Ainda recebo o erro Geolocation timed out, code 3 ...

Alguém resolveu isso?

_Update_ (2017-11-13):

Eu resolvi (pelo menos temporariamente) definindo Settings >> Privacy >> Location >> Mode como High accuracy

Oi.
Encontrei uma boa solução!
Leia meu comentário anterior sobre este problema primeiro: # issuecomment-331830285

Solução:
Primeiro chame navigator.geolocation.getCurrentPosition com: {enableHighAccuracy: true, timeout: 60000, maximumAge: 0} como PositionOptions , isso retornará a posição atual real.
se a solicitação anterior expirou, chame navigator.geolocation.getCurrentPosition com: {enableHighAccuracy: false, timeout: 30000, maximumAge: 3600000} como PositionOptions , isso retornará a posição LowAccuracy como fallback e _ (eu acho) _ nunca expirou!
Código de amostra:

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

Espero ser útil.

Estou tendo o mesmo problema aqui!
Não consigo fazer o navigator.geolocation funcionar no meu dispositivo real Android.

Acredito que não haja nada a ser consertado aqui, a geolocalização está funcionando conforme o esperado. Leia minha postagem acima.

@Rewieer , Obrigado por sua resposta!

Estou usando este código para testar navigator.geolocation em meu aplicativo.

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

Estou sempre recebendo ERROR(3): Location request timed out .
usando todas as combinações de opções.
Consigo ver o ponto azul da minha posição no mapa e o GPS funciona bem, mas não consigo obter a posição ou fazer com que navigator.geolocation funcione de forma programática.

Os possíveis problemas são:

• configuração ruim do simulador / telefone
• não em uma área coberta por GPS (funciona mal em edifícios ou na rua com grandes edifícios, por exemplo)
• tempos limite muito cedo

O uso do local de rede parece funcionar melhor nesse caso. Você tentou buscar a posição atual sem opções? (que usaria infraestrutura relacionada à rede para obter a posição)

Estou usando um dispositivo Android real (versão 5.1)
Sou capaz de determinar minha posição usando o react-native-maps (posição correta do ponto azul no mapa dentro do meu aplicativo) + Eu sou capaz de usar o aplicativo google maps e ir para a minha posição (GPS funciona).
Estou usando um grande tempo limite, alternando enableHighAccuracy para true e false, remover opções ... etc. todos falharam em obter navigator.geolocation para obter dados.

Você sujou as mãos no Android com a API nativa?

2016-11-16 15:19 GMT + 01: 00 Badis Merabet [email protected] :

Estou usando um dispositivo Android real (versão 5.1)
Sou capaz de determinar minha posição usando os mapas nativos-reagentes (azul correto
ponto de posição no mapa dentro do meu aplicativo) + Posso usar o aplicativo Google Maps e
vá para minha posição (GPS funciona).
Estou usando um grande tempo limite, alternando enableHighAccuracy para true e false,
remover opções ... etc. todos falharam em obter navigator.geolocation para obter
dados.

-
Você está recebendo isso porque foi mencionado.
Responda a este e-mail diretamente, visualize-o no GitHub
https://github.com/facebook/react-native/issues/7495#issuecomment-344935653 ,
ou silenciar o tópico
https://github.com/notifications/unsubscribe-auth/ALuPm5XL1tNLCniOMR4YAMI4ZC2fKxrsks5s3ESBgaJpZM4Ibete
.

Sim @Rewieer , concordo, a causa dos erros são configurações incorretas.

No emulador, devemos enviar latitude e longitude via configuração do emulador antes do tempo limite!

Minha solução # issuecomment-331830285 primeiro tenta obter a posição atual real via GPS e conexão de satélite e, se a solicitação expirou (ou em qualquer outro erro), tenta usar a infraestrutura relacionada à rede para obter a posição de baixa precisão .

@Rewieer Nunca trabalhei com a API nativa do Android. Estou apenas desenvolvendo JavaScript.

@badis envie seu código e log de erros.

@badis
RN Doc:
Para solicitar acesso ao local, você precisa adicionar a seguinte linha ao AndroidManifest.xml do seu aplicativo:

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

Trabalhando com o React-Native, você deve saber algumas coisas sobre o ambiente nativo subjacente, porque esses problemas acontecem muito comigo trabalhando com o React-Native.
A melhor maneira atual (do usuário) é buscar uma aproximação no início e corrigi-la à medida que avança, porque o GPS pode levar algum tempo dependendo da sua posição e da posição dos satélites próximos. Sei que a localização da rede pode parecer muito difícil, mas acho que nem todo mundo vive em São Francisco :)

@Rewieer @hoorsa
Aqui está um código de demonstração em que faço testes de recursos: https://github.com/badis/mobile-react-native
Dê uma olhada na página do mapa.
Só quero saber se o código está correto e funcionando para outra pessoa.
Depois disso, tentarei do meu lado para ver se o problema está nas configurações e na localização do meu dispositivo.

Obrigado a todos!

@badis , você adicionou <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" /> ao AndroidManifest.xml do seu aplicativo?

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

@badis , tive o mesmo problema ontem. Funciona se você simplesmente remover o último argumento (entendo que não é o ideal), conforme sugerido em https://github.com/facebook/react-native/issues/7495#issuecomment -228730196

Quais são as opções padrão para Android? talvez isso pudesse ajudar a resolver este

Acho que usamos esses padrões (inspecionando LocationModule.java):

{
enableHighAccuracy: false, // Não use GPS
maximumAge: Double.POSITIVE_INFINITY, // Aceita qualquer local em cache
tempo limite: Long.MAX_VALUE,
distanceFilter: 100
}

Além disso, estamos enfrentando o mesmo erro de localização. Desativar o parâmetro da terceira opção funciona para os modos 'Alta precisão' e 'Economia de bateria' No entanto, apenas o dispositivo está falhando a cada vez. enableHighAccuracy para true falha independentemente do modo que configuramos o dispositivo.

Isso está utilizando FusedLocationProviderClient , como o site Android Dev sugere fazer?

Desativar o parâmetro da 3ª opção funciona para os modos 'Alta precisão' e 'Economia de bateria'.

@mkpietrzyk então omitir options resolveu para você nesses dois modos?

@natterstefan

sim, para Android eu usei parâmetros padrão ... mas ter tempo limite quase infinito e maximumAge para meu aplicativo é meio que um appkiller, já que preciso saber onde meus usuários estão para verificar algumas condições.

usando a solução @hoorsa aqui, a verificação de GPS também funciona. No entanto, é muito complicado para o GPS de qualquer maneira e às vezes não responde em alta precisão ... é por isso que eu não considerei funcionando tão bem, mas hey, meio que funciona.

Estou tendo o mesmo problema, em que preciso definir o tempo limite como uma quantidade ridiculamente alta para que funcione, mas os usuários precisarão acessar as informações mais cedo. Ao criar o aplicativo pela primeira vez, posso registrar em meio segundo que as permissões para acessar a localização precisa são válidas. A implementação de localização precisa simplesmente não funciona corretamente no Android.
Para referência, tentei com / sem parâmetros. Mesmo sem quaisquer opções adicionais, ele ainda falhará ao carregar o local às vezes. O teste foi feito em um One Plus One

Também estou tendo esse problema de tempo limite.

RN .50.3

Tentei chamar a API com e sem o parâmetro maximumAge:

{enableHighAccuracy: true, timeout: 10000},

Também estou encerrando esta chamada com uma solicitação de permissão, então isso não é um problema:

PermissionsAndroid.request (
PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION,

O modo de alta precisão está ativado no dispositivo.
O manifesto tem permissões corretas.

No meu Galaxy S7 - resolve uma multa de localização.
No meu Pixel 2 - ele atinge o tempo limite após o tempo limite de 10 segundos em um local que não tem sinal GPS.
No emulador - ele atinge o tempo limite após o tempo limite de 10 segundos, A MENOS QUE eu vá para a guia de localização nos controles expandidos e clique em ENVIAR para enviar uma localização.

Parece que navigator.geolocation.getCurrentPosition NÃO funciona quando não há sinal de GPS, mesmo se houver um local antigo armazenado em cache de outro aplicativo que já havia usado o local.

Vou contornar isso tentando alta precisão e, em seguida, failover para nenhuma precisão alta se falhar muito como @olieidel fez.

Eu tenho o mesmo problema que @jacksontbryan, mas getCurrentPosition usa um local em cache, se maximumAge é omitido.

Parece funcionar bem em um Galaxy S7, mas não no meu LG G6. No LG, ele atinge o tempo limite quase todas as vezes, se maximumAge estiver definido. Se maximumAge não estiver definido, ele usa um local antigo.

Edit: Parece que omitir o argumento de opções funciona completamente.

Recomendo a todos que usem a própria implementação de módulo nativo no Android para obter resultados estáveis. É muito fácil de implementar, você terá muito mais controle sobre o GPS e não precisa se preocupar se seu aplicativo não funcionar em alguns dispositivos.

    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 Estou tentando criar um módulo nativo para seu snippet, mas não consigo fazer funcionar porque falhou na compilação. Eu postei minha essência https://gist.github.com/pewh/1fd64c8f0b3797ef2b7a7046b5a5f974 e espero que alguém gentilmente faça uma revisão na minha essência. Muito obrigado e feliz natal!

Chamar navigator.geolocation.getCurrentPosition sem nenhuma opção resolveu o problema para mim. Estou passando apenas retornos de chamada de sucesso e erro.

Testado em um dispositivo real com Android 5.1.

@ginex Tem certeza de que os dados são novos? Quando faço isso, às vezes recebo dados antigos. (Diz que estou onde estava há uma hora).

Isso realmente precisa ser consertado!

Oi

Eu também estou enfrentando o mesmo problema. Estou recebendo um erro de tempo limite em alguns dispositivos. Aumentei o tempo limite de 2 segundos para 10 minutos, mas sem esperar por 10 minutos, ele apenas me lança o erro.

Também tentei com enableHighAccuracy: false. Neste caso, consigo obter a localização (exceto no Modo de Dispositivo).

Também tentei sem passar os parâmetros. Também consigo obter a localização neste caso, mas exceto no modo de dispositivo.

Também tentei passar no máximoAge, mas sem resultado.
Este é o meu código

getCurrentPosition () {
navigator.geolocation.getCurrentPosition (
(posição) => {
console.log ('obter posição');
this.location = {
longitude: position.coords.longitude,
latitude: position.coords.latitude,
erro: nulo,
};
},
(erro) => {
console.log ('obter erro de posição', erro);
this.location = {
longitude: nulo,
latitude: nulo,
erro: erro.mensagem,
};
},
{
enableHighAccuracy: true,
tempo limite: 600000
},
);
}

Se algum de vocês estiver usando skipPermissionsRequest e geoLocation estiver expirando - consulte # 17487

Oi

@ngandhy - Não, não estou usando 'skipPermissionRequests': true. e minSdkVersion é 16

Eu tenho os mesmos problemas que todos vocês, tentei todas as combinações que as pessoas mencionam para o Android e resolva-o com esta geolocalização de fundo nativo reagir e podemos obter locais salvos e até mesmo locais GPS e esses locais serão extremamente precisos.

@badis
Sua solução funcionou para mim - obrigado!

Meu método antes de consertar:

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

Meu método após sua correção:

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

Acabei de testar este código e pode ser uma solução:
https://www.abidibo.net/blog/2017/11/23/geolocation-react-native/

Tem esse problema também, alguém tem uma solução?

Estou tendo esse problema há algum tempo e a única "solução" que funciona de forma consistente é desabilitar "enableHighAccuracy". O problema com isso é que ele usa sua rede em vez do GPS para determinar sua localização, o que perde uma tonelada de precisão.

Muitas das outras soluções parecem funcionar no início, mas descobri que geralmente é devido ao uso de uma posição em cache e se você reiniciar o telefone e iniciar o aplicativo, ele ainda falhará.

Hoje, encontrei este pacote que usa a API de locais fundidos do Google para locais Android e volta para a implementação padrão React Native para iOS (não sou o autor deste pacote, mas parabéns por tê-lo criado):

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

Só testei um pouco até agora, mas parece estar funcionando bem.

Obrigado @globetro ! Eu verifiquei isso também e parece funcionar bem!

@globetro. Obrigado.
react-native-geolocalização-service é a melhor solução.

@globetro Eu também tive sucesso com este plugin. Isso deve ser mesclado para reagir nativo como a funcionalidade de geolocalização padrão!

react-native-geolocalização-service not help me :(

Obrigado @globetro, o pacote * react -native-geolocalização-service * funcionou perfeitamente, deveria ser bom adicioná-lo como componente principal no react native.

Você realmente deseja ter dois ouvintes de localização (o que é caro), um que tenha alta precisão e outro que não.

então você deseja comparar o que é mais preciso e mais recente do que sua localização 'atual'.

Esta é uma solução 'temporária', ela realmente deve ser implementada no lado RN para que use as permissões COARSE e FINE se a alta precisão estiver habilitada.

Resolvi esse problema, aqui está o componente que criei usando uma promessa:
https://gist.github.com/a3diti/5466f7309752cbb2e63ecefff6365bb9
No Android, removi maximumAge , mantive enableHighAccuracy em true e adicionei uma verificação de permissão do componente RN PermissionsAndroid .

@ a3diti Você já testou no mundo real? A localização pode ser armazenada em cache.

@ a3diti A menos que tenham corrigido algo na versão mais recente do

Por que não mesclar o código usado aqui https://www.npmjs.com/package/react-native-geolocation-service no núcleo?

Estou enfrentando o mesmo "problema de tempo limite de solicitação", depois de R&D, tento "Reinicializar" o dispositivo e, em seguida, recebo a localização e funciona bem.

Por favor, verifique meu código.

componentDidMount = () => {
navigator.geolocation.getCurrentPosition (
(posição) => {
const initialPosition = JSON.stringify (posição);
this.setState ({initialPosition});
},
(erro) => alerta (mensagem de erro),
{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);

  });

}

Qualquer razão pela qual as pessoas ainda estão lutando com isso e não usam

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

como sugerido anteriormente? Funciona perfeitamente para mim.

Não está funcionando para os outros?

Adicionado ao arquivo AndroidManifest.xml e funciona!

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

Ei pessoal,

Tentei usar o serviço react -native-geolocalização-service, conforme sugerido por @globetro, mas fez com que meu aplicativo

@ Patrick-Bayer Estou usando no meu aplicativo no Google Play, onde funciona, mas minha versão de desenvolvimento agora está travando instantaneamente por um motivo desconhecido. Parece ser o serviço react-native-geolocalização que está causando a falha para mim também.

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

Deixe-me saber se você encontrar uma solução.

@oakis As etapas a seguir funcionaram para mim:

1. Atualize o Gradle e altere a versão em

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. Adicione "google ()" aos repositórios em seu android / build.gradle

Às vezes, mesmo depois de adicionar <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" /> ao seu AndroidManifest.xml, ele ainda pode não funcionar.
Solução Rápida

1. Você pode pedir explicitamente as informações de localização do usuário quando ele monta a primeira tela do seu aplicativo, como
   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. Nunca defina enableHighAccuracy como falso, em vez disso remova maximumAge e aumente seu timeOut . Algo como {enableHighAccuracy: true, timeout: 100000,} faria.

Espero que isso ajude alguém.

Para mim, definir enableHighAccuracy como true funciona na API 23, embora eu precise definir como false na API 26.
(são os únicos que estou testando)

EDIT: Acabei instalando o react-native-geolocalização-service e isso resolveu meus problemas 🥁

Oi,

Eu tive o mesmo problema e aqui está outra solução.

Eu adicionei a tag uses-feature abaixo em AndroidManifest.xml e parece que o aplicativo funciona bem com highAccuracy: true

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

Parece que se você definir highAccuracy: high , o React Native usa GPS_PROVIDER em vez de NETWORK_PROVIDER. E, como diz o documento do Android Developers, um aplicativo voltado para API 21 ou superior deve incluir esta tag em AndroidManifest.xml para usar GPS_PROVIDER.

Cuidado: se seu aplicativo for direcionado ao Android 5.0 (API de nível 21) ou superior, você deve declarar que seu aplicativo usa o recurso de hardware android.hardware.location.network ou android.hardware.location.gps no arquivo de manifesto, dependendo de se o seu app recebe atualizações de localização de NETWORK_PROVIDER ou de GPS_PROVIDER. Se seu aplicativo receber informações de localização de qualquer uma dessas fontes de provedor de localização, você precisará declarar que o aplicativo usa esses recursos de hardware em seu manifesto. Em dispositivos que executam versões anteriores ao Android 5.0 (API 21), solicitar a permissão ACCESS_FINE_LOCATION ou ACCESS_COARSE_LOCATION inclui uma solicitação implícita para recursos de hardware de localização. No entanto, solicitar essas permissões não solicita automaticamente os recursos de hardware de localização no Android 5.0 (API de nível 21) e superior.

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

Não sei por que você não precisa incluir android.hardware.location.network em AndroidManifest.xml ao definir highAccuracy: false que implica que LocationManager usa NETWORK_PROVIDER e, portanto, a tag é exigida de acordo com o documento.

Espero que esta solução funcione para você.

Fiz alguns experimentos e parece que o tempo limite pode ter a ver com se os serviços de localização do Google estão habilitados no dispositivo.
Percebi que ao ativar os serviços de localização no dispositivo, uma caixa de alerta pergunta "Melhorar a precisão da localização?" com um texto explicando que os serviços de localização do Google serão executados em segundo plano e também enviarão dados de localização ao google. Isso normalmente acontece em um novo dispositivo ou emulador, porque a maioria de nós já habilitou isso em nossos dispositivos regulares.

Quando não está habilitado, o dispositivo precisa obter um novo local quase sempre que você o solicitar (controlado pelas configurações de maximumAge ). Se você não tiver solicitado a localização por um tempo e o timeout não for suficiente para obter uma nova localização, o navigator.geolocation.getCurrentPosition retornará apenas um tempo limite.

Eu também vi isso sendo resolvido abrindo o Google Maps no dispositivo uma vez (que novamente obtém um local novo).

Novamente, não afirmando que esta é a explicação / solução certa, apenas adicionando minhas observações a este tópico

Só consegui observar as mudanças de localização no Android com react-native-fused-location

Alguém interessado em fazer o upstream das alterações de um dos módulos sugeridos no núcleo?

Há alguns dias, publiquei a geolocalização cruzada reagente nativa que é compatível com o módulo de geolocalização RN, mas usa a API de localização do Google mais eficiente para Android. Por isso não acho que meu módulo seja candidato a integrá-lo ao núcleo do RN, mas está disponível para quem quiser usá-lo.

react-native-geolocalização-service Este pacote está usando a API de localização fundida e está funcionando bem para obter a posição ou até mesmo observar a posição. @hramos e @reyalpsirc , experimente.

A localização fundida

Tentei quase tudo e descobri que é inconsistente. Encontrei algo que pode ser útil.

Habilitar alta precisão significa encontrar localização via rede gps + (serviços de operadora). Ao verificar as permissões de nível de aplicativo, meu dispositivo teve as permissões de localização dos serviços da operadora desativadas. Ativá-lo e remover o terceiro parâmetro de navigator.geolocation.getCurrentPosition () funciona para mim.
Experimentar
- Vá para as Configurações do seu dispositivo -> Segurança e localização -> Localização -> Permissões de nível de aplicativo
- Habilitar permissão de localização para serviços de operadora
-Remova a configuração do local (terceiro parâmetro) de getCurrentPosition
-Reinicie seu dispositivo

Espero que isto ajude!

Não tenho certeza se é relevante. Mas um exemplo de https://snack.expo.io/SkJqg8gYm. Depois de personalizar o código, ele bateu no bloco catch o tempo todo. Então eu descobri que sempre que ocorre uma exceção de javascript, ela é lançada silenciosamente. Por causa desse bloco catch foi executado. Então, certifiquei-me de que nenhum erro ocorreria ao chamar essa função. Eu acho que o texto digitado deve ser aplicado em casos como esse para evitar erros em tempo de execução.

{enableHighAccuracy: true, timeout: 10000, maximumAge: 0}
o que eu encontrei se pular o segundo parâmetro ou dando menos de 10000 valores ele dando o erro

tente dar todos os três parâmetros como acima irá resolver meu problema pelo menos no emulador

Tente adicionar essas permissões em seu _AndroidManifest.xml_ :

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

Oi, eu estava enfrentando o mesmo problema de "solicitar tempo limite". Tentei todas as soluções possíveis, conforme indicado acima, mas não funcionou para mim, mas recentemente encontrei um módulo que supera esse problema.
https://www.npmjs.com/package/react-native-geolocation-service
Isso funcionou para mim ...

@vishalTechnoFreek , também existe geolocalização cruzada reativa .

É totalmente compatível com a geolocalização RN atual, mas usando a nova API do Google. Com esta API você não se preocupa com qual modo usar, o serviço detecta automaticamente a melhor opção.

Outra vantagem é que, quando o RN corrige esse problema, você pode removê-lo sem afetar seu aplicativo, se desejar.

No meu caso, o que mencionou @manurana sobre (baixar e) abrir o aplicativo Google Maps e depois voltar para a Expo funcionou.

Estou trabalhando com Genymotion e Android 5.

Além disso, para usuários do Genymotion, para ler corretamente a posição, a janela do mapa do Genymotion deve ser aberta; caso contrário, funcionará, mas com a localização padrão da Geny

definir enableHighAccuracy como true ou false não funciona para mim.
omitir o terceiro argumento para getCurrentPosition para usar os valores padrão do módulo nativo funciona para mim.

salva-vidas 👍 isso funcionou para mim.

Eu pessoal,
Estava enfrentando o mesmo erro mas, após algumas tentativas com meus colegas, notamos algo estranho (mas normal se você pensa em GPS).

Se você executar testes "dentro do seu escritório" usando um dispositivo físico, o localizador GPS pode ser perturbado por coisas externas como paredes, ou pelo simples motivo de que você está tentando fazer esta operação "interna" e, geralmente, deve ser executada ao ar livre .

Bem, depois disso saímos de nosso escritório, reexecutamos os testes e o dispositivo responde conforme planejado (não recebemos o erro de tempo limite de solicitação).

Minha sugestão é: tente geolocalização usando "enableHighAccuracy" definido como true, se falhar (no escritório isso pode falhar), tente novamente com false, isso deve funcionar, no meu caso funcionou.

Espero que isso possa ajudar.

Estou enfrentando o mesmo problema, mas definir enableHighAccuracy como false não funciona para mim. Portanto, esta solução que parece perfeita não funciona para mim.

Eu enfrentei um problema semelhante com várias solicitações (continuamente selecionando usar local atual). Adicionei nova tentativa para a solicitação de local. não é o problema exato, mas pode ajudar alguém.

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
Este pacote resolveu o problema para mim.
Quase todas as sugestões acima não funcionaram para mim.

Olá, Visitante, resolvi o mistério, o que aconteceu é que quando pedimos a localização pela primeira vez e usamos "maximunAge" não temos uma localização anterior em cache, então há um bug, certifique-se de que na primeira vez quando pedir localização sem "maximunAge"

a resposta simples é sair de onde você está e ir para um espaço aberto e tentar novamente.

É ciência simples.

Os serviços de GPS são afetados por paredes grossas e carros.

Isso funcionou para mim. Não há necessidade de editar nada !!!

No meu caso, remover o maximumAge resolveu o problema.

Muito obrigado! Trabalhos!

Oi,
Nenhuma das soluções funciona para mim.
Eu uso navigator.geolocation, usando apenas {enableHighAccuracy: false} como o terceiro parâmetro.
No iOS funciona bem e no Android não funciona em alguns dispositivos.
Eu verifiquei no Android 7, 8, 9. Não está funcionando no telefone Lenovo com Android 7. Mas funciona com outros dispositivos com Android 7.

Alguém tem alguma solução alternativa para resolver esse problema.
Qualquer sugestão é apreciável.

obrigado

@akhilsanker talvez tente uma biblioteca como -native-fused-location

Olá @reyalpsirc ,

Obrigado pela resposta. Agradeço muito pelo seu tempo.
Não há nenhum problema no iOS e funciona bem na maioria dos dispositivos Android. Limitei a restrição de tempo e será difícil usar uma nova biblioteca, como você sugeriu.
Você tem alguma outra solução alternativa para resolver esse problema?
Obrigado pelo seu tempo.

Obrigado.

Desculpe @akhilsanker , tudo que fiz foi usar a geolocalização do react native para iOS e FusedLocation para Android.

configuração maximumAge:0 funcionou para mim:
{ enableHighAccuracy: true, timeout: 60000, maximumAge:0 }
talvez @GersonM esteja certo ...

O módulo de geolocalização foi removido do RN no mestre e não estará disponível no 0.60. Use https://github.com/react-native-community/react-native-geolocation e relate os problemas lá. Obrigado

É 2019, experimentei 3 bibliotecas de localização diferentes, nenhuma delas funciona para Android. Surpreendente.

É 2019, experimentei 3 bibliotecas de localização diferentes, nenhuma delas funciona para Android. Surpreendente.

react-native-geolocalização-service está funcionando bem.

Se um pacote não estiver funcionando, crie um ticket de problema nesse repo. Os problemas não se resolvem, junte-se à comunidade.

veja o comentário <permission> __and__ <uses-permission> meta tags

https://www.npmjs.com/package/react-native-geolocation-service
Este pacote resolveu o problema para mim.
Quase todas as sugestões acima não funcionaram para mim.

Obrigado!