स्थायी डेटा सिंक करें

इस दस्तावेज़ में Wear OS डिवाइस और हैंडहेल्ड डिवाइस.

सीधे नेटवर्क से डेटा भेजें और सिंक करें

सीधे नेटवर्क से बातचीत करने के लिए, Wear OS ऐप्लिकेशन बनाएं. पहले जैसा इस्तेमाल करें ऐसे एपीआई जिनका इस्तेमाल मोबाइल ऐप्लिकेशन को डेवलप करने के लिए किया जाता है, लेकिन Wear-OS से जुड़े कुछ खास एपीआई को बनाए रखते हैं ध्यान रखें.

Wear OS डेटा लेयर एपीआई का इस्तेमाल करके डेटा सिंक करना

DataClient, एपीआई को दिखाता है, ताकि DataItem या उसमें मौजूद कॉम्पोनेंट को पढ़ा या लिखा जा सके Asset.

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

• DataItem को Wear OS नेटवर्क में मौजूद सभी डिवाइसों पर सिंक किया जाता है. आम तौर पर, इनका साइज़ छोटा होता है.

• किसी बड़े ऑब्जेक्ट, जैसे कि इमेज को ट्रांसफ़र करने के लिए, Asset का इस्तेमाल करें. सिस्टम ट्रैक करता रहता है कि कौन-कौनसी ऐसेट पहले ही ट्रांसफ़र की जा चुकी हैं और परफ़ॉर्मेंस डुप्लीकेट कॉपी हटाने की सुविधा अपने-आप बंद हो जाएगी.

सेवाओं में होने वाले इवेंट को सुनें

WearableListenerService क्लास को बढ़ाएं. सिस्टम, WearableListenerService बेस का लाइफ़साइकल, जब यह सेवा से जुड़ा होता है डेटा आइटम या मैसेज भेजने की ज़रूरत होती है और जब कोई सेवा काम नहीं करती है, तब सेवा की बाइंडिंग को रद्द करने की ज़रूरत होती है की ज़रूरत नहीं है.

गतिविधियों में होने वाले इवेंट को सुनें

OnDataChangedListener इंटरफ़ेस लागू करें. इसके बजाय, इस इंटरफ़ेस का इस्तेमाल करें WearableListenerService में से सिर्फ़ तब बदलावों को सुनना है, जब उपयोगकर्ता सक्रिय रूप से आपके ऐप्लिकेशन का इस्तेमाल कर रहा हो.

डेटा ट्रांसफ़र करें

ब्लूटूथ ट्रांसपोर्ट पर बाइनरी बड़े ऑब्जेक्ट भेजने के लिए, जैसे कि आवाज़ की रिकॉर्डिंग किसी दूसरे डिवाइस से, आप उसे अटैच कर सकते हैं Asset को डेटा आइटम से जोड़ें और फिर डेटा आइटम को कॉपी किए गए डेटास्टोर में डालें.

ऐसेट, डेटा को कैश मेमोरी में सेव करने का काम अपने-आप करती हैं, ताकि रीट्रांसमिशन को रोका जा सके और जिससे ब्लूटूथ बैंडविड्थ बचाई जा सके. सामान्य पैटर्न, हैंडहेल्ड ऐप्लिकेशन में इमेज डाउनलोड करने और उसका साइज़ छोटा करने के लिए होता है का ऐक्सेस देने के लिए किया जा सकता है. ये उदाहरण इस पैटर्न को दिखाएं.

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

ऐसेट को ट्रांसफ़र करना

इसमें दिए गए create...() तरीकों में से किसी एक का इस्तेमाल करके एसेट बनाएं Asset क्लास. बिट मैप को बाइट स्ट्रीम में बदलें और फिर कॉल करें createFromBytes() नीचे दिए गए उदाहरण में बताए गए तरीके से ऐसेट बनाएं.

private fun createAssetFromBitmap(bitmap: Bitmap): Asset =
    ByteArrayOutputStream().let { byteStream ->
        bitmap.compress(Bitmap.CompressFormat.PNG, 100, byteStream)
        Asset.createFromBytes(byteStream.toByteArray())
    }

private static Asset createAssetFromBitmap(Bitmap bitmap) {
    final ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
    bitmap.compress(Bitmap.CompressFormat.PNG, 100, byteStream);
    return Asset.createFromBytes(byteStream.toByteArray());
}

इसके बाद, putAsset() तरीके का इस्तेमाल करके, ऐसेट को डेटा आइटम में अटैच करें DataMap या PutDataRequest. फिर डेटा आइटम को putDataItem() तरीका, जैसा कि नीचे दिए गए सैंपल में दिखाया गया है.

नीचे दिया गया नमूना PutDataRequest का इस्तेमाल करता है:

val asset: Asset = BitmapFactory.decodeResource(resources, R.drawable.image).let { bitmap ->
    createAssetFromBitmap(bitmap)
}
val request: PutDataRequest = PutDataRequest.create("/image").apply {
    putAsset("profileImage", asset)
}
val putTask: Task<DataItem> = Wearable.getDataClient(context).putDataItem(request)

Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.image);
Asset asset = createAssetFromBitmap(bitmap);
PutDataRequest request = PutDataRequest.create("/image");
request.putAsset("profileImage", asset);
Task<DataItem> putTask = Wearable.getDataClient(context).putDataItem(request);

नीचे दिया गया नमूना PutDataMapRequest का इस्तेमाल करता है:

val asset: Asset = BitmapFactory.decodeResource(resources, R.drawable.image).let { bitmap ->
    createAssetFromBitmap(bitmap)
}
val request: PutDataRequest = PutDataMapRequest.create("/image").run {
    dataMap.putAsset("profileImage", asset)
    asPutDataRequest()
}
val putTask: Task<DataItem> = Wearable.getDataClient(context).putDataItem(request)

Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.image);
Asset asset = createAssetFromBitmap(bitmap);
PutDataMapRequest dataMap = PutDataMapRequest.create("/image");
dataMap.getDataMap().putAsset("profileImage", asset);
PutDataRequest request = dataMap.asPutDataRequest();
Task<DataItem> putTask = Wearable.getDataClient(context).putDataItem(request);

एसेट पाएं

जब कोई ऐसेट बनाई जाती है, तो हो सकता है कि आप उसे पढ़ना और निकालना चाहें . यहां उदाहरण के तौर पर, ऐसेट में बदलाव का पता लगाने और ऐसेट को एक्सट्रैक्ट करने के लिए कॉलबैक:

override fun onDataChanged(dataEvents: DataEventBuffer) {
    dataEvents
            .filter { it.type == DataEvent.TYPE_CHANGED && it.dataItem.uri.path == "/image" }
            .forEach { event ->
                val bitmap: Bitmap? = DataMapItem.fromDataItem(event.dataItem)
                        .dataMap.getAsset("profileImage")
                        .let { asset -> loadBitmapFromAsset(asset) }
                // Do something with the bitmap
            }
}

fun loadBitmapFromAsset(asset: Asset): Bitmap? {
    // Convert asset into a file descriptor and block until it's ready
    val assetInputStream: InputStream? =
            Tasks.await(Wearable.getDataClient(context).getFdForAsset(asset))
            ?.inputStream

    return assetInputStream?.let { inputStream ->
        // Decode the stream into a bitmap
        BitmapFactory.decodeStream(inputStream)
    } ?: run {
        Log.w(TAG, "Requested an unknown Asset.")
        null
    }
}

@Override
public void onDataChanged(DataEventBuffer dataEvents) {
  for (DataEvent event : dataEvents) {
    if (event.getType() == DataEvent.TYPE_CHANGED &&
        event.getDataItem().getUri().getPath().equals("/image")) {
      DataMapItem dataMapItem = DataMapItem.fromDataItem(event.getDataItem());
      Asset profileAsset = dataMapItem.getDataMap().getAsset("profileImage");
      Bitmap bitmap = loadBitmapFromAsset(profileAsset);
      // Do something with the bitmap
    }
  }
}

public Bitmap loadBitmapFromAsset(Asset asset) {
    if (asset == null) {
        throw new IllegalArgumentException("Asset must be non-null");
    }
    // Convert asset into a file descriptor and block until it's ready
    InputStream assetInputStream =
        Tasks.await(Wearable.getDataClient(context).getFdForAsset(asset))
            .getInputStream();
    if (assetInputStream == null) {
        Log.w(TAG, "Requested an unknown Asset.");
        return null;
    }
    // Decode the stream into a bitmap
    return BitmapFactory.decodeStream(assetInputStream);
}

ज़्यादा जानकारी के लिए, GitHub पर Datalayer सैंपल प्रोजेक्ट देखें.