android - watches - wear os by google

Cómo detectar si el dispositivo Android está emparejado con el reloj de desgaste de Android

Question

Estoy creando una aplicación para Android que extiende las notificaciones push. Mi aplicación descarga aproximadamente 10 imágenes de un servidor cuando llega una notificación de inserción y muestra estas imágenes adicionales en el reloj. Estas imágenes son específicas de la aplicación de Android y no se muestran en el dispositivo de mano.

¿Cómo puedo saber si el dispositivo de mano está emparejado con un dispositivo de desgaste de Android para poder determinar si es necesario descargar las imágenes adicionales necesarias para la aplicación de desgaste?

¡Gracias!

Answer 1

Compruebe si hay dispositivos emparejados

Puede verificar que el usuario tenga un reloj emparejado con su dispositivo mientras no tenga que estar conectado en ese momento. Esto es mejor ya que de esta manera el reloj no tiene que estar conectado en el momento de ser detectado.

BluetoothAdapter mBtAdapter = BluetoothAdapter.getDefaultAdapter();

Set<BluetoothDevice> pairedDevices = mBtAdapter.getBondedDevices();
if (pairedDevices.size() > 0) {
    for (BluetoothDevice device : pairedDevices) {
        if(device.getDeviceClass()==BluetoothClass.Device.WEARABLE_WRIST_WATCH){
            Log.d("Found", "Paired wearable: "+ device.getName() + ", with address: " + device.getAddress());
        {
    {
} else {
    Toast.makeText(this, "No paired wearables found", Toast.LENGTH_SHORT).show();
}

Tenga en cuenta que este código requiere permisos de Bluetooth en su manifiesto.

<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN"/>

Answer 2

Estoy usando un método mucho más simple que es adecuado para mi caso de uso, verifique si la aplicación de Android está instalada:

    try {
        getPackageManager().getPackageInfo("com.google.android.wearable.app", PackageManager.GET_META_DATA);
    } catch (PackageManager.NameNotFoundException e) {
        //android wear app is not installed
    }

Answer 3

Por encima de todas las respuestas son correctas si el dispositivo de mano está conectado solo para Android Watch. ¿Qué sucede si el dispositivo de mano está conectado a más de un dispositivo (multireables) como Android Watch, HealthBand, Beacon, etc.? Las respuestas anteriores pueden no funcionar.

Las siguientes secciones le muestran cómo anunciar nodos de dispositivos que pueden procesar solicitudes de actividad, descubrir los nodos capaces de satisfacer una necesidad solicitada y enviar mensajes a esos nodos.

Capacidades de publicidad

Para iniciar una actividad en un dispositivo portátil desde un dispositivo portátil, use la clase MessageApi para enviar la solicitud. Dado que se pueden conectar múltiples dispositivos portátiles al dispositivo de mano, la aplicación portátil debe determinar que un nodo conectado es capaz de iniciar la actividad. En la aplicación de la computadora de mano, anuncie que el nodo en el que se ejecuta proporciona capacidades específicas.

Para anunciar las capacidades de su aplicación de mano:

1. Cree un archivo de configuración XML en el directorio res / values ​​/ de su proyecto y asígnele el nombre wear.xml.
2. Agregue un recurso llamado android_wear_capabilities a wear.xml.
3. Definir las capacidades que proporciona el dispositivo.

<resources>
    <string-array name="android_wear_capabilities">
        <item>android_wear</item>
    </string-array> 
</resources>

Recupera los nodos con las capacidades requeridas.

Inicialmente, puede detectar los nodos capaces llamando al método CapabilityApi.getCapability (). El siguiente ejemplo muestra cómo recuperar manualmente los resultados de los nodos accesibles con la capacidad android_wear . Use el siguiente código en el módulo de desgaste:

public abstract class BaseActivity extends Activity implements MessageApi.MessageListener, NodeApi.NodeListener,
    DataApi.DataListener, GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener {

private static final String
        SMART_WEAR_CAPABILITY_NAME = "android_wear";

protected GoogleApiClient mGoogleApiClient;
protected ArrayList<String> results;
private String TAG = "BaseActivity::Wear";

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mGoogleApiClient = new GoogleApiClient.Builder(this)
            .addApi(Wearable.API)
            .addConnectionCallbacks(this)
            .addOnConnectionFailedListener(this)
            .build();
}

private Collection<String> getNodes() {
    results = new ArrayList<>();
    NodeApi.GetConnectedNodesResult nodes =
            Wearable.NodeApi.getConnectedNodes(mGoogleApiClient).await();

    for (Node node : nodes.getNodes()) {
        Log.d(TAG, node.getId());
        results.add(node.getId());
    }

    return results;
}

@Override
protected void onResume() {
    super.onResume();
    mGoogleApiClient.connect();
}

@Override
protected void onPause() {
    super.onPause();
    Wearable.MessageApi.removeListener(mGoogleApiClient, this);
    Wearable.NodeApi.removeListener(mGoogleApiClient, this);
    Wearable.DataApi.removeListener(mGoogleApiClient, this);
    mGoogleApiClient.disconnect();
}

@Override
public void onConnected(Bundle bundle) {
    Log.d(TAG, "onConnected(): Successfully connected to Google API client");
    Wearable.MessageApi.addListener(mGoogleApiClient, this);
    Wearable.DataApi.addListener(mGoogleApiClient, this);
    Wearable.NodeApi.addListener(mGoogleApiClient, this);
    results = new ArrayList<>();

    getNodeIdOfHandheldDevice();
}

@Override
public void onConnectionSuspended(int i) {
    Log.d(TAG, "onConnectionSuspended(): Connection to Google API client was suspended");
}

@Override
public void onConnectionFailed(ConnectionResult connectionResult) {
    Log.e(TAG, "onConnectionFailed(): Failed to connect, with result: " + connectionResult);
}

@Override
public void onPeerConnected(Node node) {
    Log.e(TAG, "onPeerConnected():");
}

@Override
public void onPeerDisconnected(Node node) {
    Log.e(TAG, "onPeerDisconnected():");
}

private void getNodeIdOfHandheldDevice() {
    Wearable.CapabilityApi.getCapability(
            mGoogleApiClient, SMART_WEAR_CAPABILITY_NAME,
            CapabilityApi.FILTER_REACHABLE).setResultCallback(
            new ResultCallback<CapabilityApi.GetCapabilityResult>() {
                @Override
                public void onResult(CapabilityApi.GetCapabilityResult result) {
                    if (result.getStatus().isSuccess()) {
                        updateFindMeCapability(result.getCapability());
                    } else {
                        Log.e(TAG,
                                "setOrUpdateNotification() Failed to get capabilities, "
                                        + "status: "
                                        + result.getStatus().getStatusMessage());
                    }
                }
            });
}

private void updateFindMeCapability(CapabilityInfo capabilityInfo) {
    Set<Node> connectedNodes = capabilityInfo.getNodes();
    if (connectedNodes.isEmpty()) {
        results.clear();
    } else {
        for (Node node : connectedNodes) {
            // we are only considering those nodes that are directly connected
            if (node.isNearby()) {
                results.add(node.getId());
            }
        }
    }
}

}

Para más detalles por favor verifique Android Dev

Answer 4

Ya había 2 opciones listadas aquí. Ambos son válidos dependiendo de su caso de uso. Me gustaría agregar una tercera opción, aunque sea incompleta.

Opción 1: encontrar nodos conectados utilizando NodeApi

La clase NodeApi tiene un método para recuperar nodos conectados. Con esto está seguro de que el usuario no solo ha tenido un reloj en el pasado o probado uno en algún momento. Él realmente tiene un reloj cerca y conectado.

El inconveniente de este enfoque es que no obtendrá resultados si Bluetooth no está habilitado o si el reloj no está conectado en este momento.

El método es:

List<Node> connectedNodes =
Wearable.NodeApi.getConnectedNodes(mGoogleApiClient).await().getNodes();

Un ejemplo de código más completo se ve así:

private GoogleApiClient client;
private static final long CONNECTION_TIME_OUT_MS = 1000;

public void checkIfWearableConnected() {

    retrieveDeviceNode(new Callback() {
        @Override
        public void success(String nodeId) {
            Toast.makeText(this, "There was at least one wearable found", Toast.LENGTH_SHORT).show();
        }

        @Override
        public void failed(String message) {
            Toast.makeText(this, "There are no wearables found", Toast.LENGTH_SHORT).show();
        }
    });

}

private GoogleApiClient getGoogleApiClient(Context context) {
        if (client == null)
            client = new GoogleApiClient.Builder(context)
                    .addApi(Wearable.API)
                    .build();
        return client;
    }

private interface Callback {
        public void success(final String nodeId);
        public void failed(final String message);
    }

private void retrieveDeviceNode(final Callback callback) {
        final GoogleApiClient client = getGoogleApiClient(this);
        new Thread(new Runnable() {

            @Override
            public void run() {
                client.blockingConnect(CONNECTION_TIME_OUT_MS, TimeUnit.MILLISECONDS);
                NodeApi.GetConnectedNodesResult result =
                        Wearable.NodeApi.getConnectedNodes(client).await();
                List<Node> nodes = result.getNodes();
                if (nodes.size() > 0) {
                    String nodeId = nodes.get(0).getId();
                    callback.success(nodeId);
                } else {
                    callback.failed("no wearables found");
                }
                client.disconnect();
            }
        }).start();
    }

Opción 2: comprobar la aplicación de Android Wear

Y esa es la ventaja de la segunda opción. Si obtiene un reloj, lo primero que debe hacer para conectarse es instalar la aplicación Android Wear en la computadora de mano. Por lo tanto, puede usar el PackageManager para verificar si esta aplicación Android Wear está instalada.

El inconveniente aquí es que se puede instalar la aplicación de desgaste sin tener un reloj.

Ejemplo de código:

try {
    getPackageManager().getPackageInfo("com.google.android.wearable.app", PackageManager.GET_META_DATA);

    Toast.makeText(this, "The Android Wear App is installed", Toast.LENGTH_SHORT).show();
} catch (PackageManager.NameNotFoundException e) {
    //android wear app is not installed
    Toast.makeText(this, "The Android Wear App is NOT installed", Toast.LENGTH_SHORT).show();
}

Opción 3: comprobar si hay dispositivos emparejados

No estoy seguro de si esto es posible, pero en algunos casos esta sería la solución perfecta, ya que puede verificar que el usuario tenga un reloj emparejado con su dispositivo mientras no tenga que estar conectado en ese momento.

A continuación se muestra un ejemplo de código, sin embargo, esto no incluye la verificación de si los dispositivos emparejados son portátiles o no. Esto es sólo un punto de partida.

Ejemplo de código de: getbondeddevices () que no devuelve dispositivos Bluetooth emparejados

BluetoothAdapter mBtAdapter = BluetoothAdapter.getDefaultAdapter();

Set<BluetoothDevice> pairedDevices = mBtAdapter.getBondedDevices();
if (pairedDevices.size() > 0) {
     Toast.makeText(this, "At least one paired bluetooth device found", Toast.LENGTH_SHORT).show();
    // TODO at this point you''d have to iterate these devices and check if any of them is a wearable (HOW?)
    for (BluetoothDevice device : pairedDevices) {
        Log.d("YOUR_TAG", "Paired device: "+ device.getName() + ", with address: " + device.getAddress());
    }
} else {
    Toast.makeText(this, "No paired bluetooth devices found", Toast.LENGTH_SHORT).show();
}

Tenga en cuenta que este código requiere permisos de Bluetooth en su manifiesto.

<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN"/>

Answer 5

NodeApi utilizar NodeApi , en particular NodeApi.getConnectedNodes() .

Por ejemplo (de un subproceso en segundo plano; de lo contrario, use setResultCallback() y no setResultCallback() await() ):

List<Node> connectedNodes =
    Wearable.NodeApi.getConnectedNodes(mGoogleApiClient).await().getNodes();

Si la lista de nodos devueltos contiene al menos un elemento, entonces hay un dispositivo Android Wear conectado, de lo contrario no lo hay.

Actualización: con el lanzamiento de Google Play Services 7.3 , se agregó soporte para múltiples dispositivos Android Wear conectados simultáneamente. Puede usar CapabilityApi para solicitar nodos con capacidades específicas.