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

Wenn Nutzer ein Wear OS-Gerät einrichten, wird es mit einem Mobilgerät zu verwalten. Der Nutzer entscheidet sich später möglicherweise für ein neues Mobilgerät. und ihr vorhandenes Wear OS-Gerät mit dem neuen Mobilgerät verbinden. Einige Daten die mit einem Wear OS-Gerät verknüpft sind, auf dem aktuell verbundenen Mobilgerät gespeichert ist.

Ab Wear OS 4 können Nutzer, die eine Verbindung mit einem neuen Mobilgerät herstellen, Wear OS-Daten auf das neue Mobilgerät übertragen Daten werden automatisch synchronisiert wenn sie übertragen werden.

Wenn der Nutzer eine Übertragung anfordert, liefert die Wearable-Datenschicht DataItem-Objekte, die ursprünglich auf einem Mobilgerät gespeichert waren, auf dem anderen Mobilgerät. Dies ermöglicht eine nahtlose Nutzung Ihrer App.

In diesem Dokument wird beschrieben, wie du deine Wear OS-App konfigurieren kannst Companion-App, um dieses Szenario zu unterstützen.

Vorbereitung

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

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

Diese Objekte werden auf dem alten Gerät archiviert. Das System verpackt dann die archivierte Daten in einem DataItemBuffer-Objekt und liefert diese Daten an das die auf dem neuen Mobilgerät installiert ist.

Unmittelbar nach der Übermittlung des Archivs ruft die Wearable-Datenschicht auf den onNodeMigrated()-Listener, ähnlich wie bei App-Benachrichtigungen Daten werden vom Wear OS-Gerät geschrieben.

Übertragene Daten beibehalten

Deine App ist dafür verantwortlich, die übertragenen DataItem-Objekte beizubehalten. Kurz nach der Übermittlung der Daten an das neue Mobilgerät wird das Archiv vom alten Gerät gelöscht.

Achten Sie darauf, dass jede der folgenden Bedingungen erfüllt ist:

  1. Ihre App ist auf beiden Mobilgeräten installiert, die am übertragen werden.
  2. Die mobilen Apps, die auf jedem Mobilgerät installiert sind, haben ein Paket. Signaturen, die übereinstimmen.

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

Daten vom alten Mobilgerät empfangen

Um Daten auf dem neuen Mobilgerät zu empfangen, die auf dem alten Mobilgerät archiviert wurden muss der onNodeMigrated()-Callback in der mobilen App implementiert sein. Teil der Klasse WearableListenerService. Führen Sie dazu folgende Schritte aus: Schritte:

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

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

  2. Deklariere und exportiere die WearableListenerService in der Manifestdatei:

    <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. Dienstklasse erstellen, die WearableListenerService erweitert und überschreibt onNodeMigrated().

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