Detección de la ubicación en Wear OS

El factor de forma fácilmente visible y pequeño de un reloj hace de Wear OS by Google una plataforma ideal para apps que informan y registran la ubicación del usuario y responden a ella. A modo de ejemplo, puedes compilar apps que proporcionen a los usuarios actualizaciones en tiempo real sobre distancia, instrucciones sobre cómo llegar a un lugar y velocidad, o colas visibles sobre los alrededores de los usuarios.

Consulta los siguientes recursos relacionados:

Algunos relojes tienen un sensor de GPS incorporado que obtiene datos de ubicación sin requerir que el teléfono esté conectado. No obstante, cuando solicitas datos de ubicación en una app para reloj, no tienes que preocuparte por la ubicación en la que se originan los datos; el sistema los obtiene con el método más eficaz en términos de consumo de energía. Sin embargo, como se describe en las secciones siguientes, tu app debe controlar la pérdida de datos de ubicación.

El método de obtención de datos de ubicación recomendado en un reloj consiste en usar el proveedor de ubicación combinada. Además, en este documento, se describe la manera de comprobar la presencia de sensores de ubicación en el reloj, recibir datos de ubicación y supervisar conexiones de datos de conexión mediante dispositivos móviles. Consulta también Datos de ubicación para relojes sincronizados con iPhones.

Para reducir el impacto negativo de la obtención de datos de ubicación en la duración de la batería, asegúrate de que tu app llame a setPriority() configurado en PRIORITY_BALANCED_POWER_ACCURACY. No debes solicitar la ubicación más de una vez por minuto mediante setInterval().

Nota: En este documento, se supone que sabes usar la API de servicios de Google Play para obtener datos de ubicación.

Uso del proveedor de ubicación combinada

En un reloj, deberías obtener datos de ubicación mediante la FusedLocationProviderApi (FLP). Si el reloj no tiene sensor GPS, la FLP usa automáticamente los datos de ubicación del teléfono. Para obtener más información, consulta Creación de un cliente de servicios de ubicación.

Para obtener información sobre cómo solicitar actualizaciones de ubicación y cómo realizar un seguimiento continuo de la ubicación de un usuario, consulta Cómo recibir actualizaciones de ubicación.

Cómo detectar un GPS incorporado

Si un usuario sale a correr con un reloj sin sensor GPS incorporado y no lleva con él el teléfono sincronizado, tu app para relojes no podrá obtener datos de ubicación mediante una conexión a la red. Tu app debería detectar la situación y advertir al usuario que la funcionalidad de ubicación no está disponible.

Para determinar si un reloj tiene un sensor GPS incorporado, usa el método hasSystemFeature(). El siguiente código detecta si el reloj tiene un sensor GPS incorporado cuando inicias una actividad:

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

Cómo controlar eventos de desconexión

Si un reloj no tiene un sensor GPS incorporado, perderá abruptamente la transmisión de datos de ubicación cuando pierda la conexión de datos anclada a un teléfono. Si tu app espera una transmisión de datos constante, debe poder detectar la pérdida de conexión, advertir al usuario y reducir correctamente la funcionalidad.

Para detectar la pérdida de conexión de datos anclada a una red, usa el método GetConnectedNodesResult de NodeApi. Por ejemplo:

  1. Inicializa un GoogleApiClient y crea un método que llame a la NodeApi, p. ej., un método llamado 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. Usa el siguiente método de devolución de llamada para obtener el resultado del 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);
        }
        

Control de ubicaciones no encontradas

Cuando se pierde la señal de GPS, puedes recuperar la última ubicación conocida del reloj del usuario. Esta acción resulta útil cuando no puedes obtener datos del GPS o cuando el reloj no posee un GPS incorporado y pierde la conexión con el teléfono. Para obtener más información, consulta Cómo obtener la última ubicación conocida.