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 onNodeMigrated(), 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:19.0.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 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())
            }
        }

        // Callback stops automatically after 20 seconds of data processing.
        // If you think you need more time, delegate to a coroutine or thread.
        runBlocking {
            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 Task<DataItem> 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;
            return 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());
            }
        }

        for (dataItem in dataItemsToHandle) {
            handleDataItem(nodeId, dataItem);
        }

        // Callback stops automatically after 20 seconds of data processing.
        // If you think you need more time, delegate to another thread.
    }
}