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. Der Nutzer kann sich später dafür entscheiden, ein neues Mobilgerät zu kaufen und sein vorhandenes Wear OS-Gerät mit diesem neuen Mobilgerät zu verbinden. Einige Daten, die sich auf ein Wear OS-Gerät beziehen, werden auf dem aktuell verbundenen Mobilgerät gespeichert.

Ab Wear OS 4 können Nutzer, wenn sie eine Verbindung zu einem neuen Mobilgerät herstellen, Wear OS-Daten auf das neue Mobilgerät übertragen. Die Daten werden bei der Übertragung automatisch synchronisiert.

Wenn der Nutzer eine Übertragung anfordert, überträgt die Wearable Data Layer DataItem-Objekte, die ursprünglich auf einem Mobilgerät gespeichert waren, an das andere Mobilgerät. So können Nutzer Ihre App nahtlos nutzen.

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

Vorbereitung

Bei der Datenübertragung werden DataItem-Objekte je nach App, zu der die Daten gehören, unterschiedlich behandelt:

Objekte, deren Eigentümer die Wear OS-App ist
Diese Objekte werden auf dem Wear OS-Gerät aufbewahrt.
Objekte, deren Inhaber die mobile App ist

Diese Objekte werden auf dem alten Gerät archiviert. Das System verpackt die archivierten Daten dann in einem DataItemBuffer-Objekt und übergibt diese Daten an die mobile App, die auf dem neuen Mobilgerät installiert ist.

Unmittelbar nach der Übermittlung des Archivs ruft die Wearable Data Layer den onNodeMigrated()-Listener auf, ähnlich wie Ihre App benachrichtigt wird, wenn Daten vom Wear OS-Gerät geschrieben werden.

Übertragene Daten beibehalten

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

Die folgenden Bedingungen müssen erfüllt sein:

  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 ausgeliefert, sondern verworfen.

Daten vom alten Mobilgerät empfangen

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

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

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

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

    <service
android:name=".MyWearableListenerService"
android:exported="true">
<intent-filter>
    ...
    <action android:name="com.google.android.gms.wearable.NODE_MIGRATED" />
    <data android:scheme="wear" />
</intent-filter>
</service>

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

    Kotlin

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

    Java

    public class MyWearableListenerService extends WearableListenerService {
    private final DataClient dataClient = Wearable.getDataClient(this);

    private boolean shouldHandleDataItem(String nodeId, DataItem dataItem) {
        // Your logic here
        return Objects.requireNonNull(dataItem.getUri().getPath())
                .startsWith("/my_feature_path/");
    }

    private Task<DataItem> handleDataItem(String nodeId, DataItem dataItem) {
        byte[] data = dataItem.getData();
        String path = dataItem.getUri().getPath();
        // Your logic here
        if (data != null && path != null && Arrays.toString(data)
                .startsWith("Please restore")) {
            assert path != null;
            return dataClient.putDataItem(
                        PutDataRequest.create(path).setData(data));
    }

    @Override
    public void onNodeMigrated(@NonNull String nodeId, DataItemBuffer archive) {
        List<DataItem> dataItemsToHandle = new ArrayList<>();

        for (DataItem dataItem : archive) {
            if (shouldHandleDataItem(nodeId, dataItem)) {
                dataItemsToHandle.add(dataItem.freeze());
            }
        }

        for (dataItem in dataItemsToHandle) {
            handleDataItem(nodeId, dataItem);
        }

        // Callback stops automatically after 20 seconds of data processing.
        // If you think you need more time, delegate to another thread.
    }
}