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

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

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

ध्यान दें: नए मोबाइल डिवाइस पर डेटा ट्रांसफ़र करने की यह प्रोसेस, क्लाउड बैकअप और रीस्टोर करने की प्रोसेस से अलग है. क्लाउड बैकअप और रीस्टोर करने की प्रोसेस में, उपयोगकर्ता नए Wear OS डिवाइस पर डेटा रीस्टोर करता है.

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

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

तैयारी

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

Wear OS ऐप्लिकेशन के मालिकाना हक वाले ऑब्जेक्ट

ये ऑब्जेक्ट, Wear OS डिवाइस पर सेव रहते हैं.

मोबाइल ऐप्लिकेशन के मालिकाना हक वाले ऑब्जेक्ट

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

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

**ध्यान दें:** डेटा सिर्फ़ तब ट्रांसफ़र किया जाता है, जब वह Wearable Data Layer में सेव हो.

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

**चेतावनी:** डेटा खोने से बचने के लिए, इस सेक्शन में दिए गए निर्देशों का पालन करें.

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

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

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

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

पुराने मोबाइल डिवाइस से डेटा पाना

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

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

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

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() को ओवरराइड करती हो.

   चेतावनी: सिस्टम के संसाधनों, जैसे कि बैटरी लाइफ़ को बचाने और एएनआर से बचने के लिए, ज़्यादा पावर या समय लेने वाले टास्क 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