Synchronizuj dane trwałe

Ten dokument opisuje sposób synchronizowania danych między urządzeniem z Wear OS a urządzeniem podręcznym.

Wysyłaj i synchronizuj dane bezpośrednio z sieci

Utwórz aplikacje na Wear OS, aby komunikowały się bezpośrednio z siecią. Możesz używać tych samych interfejsów API, których używasz do tworzenia aplikacji mobilnych, ale pamiętaj o różnicach związanych z Wear OS.

Synchronizowanie danych za pomocą interfejsu Wear OS Data Layer API

DataClient udostępnia interfejs API do odczytu lub zapisu w DataItem lub Asset przez komponenty.

Uwaga: klasa służy do przenoszenia danych i nie pełni funkcji mechanizmu przechowywania danych. Utwórz własną kopię danych, do których aplikacja ma dostęp, np. w bazie danych sal.

Elementy danych i zasoby możesz konfigurować bez połączenia z żadnymi urządzeniami. Są zsynchronizowane, gdy urządzenia nawiążą połączenie sieciowe. Dane te są prywatne dla Twojej aplikacji i tylko dla niej dostępne na innych urządzeniach.

• Aplikacja DataItem jest synchronizowana na wszystkich urządzeniach w sieci Wear OS. Są zwykle małe.

  Uwaga: po odinstalowaniu aplikacji z telefonu elementy danych i zasoby są resetowane.

• Aby przenieść większy obiekt, na przykład obraz, użyj Asset. System śledzi, które zasoby zostały już przeniesione, i automatycznie przeprowadza deduplikację.

Nasłuchuj zdarzeń w usługach

Rozszerz klasę WearableListenerService. System zarządza cyklem życia podstawowego WearableListenerService przez powiązanie z usługą, gdy musi wysyłać elementy danych lub wiadomości, oraz usuwanie powiązania usługi, gdy nie są potrzebne żadne działania.

Nasłuchuj zdarzeń w działaniach

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

Przenoszenie danych

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

Uwaga: interfejs Data Layer API może wysyłać wiadomości i synchronizować dane tylko na telefonach z Androidem i zegarkach 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 w aplikacji na Wear stosuj ten sam wzorzec co w aplikacji mobilnej, z kilkoma niewielkimi różnicami opisanymi w artykule Dostęp do sieci i synchronizacja w Wear OS.

Zasoby automatycznie obsługują buforowanie danych, aby zapobiec ponownemu przesyłaniu i oszczędzać przepustowość Bluetooth. Typowym wzorcem są aplikacje mobilne, które pobierają obraz, zmniejszają go do odpowiedniego rozmiaru, aby wyświetlał się na nim, i przesyłały do aplikacji jako zasób. Poniższe przykłady obrazują ten wzorzec.

Uwaga: chociaż rozmiar elementów danych jest teoretycznie ograniczony do 100 KB, w praktyce można używać większych elementów danych. W przypadku większych elementów danych rozdziel dane według unikalnych ścieżek i unikaj używania jednej ścieżki dla wszystkich danych. Przenoszenie dużych zasobów w wielu przypadkach wpływa na wrażenia użytkownika, dlatego przetestuj swoje aplikacje, aby upewnić się, że działają dobrze podczas przenoszenia dużych zasobów.

Przenoszenie zasobu

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

Kotlin

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

Java

private static Asset createAssetFromBitmap(Bitmap bitmap) {
    final ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
    bitmap.compress(Bitmap.CompressFormat.PNG, 100, byteStream);
    return 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 poniższych przykładach.

W przykładzie poniżej użyto parametru PutDataRequest:

Kotlin

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

Java

Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.image);
Asset asset = createAssetFromBitmap(bitmap);
PutDataRequest request = PutDataRequest.create("/image");
request.putAsset("profileImage", asset);
Task<DataItem> putTask = Wearable.getDataClient(context).putDataItem(request);

W przykładzie poniżej użyto parametru PutDataMapRequest:

Kotlin

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

Java

Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.image);
Asset asset = createAssetFromBitmap(bitmap);
PutDataMapRequest dataMap = PutDataMapRequest.create("/image");
dataMap.getDataMap().putAsset("profileImage", asset);
PutDataRequest request = dataMap.asPutDataRequest();
Task<DataItem> putTask = Wearable.getDataClient(context).putDataItem(request);

Odbierz zasoby

Podczas tworzenia zasobu warto go odczytać i wyodrębnić po drugiej stronie połączenia. Oto przykład implementacji wywołania zwrotnego w celu wykrycia zmiany zasobu i wyodrębnienia go:

Kotlin

override fun onDataChanged(dataEvents: DataEventBuffer) {
    dataEvents
            .filter { it.type == DataEvent.TYPE_CHANGED && it.dataItem.uri.path == "/image" }
            .forEach { event ->
                val bitmap: Bitmap? = DataMapItem.fromDataItem(event.dataItem)
                        .dataMap.getAsset("profileImage")
                        .let { asset -> loadBitmapFromAsset(asset) }
                // Do something with the bitmap
            }
}

fun loadBitmapFromAsset(asset: Asset): Bitmap? {
    // Convert asset into a file descriptor and block until it's ready
    val assetInputStream: InputStream? =
            Tasks.await(Wearable.getDataClient(context).getFdForAsset(asset))
            ?.inputStream

    return assetInputStream?.let { inputStream ->
        // Decode the stream into a bitmap
        BitmapFactory.decodeStream(inputStream)
    } ?: run {
        Log.w(TAG, "Requested an unknown Asset.")
        null
    }
}

Java

@Override
public void onDataChanged(DataEventBuffer dataEvents) {
  for (DataEvent event : dataEvents) {
    if (event.getType() == DataEvent.TYPE_CHANGED &&
        event.getDataItem().getUri().getPath().equals("/image")) {
      DataMapItem dataMapItem = DataMapItem.fromDataItem(event.getDataItem());
      Asset profileAsset = dataMapItem.getDataMap().getAsset("profileImage");
      Bitmap bitmap = loadBitmapFromAsset(profileAsset);
      // Do something with the bitmap
    }
  }
}

public Bitmap loadBitmapFromAsset(Asset asset) {
    if (asset == null) {
        throw new IllegalArgumentException("Asset must be non-null");
    }
    // Convert asset into a file descriptor and block until it's ready
    InputStream assetInputStream =
        Tasks.await(Wearable.getDataClient(context).getFdForAsset(asset))
            .getInputStream();
    if (assetInputStream == null) {
        Log.w(TAG, "Requested an unknown Asset.");
        return null;
    }
    // Decode the stream into a bitmap
    return BitmapFactory.decodeStream(assetInputStream);
}

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