Mengirim dan menerima pesan di Wear

Untuk mengirim pesan, gunakan API MessageClient dan lampirkan item berikut ke pesan:

  • Payload acak (opsional)
  • Jalur yang mengidentifikasi tindakan pesan secara unik

Tidak seperti item data, tidak ada sinkronisasi antara aplikasi di perangkat genggam dan perangkat wearable. Pesan adalah mekanisme komunikasi satu arah yang bagus untuk remote procedure call (RPC), seperti pengiriman pesan ke perangkat wearable untuk memulai aktivitas.

Beberapa perangkat wearable dapat dihubungkan ke perangkat genggam pengguna. Setiap perangkat yang terhubung di jaringan tersebut akan dianggap sebagai node. Dengan beberapa perangkat yang terhubung, Anda harus mempertimbangkan node mana yang menerima pesan. Misalnya, dalam aplikasi transkripsi suara yang menerima data suara pada perangkat wearable, Anda harus mengirim pesan ke node dengan kapasitas daya dan baterai pemrosesan untuk menangani permintaan, seperti perangkat genggam.

Catatan: Dengan versi layanan Google Play di bawah 7.3.0, hanya satu perangkat wearable yang dapat terhubung ke perangkat genggam pada waktu yang sama. Anda mungkin perlu mengupdate kode yang ada untuk mempertimbangkan fitur beberapa node yang terhubung. Jika Anda tidak menerapkan perubahan, pesan dapat gagal terkirim ke perangkat yang dituju.

Lihat referensi terkait berikut:

Kirim SMS

Aplikasi wearable dapat memberikan fungsionalitas bagi pengguna seperti transkripsi suara. Pengguna dapat berbicara melalui mikrofon perangkat wearable dan menyimpan transkripsi ke catatan. Karena perangkat wearable biasanya tidak memiliki kapasitas daya dan baterai pemrosesan yang diperlukan untuk menangani aktivitas transkripsi suara, aplikasi tersebut harus melimpahkan pekerjaan ini ke perangkat terhubung yang lebih mampu melakukannya.

Bagian berikut menunjukkan cara memberi tahu node perangkat yang dapat memproses permintaan aktivitas, menemukan node yang mampu memenuhi kebutuhan yang diminta, dan mengirim pesan ke node tersebut.

Untuk meluncurkan aktivitas pada perangkat genggam dari perangkat wearable, gunakan class MessageClient untuk mengirim permintaan. Karena beberapa perangkat wearable dapat dihubungkan ke perangkat genggam, aplikasi wearable perlu menentukan bahwa node yang terhubung mampu meluncurkan aktivitas. Di aplikasi genggam Anda, beri tahukan bahwa node yang dijalankan memberikan kemampuan spesifik.

Untuk memberi tahu kemampuan aplikasi perangkat genggam Anda:

  1. Buat file konfigurasi XML di direktori res/values/ project Anda dan berikan nama wear.xml.
  2. Tambahkan referensi bernama android_wear_capabilities ke wear.xml.
  3. Tentukan kemampuan yang disediakan perangkat tersebut.

Catatan: Kemampuan adalah string kustom yang Anda tetapkan dan harus unik dalam aplikasi.

Contoh berikut menunjukkan cara menambahkan kemampuan bernama voice_transcription ke 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>
    

Mengambil node dengan kemampuan yang diperlukan

Pada awalnya, Anda dapat mendeteksi node yang mampu dengan memanggil metode getCapability dari class CapabilityClient. Contoh berikut menunjukkan cara mengambil hasil dari node yang dapat dijangkau secara manual dengan kemampuan 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);
    }
    

Untuk mendeteksi node yang mampu saat terhubung ke perangkat wearable, daftarkan instance pemroses, khususnya OnCapabilityChangedListener dari objek CapabilityClient. Contoh berikut menunjukkan cara mendaftarkan pemroses dan mengambil hasil node yang dapat dijangkau dengan kemampuan 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. Named or anonymous classes can also be used.
        CapabilityClient.OnCapabilityChangedListener capabilityListener =
            capabilityInfo -> { updateTranscriptionCapability(capabilityInfo); };
        Wearable.getCapabilityClient(context).addListener(
            capabilityListener,
            VOICE_TRANSCRIPTION_CAPABILITY_NAME);
    }
    

Setelah mendeteksi node yang mampu, tentukan tujuan pengiriman pesan. Anda harus memilih node yang dekat dengan perangkat wearable untuk meminimalkan perutean pesan melalui beberapa node. Node di sekitar ditentukan sebagai node yang langsung terhubung ke perangkat. Untuk menentukan apakah node ada di sekitar, panggil metode Node.isNearby().

Contoh berikut menunjukkan cara yang mungkin dalam menentukan node terbaik untuk digunakan:

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

Mengirim pesan

Setelah Anda mengidentifikasi node terbaik yang akan digunakan, kirim pesan menggunakan class MessageClient.

Contoh di bawah menunjukkan cara mengirim pesan ke node yang mampu mentranskripsi dari perangkat wearable. Verifikasi apakah node tersebut tersedia sebelum Anda mencoba mengirim pesan. Panggilan ini sinkron dan memblokir pemrosesan hingga sistem mengantrekan pesan untuk dikirim.

Catatan: Kode hasil yang sukses tidak menjamin pengiriman pesan. Jika aplikasi Anda memerlukan keandalan data, pertimbangkan untuk menggunakan objek DataItem atau class ChannelClient dalam mengirim data antara perangkat.

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

Catatan: Untuk mempelajari lebih lanjut panggilan asinkron dan sinkron ke layanan Google Play dan waktu penggunaannya, lihat Tasks API.

Anda juga dapat menyiarkan pesan ke semua node yang terhubung. Untuk mengambil semua node terhubung yang dapat Anda kirimi pesan, terapkan kode berikut:

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

Menerima pesan

Agar mendapatkan notifikasi pesan yang diterima, terapkan antarmuka MessageClient.OnMessageReceivedListener untuk memberi peristiwa pesan bagi pemroses. Kemudian, daftarkan pemroses dengan metode addListener. Contoh ini menunjukkan cara Anda menerapkan pemroses untuk memeriksa VOICE_TRANSCRIPTION_MESSAGE_PATH. Jika kondisi ini berupa true, mulailah aktivitas untuk memproses data suara.

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

Cuplikan ini memerlukan detail penerapan selengkapnya. Pelajari cara menerapkan layanan atau aktivitas pemroses yang lengkap di Memproses Peristiwa Lapisan Data.