Wear OS का डेटा, नए मोबाइल डिवाइस पर ट्रांसफ़र करें

जब लोग Wear OS डिवाइस सेट अप करते हैं, तब वे Wear OS डिवाइस को किसी फ़ोन या टैबलेट से कनेक्ट करते हैं. ऐसा हो सकता है कि उपयोगकर्ता बाद में नया फ़ोन खरीदे और अपने मौजूदा Wear OS डिवाइस को इस नए फ़ोन से कनेक्ट करे. Wear OS डिवाइस से जुड़ा कुछ डेटा, फ़िलहाल कनेक्ट किए गए फ़ोन या टैबलेट पर सेव होता है.

Wear OS 4 से, जब उपयोगकर्ता किसी नए फ़ोन या टैबलेट से कनेक्ट करते हैं, तो वे Wear OS का डेटा नए फ़ोन या टैबलेट पर ट्रांसफ़र कर सकते हैं. डेटा ट्रांसफ़र होने पर, वह अपने-आप सिंक हो जाता है.

जब उपयोगकर्ता डेटा ट्रांसफ़र करने का अनुरोध करता है, तब Wearable Data Layer, DataItem ऑब्जेक्ट डिलीवर करता है. ये ऑब्जेक्ट, मूल रूप से एक मोबाइल डिवाइस पर सेव किए जाते हैं और दूसरे मोबाइल डिवाइस पर ट्रांसफ़र किए जाते हैं. इससे आपके ऐप्लिकेशन के उपयोगकर्ताओं को बिना किसी रुकावट के बेहतरीन अनुभव मिलता है.

इस दस्तावेज़ में बताया गया है कि इस सुविधा के साथ काम करने के लिए, Wear OS ऐप्लिकेशन और उसके साथ काम करने वाले मोबाइल ऐप्लिकेशन को कैसे कॉन्फ़िगर किया जा सकता है.

वीडियो की रणनीति

डेटा ट्रांसफ़र करने की प्रोसेस, DataItem ऑब्जेक्ट को अलग-अलग तरीके से हैंडल करती है. यह इस बात पर निर्भर करता है कि डेटा का मालिकाना हक किस ऐप्लिकेशन के पास है:

Wear OS ऐप्लिकेशन के मालिकाना हक वाले ऑब्जेक्ट
ये ऑब्जेक्ट, Wear OS डिवाइस पर सेव किए जाते हैं.
मोबाइल ऐप्लिकेशन के मालिकाना हक वाले ऑब्जेक्ट

ये ऑब्जेक्ट, पुराने डिवाइस पर संग्रहित किए जाते हैं. इसके बाद, सिस्टम संग्रहित किए गए डेटा को DataItemBuffer ऑब्जेक्ट में पैकेज करता है. साथ ही, इस डेटा को नए मोबाइल डिवाइस पर इंस्टॉल किए गए मोबाइल ऐप्लिकेशन को डिलीवर करता है.

संग्रह डिलीवर होने के तुरंत बाद, Wearable Data Layer, onNodeMigrated() लिसनर को शुरू कर देता है. यह ठीक उसी तरह काम करता है जैसे Wear OS डिवाइस से डेटा लिखे जाने पर, आपके ऐप्लिकेशन को सूचना मिलती है.

ट्रांसफ़र किए गए डेटा को सुरक्षित रखना

ट्रांसफ़र किए गए DataItem ऑब्जेक्ट को सुरक्षित रखना, आपके ऐप्लिकेशन की ज़िम्मेदारी है. डेटा को नए मोबाइल डिवाइस पर डिलीवर करने के कुछ समय बाद, पुराने डिवाइस से संग्रह मिटा दिया जाता है.

पक्का करें कि ये सभी शर्तें पूरी होती हों:

  1. आपका ऐप्लिकेशन, डेटा ट्रांसफ़र करने वाले दोनों मोबाइल डिवाइसों पर इंस्टॉल हो.
  2. हर मोबाइल डिवाइस पर इंस्टॉल किए गए मोबाइल ऐप्लिकेशन के पैकेज सिग्नेचर मेल खाते हों.

ऐसा न करने पर, संग्रहित किए गए DataItem ऑब्जेक्ट डिलीवर नहीं किए जाते. इसके बजाय, उन्हें खारिज कर दिया जाता है.

पुराने फ़ोन या टैबलेट से डेटा पाना

पुराने मोबाइल डिवाइस पर संग्रहित किया गया डेटा, नए मोबाइल डिवाइस पर पाने के लिए, आपके मोबाइल ऐप्लिकेशन को WearableListenerService क्लास का हिस्सा, onNodeMigrated() कॉलबैक लागू करना होगा. इसके लिए, यह तरीका अपनाएं:

  1. अपने मोबाइल ऐप्लिकेशन की बिल्ड फ़ाइल में, Google Play services में मौजूद Wearable लाइब्रेरी के नए वर्शन की डिपेंडेंसी शामिल करें:

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

  2. अपने ऐप्लिकेशन की मेनिफ़ेस्ट फ़ाइल में WearableListenerService का एलान करें और उसे एक्सपोर्ट करें:

    <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. WearableListenerService को बढ़ाने वाली और 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)
            }
        }
    }
}
    DataLayerService.kt