שליחה וקבלה של הודעות ב-Wear

כדי לשלוח הודעות באמצעות MessageClient API ולצרף את הפריטים הבאים להודעה:

  • מטען ייעודי (payload) שרירותי אופציונלי
  • נתיב שמזהה באופן ייחודי את פעולת ההודעה

בניגוד לפריטי נתונים, לא מתבצע סנכרון אפליקציות לבישים ולמכשירים ניידים. הודעות הן מנגנון תקשורת חד-כיווני שמועיל לקריאות להליך מרוחק (RPC), למשל, שליחת הודעה לגאדג'ט הלביש כדי להתחיל פעילות.

אפשר לחבר כמה מכשירים לבישים למכשירים ניידים של משתמשים. כל מכשיר מחובר ב- הרשת נחשבת לצומת.

כשיש כמה מכשירים מחוברים, צריך להחליט והצמתים יקבלו את ההודעות. לדוגמה, באפליקציה של תמלול קולי שמקבלת נתונים קוליים המכשיר הלביש, שליחת ההודעה לצומת עם עוצמת העיבוד והסוללה היכולת לטפל בבקשה, למשל מכשיר נייד.

הערה: כאשר אתם מציינים את פרטי ההודעה, קחו בחשבון את האפשרות וצמתים מחוברים. צריך לוודא שההודעה נמסרת למכשירים או לצמתים הרלוונטיים.

כדאי לעיין באפליקציה לדוגמה הבאה כדי לראות דוגמאות לשימוש: שכבת נתונים

שליחת הודעה

אפליקציה לבישה יכולה לספק למשתמשים תכונות כמו פקודות קוליות תמליל. המשתמשים יכולים לדבר אל המיקרופון של המכשיר הלביש שלהם ולקבל תמליל נשמרה בהערה. בדרך כלל, למכשיר לביש אין כוח עיבוד וסוללה יכולת הפעולה הזו שנדרשת לטיפול בפעילות התמלול הקולי, והאפליקציה צריכה להסיר את עומס העבודה הזה למכשיר מחובר ומשופר.

בקטעים הבאים מוסבר איך לפרסם צמתים של מכשירים שיכולים לעבד פעילות בקשות, לגלות את הצמתים שמסוגלים לתת מענה לצורך מבוקש ולשלוח הודעות צמתים.

כדי להתחיל פעילות במכשיר נייד ממכשיר לביש, צריך להשתמש ב- כיתה אחת ( MessageClient) כדי לשלוח את הבקשה. מאחר שיש כמה גאדג'טים לבישים יכול להיות מחובר אל מכשיר נייד, האפליקציה הלבישת צריכה לזהות שצומת מחובר מסוגל להפעיל את הפעילות. באפליקציה לנייד, מפרסמים שהצומת שעליו הוא פועל, מספקת יכולות ספציפיות.

כדי לפרסם את היכולות של האפליקציה להחזקה ביד:

  1. יוצרים קובץ תצורה של XML בספרייה res/values/ של הפרויקט, נותנים לה את השם wear.xml.
  2. צריך להוסיף משאב בשם android_wear_capabilities אל wear.xml.
  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>

אחזור צמתים עם היכולות הנדרשות

בהתחלה, אפשר לזהות את הצמתים הרלוונטיים על ידי שליחת קריאה ה-method getCapability כיתה אחת ( CapabilityClient). כדי להשתמש בשיטה הזו, צריך להתקין את האפליקציה ל-Wear OS ואת האפליקציה לטלפון צריך להיות להם אותו מזהה אפליקציה. הדוגמה הבאה מראה איך לאחזר באופן ידני את התוצאות של צמתים שאפשר להגיע אליהם באמצעות יכולת voice_transcription:

Kotlin

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

Java

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. הדוגמה הבאה מראה איך רושמים את ה-listener ומאחזרים תוצאה עם צמתים זמינים שיש להם יכולת voice_transcription:

Kotlin

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

Java

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);
}

לאחר איתור הצמתים המתאימים, יש לקבוע להיכן לשלוח את ההודעה. בחירת צומת שנמצא בקרבת המכשיר הלביש כדי לצמצם לניתוב הודעות דרך מספר צמתים. צומת קרוב מוגדר כצומת שמחובר באופן ישיר למכשיר. כדי לקבוע אם צומת נמצא בקרבת מקום, למשל מחובר באמצעות Bluetooth, צריך לקרוא ל- Node.isNearby(). אם יש יותר מצומת אחד בקרבת מקום, צריך לבחור אחד באופן שרירותי. באופן דומה, אם אין צומת ניתן בקרבת מקום, ניתן לבחור צומת מסוגל באופן שרירותי.

הדוגמה הבאה ממחישה איך לקבוע באיזה צומת הכי כדאי להשתמש:

Kotlin

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
}

Java

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 class כדי לשלוח נתונים בין מכשירים.

Kotlin

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 { ... }
        }
    }
}

Java

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.

אפשר גם לשדר הודעות לכל הצמתים המחוברים. כדי לאחזר את כל וצמתים מחוברים שאליהם אפשר לשלוח הודעות, מטמיעים את הקוד הבא:

Kotlin

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

Java

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 . הדוגמה הבאה מראה איך אפשר להטמיע את ה-listener כדי לבדוק את VOICE_TRANSCRIPTION_MESSAGE_PATH אם התנאי הזה הוא true, התחלת פעילות כדי לעבד את הנתונים שנאספים בזיהוי קולי.

Kotlin

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

Java

@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);
    }
}

בקוד הזה נדרשים פרטים נוספים לגבי ההטמעה. מידע על איך להטמיע שירות או פעילות של האזנה מלאה האזנה לאירועים של שכבת נתונים.