O Google tem o compromisso de promover a igualdade racial para as comunidades negras. Saiba como.

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.