Comunicación Android con Wear

Para realizar la comunicación de la companion app con el wear, vamos a usar Data layer messages.

Vamos a crear una primera aplicación con la que vamos a pasarle un simple string a nuestro wear a través de nuestro teléfono.

Envío de mensajes

Lo primero que debemos de hacer, es añadir al gradle las siguientes dependencias:

dependencies {
  compile fileTree(dir: 'libs', include: ['*.jar'])
  compile 'com.android.support:appcompat-v7:21.0.+'
  compile 'com.google.android.gms:play-services:6.5.+'
}

También es necesario en el archivo Manifest, añadir el siguiente meta-data, para poder configurar el cliente de google:

<aplication>
...
<meta-data android:name="com.google.android.gms.version"
android:value="@integer/google_play_services_version" />
</application>

Creando al emisor (Companion App).

Para enviar un mensaje, vamos a necesitar actualizar el código en el main activity de nuestra aplicación android. Lo primero que necesitamos hacer, es crear un servicio de Google para poder acceder a la API del Wear.

public class MainActivity extends AppCompatActivity implements 
  GoogleApiClient.connectionCallbacks, GoogleApiClient.OnConnectionFailedListener {

  GoogleApiClient googleApiClient;

  @Override 
  protected void onCreate(Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 
    setContentView(R.layout.activity_handheld);

    // Build a new GoogleApiClient for the Wearable API
    googleApiClient = new GoogleApiClient.Builder(this)
      .addApi(Wearable.API)
      .addConnectionCallbacks(this)
      .addOnConnectionFailedListener(this)
      .build();
  } 
}

En segundo lugar, necesitamos crear los métodos callback para nuestro data layer. (En este ejemplo se va a enviar un mensaje desde onConnected). Básicamente lo que aqui hacemos es conectar con el cliente de google en onStart y en onCreate creamos una instancia de la clase SendToDataLayerThread que vamos a implementar en el siguiente paso, donde le pasamos el path y la variable message.

// Connect to the data layer when the Activity starts

@Override
protected void onStart() {
  super.onStart();
  googleApiClient.connect();
}

// Send a message when the data layer connection is successful.
@Override
public void onConnected(Bundle connectionHint) {
  String message = "Hello wearable\n Via the data layer";

  //Requires a new thread to avoid blocking the UI
  new SendToDataLayerThread("/message_path", message).start();
}

// Disconnect from the data layer when the Activity stops
@Override
protected void onStop() {
  if (null != googleApiClient && googleApiClient.isConnected()) {
    googleApiClient.disconnect();
  }

  super.onStop();
}

// Placeholders for required connection callbacks
@Override
public void onConnectionSuspended(int cause) { }

@Override
public void onConnectionFailed(ConnectionResult connectionResult) { }

Una manera de pasar más información de nuestra compaion app es añadir un dataMap a nuestro data layer en vez de una cadena de texto.

Por último, solo nos queda crear la clase SendToDataLayerThread vista en el paso anterior para el envío de nuestro mensaje.

class SendToDataLayerThread extends Thread {
  String path;
  String message;

  // Constructor to send a message to the data layer
  SendToDataLayerThread(String p, String msg) {
    path = p;
    message = msg;
  }

  public void run() {
    NodeApi.GetConnectedNodesResult nodes = Wearable.NodeApi.getConnectedNodes(googleApiClient).await();
    for (Node node : nodes.getNodes()) {
      SendMessageResult result = Wearable.MessageApi.sendMessage(googleApiClient, node.getId(), path, message.getBytes()).await();

      if (result.getStatus().isSuccess()) {
        Log.v("myTag", "Mensaje: {" + message + "} enviado a: " + node.getDisplayName());
      }
      else {
        // Log an error
        Log.v("myTag", "ERROR: Falló el envío");
      }
    }
  }
}

Turno del receptor (Android Wear).

Aquí vamos a ver como implementar un listener de mensajes. En todo este bloque vamos a realizar todos los cambios en la parte del wear.

Dependencias

Hay que añadir las siguientes dependencias en el gradle del módulo WEAR.

dependencies {
  compile fileTree(dir: 'libs', include: ['*.jar'])
  compile 'com.google.android.support:wearable:1.1.+'
  compile 'com.google.android.gms:play-services-wearable:6.5.+'
}
Creando la clase ListenerService

Para hacer que nuestro wear escuche para poder recibir un mensaje, tenemos que extender nuestro clase principal a WearableListenerServices tal y como podemos ver en el siguiente ejemplo.

Public class ListenerService extends WearableListenerService {

    @Override
    public void onMessageReceived(MessageEvent messageEvent) {

        if (messageEvent.getPath().equals("/message_path")) {
            final String message = new String(messageEvent.getData());
            Log.v("myTag", "Path del mensaje recibido: " + messageEvent.getPath());
            Log.v("myTag", "Mensaje recibido: " + message);
        }
        else {
            super.onMessageReceived(messageEvent);
        }
    }
}

Con todo esto, ya tenemos comunicación de nuestra aplicación wear con su companion app, espero que os haya servido de ayuda y si tenéis cualquier duda en la que puedo llegar, ya sabéis, dejad un comentario o a través de mi Twitter.

Fuente: Readthedocs.org

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

A %d blogueros les gusta esto: