Unlimited WordPress themes, graphics, videos & courses! Unlimited asset downloads! From $16.50/m
Advertisement
  1. Code
  2. Android SDK
Code

Dapatkan Wear OS dan Android Talking: Bertukar Informasi melalui Lapisan Data yang Dapat Dipakai

by
Difficulty:IntermediateLength:LongLanguages:

Indonesian (Bahasa Indonesia) translation by Ilham Saputra (you can also view the original English article)

Ketika datang untuk melakukan tugas yang cepat dan sederhana, aplikasi yang dapat dikenakan memiliki keuntungan, karena smartwatch yang ada di pergelangan tangan Anda akan selalu lebih mudah diakses daripada smartphone atau tablet yang beredar di suatu tempat di tas Anda.

Tetapi tidak ada yang namanya gadget yang sempurna, dan tidak ada yang mengoceh tentang masa pakai baterai smartwatch mereka atau mengklaim bahwa itu sama cepat dan kuatnya seperti smartphone atau tablet mereka.

Untuk memberikan pengalaman pengguna sebaik mungkin, Anda perlu bermain untuk kekuatan perangkat. Jika Anda mengembangkan untuk Wear OS (sistem operasi yang sebelumnya dikenal sebagai Android-Wear), maka Anda berada dalam posisi yang unik untuk memilih fitur terbaik dari dua perangkat yang sangat berbeda.

Pada dasarnya, Anda dapat memiliki yang terbaik dari kedua dunia!

Dalam artikel ini, saya akan menunjukkan kepada Anda cara memanfaatkan segala sesuatu yang OS Android dan OS Wear tawarkan, dengan membuka saluran komunikasi di antara keduanya. Setelah aplikasi genggam Anda dan mitra yang dapat dikenakannya sedang mengobrol, Anda dapat mendelegasikan tugas berdasarkan perangkat yang paling sesuai untuknya—apakah itu membebani tugas-tugas padat baterai ke perangkat genggam, atau memastikan informasi penting aplikasi Anda selalu mudah diakses dengan menampilkannya di pergelangan tangan pengguna.

Pada akhir artikel ini, Anda akan membuat aplikasi genggam dan yang dapat dikenakan yang dapat bertukar informasi melalui Lapisan Data yang Dapat Dipakai dan API MessageClient.

Apa itu Lapisan Data yang Dapat Dipakai?

Lapisan Data yang Dapat Dipakai menyediakan akses ke berbagai kelas klien yang dapat Anda gunakan untuk menyimpan dan mengambil data, tanpa harus membuat tangan Anda kotor dengan detail teknis seperti serialisasi data. Setelah informasi ini ada di Lapisan Data, itu dapat diakses oleh perangkat genggam dan perangkat yang dapat dikenakan.

Dalam artikel ini, kami akan berfokus pada API MessageClient, yang merupakan mekanisme komunikasi satu arah yang dapat Anda gunakan untuk mengirim informasi ke Lapisan Data yang Dapat Dipakai. API ini sangat berguna untuk menjalankan panggilan prosedur jarak jauh (RPC), seperti meluncurkan Activity dari jarak jauh pada perangkat genggam atau perangkat yang dapat dikenakan.

Mari kita lihat contoh: bayangkan Anda telah membuat aplikasi navigasi. Aplikasi ini perlu a) mengambil pembaruan lokasi, dan b) memberikan petunjuk kepada pengguna.

Memantau lokasi perangkat adalah tugas intensif yang dapat menguras baterai terbatas dengan cepat ke perangkat yang dapat dikenakan khusus. Menggunakan API MessageClient, aplikasi wearable Anda dapat menginstruksikan rekan genggamnya untuk melakukan pekerjaan ini sebagai gantinya. Setelah perangkat genggam melakukan pengangkatan yang berat ini, perangkat dapat mengirim kembali informasi yang dihasilkan ke perangkat yang dapat dikenakan melalui Lapisan Data, sehingga aplikasi Anda mendapatkan informasi yang dibutuhkan tanpa mengambil sisa baterai yang dapat dikenakan.

Sebagai aturan umum, jika aplikasi yang dapat dikenakan Anda perlu melakukan tugas yang membutuhkan daya baterai atau pemrosesan yang signifikan, atau interaksi pengguna yang rumit, maka Anda harus mempertimbangkan untuk membatalkan pekerjaan ini ke aplikasi genggam yang terkait. Sebaliknya, jika aplikasi Anda berkaitan dengan informasi yang sangat sensitif terhadap waktu, atau konten yang kemungkinan diakses pengguna saat bepergian, maka Anda harus menampilkan informasi ini di aplikasi yang dapat dikenakan.

Dalam contoh aplikasi navigasi kami, menekan setiap rangkaian petunjuk dari perangkat genggam ke perangkat yang dapat dikenakan membuat informasi ini lebih mudah diakses, terutama bagi seseorang yang keluar dan sekitar, dan kehilangan harapan!

Di luar kotak, API MessageClient adalah mekanisme komunikasi satu arah, tetapi Anda dapat menerapkan pesan dua arah dengan membuat pengirim dan penerima di modul genggam dan dpt dipakai proyek Anda—itulah yang akan kami lakukan.

Membuat Modul Wearable dan Handheld

Dalam artikel ini, kami akan membuat aplikasi yang dapat dikenakan yang akan dikenali ketika rekan genggamnya mengirim pesan baru ke Lapisan Data. Aplikasi yang dapat dikenakan ini kemudian akan merespons dengan mengambil pesan ini dan menampilkannya sebagai bagian dari UI-nya.

Kemudian, kami akan berkumur dan mengulangi, membuat aplikasi genggam yang memantau Lapisan Data untuk pesan yang dikirim dari mitra yang dapat dikenakan.

Informasi yang dikirim melalui API MessageClient hanya dapat diakses oleh aplikasi yang membuatnya. Jika sistem akan mengidentifikasi perangkat yang dapat dikenakan dan genggam Anda sebagai milik aplikasi yang sama, maka mereka harus memiliki nama paket, kode versi, dan sertifikat penandatanganan yang sama. Cara termudah untuk mencentang semua kotak ini adalah membuat proyek yang terdiri dari modul yang dapat dikenakan dan genggam:

  • Buat proyek baru bernama DataLayer.
  • Pada layar Target Android Device, pilih Phone and Tablet and Wear. Klik Next.
  • Untuk ponsel dan modul tablet Anda, pilih template Empty Activity, lalu klik Next.
  • Untuk modul yang dapat dikenakan, pilih template Black Wear Activity, lalu klik Next, diikuti oleh Finish.

Membuat Aplikasi Genggam Anda

Karena kami menerapkan komunikasi dua arah, baik perangkat genggam dan modul seluler kami membutuhkan pendengar dan pengirimnya sendiri. Mari mulai dengan menerapkan fungsi ini di aplikasi genggam kami.

Saya akan menjaga hal-hal sederhana dan membuat UI yang terdiri dari TextView yang akan menampilkan berbagai pesan yang diambil dari Lapisan Data dan tombol yang, ketika diketuk, akan mengirim pesannya sendiri ke Lapisan Data.

Buka file activity_main.xml modul seluler Anda, dan tambahkan yang berikut:

Karena kami mereferensikan beberapa nilai dimens.xml, kami perlu memberikan definisi untuk nilai-nilai ini:

  • Control-click direktori res/values modul seluler.
  • Pilih New > Values resource file.
  • Namai file ini dimens.xml dan kemudian klik OK.
  • Tambahkan berikut:

Ini memberi kita antarmuka pengguna berikut:

Create the user interface for your projects handheld component

Tambahkan Dependensi

Buka file build.gradle modul seluler dan tambahkan dependensi berikut:

Menampilkan dan Mengirim Pesan di MainActivity

Dalam MainActivity, kita perlu melakukan berikut:

  1. Pertahankan pengguna dalam lingkaran!

Saat pengguna mengetuk tombol Talk to the Wearable, ada dua hal yang perlu terjadi:

  • Handheld mengirim pesan ke perangkat yang dapat dikenakan. Saya akan menggunakan "I received a message from the handheld."
  • Handheld menyediakan konfirmasi visual bahwa pesan telah berhasil dikirim. Saya akan menggunakan "I sent a message to the wearable."

Saat pengguna mengetuk genggam tombol Talk to the Wearable, handheld akan berusaha mengirim pesan ke Lapisan Data. Sistem hanya menganggap pesan ini berhasil dikirim setelah antre untuk dikirim ke perangkat tertentu, yang berarti setidaknya satu perangkat yang dipasangkan harus tersedia.

Dalam skenario kasus terbaik, pengguna mengetuk Talk to Wearable, pesan akan diantrekan untuk pengiriman, dan handheld kami dengan penuh kemenangan menyatakan bahwa: "I just sent a message to the wearable."

Namun, jika tidak ada perangkat yang dapat dikenakan yang tersedia, maka pesan tidak diantrekan, dan secara default pengguna tidak mendapat konfirmasi bahwa aplikasi kami bahkan mencoba mengirim pesan. Ini dapat membuat pengguna bertanya-tanya apakah aplikasi rusak, jadi saya juga akan menampilkan Sending message…. pemberitahuan, terlepas dari apakah pesan berhasil diantrekan atau tidak.

Saat menguji aplikasi ini, Anda mungkin juga ingin memicu beberapa pesan secara berurutan. Untuk memperjelas kapan setiap pesan telah diantrekan untuk pengiriman, saya menambahkan penghitung untuk setiap pesan, sehingga handheld kami akan menampilkan I just sent a message to the wearable 2I just sent a message to the wearable 3, dan segera. Di sisi lain sambungan, perangkat kami yang dapat dikenakan akan menampilkan I just received a message from the handheld 2I just received a message from the handheld 3, and segera.

2. Tampilkan pesan yang diterima

Di bagian selanjutnya, kami akan membuat MessageService yang memantau Lapisan Data dan mengambil pesan. Karena layanan kami akan melakukan tugasnya pada utas yang berbeda, maka akan disiarkan informasi ini ke MainActivity kami, yang kemudian akan bertanggung jawab untuk memperbarui UI.

3. Tentukan path

Setiap pesan yang Anda transmisikan melalui API MessageClient harus berisi jalur, yang merupakan string yang secara unik mengidentifikasi pesan dan memungkinkan aplikasi Anda untuk mengaksesnya dari sisi lain koneksi.

Jalur ini selalu dimulai dengan garis miring (saya menggunakan /my_path) dan juga dapat berisi muatan opsional, dalam bentuk susunan byte.

4. Periksa node Anda!

Di layanan Google Play 7.3.0 dan lebih tinggi, Anda dapat menghubungkan beberapa Produk yang dapat dikenakan ke satu perangkat genggam—misalnya, pengguna mungkin mengeluarkan banyak perangkat yang dapat digunakan atau beralih secara bersamaan. Perangkat OS Wear juga dapat disambungkan ke beberapa perangkat genggam selama masa pakainya, misalnya jika pengguna memiliki ponsel pintar Android dan tablet, atau mereka mengganti ponsel lama mereka dengan ponsel cerdas yang baru. Perhatikan bahwa perangkat apa pun yang dapat terhubung ke Lapisan Data disebut sebagai node dalam kode aplikasi.

Dalam artikel ini, saya akan berasumsi hanya akan ada satu perangkat yang dapat dikenakan. Alternatifnya, Anda bisa selektif tentang perangkat mana yang Anda kirimi pesan, menggunakan GetConnectedNodes atau getLocalNode.

Mari kita menerapkan semua ini di MainActivity kami:

Membuat Listening Service

Pada titik ini, perangkat genggam kami mampu mendorong pesan ke Lapisan Data, tetapi karena kami ingin menerapkan komunikasi dua arah, itu juga perlu untuk mendengarkan pesan yang tiba di Lapisan Data.

Di bagian ini, kami akan membuat layanan yang melakukan hal berikut:

  1. Pantau Lapisan Data untuk acara

Anda dapat memantau Lapisan Data baik dengan mengimplementasikan antarmuka DataClient.OnDataChangedListener atau dengan memperluas WearableListenerService. Saya memilih yang terakhir, karena ada beberapa manfaat untuk memperluas WearableListenerService. Pertama, WearableListenerService berfungsi pada utas latar belakang, jadi Anda tidak perlu khawatir memblokir utas UI utama. Kedua, sistem mengelola siklus hidup WearableListenerService untuk memastikannya tidak mengkonsumsi sumber daya yang tidak perlu, mengikat dan melepaskan layanan sesuai kebutuhan.

Kekurangannya adalah WearableListenerService akan mendengarkan acara bahkan ketika aplikasi Anda tidak berjalan, dan aplikasi akan diluncurkan jika mendeteksi acara yang relevan. Jika aplikasi Anda hanya perlu merespons acara ketika sudah berjalan, maka WearableListenerService dapat menghabiskan baterai perangkat secara tidak perlu.

2. Ganti callback data yang relevan

WearableListenerService dapat mendengarkan berbagai peristiwa Lapisan Data, jadi Anda perlu mengganti metode panggilan balik peristiwa data untuk acara yang ingin Anda tangani. Di layanan kami, saya menerapkan onMessageReceived, yang akan dipicu saat pesan dikirim dari nodus jarak jauh.

3. Periksa path

Setiap kali pesan dikirim ke Lapisan Data, aplikasi kami perlu memeriksa apakah ia memiliki pengidentifikasi my_path yang benar.

4. Menyiarkan pesan untuk MainActivity

Karena WearableListenerService berjalan di utas yang berbeda, itu tidak dapat memperbarui UI secara langsung. Untuk menampilkan pesan dalam aplikasi kami, kami harus meneruskannya ke MainActivity, menggunakan LocalBroadcastManager.

Untuk membuat Layanan:

  • Pastikan Anda memiliki modul mobile yang dipilih.
  • Pilih New > Service dari toolbar Android Studio.
  • Namai Layanan ini MessageService.
  • Tambahkan berikut:

Akhirnya, buka Manifest dan tambahkan beberapa informasi ke entri MessageService:

Seperti yang telah disebutkan, sistem hanya menganggap pesan berhasil dikirim setelah antre untuk pengiriman, yang hanya dapat terjadi jika satu atau beberapa perangkat yang dapat dikenakan tersedia.

Anda dapat melihat ini dalam tindakan dengan menginstal modul ponsel pada smartphone atau tablet yang kompatibel, atau Android Virtual Device (AVD). Klik tombol Talk to Wearable dan aplikasi akan menampilkan Sending message... hanya teks. I just sent the wearable... tidak akan muncul.

Jika pesan kami akan antri untuk dikirim, kami perlu menerapkan kumpulan komponen pengirim dan penerima lain dalam modul wearable proyek kami.

Membuat Aplikasi Wearable Anda

Aplikasi yang dapat dikenakan kami akan memiliki fungsi yang sama dengan mitra genggamnya, jadi saya akan melewati semua kode yang telah kami bahas.

Sekali lagi, mari mulai dengan membuat antarmuka pengguna aplikasi. Buka file activity_main.xml dari wear module dan tambahkan yang berikut:

Pada titik ini, antarmuka pengguna Anda akan terlihat seperti ini:

Create the UI for your Android projects Wear OS module

Buka build.gradle Anda dan tambahkan dependensi berikut:

Sekarang, kita perlu mengirim pesan kami ke Lapisan Data:

Selanjutnya, kita perlu membuat pendengar yang akan memantau Lapisan Data untuk pesan masuk dan memberi tahu MainActivity setiap kali pesan baru diterima:

  • Pastikan modul wear dipilih.
  • Pilih New > Service dari toolbar Android Studio.
  • Nama Layanan ini MessageService dan kemudian tambahkan berikut:

Buka modul Manifest, dan membuat penyaring intent untuk WearableListenerService:

Anda dapat men-download lengkap proyek dari GitHub.

Pengujian aplikasi Anda

Pada titik ini Anda memiliki dua aplikasi yang dapat bertukar pesan melalui Lapisan Data, tetapi jika Anda ingin menerapkan keterampilan komunikasi ini, Anda harus memasang proyek Anda di perangkat genggam dan perangkat yang dapat dikenakan.

Jika Anda seorang pengembang Android, kemungkinan Anda memiliki setidaknya satu ponsel cerdas Android atau tablet yang tergeletak di sekitar, tetapi perangkat yang dapat dikenakan masih terasa seperti produk yang relatif baru dan khusus, sehingga Anda mungkin belum berinvestasi dalam jam tangan cerdas.

Jika Anda memutuskan untuk mengejar pengembangan OS Wear, maka Anda harus mengambil risiko dan membeli jam tangan cerdas di beberapa titik, karena tidak ada pengganti untuk menguji aplikasi Anda di perangkat Android nyata. Namun, jika Anda hanya bereksperimen dengan OS Wear, maka Anda dapat membuat AVD yang mengemulasikan yang dapat dikenakan, dengan cara yang persis sama seperti Anda membuat AVD yang mengemulasikan ponsel pintar atau tablet. Anda kemudian bisa mendapatkan AVD dan perangkat Android fisik Anda berbicara, menggunakan port forwarding.

Langkah pertama adalah membuat AVD yang dapat dikenakan dan menginstal modul wear Anda pada perangkat yang diemulasi ini:

  • Pilih Tools > Android> AVD Manager dari toolbar Android Studio.
  • Klik Create Virtual Device...
  • Pilih Wear dari menu sebelah kiri.
  • Pilih wearable yang ingin Anda tiru, dan kemudian klik Next.
  • Pilih gambar sistem Anda, dan kemudian klik Next.
  • Beri nama AVD Anda, dan kemudian klik Finish.
  • Pilih Run > Run... dari toolbar Android Studio.
  • Dalam popup kecil yang muncul, pilih Wear...
  • Pilih AVD yang dapat dikenakan yang baru saja Anda buat. Setelah beberapa saat, AVD akan diluncurkan dengan komponen yang dapat dikenakan Anda sudah terpasang.

Selanjutnya, instal modul genggam di smartphone atau tablet Anda:

  • Hubungkan perangkat Android fisik Anda ke mesin pengembangan Anda.
  • Pilih Run > Run... dari toolbar Android Studio.
  • Memilih mobile bila diminta.

Akhirnya, kita perlu mendapatkan perangkat Android fisik dan pembicaraan AVD kami:

  • Pastikan Bluetooth diaktifkan di genggam Anda (Settings > Bluetooth) dan terhubung ke mesin pengembangan Anda melalui kabel USB.
  • Di perangkat genggam Anda, buka Play Store dan unduh OS Wear dengan aplikasi Google (sebelumnya Android Wear).
  • Meluncurkan aplikasi memakai OS.
  • Pada wearable yang dapat Anda emulasi, klik tombol Home di strip yang menyertai (tempat kursor diposisikan di screenshot berikut) dan kemudian buka Settings aplikasi.

Testing your project by connecting your emulator and your Android smartphone or tablet

  • Pilih System > About dan klik Build number berulang kali, hingga Anda melihat pesan You are now a developer.
  • Kembali ke menu Settings utama dengan mengklik tombol Back dua kali. Anda harus melihat item Developer Options baru; beri klik.
  • Pilih ADB Debugging.
  • Di mesin pengembangan Anda, buka Command Prompt (Windows) atau Terminal (Mac) baru dan kemudian ubah direktori (cd) sehingga mengarah ke folder platform-alat SDK Android. Sebagai contoh, perintah saya terlihat seperti ini:
  • Pastikan ADB (Android Debug Bridge) mengenali emulator dan ponsel cerdas atau tablet yang Anda pasang, dengan menjalankan perintah /.adb device. Ini harus mengembalikan kode untuk dua perangkat terpisah.
  • Maju port komunikasi Anda AVD ke terlampir smartphone atau tablet, dengan menjalankan perintah berikut dalam jendela Terminal Command Prompt:
  • Di genggam Anda, luncurkan aplikasi OS Wear. Arahkan melalui dialog pengantar apa pun, hingga Anda mencapai layar OS OS utama.
  • Buka dropdown di sudut kiri atas dan pilih Add a new watch.
  • Ketuk ikon putus-putus di sudut kanan atas, dan pilih Pair with emulator. Setelah beberapa saat, handheld harus terhubung ke emulator Anda.
Use the Wear OS app to pair your emulator with your Android smartphone or tablet

Anda sekarang siap menguji aplikasi Anda! Luncurkan komponen Wear pada emulator Anda dan komponen ponsel di genggam Anda, dan bereksperimen dengan mengetuk tombol Talk... yang berbeda.

Saat Anda mengetuk Talk to the wearable di genggam, pesan berikut akan muncul:

  • Handheld: “I just sent the handheld a message."
  • Wearable: “I just received a message from the handheld.”
You can now exchange messages over the Data Layer using the MessageClient API

Saat Anda mengetuk Talk to the handheld pada perangkat yang dapat dikenakan, pesan berikut akan muncul:

  • Wearable: “I just sent the handheld a message."
  • Handheld: ‘I just received a message from the wearable.”

Kesimpulan

Dalam artikel ini, kami melihat cara bertukar pesan antara perangkat genggam Anda dan aplikasi yang dapat dikenakan, di atas Lapisan Data yang Dapat Dipakai.

Dalam produksi, Anda mungkin menggunakan teknik ini untuk melakukan sesuatu yang lebih menarik daripada sekadar menukar beberapa baris teks yang sama! Misalnya, jika Anda mengembangkan aplikasi yang memutar musik pada ponsel cerdas pengguna, Anda dapat memberi mereka kemampuan untuk memutar, menjeda, dan melompati lagu langsung dari perangkat yang dapat dikenakan mereka, dengan mengirimkan petunjuk ini dari perangkat yang dapat dikenakan ke perangkat genggam, melalui Lapisan Data .

Anda dapat mempelajari lebih lanjut tentang Lapisan Data yang Dapat Dipakai, termasuk cara menyinkronkan data yang lebih kompleks, ke lebih dari pada dokumen Android resmi.

Advertisement
Advertisement
Advertisement
Advertisement
Looking for something to help kick start your next project?
Envato Market has a range of items for sale to help get you started.