Wear OS-Daten auf ein neues Mobilgerät übertragen

Wenn Nutzer ein Wear OS-Gerät einrichten, verbinden sie es mit einem bestimmten Mobilgerät. Später entscheiden sie sich möglicherweise für ein neues Mobilgerät und verbinden ihr vorhandenes Wear OS-Gerät mit diesem neuen Mobilgerät. Einige Daten im Zusammenhang mit einem Wear OS-Gerät werden auf dem aktuell verbundenen Mobilgerät gespeichert.

Ab Wear OS 4 können Nutzer beim Verbinden mit einem neuen Mobilgerät Wear OS-Daten auf das neue Mobilgerät übertragen. Die Daten werden bei der Übertragung automatisch synchronisiert.

Wenn der Nutzer eine Übertragung anfordert, liefert die Wearable Data Layer DataItem-Objekte, die ursprünglich auf einem Mobilgerät gespeichert waren, an das andere Mobilgerät. So wird für einen reibungslosen Ablauf für Nutzer Ihrer App gesorgt.

In diesem Dokument wird beschrieben, wie Sie Ihre Wear OS-App und die zugehörige mobile App so konfigurieren, dass dieses Szenario unterstützt wird.

Vorbereitung

Beim Datenübertragungsvorgang werden DataItem-Objekte je nach App, der die Daten gehören, unterschiedlich behandelt:

Objekte, die der Wear OS-App gehören
Diese Objekte bleiben auf dem Wear OS-Gerät erhalten.
Objekte, die der mobilen App gehören

Diese Objekte werden auf dem alten Gerät archiviert. Das System packt die archivierten Daten dann in ein DataItemBuffer-Objekt und liefert sie an die mobile App, die auf dem neuen Mobilgerät installiert ist.

Unmittelbar nach der Lieferung des Archivs ruft die Wearable Data Layer-API den onNodeMigrated() Listener auf. Das funktioniert ähnlich wie bei der Benachrichtigung Ihrer App, wenn Daten vom Wear OS-Gerät geschrieben werden.

Übertragene Daten beibehalten

Ihre App ist dafür verantwortlich, die übertragenen DataItem-Objekte beizubehalten. Kurz nachdem die Daten auf das neue Mobilgerät geliefert wurden, wird das Archiv vom alten Gerät gelöscht.

Achten Sie darauf, dass alle folgenden Bedingungen erfüllt sind:

  1. Ihre App ist auf beiden Mobilgeräten installiert, die an der Übertragung beteiligt sind.
  2. Die auf den einzelnen Mobilgeräten installierten mobilen Apps haben übereinstimmende Paketsignaturen.

Andernfalls werden die archivierten DataItem-Objekte nicht geliefert, sondern verworfen.

Daten vom alten Mobilgerät empfangen

Damit Daten auf dem neuen Mobilgerät empfangen werden können, die auf dem alten Mobil gerät archiviert wurden, muss Ihre mobile App den onNodeMigrated() Callback implementieren, der Teil der WearableListenerService Klasse ist. Führen Sie dazu folgende Schritte aus:

  1. Fügen Sie in der Build-Datei Ihrer mobilen App eine Abhängigkeit von der neuesten Version der Wearable-Bibliothek in den Google Play-Diensten ein:

    dependencies {
    ...
    implementation 'com.google.android.gms:play-services-wearable:19.0.0'
}

  2. Deklarieren und exportieren Sie WearableListenerService in der Manifestdatei Ihrer App:

    <service
    android:name=".snippets.datalayer.MyWearableListenerService"
    android:exported="true"
    tools:ignore="ExportedService">
    <intent-filter>
        <action android:name="com.google.android.gms.wearable.NODE_MIGRATED" />
        <data android:scheme="wear" android:host="*" />
    </intent-filter>
</service>
    AndroidManifest.xml

  3. Erstellen Sie eine Dienstklasse, die WearableListenerService erweitert und onNodeMigrated() überschreibt.

    class MyWearableListenerService : WearableListenerService() {
    val dataClient: DataClient = Wearable.getDataClient(this)

    private fun shouldHandleDataItem(nodeId: String, dataItem: DataItem): Boolean {
        // Your logic here
        return dataItem.uri.path?.startsWith("/my_feature_path/") == true
    }

    private fun handleDataItem(nodeId: String, dataItem: DataItem) {
        val data = dataItem.data ?: return
        val path = dataItem.uri.path ?: return
        // Your logic here
        if (data.toString().startsWith("Please restore")) {
            dataClient.putDataItem(PutDataRequest.create(path).setData(data))
        }
    }

    override fun onNodeMigrated(nodeId: String, archive: DataItemBuffer) {
        val dataItemsToHandle = mutableListOf<DataItem>()

        for (dataItem in archive) {
            if (shouldHandleDataItem(nodeId, dataItem)) {
                dataItemsToHandle.add(dataItem.freeze())
            }
        }

        // Callback stops automatically after 20 seconds of data processing.
        // If you think you need more time, delegate to a coroutine or thread.
        runBlocking {
            for (dataItem in dataItemsToHandle) {
                handleDataItem(nodeId, dataItem)
            }
        }
    }
}
    DataLayerService.kt