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 डेटा लेयर, onNodeMigrated() लिसनर को ट्रिगर करता है. यह उसी तरह होता है जिस तरह Wear OS डिवाइस से डेटा लिखे जाने पर, आपके ऐप्लिकेशन को सूचना दी जाती है.

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

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

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

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

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

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

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

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

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

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

    <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. ऐसी सेवा क्लास बनाएं जो WearableListenerService को एक्सटेंड करती हो और 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.
    }
}