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 aplicativos que registram, reportam e respondem à localização do usuário. Como exemplos, você pode compilar aplicativos 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 celular conectado. Quando você solicita dados de localização em um aplicativo de relógio, não é preciso se preocupar com a origem desses dados; o sistema os obtém pelo método mais eficiente. No entanto, conforme é descrito nas seções abaixo, seu aplicativo 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 dado 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 aplicativo chame setPriority() definido como PRIORITY_BALANCED_POWER_ACCURACY. Você deve solicitar a localização com a frequência máxima de uma vez por minuto usando setInterval().

Observação: este documento pressupõe que você sabe usar a API de serviços do Google Play para recuperar dados de localização.

Usar o Fused Location Provider

Em um relógio, você deve obter dados de localização usando o FusedLocationProviderApi (FLP). O FLP automaticamente usa os dados de localização do celular se o relógio não tiver um sensor de GPS. Para obter mais informações, consulte Criar um cliente de serviços de localização.

Para obter 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 tem um sensor de GPS integrado e deixar o celular pareado em casa, seu aplicativo de relógio não poderá obter dados de localização por meio de uma conexão vinculada. Seu aplicativo deverá detectar a situação e avisar o usuário de que a funcionalidade de localização está indisponí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, o relógio perderá seu stream de dados de localização repentinamente quando perder a conexão de dados vinculada a um celular. Se seu aplicativo esperar um stream constante de dados, ele deverá 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 obter 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 GPS não tem um GPS integrado e perde sua conexão com o celular. Para obter mais informações, consulte Obter a última localização conhecida.