שליחה וקבלה של הודעות ב-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>

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

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

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

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 . הדוגמה הבאה מראה איך אפשר להטמיע את ה-listener כדי לבדוק את 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);
    }
}

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