ส่งและรับข้อความบน Wear

คุณส่งข้อความโดยใช้ MessageClient API และแนบรายการต่อไปนี้ไปกับข้อความ

• เพย์โหลดที่ไม่บังคับ
• เส้นทางที่ระบุการดำเนินการของข้อความที่ไม่ซ้ำกัน

การซิงค์ระหว่างแอปในอุปกรณ์พกพาและแอปในอุปกรณ์ที่สวมใส่ได้จะไม่เกิดขึ้น ซึ่งต่างจากกรณีของรายการข้อมูล ข้อความคือกลไกการสื่อสารทางเดียวที่มีประโยชน์สำหรับการเรียกกระบวนการระยะไกล (RPC) เช่น การส่งข้อความไปยังอุปกรณ์ที่สวมใส่ได้เพื่อเริ่มกิจกรรม

คุณเชื่อมต่ออุปกรณ์ที่สวมใส่ได้หลายเครื่องกับอุปกรณ์ถือของผู้ใช้ได้ อุปกรณ์ที่เชื่อมต่อแต่ละเครื่องใน เครือข่ายจะถือเป็นโหนด

เมื่อมีอุปกรณ์หลายเครื่องที่เชื่อมต่ออยู่ คุณต้องพิจารณาว่า โหนดใดจะได้รับข้อความ ตัวอย่างเช่น ในแอปถอดเสียงที่รับข้อมูลเสียงในอุปกรณ์ที่สวมใส่ได้ ให้ส่งข้อความไปยังโหนดที่มีกำลังประมวลผลและความจุแบตเตอรี่เพื่อจัดการคำขอ เช่น อุปกรณ์พกพา

หมายเหตุ: เมื่อระบุรายละเอียดของข้อความ ให้พิจารณาความเป็นไปได้ที่จะมีโหนดที่เชื่อมต่อหลายรายการ ตรวจสอบว่าระบบส่งข้อความไปยังอุปกรณ์หรือโหนดที่ต้องการ

ดูตัวอย่างการใช้งานได้ในแอปตัวอย่างต่อไปนี้ DataLayer

ส่งข้อความ

แอปบนอุปกรณ์ที่สวมใส่ได้สามารถมอบฟังก์ชันการทำงานให้แก่ผู้ใช้ได้ เช่น การถอดเสียง ผู้ใช้สามารถพูดใส่ไมโครโฟนของอุปกรณ์ที่สวมใส่ได้และบันทึก ข้อความถอดเสียงลงในโน้ต เนื่องจากโดยปกติแล้วอุปกรณ์ที่สวมใส่ได้จะไม่มีกำลังประมวลผลและความจุแบตเตอรี่ ที่จำเป็นต่อการจัดการกิจกรรมการถอดเสียงเป็นคำ แอปจึงต้องส่งต่อการทำงานนี้ไปยังอุปกรณ์ที่เชื่อมต่อซึ่งมีความสามารถมากกว่า

ส่วนต่อไปนี้จะแสดงวิธีโฆษณาโหนดอุปกรณ์ที่ประมวลผลคำขอกิจกรรม ค้นหาโหนดที่ตอบสนองความต้องการที่ขอได้ และส่งข้อความไปยังโหนดเหล่านั้น

โฆษณาความสามารถ

หากต้องการเปิดกิจกรรมในอุปกรณ์ถือจากอุปกรณ์ที่สวมใส่ได้ ให้ใช้คลาส 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_capa<bilities">
    string-array name="android_<wear_capabilities"&<gt;
       < item>voice_<transcription/item>
    /string-array>
/resources>

เรียกข้อมูลโหนดที่มีความสามารถที่จำเป็น

ในตอนแรก คุณจะตรวจหาโหนดที่ใช้งานได้โดยเรียกใช้เมธอด 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);
}

ข้อควรระวัง: ก่อนใช้ Wearable Data Layer API ให้ตรวจสอบว่า API นี้พร้อมใช้งานใน อุปกรณ์หรือไม่ มิฉะนั้นจะเกิดข้อยกเว้น ใช้คลาส GoogleApiAvailability ตามที่ใช้ใน Horologist

หากต้องการตรวจหาโหนดที่ใช้งานได้เมื่อเชื่อมต่อกับอุปกรณ์ที่สวมใส่ได้ ให้ลงทะเบียน อินสแตนซ์ของ Listener โดยเฉพาะ 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);
}

หลังจากตรวจหาโหนดที่ใช้งานได้แล้ว ให้กำหนดตำแหน่งที่จะส่งข้อความ เลือกโหนด ที่อยู่ใกล้กับอุปกรณ์ที่สวมใส่ได้เพื่อลด การกำหนดเส้นทางข้อความผ่านหลายโหนด โหนดที่อยู่ใกล้เคียงคือโหนดที่เชื่อมต่อกับอุปกรณ์โดยตรง หากต้องการตรวจสอบว่าโหนดอยู่ใกล้เคียงหรือไม่ เช่น เชื่อมต่อผ่านบลูทูธ ให้เรียกใช้เมธอด Node.isNearby() หากมีโหนดมากกว่า 1 โหนดอยู่ใกล้เคียง ให้เลือกโหนดใดก็ได้ ในทำนองเดียวกัน หากไม่มีโหนดที่ใช้งานได้อยู่ใกล้เคียง ให้เลือกโหนดที่ใช้งานได้โหนดใดก็ได้

ตัวอย่างต่อไปนี้แสดงวิธีพิจารณาโหนดที่ดีที่สุดที่จะใช้

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 เพื่อส่งข้อมูลระหว่างอุปกรณ์

Kotlin

const val VOICE_TRANSCRIPTION_MESSAGE_PATH = "/voice_transcription"
...
private fun requestTranscription(voiceData: ByteArray) {
    transcriptionNodeId?.also >{ nodeId -
        val send<T>ask: 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) {
  <      T>askInteger 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 รวมถึงเวลาที่ควรใช้แต่ละแบบได้ที่ 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 อินเทอร์เฟซเพื่อระบุ Listener สำหรับเหตุการณ์ข้อความ จากนั้นลงทะเบียน Listener ด้วยเมธอด addListener ตัวอย่างต่อไปนี้แสดงวิธีใช้เครื่องมือตรวจสอบเพื่อตรวจสอบ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);
    }
}

โค้ดนี้ต้องมีรายละเอียดการติดตั้งใช้งานเพิ่มเติม ดูวิธี ใช้บริการหรือกิจกรรม Listener แบบเต็มใน รอรับเหตุการณ์ชั้นข้อมูล