Android Dev Summit, October 23-24: two days of technical content, directly from the Android team. Sign-up for livestream updates.

Detectar a localização no Wear OS

O formato pequeno e de fácil visualização de um relógio torna o Wear OS by Google uma plataforma ideal para apps que registram, informam e respondem à localização do usuário. Como exemplos, você pode compilar apps que fornecem aos usuários atualizações em tempo real sobre distância, velocidade e direção, ou que fornecem dicas de fácil visualização sobre o local onde se encontram.

Alguns relógios têm um sensor de GPS integrado que recupera dados de localização sem exigir um smartphone conectado. Quando você solicita dados de localização em um app de relógio, não é preciso se preocupar com a origem desses dados; o sistema os recebe pelo método mais eficiente. No entanto, conforme é descrito nas seções abaixo, seu app precisa processar a perda de dados de localização.

O método recomendado para adquirir dados de localização em um relógio é usar o Fused Location Provider. Além disso, este documento descreve como verificar a presença de sensores de localização no relógio, receber dados de localização e monitorar conexões de dados vinculadas. Confira também Dados de localização para relógios pareados com iPhones.

Para reduzir o impacto negativo da aquisição de dados de local na duração da bateria, certifique-se de que seu app chame setPriority() definido como PRIORITY_BALANCED_POWER_ACCURACY. Você precisa pedir a localização com a frequência máxima de uma vez por minuto usando setInterval().

Observação: este documento pressupõe que você saiba usar a API do Google Play Services para recuperar dados de local.

Usar o Fused Location Provider

Em um smartwatch, você deve receber dados de local usando o FusedLocationProviderApi (FLP). O FLP usará os dados de local do smartphone automaticamente se o smartwatch não tiver um sensor de GPS. Para mais informações, consulte Criar um cliente de serviços de localização.

Para mais informações sobre como solicitar atualizações de localização e rastrear a localização de um usuário continuamente, consulte Receber atualizações de localização.

Detectar GPS integrado

Se um usuário for caminhar com um relógio que não tenha um sensor de GPS integrado e deixar o smartphone pareado em casa, seu app de relógio não poderá receber dados de localização por meio de uma conexão vinculada. O app precisará detectar a situação e avisar o usuário de que a funcionalidade de localização não está disponível.

Para determinar se um smartwatch tem um sensor de GPS integrado, use o método hasSystemFeature(). O código a seguir detectará se o relógio tem um sensor de GPS integrado quando você iniciar uma atividade:

Kotlin

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.main_activity)

        if (!hasGps()) {
            Log.d(TAG, "This hardware doesn't have GPS.")
            // Fall back to functionality that does not use location or
            // warn the user that location function is not available.
        }
    }

    private fun hasGps(): Boolean =
            packageManager.hasSystemFeature(PackageManager.FEATURE_LOCATION_GPS)
    

Java

    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main_activity);

        if (!hasGps()) {
            Log.d(TAG, "This hardware doesn't have GPS.");
            // Fall back to functionality that does not use location or
            // warn the user that location function is not available.
        }

        ...
    }

    private boolean hasGps() {
        return getPackageManager().hasSystemFeature(PackageManager.FEATURE_LOCATION_GPS);
    }
    

Processar eventos de desconexão

Se um relógio não tiver um sensor de GPS integrado, ele perderá o stream de dados de localização repentinamente quando perder a conexão de dados vinculada a um smartphone. Se seu app esperar um stream constante de dados, ele precisará detectar a perda de conexão, avisar o usuário e remover a funcionalidade de forma eficiente.

Para detectar a perda de uma conexão de dados vinculada, use o método GetConnectedNodesResult da NodeApi. Por exemplo:

  1. Inicialize um GoogleApiClient e crie um método que chame a NodeApi, por exemplo, um método chamado inspectNodes:

    Kotlin

        private lateinit var googleApiClient: GoogleApiClient
        private var wearableConnected = false
    
        override fun onCreate(savedInstanceState: Bundle?) {
            super.onCreate(savedInstanceState)
    
            googleApiClient = GoogleApiClient.Builder(this)
                    .addApi(Wearable.API)
                    .addConnectionCallbacks(object : GoogleApiClient.ConnectionCallbacks {
                        override fun onConnected(connectionHint: Bundle?) {
                            inspectNodes()
                        }
    
                        override fun onConnectionSuspended(cause: Int) {}
                    })
                    .build()
    
        }
    
        private fun inspectNodes() {
            Wearable.NodeApi
                    .getConnectedNodes(googleApiClient)
                    .setResultCallback(this, 1000, TimeUnit.MILLISECONDS)
        }
        

    Java

        private GoogleApiClient googleApiClient;
        private boolean wearableConnected = false;
    
        @Override
        public void onCreate() {
            super.onCreate();
    
            googleApiClient = new GoogleApiClient.Builder(this)
                    .addApi(Wearable.API)
                    .addConnectionCallbacks(new GoogleApiClient.ConnectionCallbacks() {
                        @Override
                        public void onConnected(Bundle connectionHint) {
                            inspectNodes();
                        }
    
                        @Override
                        public void onConnectionSuspended(int cause) {
                        }
                    })
                    .build();
        }
    
        private void inspectNodes(){
            Wearable.NodeApi.getConnectedNodes(googleApiClient).setResultCallback(this, 1000, TimeUnit.MILLISECONDS);
        }
        
  2. Use o método de callback a seguir para conseguir o resultado de usar o método inspectNodes:

    Kotlin

        override fun onResult(getConnectedNodesResult: NodeApi.GetConnectedNodesResult) {
            wearableConnected = false
            getConnectedNodesResult.nodes.forEach { node ->
                wearableConnected = wearableConnected or node.isNearby
            }
            Log.v("TEST", "wearableConnected: $wearableConnected")
        }
        

    Java

        @Override
        public void onResult(NodeApi.GetConnectedNodesResult getConnectedNodesResult) {
            if (getConnectedNodesResult != null && getConnectedNodesResult.getNodes() != null){
                wearableConnected = false;
                for (Node node : getConnectedNodesResult.getNodes()){
                    if (node.isNearby()){
                        wearableConnected = true;
                    }
                }
            }
            Log.v("TEST", "wearableConnected: " + wearableConnected);
        }
        

Processar localização não encontrada

Quando o sinal de GPS é perdido, você pode recuperar a última localização conhecida do relógio do usuário. Recuperar a última localização conhecida é útil quando não é possível utilizar o GPS ou quando o relógio não tem um GPS integrado e perde a conexão com o smartphone. Para mais informações, consulte Recuperar a última localização conhecida.