Transferir dados do Wear OS para um novo dispositivo móvel

Quando os usuários configuram um dispositivo Wear OS, eles o conectam a um dispositivo móvel específico. Mais tarde, o usuário pode decidir comprar um novo dispositivo móvel e conectar o dispositivo Wear OS a ele. Alguns dados relacionados a um dispositivo Wear OS são armazenados no dispositivo móvel conectado no momento.

A partir do Wear OS 4, os usuários podem transferir dados do Wear OS para um novo dispositivo móvel. Esses dados são sincronizados automaticamente ao serem transferidos.

Quando o usuário solicita uma transferência, a camada de dados wearable envia objetos DataItem, originalmente armazenados em um dispositivo móvel, para outro dispositivo. Isso proporciona a melhor experiência aos usuários do seu app.

Este documento descreve como configurar o app para Wear OS e o app complementar para dispositivos móveis, para dar suporte a esse cenário.

Preparação

O processo de transferência de dados processa objetos DataItem de maneira diferente, dependendo de qual app é o proprietário dos dados:

Objetos que pertencem ao app para Wear OS

Esses objetos são preservados no dispositivo Wear OS.

Objetos que pertencem ao app para dispositivos móveis

Esses objetos são arquivados no dispositivo antigo. Em seguida, o sistema empacota os dados arquivados em um objeto DataItemBuffer e os entrega ao app para dispositivos móveis instalado no novo dispositivo.

Imediatamente após o envio do arquivo, a camada de dados wearable invoca o listener onDataChanged(), da mesma forma que o app é notificado quando os dados são gravados pelo dispositivo Wear OS.

Preservar dados transferidos

É responsabilidade do app preservar os objetos DataItem transferidos. Logo após a entrega dos dados ao novo dispositivo móvel, o arquivo é excluído do dispositivo antigo.

Confira se todas as condições abaixo são verdadeiras:

1. O app está instalado nos dois dispositivos móveis envolvidos na transferência.
2. Os apps instalados em cada dispositivo móvel têm assinaturas de pacote correspondentes.

Caso contrário, os objetos DataItem arquivados não serão entregues e serão descartados.

Receber dados do dispositivo móvel antigo

Para receber dados que foram arquivado no dispositivo móvel antigo no novo dispositivo móvel, seu app precisa implementar o callback onNodeMigrated(), parte da classe WearableListenerService. Para isso, siga estas etapas:

1. No arquivo de build do app para dispositivos móveis, inclua uma dependência da versão mais recente da biblioteca de wearables no Google Play Services:

   dependencies {
       ...
       implementation 'com.google.android.gms:play-services-wearable:18.1.0'
   }
   

2. Declare e exporte o WearableListenerService no arquivo de manifesto do seu app:

   <service
   android:name=".MyWearableListenerService"
   android:exported="true">
   <intent-filter>
       ...
       <action android:name="com.google.android.gms.wearable.NODE_MIGRATED" />
       <data android:scheme="wear" />
   </intent-filter>
   </service>
   

3. Crie uma classe de serviço que estenda WearableListenerService e modifique onNodeMigrated().

   Kotlin

   
   class MyWearableListenerService : WearableListenerService() {
       val dataClient: DataClient = Wearable.getDataClient(this)
   
       private fun shouldHandleDataItem(nodeId: String,
               dataItem: DataItem): Boolean {
           // Your logic here
           return dataItem.uri.path?.startsWith("/my_feature_path/") == true
       }
   
       private suspend fun handleDataItem(nodeId: String, dataItem: DataItem) {
           val data = dataItem.data ?: return
           val path = dataItem.uri.path ?: return
           // Your logic here
           if (data.toString().startsWith("Please restore")) {
               dataClient.putDataItem(
                   PutDataRequest.create(path).setData(data))
           }
       }
   
       override fun onNodeMigrated(nodeId: String, archive: DataItemBuffer) {
           val dataItemsToHandle = mutableListOf<DataItem>()
   
           for (dataItem in archive) {
               if (shouldHandleDataItem(nodeId, dataItem)) {
                   dataItemsToHandle.add(dataItem.freeze())
               }
           }
   
           CoroutineScope(Job() + Dispatchers.IO).launch {
               for (dataItem in dataItemsToHandle) {
                   handleDataItem(nodeId, dataItem)
               }
           }
       }
   }
   
   

   Java

   
   public class MyWearableListenerService extends WearableListenerService {
       private final DataClient dataClient = Wearable.getDataClient(this);
   
       private boolean shouldHandleDataItem(String nodeId, DataItem dataItem) {
           // Your logic here
           return Objects.requireNonNull(dataItem.getUri().getPath())
                   .startsWith("/my_feature_path/");
       }
   
       private void handleDataItem(String nodeId, DataItem dataItem) {
           byte[] data = dataItem.getData();
           String path = dataItem.getUri().getPath();
           // Your logic here
           if (data != null && path != null && Arrays.toString(data)
                   .startsWith("Please restore")) {
               assert path != null;
               dataClient.putDataItem(
                       PutDataRequest.create(path).setData(data));
           }
       }
   
       @Override
       public void onNodeMigrated(@NonNull String nodeId, DataItemBuffer archive) {
           List<DataItem> dataItemsToHandle = new ArrayList<>();
   
           for (DataItem dataItem : archive) {
               if (shouldHandleDataItem(nodeId, dataItem)) {
                   dataItemsToHandle.add(dataItem.freeze());
               }
           }
   
           Thread thread = new Thread(() -> {
               for (DataItem dataItem : dataItemsToHandle) {
                   handleDataItem(nodeId, dataItem);
               }
           });
           thread.start();
       }
   }