डेटा लेयर एपीआई के साथ डेटा आइटम सिंक करना

DataItem उस इंटरफ़ेस को तय करता है जिसका इस्तेमाल सिस्टम, हैंडहेल्ड और डेटा के बीच डेटा सिंक करने के लिए करता है पहने जाने वाले डिवाइस. आम तौर पर, DataItem में ये कॉम्पोनेंट होते हैं:

• पेलोड: यह बाइट कलेक्शन, जिसे डेटा के साथ सेट किया जा सकता है, आपको अपना ऑब्जेक्ट सीरियलाइज़ेशन करने देते हैं और डीसीरियलाइज़ेशन. पेलोड का साइज़ 100 केबी से ज़्यादा नहीं होना चाहिए.
• पाथ: एक यूनीक स्ट्रिंग, जो फ़ॉरवर्ड स्लैश से शुरू होनी चाहिए, जैसे कि "/path/to/data".

ध्यान दें: डेटा लेयर एपीआई सिर्फ़ मैसेज भेज सकता है और डेटा को Android फ़ोन या Wear OS के साथ सिंक कर सकता है स्मार्टवॉच. अगर आपका Wear OS डिवाइस किसी iOS डिवाइस से जोड़ा गया है, तो डेटा लेयर एपीआई काम करेगा.

इस कारण से, डेटा लेयर API का उपयोग का मुख्य तरीका है. इसके बजाय, मोबाइल ऐप्लिकेशन जैसा ही होता है. हालांकि, इसमें कुछ मामूली अंतर भी होते हैं.

आम तौर पर, आप DataItem को लागू नहीं करते सकता है. इसके बजाय, आप ये काम करते हैं:

1. किसी PutDataRequest ऑब्जेक्ट, खास तौर पर पहचानने के लिए स्ट्रिंग पाथ की जानकारी देता है आइटम.
2. पर कॉल करें पेलोड सेट करने के लिए setData().
3. अगर सिंक करने में देरी से उपयोगकर्ता अनुभव पर बुरा असर पड़ता है, तो कॉल करें setUrgent().
4. putDataItem तरीके का इस्तेमाल करें DataClient क्लास का इस्तेमाल करें.

डेटा आइटम का अनुरोध करने पर, सिस्टम ऐसे ऑब्जेक्ट दिखाता है जो DataItem इंटरफ़ेस. हालाँकि, रॉ बाइट के साथ काम करने के बजाय setData(), हमारा सुझाव है कि आप डेटा मैप का इस्तेमाल करना, जो Bundle जैसे इंटरफ़ेस वाले डेटा आइटम को दिखाता है.

ज़्यादा जानकारी के लिए, Dataलेयर सैंपल ऐप्लिकेशन.

डेटा मैप के साथ डेटा सिंक करना

जब भी हो सके, का इस्तेमाल करें. DataMap क्लास. इससे आपको डेटा आइटम पर Android Bundle, इसलिए, सिस्टम आपके लिए ऑब्जेक्ट को क्रम से लगाने और डीसीरियलाइज़ेशन की सुविधा इस्तेमाल करता है. साथ ही, आपके पास डेटा में बदलाव करने का विकल्प होता है की-वैल्यू पेयर के साथ होनी चाहिए.

डेटा मैप का इस्तेमाल करने के लिए:

1. किसी PutDataMapRequest ऑब्जेक्ट, डेटा आइटम का पाथ सेट कर रहा है.

   ध्यान दें: पाथ स्ट्रिंग, डेटा आइटम होता है, जिसकी मदद से इसे कनेक्शन के दोनों ओर से ऐक्सेस किया जा सकता है. रास्ता फ़ॉरवर्ड स्लैश से शुरू होना चाहिए. अगर आपने अपने ऐप्लिकेशन में, डेटा के स्ट्रक्चर से मेल खाने वाली पाथ स्कीम बनाएं.

2. पर कॉल करें PutDataMapRequest.getDataMap() का इस्तेमाल करके, डेटा मैप देखा जा सकता है पर वैल्यू सेट करता है.
3. put...() तरीकों का इस्तेमाल करके, डेटा मैप के लिए वैल्यू सेट करें, जैसे कि putString().
4. अगर सिंक करने में देरी से उपयोगकर्ता अनुभव पर बुरा असर पड़ता है, तो कॉल करें setUrgent().
5. पर कॉल करें PutDataMapRequest.asPutDataRequest() PutDataRequest ऑब्जेक्ट.
6. putDataItem तरीके का इस्तेमाल करें DataClient क्लास का इस्तेमाल करें.

   ध्यान दें: अगर हैंडसेट और पहने जाने वाले डिवाइस डिसकनेक्ट हो गए हैं, कनेक्शन फिर से शुरू होने पर, डेटा को बफ़र और सिंक किया जाता है.

नीचे दिए गए उदाहरण में, increaseCounter() तरीके से डेटा मैप करके इसमें डेटा रखें:

private const val COUNT_KEY = "com.example.key.count"

class MainActivity : Activity() {

    private lateinit var dataClient: DataClient
    private var count = 0
    ...
    // Create a data map and put data in it
    private fun increaseCounter() {
        val putDataReq: PutDataRequest = PutDataMapRequest.create("/count").run {
            dataMap.putInt(COUNT_KEY, count++)
            asPutDataRequest()
        }
        val putDataTask: Task<DataItem> = dataClient.putDataItem(putDataReq)
    }
    ...
}

public class MainActivity extends Activity {
    private static final String COUNT_KEY = "com.example.key.count";
    private DataClient dataClient;
    private int count = 0;
    ...
    // Create a data map and put data in it
    private void increaseCounter() {
        PutDataMapRequest putDataMapReq = PutDataMapRequest.create("/count");
        putDataMapReq.getDataMap().putInt(COUNT_KEY, count++);
        PutDataRequest putDataReq = putDataMapReq.asPutDataRequest();
        Task<DataItem> putDataTask = dataClient.putDataItem(putDataReq);
    }
  ...
}

हैंडलिंग के बारे में ज़्यादा जानकारी पाने के लिए Tasks को देखने के लिए, रेफ़रंस के लिए दस्तावेज़.

DataItem की प्राथमिकता सेट करें

DataClient एपीआई, इसे सिंक करने के लिए ज़रूरी अनुरोधों की अनुमति देता है DataItem ऑब्जेक्ट हैं. आम तौर पर, सिस्टम डेटा आइटम की डिलीवरी में देरी करता है को Wear OS नेटवर्क से कनेक्ट किया है, ताकि लोगों के डिवाइसों की बैटरी लाइफ़ बढ़ाई जा सके. अगर डेटा आइटम सिंक करने में देरी से उपयोगकर्ता अनुभव पर बुरा असर पड़ता है, तो उन्हें तुरंत जुड़ने की ज़रूरत नहीं है. उदाहरण के लिए, रिमोट कंट्रोल ऐप्लिकेशन में उपयोगकर्ता कार्रवाइयों को तुरंत दिखाने के लिए, सिस्टम आपके डेटा आइटम को सिंक कर सकता है कॉल करके तुरंत setUrgent().

अगर आप setUrgent() को कॉल नहीं करते हैं, तो हो सकता है कि सिस्टम 30 मिनट पहले से देरी करे ग़ैर-ज़रूरी डेटा आइटम सिंक किए जा रहे हैं. हालांकि, आम तौर पर कुछ ही समय में मिनट. डिफ़ॉल्ट तौर पर, अनुरोध करना बहुत ज़रूरी नहीं है, इसलिए आपको setUrgent() अगर आपको Wear OS API के पिछले वर्शन पर मिल जाएगा.

डेटा आइटम इवेंट को सुनें

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

नीचे दिए गए उदाहरण में दिए गए कोड स्निपेट से ऐप्लिकेशन को तब सूचना मिलती है, जब काउंटर का इस्तेमाल पिछले उदाहरण बदलावों में किया गया है:

private const val COUNT_KEY = "com.example.key.count"

class MainActivity : Activity(), DataClient.OnDataChangedListener {

    private var count = 0

    override fun onResume() {
        super.onResume()
        Wearable.getDataClient(this).addListener(this)
    }

    override fun onPause() {
        super.onPause()
        Wearable.getDataClient(this).removeListener(this)
    }

    override fun onDataChanged(dataEvents: DataEventBuffer) {
        dataEvents.forEach { event ->
            // DataItem changed
            if (event.type == DataEvent.TYPE_CHANGED) {
                event.dataItem.also { item ->
                    if (item.uri.path.compareTo("/count") == 0) {
                        DataMapItem.fromDataItem(item).dataMap.apply {
                            updateCount(getInt(COUNT_KEY))
                        }
                    }
                }
            } else if (event.type == DataEvent.TYPE_DELETED) {
                // DataItem deleted
            }
        }
    }

    // Method to update the count
    private fun updateCount(int: Int) { ... }
    ...
}

public class MainActivity extends Activity implements DataClient.OnDataChangedListener {
    private static final String COUNT_KEY = "com.example.key.count";
    private int count = 0;

    @Override
    protected void onResume() {
        super.onResume();
        Wearable.getDataClient(this).addListener(this);
    }

    @Override
    protected void onPause() {
        super.onPause();
        Wearable.getDataClient(this).removeListener(this);
    }

    @Override
    public void onDataChanged(DataEventBuffer dataEvents) {
        for (DataEvent event : dataEvents) {
            if (event.getType() == DataEvent.TYPE_CHANGED) {
                // DataItem changed
                DataItem item = event.getDataItem();
                if (item.getUri().getPath().compareTo("/count") == 0) {
                    DataMap dataMap = DataMapItem.fromDataItem(item).getDataMap();
                    updateCount(dataMap.getInt(COUNT_KEY));
                }
            } else if (event.getType() == DataEvent.TYPE_DELETED) {
                // DataItem deleted
            }
        }
    }

    // Method to update the count
    private void updateCount(int c) { ... }
    ...
}

यह गतिविधि DataClient.OnDataChangedListener इंटरफ़ेस. गतिविधि अपने-आप जुड़ती है अंदर मौजूद डेटा आइटम इवेंट को सुनने के लिए, लिसनर के तौर पर यह onResume() तरीके का इस्तेमाल करता है और onPause() तरीका. इमेज, व्यू मॉडल, और सेवाओं के लिए, Dataलेयर सैंपल देखें है.

लिसनर को सेवा के तौर पर भी लागू किया जा सकता है. ज़्यादा जानकारी के लिए, यह देखें डेटा लेयर के बारे में जानें इवेंट.