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

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

• वैकल्पिक स्वैच्छिक पेलोड
• ऐसा पाथ जो मैसेज की कार्रवाई की खास तौर पर पहचान करता है

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

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

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

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

मैसेज भेजें

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

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

विज्ञापन दिखाने की सुविधाएं

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

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

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

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

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

<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>

ज़रूरी क्षमताओं वाले नोड वापस पाना

शुरुआत में, आप getCapability तरीका CapabilityClient क्लास. इस तरीके का इस्तेमाल करने के लिए, आपका 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);
}

पहने जाने वाले डिवाइस से कनेक्ट होने पर सक्षम नोड का पता लगाने के लिए, लिसनर का इंस्टेंस, खास तौर पर OnCapabilityChangedListener एक CapabilityClient ऑब्जेक्ट में. नीचे दिए गए उदाहरण में, लिसनर को रजिस्टर करें और रीचेबल नोड के साथ नतीजा पाएं 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);
    }
}

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