Menyinkronkan data

Dokumen ini menjelaskan cara menyinkronkan data antara perangkat Wear OS dan ponsel. Lihat panduan ringkasan tentang kapan harus menggunakan Data Layer API dan kapan harus menggunakan infrastruktur Anda.

Mengirim dan menyinkronkan data langsung dari jaringan

Buat aplikasi Wear OS untuk berkomunikasi langsung dengan jaringan. Gunakan API yang sama dengan yang Anda gunakan untuk pengembangan seluler, tetapi perhatikan beberapa perbedaan khusus Wear OS.

Menyinkronkan data menggunakan Wear OS Data Layer API

DataClient mengekspos API agar komponen dapat membaca atau menulis ke DataItem atau Asset.

Anda dapat menetapkan item data dan aset tanpa terhubung ke perangkat mana pun. Data tersebut disinkronkan saat perangkat membuat koneksi jaringan. Data ini bersifat pribadi untuk aplikasi Anda dan hanya dapat diakses oleh aplikasi Anda di perangkat lain.

• DataItem disinkronkan di semua perangkat dalam jaringan Wear OS. Item data tersebut biasanya berukuran kecil.

• Gunakan Asset untuk mentransfer objek yang lebih besar, seperti gambar. Sistem melacak aset mana yang sudah ditransfer dan melakukan penghapusan duplikat secara otomatis.

Memproses peristiwa di layanan

Perluas class WearableListenerService. Sistem akan mengelola siklus proses WearableListenerService dasar, melakukan binding ke layanan saat perlu mengirimkan item data atau pesan, dan membatalkan layanan ketika tidak diperlukan.

Memproses peristiwa dalam aktivitas

Terapkan antarmuka OnDataChangedListener. Gunakan antarmuka ini, bukan WearableListenerService, jika Anda ingin memproses perubahan hanya saat pengguna aktif menggunakan aplikasi Anda.

description: Mentransfer objek biner besar, seperti gambar, antara ponsel Android dan smartwatch Wear OS menggunakan Aset di Data Layer API. keywords_public: Wear OS, Data Layer API, Aset, transfer data Bluetooth, sinkronisasi data, DataMap, PutDataRequest

Menyinkronkan data

Untuk membagikan objek biner besar melalui transportasi Bluetooth, seperti rekaman suara dari perangkat lain, Anda dapat melampirkan Asset ke item data, lalu memasukkan item data ke dalam penyimpanan data replika. Namun, jika pertukaran adalah pertukaran satu kali antara dua perangkat yang terhubung, pertimbangkan apakah transfer langsung yang lebih sederhana lebih tepat.

Catatan: Data Layer API hanya dapat mengirim pesan dan menyinkronkan data dengan ponsel yang menjalankan Android atau smartwatch Wear OS. Jika perangkat Wear OS disambungkan dengan perangkat iOS, Data Layer API tidak akan berfungsi.

Karena alasan ini, jangan gunakan Data Layer API sebagai cara utama untuk berkomunikasi dengan jaringan. Sebagai gantinya, ikuti pola yang sama di aplikasi Wear OS seperti di aplikasi ponsel—dengan beberapa perbedaan kecil, seperti yang dijelaskan dalam Akses dan sinkronisasi jaringan di Wear OS.

Aset secara otomatis menangani caching data untuk mencegah transmisi ulang dan menghemat bandwidth Bluetooth. Pola umum ditujukan bagi aplikasi ponsel untuk mendownload gambar, memperkecil ke ukuran yang sesuai untuk tampilan di smartwatch, dan membagikannya ke aplikasi smartwatch sebagai aset. Contoh berikut menunjukkan pola ini.

Mentransfer aset

Buat aset menggunakan salah satu metode create...() dalam class Asset. Konversi bitmap ke array byte, lalu panggil createFromBytes() untuk membuat aset, seperti yang ditunjukkan pada contoh berikut.

private fun createAssetFromBitmap(bitmap: Bitmap): Asset =
    ByteArrayOutputStream().let { byteStream ->
        bitmap.compress(Bitmap.CompressFormat.PNG, 100, byteStream)
        Asset.createFromBytes(byteStream.toByteArray())
    }
DataLayerActivity.kt

Selanjutnya, lampirkan aset ke item data dengan metode putAsset() di DataMap atau PutDataRequest. Kemudian, masukkan item data ke penyimpanan data menggunakan metode putDataItem(), seperti yang ditunjukkan dalam contoh berikut.

Contoh berikut menggunakan PutDataRequest:

private fun Context.sendImagePutDataRequest(): Task<DataItem> {

    val asset: Asset = createAssetFromBitmap(BitmapFactory.decodeResource(resources, R.drawable.ic_walk))
    val request: PutDataRequest = PutDataRequest.create("/image").apply {
        putAsset("profileImage", asset)
    }
    val putTask: Task<DataItem> = Wearable.getDataClient(this).putDataItem(request)

    return putTask
}
DataLayerActivity.kt

Contoh berikut menggunakan PutDataMapRequest:

private fun Context.sendImagePutDataMapRequest(): Task<DataItem> {

    val asset: Asset = createAssetFromBitmap(BitmapFactory.decodeResource(resources, R.drawable.ic_walk))
    val request: PutDataRequest = PutDataMapRequest.create("/image").run {
        dataMap.putAsset("profileImage", asset)
        asPutDataRequest()
    }
    val putTask: Task<DataItem> = Wearable.getDataClient(this).putDataItem(request)

    return putTask
}
DataLayerActivity.kt

Menerima aset

Setelah membuat aset, Anda biasanya membaca dan mengekstraknya di sisi lain koneksi. Contoh berikut menunjukkan cara menerapkan callback untuk mendeteksi perubahan aset dan mengekstrak aset:

override fun onDataChanged(dataEvents: DataEventBuffer) {
    dataEvents
        .filter { it.type == DataEvent.TYPE_CHANGED && it.dataItem.uri.path == "/image" }
        .forEach { event ->
            val asset = DataMapItem.fromDataItem(event.dataItem)
                .dataMap.getAsset("profileImage")

            asset?.let { safeAsset ->
                lifecycleScope.launch {
                    val bitmap = loadBitmapFromAsset(safeAsset)
                    // Do something with the bitmap
                }
            }
        }
}

private suspend fun loadBitmapFromAsset(asset: Asset): Bitmap? = withContext(Dispatchers.IO) {
    try {
        val assetResult = Wearable.getDataClient(this@DataLayerActivity2)
            .getFdForAsset(asset)
            .await()

        assetResult?.inputStream?.use { inputStream ->
            BitmapFactory.decodeStream(inputStream)
        }
    } catch (e: Exception) {
        e.printStackTrace()
        null
    }
}
DataLayerActivity.kt

Untuk mengetahui informasi selengkapnya, lihat project contoh DataLayer di GitHub.