Você envia mensagens usando a API
MessageClient e anexa os seguintes itens à mensagem:
- Um payload arbitrário (opcional)
- Um caminho que identifique de forma exclusiva a ação da mensagem
Ao contrário do caso de itens de dados, não ocorre sincronização entre os apps de dispositivos portáteis e de wearables. As mensagens são um mecanismo de comunicação de uma única direção que é útil para chamadas de procedimento remoto (RPC, na sigla em inglês), como uma mensagem enviada ao wearable para iniciar uma atividade.
Vários dispositivos wearable podem ser conectados ao dispositivo portátil de um usuário. Cada dispositivo conectado à rede é considerado um nó. Com vários dispositivos conectados, você precisa considerar quais nós recebem as mensagens. Por exemplo, em um app de transcrição de voz que recebe dados de voz no dispositivo wearable, você precisa enviar a mensagem para um nó com o poder de processamento e a capacidade de bateria para processar a solicitação, como um dispositivo portátil.
Observação: com versões do Google Play Services anteriores à 7.3.0, apenas um dispositivo wearable pode ser conectado por vez ao dispositivo portátil. Você pode precisar atualizar o código existente para considerar o recurso de conexão simultânea a vários nós. Caso você não implemente as mudanças, as mensagens podem não ser entregues aos dispositivos pretendidos.
Confira os seguintes recursos relacionados:
Enviar mensagem
Um app wearable pode fornecer funcionalidade para os usuários, como a transcrição de voz. O usuário pode falar no microfone do dispositivo wearable e ter a transcrição salva em formato de nota. Como um dispositivo wearable normalmente não tem o poder de processamento e a capacidade da bateria necessários para processar a atividade de transcrição de voz, o app precisa transferir esse trabalho para um dispositivo conectado mais potente.
As seções a seguir mostram como anunciar nós de dispositivos que podem processar solicitações de atividades, descobrir os nós capazes de atender uma necessidade de solicitação e enviar mensagens para esses nós.
Anunciar capacidades
Para iniciar uma atividade em um dispositivo portátil usando um dispositivo wearable, use a classe
MessageClient para enviar a solicitação. Como vários wearables podem ser conectados ao dispositivo portátil, o app para wearables precisa determinar se um nó conectado é capaz de iniciar a atividade. No app portátil, anuncie que o nó em que ele é executado tem recursos específicos.
Para anunciar os recursos do app portátil:
- Crie um arquivo de configuração XML no diretório
res/values/do seu projeto e nomeie-o comowear.xml. - Adicione um recurso chamado
android_wear_capabilitiesawear.xml. - Defina os recursos que o dispositivo oferece.
Observação: recursos são strings personalizadas que você define e precisam ser únicos dentro do app.
O exemplo a seguir mostra como adicionar uma capacidade chamada voice_transcription a wear.xml:
<resources xmlns:tools="http://schemas.android.com/tools"
tools:keep="@array/android_wear_capabilities">
<string-array name="android_wear_capabilities">
<item>voice_transcription</item>
</string-array>
</resources>
Recuperar nós com os recursos necessários
Inicialmente, você pode detectar os nós compatíveis chamando o método getCapability da classe
CapabilityClient. O exemplo a seguir mostra como recuperar manualmente os resultados dos nós ao alcance com a capacidade voice_transcription:
Kotlin
private const val VOICE_TRANSCRIPTION_CAPABILITY_NAME = "voice_transcription"
...
private fun setupVoiceTranscription() {
val capabilityInfo: CapabilityInfo = Tasks.await(
Wearable.getCapabilityClient(context)
.getCapability(
VOICE_TRANSCRIPTION_CAPABILITY_NAME,
CapabilityClient.FILTER_REACHABLE
)
)
// capabilityInfo has the reachable nodes with the transcription capability
updateTranscriptionCapability(capabilityInfo)
}
Java
private static final String
VOICE_TRANSCRIPTION_CAPABILITY_NAME = "voice_transcription";
...
private void setupVoiceTranscription() {
CapabilityInfo capabilityInfo = Tasks.await(
Wearable.getCapabilityClient(context).getCapability(
VOICE_TRANSCRIPTION_CAPABILITY_NAME, CapabilityClient.FILTER_REACHABLE));
// capabilityInfo has the reachable nodes with the transcription capability
updateTranscriptionCapability(capabilityInfo);
}
Para detectar nós compatíveis conforme eles forem conectados ao dispositivo wearable, registre uma instância de um listener, mais especificamente, um OnCapabilityChangedListener de um objeto
CapabilityClient. O exemplo a seguir mostra como registrar o listener e recuperar os resultados de nós ao alcance com o recurso voice_transcription:
Kotlin
private fun setupVoiceTranscription() {
updateTranscriptionCapability(capabilityInfo).also { capabilityListener ->
Wearable.getCapabilityClient(context).addListener(
capabilityListener,
VOICE_TRANSCRIPTION_CAPABILITY_NAME
)
}
}
Java
private void setupVoiceTranscription() {
...
// This example uses a Java 8 Lambda. Named or anonymous classes can also be used.
CapabilityClient.OnCapabilityChangedListener capabilityListener =
capabilityInfo -> { updateTranscriptionCapability(capabilityInfo); };
Wearable.getCapabilityClient(context).addListener(
capabilityListener,
VOICE_TRANSCRIPTION_CAPABILITY_NAME);
}
Depois de detectar os nós compatíveis, determine o destino da mensagem. Você precisa escolher um nó que esteja próximo ao seu dispositivo wearable para minimizar o roteamento de mensagens por vários nós. Um nó próximo é um nó que está diretamente conectado ao dispositivo. Para determinar se um nó está próximo, chame o método Node.isNearby().
O exemplo a seguir mostra como você pode determinar o melhor nó para usar:
Kotlin
private var transcriptionNodeId: String? = null
private fun updateTranscriptionCapability(capabilityInfo: CapabilityInfo) {
transcriptionNodeId = pickBestNodeId(capabilityInfo.nodes)
}
private fun pickBestNodeId(nodes: Set<Node>): String? {
// Find a nearby node or pick one arbitrarily
return nodes.firstOrNull { it.isNearby }?.id ?: nodes.firstOrNull()?.id
}
Java
private String transcriptionNodeId = null;
private void updateTranscriptionCapability(CapabilityInfo capabilityInfo) {
Set<Node> connectedNodes = capabilityInfo.getNodes();
transcriptionNodeId = pickBestNodeId(connectedNodes);
}
private String pickBestNodeId(Set<Node> nodes) {
String bestNodeId = null;
// Find a nearby node or pick one arbitrarily
for (Node node : nodes) {
if (node.isNearby()) {
return node.getId();
}
bestNodeId = node.getId();
}
return bestNodeId;
}
Entregar a mensagem
Depois de identificar o melhor nó para usar, envie a mensagem usando a classe
MessageClient.
O exemplo abaixo mostra como enviar uma mensagem para o nó compatível com transcrições a partir de um dispositivo wearable. Verifique se o nó está disponível antes de tentar enviar a mensagem. Esse chamado é síncrono e bloqueia o processamento até o sistema colocar a mensagem na fila de entrega.
Observação: um código de resultado bem-sucedido não garante que a mensagem foi entregue. Se o app exigir confiabilidade de dados, use objetos DataItem ou a classe ChannelClient para enviar dados entre dispositivos.
Kotlin
const val VOICE_TRANSCRIPTION_MESSAGE_PATH = "/voice_transcription"
...
private fun requestTranscription(voiceData: ByteArray) {
transcriptionNodeId?.also { nodeId ->
val sendTask: Task<*> = Wearable.getMessageClient(context).sendMessage(
nodeId,
VOICE_TRANSCRIPTION_MESSAGE_PATH,
voiceData
).apply {
addOnSuccessListener { ... }
addOnFailureListener { ... }
}
}
}
Java
public static final String VOICE_TRANSCRIPTION_MESSAGE_PATH = "/voice_transcription";
private void requestTranscription(byte[] voiceData) {
if (transcriptionNodeId != null) {
Task<Integer> sendTask =
Wearable.getMessageClient(context).sendMessage(
transcriptionNodeId, VOICE_TRANSCRIPTION_MESSAGE_PATH, voiceData);
// You can add success and/or failure listeners,
// Or you can call Tasks.await() and catch ExecutionException
sendTask.addOnSuccessListener(...);
sendTask.addOnFailureListener(...);
} else {
// Unable to retrieve node with transcription capability
}
}
Observação: para saber mais sobre chamadas síncronas e assíncronas para o Google Play Services e quando usar cada uma delas, consulte a API Tasks.
Você também pode transmitir mensagens para todos os nós conectados. Para recuperar todos os nós conectados aos quais você pode enviar mensagens, implemente o seguinte código:
Kotlin
private fun getNodes(): Collection<String> {
return Tasks.await(Wearable.getNodeClient(context).connectedNodes).map { it.id }
}
Java
private Collection<String> getNodes() {
HashSet <String>results = new HashSet<String>();
List<Node> nodes =
Tasks.await(Wearable.getNodeClient(context).getConnectedNodes());
for (Node node : nodes.getNodes()) {
results.add(node.getId());
}
return results;
}
Receber uma mensagem
Para receber notificações de mensagens recebidas, implemente a interface
MessageClient.OnMessageReceivedListener para fornecer um listener para eventos de mensagem. Em seguida, registre o listener com o método addListener. Este exemplo mostra como você pode implementar o listener para verificar o VOICE_TRANSCRIPTION_MESSAGE_PATH. Se essa condição for true, inicie uma atividade para processar os dados de voz.
Kotlin
fun onMessageReceived(messageEvent: MessageEvent) {
if (messageEvent.path == VOICE_TRANSCRIPTION_MESSAGE_PATH) {
val startIntent = Intent(this, MainActivity::class.java).apply {
addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
putExtra("VOICE_DATA", messageEvent.data)
}
startActivity(this, startIntent)
}
}
Java
@Override
public void onMessageReceived(MessageEvent messageEvent) {
if (messageEvent.getPath().equals(VOICE_TRANSCRIPTION_MESSAGE_PATH)) {
Intent startIntent = new Intent(this, MainActivity.class);
startIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
startIntent.putExtra("VOICE_DATA", messageEvent.getData());
startActivity(this, startIntent);
}
}
Isso é apenas um snippet que precisa de mais detalhes de implementação. Saiba como implementar uma atividade ou um serviço completo de listener em Detectar eventos de Data Layer.