Daten synchronisieren

In diesem Dokument wird beschrieben, wie du Daten zwischen einem Wear OS-Gerät und einem Smartphone synchronisierst. In der Übersicht finden Sie Informationen dazu, wann Sie die Data Layer API und wann Sie Ihre Infrastruktur verwenden sollten.

Daten direkt über das Netzwerk senden und synchronisieren

Wear OS-Apps entwickeln, die direkt mit dem Netzwerk kommunizieren Verwende dieselben APIs wie für die Entwicklung für Mobilgeräte, beachte aber einige Wear OS-spezifische Unterschiede.

Daten mit der Wear OS Data Layer API synchronisieren

Ein DataClient stellt eine API bereit, über die Komponenten in einem DataItem oder Asset lesen oder schreiben können.

Datenelemente und Assets können auch festgelegt werden, wenn keine Verbindung zu Geräten besteht. Sie werden synchronisiert, wenn die Geräte eine Netzwerkverbindung herstellen. Diese Daten sind für deine App privat und können nur von deiner App auf anderen Geräten abgerufen werden.

  • Eine DataItem wird auf allen Geräten in einem Wear OS-Netzwerk synchronisiert. Sie sind im Allgemeinen klein.

  • Verwenden Sie ein Asset, um ein größeres Objekt wie ein Bild zu übertragen. Das System verfolgt, welche Assets bereits übertragen wurden, und führt automatisch eine Deduplizierung durch.

Auf Ereignisse in Diensten warten

Erweitern Sie die Klasse WearableListenerService. Das System verwaltet den Lebenszyklus des Basis-WearableListenerService, bindet den Dienst, wenn Datenelemente oder Nachrichten gesendet werden müssen, und hebt die Bindung des Dienstes auf, wenn keine Arbeit erforderlich ist.

Auf Ereignisse in Aktivitäten warten

OnDataChangedListener-Schnittstelle implementieren. Verwenden Sie diese Schnittstelle anstelle eines WearableListenerService, wenn Sie nur dann auf Änderungen reagieren möchten, wenn der Nutzer Ihre App aktiv verwendet.

description: Mit Assets in der Data Layer API kannst du große binäre Objekte wie Bilder zwischen Android-Smartphones und Wear OS-Smartwatches übertragen. keywords_public: Wear OS, Data Layer API, Assets, Bluetooth-Datenübertragung, Datensynchronisierung, DataMap, PutDataRequest

Daten synchronisieren

Wenn du große binäre Objekte über die Bluetooth-Übertragung teilen möchtest, z. B. eine Sprachaufnahme von einem anderen Gerät, kannst du ein Asset an ein Datenelement anhängen und das Datenelement dann in den replizierten Datenspeicher einfügen.

Hinweis: Die Datenebene API kann nur Nachrichten an Smartphones mit Android oder Wear OS-Smartwatches senden und Daten mit ihnen synchronisieren. Wenn ein Wear OS-Gerät mit einem iOS-Gerät gekoppelt ist, funktioniert die Data Layer API nicht.

Verwende die Data Layer API daher nicht als primäre Methode für die Kommunikation mit einem Netzwerk. Verwende stattdessen in deiner Wear OS-App dasselbe Muster wie in einer Smartphone-App – mit einigen geringfügigen Unterschieden, die unter Netzwerkzugriff und Synchronisierung unter Wear OS beschrieben werden.

Assets verarbeiten das Caching von Daten automatisch, um eine erneute Übertragung zu verhindern und Bluetooth-Bandbreite zu sparen. Ein gängiges Muster ist, dass eine Smartphone-App ein Bild herunterlädt, es auf eine für die Anzeige auf der Smartwatch geeignete Größe verkleinert und es als Asset für die Smartwatch-App freigibt. Die folgenden Beispiele veranschaulichen dieses Muster.

Asset übertragen

Erstellen Sie das Asset mit einer der create...()-Methoden in der Klasse Asset. Konvertieren Sie eine Bitmap in ein Byte-Array und rufen Sie dann createFromBytes() auf, um das Asset zu erstellen, wie im folgenden Beispiel gezeigt.

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

Hängen Sie das Asset als Nächstes mit der Methode putAsset() in DataMap oder PutDataRequest an ein Datenelement an. Anschließend wird das Datenelement mit der Methode putDataItem() in den Datenspeicher eingefügt, wie in den folgenden Beispielen gezeigt.

Im folgenden Beispiel wird PutDataRequest verwendet:

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
}

Im folgenden Beispiel wird PutDataMapRequest verwendet:

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
}

Assets erhalten

Nachdem Sie ein Asset erstellt haben, lesen und extrahieren Sie es normalerweise auf der anderen Seite der Verbindung. Das folgende Beispiel zeigt, wie der Callback implementiert wird, um eine Asset-Änderung zu erkennen und das Asset zu extrahieren:

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

Weitere Informationen findest du im DataLayer-Beispielprojekt auf GitHub.