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 criar 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.

Confira os seguintes recursos relacionados:

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 Provedor de localização combinada. 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 localização na duração da bateria, certifique-se de que seu app chame setPriority() definido como PRIORITY_BALANCED_POWER_ACCURACY. Solicite 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 provedor de localização combinada

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 ver mais informações, consulte Criar um cliente de serviços de localização.

Para ver 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 relógio 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. 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 uso do 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 ver mais informações, consulte Recuperar a última localização conhecida.