Mentransfer data Wear OS ke perangkat seluler baru

Saat menyiapkan perangkat Wear OS, pengguna menghubungkan perangkat Wear OS ke perangkat seluler tertentu. Setelah itu, pengguna mungkin memutuskan untuk mendapatkan perangkat seluler baru dan menghubungkan perangkat Wear OS yang ada ke perangkat seluler baru ini. Beberapa data yang terkait dengan perangkat Wear OS disimpan di perangkat seluler yang saat ini terhubung.

Mulai Wear OS 4, saat pengguna terhubung ke perangkat seluler baru, mereka dapat mentransfer data Wear OS ke perangkat seluler baru. Data disinkronkan secara otomatis saat ditransfer.

Saat pengguna meminta transfer, Lapisan Data Wearable mengirimkan objek DataItem yang awalnya disimpan di satu perangkat seluler ke perangkat seluler lainnya. Hal ini memungkinkan pengalaman yang lancar bagi pengguna aplikasi Anda.

Dokumen ini menjelaskan cara mengonfigurasi aplikasi Wear OS, dan aplikasi seluler pendampingnya, untuk mendukung skenario ini.

Persiapan

Proses transfer data menangani objek DataItem dengan cara yang berbeda, bergantung pada aplikasi yang memiliki data:

Objek yang dimiliki oleh aplikasi Wear OS

Objek ini dipertahankan di perangkat Wear OS.

Objek yang dimiliki oleh aplikasi seluler

Objek ini diarsipkan di perangkat lama. Selanjutnya, sistem akan memaketkan data yang diarsipkan ke dalam objek DataItemBuffer lalu mengirimkan data ini ke aplikasi seluler yang diinstal di perangkat seluler baru.

Segera setelah arsip dikirim, Lapisan Data Wearable memanggil pemroses onDataChanged(), serupa dengan bagaimana aplikasi diberi tahu saat data ditulis oleh perangkat Wear OS.

Mempertahankan data yang ditransfer

Aplikasi Anda bertanggung jawab untuk mempertahankan objek DataItem yang ditransfer. Segera setelah data dikirim ke perangkat seluler baru, arsip akan dihapus dari perangkat lama.

Pastikan setiap kondisi berikut terpenuhi:

1. Aplikasi Anda diinstal di kedua perangkat seluler yang terlibat dalam proses transfer.
2. Aplikasi seluler, yang diinstal di setiap perangkat seluler, memiliki tanda tangan paket yang cocok.

Jika tidak, objek DataItem yang diarsipkan tidak akan dikirim dan akan dihapus.

Menerima data dari perangkat seluler lama

Untuk menerima data di perangkat seluler baru yang diarsipkan di perangkat seluler lama, aplikasi seluler Anda harus mengimplementasikan callback onNodeMigrated(), bagian dari class WearableListenerService ini. Caranya, selesaikan langkah-langkah berikut:

1. Dalam file build aplikasi seluler, sertakan dependensi pada versi terbaru library wearable di layanan Google Play:

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

2. Deklarasikan dan ekspor WearableListenerService dalam file manifes aplikasi Anda:

   <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. Buat class layanan yang memperluas WearableListenerService dan mengganti 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();
       }
   }