W tym dokumencie opisujemy, jak synchronizować dane między urządzeniem z Wear OS a urządzenia przenośnego.
Wysyłaj i synchronizuj dane bezpośrednio z sieci
Utwórz aplikacje na Wear OS, aby komunikowały się bezpośrednio z siecią. Użyj tego samego interfejsów API, których używasz do programowania aplikacji mobilnych, ale pamiętaj o niektórych interfejsach dla Wear OS. między różnymi czynnikami.
Synchronizowanie danych za pomocą interfejsu Wear OS Data Layer API
DataClient
udostępnia interfejs API do odczytu lub zapisu w komponentach w klasie DataItem
lub
Asset
Elementy danych i zasoby możesz konfigurować bez połączenia z żadnymi urządzeniami. Są zsynchronizowane, gdy urządzenia nawiążą połączenie sieciowe. Te dane jest prywatny dla aplikacji i będzie dostępny tylko dla niej na innych urządzeniach.
Aplikacja
DataItem
jest synchronizowana na wszystkich urządzeniach w sieci Wear OS. Są zwykle małe.Aby przenieść większy obiekt, na przykład obraz, użyj
Asset
. System śledzi, które zasoby zostały już przeniesione, oraz śledzi ich skuteczność automatycznie usuwać duplikaty.
Nasłuchuj zdarzeń w usługach
Rozszerz klasę WearableListenerService
. System zarządza
cykl życia podstawowego WearableListenerService
, powiązanie z usługą, gdy
musi wysyłać elementy danych lub wiadomości i usuwać powiązanie usługi, gdy nie jest wykonywana żadna praca
niezbędną.
Nasłuchuj zdarzeń w działaniach
Wdróż interfejs OnDataChangedListener
. Użyj tego interfejsu
dla WearableListenerService
, gdy chcesz nasłuchiwać zmian tylko wtedy, gdy
aktywnie korzysta z aplikacji.
Przenoszenie danych
Aby wysyłać binarne duże obiekty przez łączność Bluetooth, np. nagranie głosowe
z innego urządzenia, możesz podłączyć
Asset
do elementu danych, a następnie umieść go w zreplikowanym magazynie danych.
Komponenty automatycznie obsługują buforowanie danych, aby zapobiegać ich ponownemu przesyłaniu. w celu oszczędzania przepustowości Bluetooth. Typowym wzorcem jest używanie przez aplikacje przenośne pobierania obrazu, a potem zmniejszanie go do odpowiedniego rozmiaru. do wyświetlania na takim urządzeniu i przekazywać go do aplikacji jako zasób. Przykłady poniżej które pokazują 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. Dla: dla większych elementów danych, należy rozdzielać dane według unikalnych ścieżek i unikać używając jednej ścieżki dla wszystkich danych. Przenoszenie dużych zasobów wpływa na wrażenia użytkowników w wielu krajach dlatego przetestuj swoje aplikacje i upewnij się, że działają dobrze podczas przenoszenia dużych zasobów.
Przenoszenie zasobu
Utwórz zasób, korzystając z jednej z metod create...()
w pliku
Asset
.
Przekonwertuj bitmapę na strumień bajtowy, a następnie wywołaj
createFromBytes()
w celu utworzenia zasobu, jak widać w przykładzie poniżej.
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, korzystając z metody putAsset()
w
DataMap
lub
PutDataRequest
. Następnie umieść element danych w magazynie danych za pomocą
putDataItem()
, jak pokazano w przykładach poniżej.
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 zwykle odczytać i wyodrębnić jego zawartość po drugiej stronie połączenia. Oto przykład implementacji wywołanie zwrotne 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.