Synchronizuj dane

W tym dokumencie opisujemy, jak synchronizować dane między urządzeniem z Wear OS a telefonem. Wskazówki dotyczące tego, kiedy używać interfejsu Data Layer API, a kiedy infrastruktury, znajdziesz w omówieniu.

Wysyłanie i synchronizowanie danych bezpośrednio z sieci

Twórz aplikacje na Wear OS, które komunikują się bezpośrednio z siecią. Używaj tych samych interfejsów API, których używasz do tworzenia aplikacji mobilnych, ale pamiętaj o kilku różnicach związanych z Wear OS.

Synchronizowanie danych za pomocą interfejsu Wear OS Data Layer API

DataClient udostępnia interfejs API, za pomocą którego komponenty mogą odczytywać lub zapisywać dane w DataItem lub Asset.

Elementy danych i zasoby można ustawiać, gdy nie ma połączenia z żadnym urządzeniem. Są one synchronizowane, gdy urządzenia nawiążą połączenie sieciowe. Te dane są prywatne dla Twojej aplikacji i są dostępne tylko dla niej na innych urządzeniach.

  • DataItem jest synchronizowany na wszystkich urządzeniach w sieci Wear OS. Zwykle mają niewielki rozmiar.

  • Użyj Asset, aby przesłać większy obiekt, np. obraz. System śledzi, które zasoby zostały już przesłane, i automatycznie usuwa duplikaty.

Nasłuchiwanie zdarzeń w usługach

Rozszerz klasę WearableListenerService. System zarządza cyklem życia podstawowej usługi WearableListenerService, wiążąc ją, gdy trzeba wysłać elementy danych lub wiadomości, i odwiązując, gdy nie jest potrzebna.

Nasłuchiwanie zdarzeń w aktywnościach

Zaimplementuj interfejs OnDataChangedListener. Użyj tego interfejsu zamiast WearableListenerService, jeśli chcesz nasłuchiwać zmian tylko wtedy, gdy użytkownik aktywnie korzysta z Twojej aplikacji.

description: Transfer large binary objects, such as images, between Android phones and Wear OS watches using Assets in the Data Layer API. keywords_public: Wear OS, Data Layer API, Assets, Bluetooth data transfer, data synchronization, DataMap, PutDataRequest

Synchronizowanie danych

Aby udostępniać duże obiekty binarne przez Bluetooth, np. nagranie głosowe z innego urządzenia, możesz dołączyć Asset do elementu danych, a następnie umieścić ten element w replikowanym magazynie danych.

Uwaga: interfejs Data Layer API może wysyłać wiadomości i synchronizować dane tylko z telefonami z Androidem lub zegarkami z Wear OS. Jeśli urządzenie z Wear OS jest sparowane z urządzeniem z iOS, interfejs Data Layer API nie będzie działać.

Z tego powodu nie używaj interfejsu Data Layer API jako głównego sposobu komunikacji z siecią. Zamiast tego postępuj w aplikacji na Wear OS tak samo jak w aplikacji na telefon – z niewielkimi różnicami opisanymi w sekcji Dostęp do sieci i synchronizacja w Wear OS.

Zasoby automatycznie obsługują buforowanie danych, aby zapobiegać ponownemu przesyłaniu i oszczędzać przepustowość Bluetooth. Typowym rozwiązaniem jest pobranie obrazu przez aplikację na telefon, zmniejszenie go do odpowiedniego rozmiaru do wyświetlania na zegarku i udostępnienie go aplikacji na zegarku jako zasobu. Poniższe przykłady pokazują ten wzorzec.

Przesyłanie zasobu

Utwórz zasób za pomocą jednej z metod create...() w klasie Asset. Przekonwertuj bitmapę na tablicę bajtów, a następnie wywołaj createFromBytes(), aby utworzyć zasób, jak pokazano w tym przykładzie.

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

Następnie dołącz zasób do elementu danych za pomocą metody putAsset() w DataMap lub PutDataRequest. Następnie umieść element danych w magazynie danych za pomocą metody putDataItem(), jak pokazano w tych przykładach.

Ten przykład używa 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
}

Ten przykład używa 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
}

Odbieranie zasobów

Po utworzeniu zasobu zwykle odczytujesz go i wyodrębniasz po drugiej stronie połączenia. Ten przykład pokazuje, jak zaimplementować wywołanie zwrotne, aby wykryć zmianę zasobu i go wyodrębnić:

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
    }
}

Więcej informacji znajdziesz w przykładowym projekcie DataLayer w GitHubie.