Wear और Android की मदद से मैसेज भेजें और पाएं

MessageClient एपीआई का इस्तेमाल करके मैसेज भेजे जाते हैं. मैसेज में ये आइटम अटैच किए जाते हैं:

• कोई भी पेलोड (ज़रूरी नहीं)
• ऐसा पाथ जो मैसेज की कार्रवाई की खास तौर पर पहचान करता है

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

एक उपयोगकर्ता के हैंडहेल्ड डिवाइस से, कई पहनने योग्य डिवाइस कनेक्ट किए जा सकते हैं. नेटवर्क से कनेक्ट किए गए हर डिवाइस को नोड माना जाता है.

एक से ज़्यादा डिवाइसों के कनेक्ट होने पर, आपको यह ध्यान रखना होगा कि मैसेज किन नोड को मिलेंगे. उदाहरण के लिए, अगर कोई वॉइस ट्रांसक्रिप्शन ऐप्लिकेशन, पहनने लायक डिवाइस पर वॉइस डेटा पाता है, तो मैसेज को ऐसे नोड पर भेजें जिसमें अनुरोध को प्रोसेस करने की क्षमता और बैटरी की क्षमता हो. जैसे, कोई हैंडहेल्ड डिवाइस.

ध्यान दें: मैसेज की जानकारी देते समय, कनेक्ट किए गए कई नोड के बारे में सोचें. पक्का करें कि मैसेज, उन डिवाइसों या नोड पर डिलीवर हो जिन पर उसे डिलीवर होना चाहिए.

मैसेज भेजें

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

यहां दिए गए सेक्शन में, डिवाइस नोड का विज्ञापन दिखाने का तरीका बताया गया है. ये नोड, गतिविधि के अनुरोधों को प्रोसेस कर सकते हैं. साथ ही, इनमें यह भी बताया गया है कि अनुरोध की गई ज़रूरत को पूरा करने वाले नोड का पता कैसे लगाया जाए और उन नोड को मैसेज कैसे भेजे जाएं.

डिवाइस की सुविधाओं का विज्ञापन देना

स्मार्टवॉच से किसी हैंडहेल्ड डिवाइस पर गतिविधि शुरू करने के लिए, अनुरोध भेजने के लिए MessageClient क्लास का इस्तेमाल करें. एक हैंडहेल्ड डिवाइस से कई वियरेबल कनेक्ट किए जा सकते हैं. इसलिए, वियरेबल ऐप्लिकेशन को यह तय करना होगा कि कनेक्ट किया गया नोड, गतिविधि लॉन्च कर सकता है या नहीं. अपने हैंडहेल्ड ऐप्लिकेशन में यह विज्ञापन दिखाएं कि जिस नोड पर यह ऐप्लिकेशन चलता है उसमें कुछ खास सुविधाएं उपलब्ध हैं.

अपने हैंडहेल्ड ऐप्लिकेशन की सुविधाओं का विज्ञापन दिखाने के लिए, यह तरीका अपनाएं:

1. अपने प्रोजेक्ट की res/values/ डायरेक्ट्री में एक्सएमएल कॉन्फ़िगरेशन फ़ाइल बनाएं और उसका नाम wear.xml रखें.
2. wear.xml में android_wear_capabilities नाम का संसाधन जोड़ें.
3. डिवाइस की उन क्षमताओं के बारे में बताएं जो वह उपलब्ध कराता है.

ध्यान दें: क्षमताएं, कस्टम स्ट्रिंग होती हैं. इन्हें आपको तय करना होता है. साथ ही, ये आपके ऐप्लिकेशन में यूनीक होनी चाहिए.

यहां दिए गए उदाहरण में, wear.xml में voice_transcription नाम की सुविधा जोड़ने का तरीका बताया गया है:

<resources xmlns:tools="http://schemas.android.com/tools"
           tools:keep="@array/android_wear_capabilities">
    <string-array name="android_wear_capabilities">
        <item>voice_transcription</item>
    </string-array>
</resources>

ज़रूरी सुविधाओं वाले नोड वापस पाना

शुरुआत में, CapabilityClient क्लास के getCapability तरीके को कॉल करके, ज़रूरी नोड का पता लगाया जा सकता है. इस तरीके का इस्तेमाल करने के लिए, आपके Wear OS ऐप्लिकेशन और फ़ोन ऐप्लिकेशन का ऐप्लिकेशन आईडी एक ही होना चाहिए. यहां दिए गए उदाहरण में, voice_transcription सुविधा वाले उन नोड के नतीजे मैन्युअल तरीके से वापस पाने का तरीका दिखाया गया है जिन तक पहुंचा जा सकता है:

private const val VOICE_TRANSCRIPTION_CAPABILITY_NAME = "voice_transcription"
...
private fun setupVoiceTranscription() {
    val capabilityInfo: CapabilityInfo = Tasks.await(
            Wearable.getCapabilityClient(context)
                    .getCapability(
                            VOICE_TRANSCRIPTION_CAPABILITY_NAME,
                            CapabilityClient.FILTER_REACHABLE
                    )
    )
    // capabilityInfo has the reachable nodes with the transcription capability
    updateTranscriptionCapability(capabilityInfo)
}

private static final String
    VOICE_TRANSCRIPTION_CAPABILITY_NAME = "voice_transcription";
    ...
private void setupVoiceTranscription() {
    CapabilityInfo capabilityInfo = Tasks.await(
        Wearable.getCapabilityClient(context).getCapability(
            VOICE_TRANSCRIPTION_CAPABILITY_NAME, CapabilityClient.FILTER_REACHABLE));
    // capabilityInfo has the reachable nodes with the transcription capability
    updateTranscriptionCapability(capabilityInfo);
}

चेतावनी: Wearable Data Layer API का इस्तेमाल करने से पहले, यह देख लें कि यह किसी डिवाइस पर उपलब्ध है या नहीं. ऐसा न करने पर, एक अपवाद होता है. GoogleApiAvailability क्लास का इस्तेमाल करें. इसे Horologist में लागू किया गया है.

पहनने योग्य डिवाइस से कनेक्ट होने वाले नोड का पता लगाने के लिए, लिसनर का एक इंस्टेंस रजिस्टर करें. खास तौर पर, CapabilityClient ऑब्जेक्ट का OnCapabilityChangedListener. यहां दिए गए उदाहरण में, लिसनर को रजिस्टर करने और उन नोड के साथ नतीजे पाने का तरीका बताया गया है जिन तक पहुंचा जा सकता है और जिनमें voice_transcription की सुविधा है:

private fun setupVoiceTranscription() {
    updateTranscriptionCapability(capabilityInfo).also { capabilityListener ->
        Wearable.getCapabilityClient(context).addListener(
                capabilityListener,
                VOICE_TRANSCRIPTION_CAPABILITY_NAME
        )
    }
}

private void setupVoiceTranscription() {
    ...
    // This example uses a Java 8 Lambda. You can use named or anonymous classes.
    CapabilityClient.OnCapabilityChangedListener capabilityListener =
        capabilityInfo -> { updateTranscriptionCapability(capabilityInfo); };
    Wearable.getCapabilityClient(context).addListener(
        capabilityListener,
        VOICE_TRANSCRIPTION_CAPABILITY_NAME);
}

मैसेज पाने की सुविधा वाले नोड का पता लगाने के बाद, यह तय करें कि मैसेज कहां भेजना है. अपने पहनने योग्य डिवाइस के आस-पास मौजूद कोई नोड चुनें, ताकि मैसेज को कई नोड से रूट करने की ज़रूरत न पड़े. आस-पास के नोड को ऐसे नोड के तौर पर तय किया जाता है जो डिवाइस से सीधे तौर पर कनेक्ट होता है. यह पता लगाने के लिए कि कोई नोड आस-पास है या नहीं, जैसे कि ब्लूटूथ से कनेक्ट किया गया है, Node.isNearby() तरीके का इस्तेमाल करें. अगर आस-पास एक से ज़्यादा नोड मौजूद हैं, तो उनमें से कोई भी नोड चुनें; इसी तरह, अगर आस-पास कोई भी नोड मौजूद नहीं है, तो कोई भी नोड चुनें.

यहां दिए गए उदाहरण में, इस्तेमाल करने के लिए सबसे सही नोड का पता लगाने का तरीका बताया गया है:

private var transcriptionNodeId: String? = null

private fun updateTranscriptionCapability(capabilityInfo: CapabilityInfo) {
    transcriptionNodeId = pickBestNodeId(capabilityInfo.nodes)
}

private fun pickBestNodeId(nodes: Set<Node>): String? {
    // Find a nearby node or pick one arbitrarily.
    return nodes.firstOrNull { it.isNearby }?.id ?: nodes.firstOrNull()?.id
}

private String transcriptionNodeId = null;

private void updateTranscriptionCapability(CapabilityInfo capabilityInfo) {
    Set<Node> connectedNodes = capabilityInfo.getNodes();

    transcriptionNodeId = pickBestNodeId(connectedNodes);
}

private String pickBestNodeId(Set<Node> nodes) {
    String bestNodeId = null;
    // Find a nearby node or pick one arbitrarily.
    for (Node node : nodes) {
        if (node.isNearby()) {
            return node.getId();
         }
         bestNodeId = node.getId();
    }
    return bestNodeId;
}

मैसेज डिलीवर करना

इस्तेमाल करने के लिए नोड की पहचान करने के बाद, MessageClient क्लास का इस्तेमाल करके मैसेज भेजें.

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

ध्यान दें: नतीजे के तौर पर मिले कोड से, यह पक्का नहीं होता कि मैसेज डिलीवर हो गया है. अगर आपके ऐप्लिकेशन को डेटा की विश्वसनीयता की ज़रूरत है, तो डिवाइसों के बीच डेटा भेजने के लिए DataItem ऑब्जेक्ट या ChannelClient क्लास का इस्तेमाल करें.

const val VOICE_TRANSCRIPTION_MESSAGE_PATH = "/voice_transcription"
...
private fun requestTranscription(voiceData: ByteArray) {
    transcriptionNodeId?.also { nodeId ->
        val sendTask: Task<*> = Wearable.getMessageClient(context).sendMessage(
                nodeId,
                VOICE_TRANSCRIPTION_MESSAGE_PATH,
                voiceData
        ).apply {
            addOnSuccessListener { ... }
            addOnFailureListener { ... }
        }
    }
}

public static final String VOICE_TRANSCRIPTION_MESSAGE_PATH = "/voice_transcription";
private void requestTranscription(byte[] voiceData) {
    if (transcriptionNodeId != null) {
        Task<Integer> sendTask =
            Wearable.getMessageClient(context).sendMessage(
              transcriptionNodeId, VOICE_TRANSCRIPTION_MESSAGE_PATH, voiceData);
         // You can add success and/or failure listeners,
         // Or you can call Tasks.await() and catch ExecutionException
         sendTask.addOnSuccessListener(...);
         sendTask.addOnFailureListener(...);
    } else {
        // Unable to retrieve node with transcription capability
    }
}

ध्यान दें: Google Play services को एसिंक्रोनस और सिंक्रोनस कॉल करने के बारे में ज़्यादा जानने के लिए, Tasks API देखें. साथ ही, यह भी जानें कि इनमें से किसका इस्तेमाल कब करना है.

कनेक्ट किए गए सभी नोड पर भी मैसेज ब्रॉडकास्ट किए जा सकते हैं. कनेक्ट किए गए उन सभी नोड को वापस पाने के लिए जिन पर मैसेज भेजे जा सकते हैं, यह कोड लागू करें:

private fun getNodes(): Collection<String> {
    return Tasks.await(Wearable.getNodeClient(context).connectedNodes).map { it.id }
}

private Collection<String> getNodes() {
    HashSet <String>results = new HashSet<String>();
    List<Node> nodes =
        Tasks.await(Wearable.getNodeClient(context).getConnectedNodes());
    for (Node node : nodes.getNodes()) {
        results.add(node.getId());
    }
    return results;
}

मैसेज पाना

मैसेज मिलने की सूचना पाने के लिए, MessageClient.OnMessageReceivedListener इंटरफ़ेस लागू करें, ताकि मैसेज इवेंट के लिए लिसनर उपलब्ध कराया जा सके. इसके बाद, addListener तरीके का इस्तेमाल करके, लिसनर को रजिस्टर करें. यहां दिए गए उदाहरण में, VOICE_TRANSCRIPTION_MESSAGE_PATH की जांच करने के लिए लिसनर को लागू करने का तरीका बताया गया है. अगर यह शर्त true है, तो आवाज़ के डेटा को प्रोसेस करने के लिए कोई गतिविधि शुरू करें.

fun onMessageReceived(messageEvent: MessageEvent) {
    if (messageEvent.path == VOICE_TRANSCRIPTION_MESSAGE_PATH) {
        val startIntent = Intent(this, MainActivity::class.java).apply {
            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
            putExtra("VOICE_DATA", messageEvent.data)
        }
        startActivity(this, startIntent)
    }
}

@Override
public void onMessageReceived(MessageEvent messageEvent) {
    if (messageEvent.getPath().equals(VOICE_TRANSCRIPTION_MESSAGE_PATH)) {
        Intent startIntent = new Intent(this, MainActivity.class);
        startIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        startIntent.putExtra("VOICE_DATA", messageEvent.getData());
        startActivity(this, startIntent);
    }
}

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