Trasferire i dati di Wear OS su un nuovo dispositivo mobile

Quando gli utenti configurano un dispositivo Wear OS, lo collegano a un determinato dispositivo mobile. In un secondo momento, l'utente potrebbe decidere di acquistare un nuovo dispositivo mobile e collegare il dispositivo Wear OS esistente a questo nuovo dispositivo mobile. Alcuni dati relativi a un dispositivo Wear OS vengono memorizzati sul dispositivo mobile attualmente connesso.

A partire da Wear OS 4, quando gli utenti si connettono a un nuovo dispositivo mobile, possono trasferire i dati di Wear OS al nuovo dispositivo mobile. I dati vengono sincronizzati automaticamente durante il trasferimento.

Quando l'utente richiede un trasferimento, il livello dati indossabili invia DataItem oggetti, originariamente memorizzati su un dispositivo mobile, all'altro dispositivo mobile. In questo modo, gli utenti della tua app possono usufruire di un'esperienza fluida.

Questo documento descrive come configurare l'app per Wear OS e la relativa app mobile complementare per supportare questo scenario.

Preparazione

La procedura di trasferimento dei dati gestisce gli oggetti DataItem in modo diverso, a seconda dell'app proprietaria dei dati:

Oggetti di proprietà dell'app per Wear OS
Questi oggetti vengono conservati sul dispositivo Wear OS.
Oggetti di proprietà dell'app mobile

Questi oggetti vengono archiviati sul vecchio dispositivo. Il sistema comprime i dati archiviati in un DataItemBuffer oggetto e li invia all' app mobile installata sul nuovo dispositivo mobile.

Subito dopo l'invio dell'archivio, il livello dati indossabili richiama il onNodeMigrated() listener, in modo simile a come l'app riceve una notifica quando i dati vengono scritti dal dispositivo Wear OS.

Conservare i dati trasferiti

È responsabilità della tua app conservare gli oggetti DataItem trasferiti. Poco dopo l'invio dei dati al nuovo dispositivo mobile, l'archivio viene eliminato dal vecchio dispositivo.

Assicurati che siano soddisfatte le seguenti condizioni:

  1. L'app è installata su entrambi i dispositivi mobili coinvolti nel trasferimento.
  2. Le app mobile installate su ogni dispositivo mobile hanno firme del pacchetto corrispondenti.

In caso contrario, gli oggetti DataItem archiviati non vengono inviati e vengono invece eliminati.

Ricevere dati dal vecchio dispositivo mobile

Per ricevere i dati sul nuovo dispositivo mobile che sono stati archiviati sul vecchio dispositivo mobile il dispositivo, l'app mobile deve implementare il onNodeMigrated() callback, che fa parte della classe WearableListenerService. Per farlo, segui questi passaggi:

  1. Nel file di build dell'app mobile, includi una dipendenza dalla versione più recente della libreria indossabile in Google Play Services:

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

  2. Dichiara ed esporta WearableListenerService nel file manifest dell'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>

  3. Crea una classe di servizio che estenda WearableListenerService e sostituisca onNodeMigrated().

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