Membuat Aplikasi Android untuk Masalah

1. Selamat datang

Matter, yang dibuat dengan tujuan menyatukan standar IoT, menghubungkan perangkat smart home di berbagai ekosistem seperti Google Home, Zigbee, Bluetooth Mesh, Z-Wave, dan banyak lagi.

Perangkat seluler adalah titik interaksi pusat dengan perangkat smart home. Jika ingin mem-build aplikasi Android sendiri untuk mendukung perangkat Matter, kami dapat membantu Anda memulai dengan cepat.

Google Home Sample App for Matter (GHSA for Matter) menampilkan Home Mobile SDK API, yang memungkinkan pengguna memesan dan membagikan perangkat. Anda juga dapat menggunakan aplikasi contoh sebagai alat pembelajaran untuk lebih memahami konsep Utama, serta alat untuk men-debug dan memecahkan masalah interaksi dengan perangkat Matter.

Yang akan Anda lakukan

Dalam Codelab ini, Anda akan mendownload kode sumber untuk aplikasi contoh dan mempelajari cara menggunakan Home Mobile SDK untuk membuat komisi dan membagikan perangkat. Anda juga akan mempelajari cara menggunakan Commissioning dan library Cluster dari repositori Matter (connectedhomeip).

Setelah mendownload aplikasi contoh, kami akan meninjau kode sumber di Android Studio dan menerapkan Home Mobile SDK API berikut:

Anda juga akan mempelajari lebih lanjut konsep komisi, kain Matter, dan cara mengontrol perangkat Matter.

Yang Anda butuhkan

Sebelum memulai, pastikan Anda menyelesaikan langkah-langkah berikut:

Anda tidak memerlukan hub, misalnya Google Nest Hub (Generasi ke-2), untuk memesan dan mengontrol perangkat dengan aplikasi contoh.

2. Memulai persiapan

Repositori GitHub aplikasi contoh mencakup library pihak ketiga dari repositori Matter (connectedhomeip). Library native ini berukuran lebih dari 50 MB dan memerlukan penggunaan Git Large File Storage (LFS).

Aplikasi awal codelab terletak di cabang codelab. Untuk mulai menggunakan kode sumber codelab, Anda dapat mendownload file ZIP. ZIP ini mencakup library native Matter SDK tanpa memerlukan Git LFS:

Anda akan menggunakan file ZIP codelab ini untuk membuat sampel yang berfungsi.

Versi Codelab

Cabang codelab diberi tag dengan rilis 1.2.2 aplikasi contoh. Untuk membandingkan update saat Anda menyelesaikan setiap langkah, Anda dapat mendownload kode sumber yang lengkap untuk rilis ini.

Jika Anda ingin meng-clone repositori GitHub, ikuti petunjuk di Contoh aplikasi README.

Dependensi

Kami akan memandu Anda memahami kode sumber yang diperlukan untuk berbagi dan menetapkan perangkat, tetapi sebaiknya Anda mengetahui dependensi berikut sebelum memulai:

  • Home Mobile SDK.
    implementation 'com.google.android.gms:play-services-home:16.0.0'
  • Library SDK Matter.
    // Native libs
implementation fileTree(dir: "third_party/connectedhomeip/libs", include: ["*.jar", "*.so"])
  • Desain Material. Untuk mempelajari lebih lanjut, baca MDC-103 Android: Tema Material dengan Warna, Ketinggian dan Jenis (Kotlin) dan Material Theme Builder.
    implementation 'com.google.android.material:material:1.5.0'
  • Proto DataStore, yang digunakan untuk mempertahankan data aplikasi. Repositori dan Serializer Datastore disimpan di java/data, termasuk skema untuk perangkat dan preferensi pengguna. Untuk mempelajari DataStore lebih lanjut, lihat Bekerja dengan Proto DataStore.
    implementation "androidx.datastore:datastore:$dataStoreVersion"
implementation 'androidx.datastore:datastore-core:1.0.0'
implementation 'com.google.protobuf:protobuf-javalite:3.18.0'
  • Hilt untuk mempertahankan data dan mendukung injeksi dependensi.
    kapt 'com.google.dagger:hilt-compiler:2.41'
implementation 'com.google.dagger:hilt-android:2.41'

Kode sumber

Antarmuka pengguna dan sebagian besar fungsinya telah dibuat untuk Anda.

Untuk codelab ini, kita akan menambahkan fungsi Matter ke file berikut:

  • java/commissioning/AppCommissioningService: memungkinkan Anda memesan perangkat untuk pengembangan
  • java/screens/HomeFragment dan java/screens/HomeViewModel.kt: mencakup fungsi komisi Home Mobile SDK
  • java/screens/DeviceViewModel: mencakup panggilan Share Device API

Setiap file diberi komentar dengan blok kode yang akan Anda ubah, misalnya:

// CODELAB: add commissioningFunction()

Ini memungkinkan Anda menemukan bagian yang sesuai dengan cepat di codelab.

3. Komisi ke Google

Sebelum Anda dapat mengontrol perangkat dan mengizinkan perangkat tersebut berkomunikasi satu sama lain dalam kain yang sama, perangkat tersebut harus digunakan oleh Komisaris, yang dalam hal ini adalah aplikasi contoh, Aplikasi Contoh Google Home untuk Matter.

Penting untuk memahami konsep berikut tentang komisi Matter:

  • Dengan Fabric, perangkat dapat berkomunikasi satu sama lain.
  • Fabric menyimpan kumpulan kredensial unik yang dibagikan.
  • Ekosistem bertanggung jawab untuk menerbitkan root certificate tepercaya, menetapkan ID kain, dan menetapkan ID node unik. Ekosistem adalah layanan back-end dari seorang komisaris, misalnya Home Graph untuk ekosistem Google Home.
  • Perangkat dapat dipesan ke lebih dari satu Fabric (fitur multi-admin).

Untuk memesan perangkat, Anda perlu menggunakan CommissioningClient API. Panggilan ke .commissionDevice() akan menampilkan IntentSender, yang akan meluncurkan aktivitas yang tepat pada Layanan Google Play:

interface CommissioningClient {
  Task<IntentSender> commissionDevice(CommissioningRequest request);
}

Di bagian berikutnya, kita akan membahas kode minimal yang diperlukan untuk menetapkan perangkat ke kain Google.

Langkah 1: Peluncur Aktivitas

Untuk menangani IntentSender dari CommissioningClient, Anda dapat menggunakan ActivityResultLauncher:

private lateinit var commissioningLauncher: ActivityResultLauncher<IntentSenderRequest>

commissioningLauncher = registerForActivityResult(
    StartIntentSenderForResult()
) { result: ActivityResult ->
    if (result.resultCode == RESULT_OK) {
        Timber.d(TAG, "Commissioning succeeded.")
    } else {
        Timber.d(TAG, "Commissioning failed. " + result.resultCode)
    }
}

Langkah 2: Memastikan fungsi

Berikut adalah contoh dasar yang menggunakan CommissioningClient API untuk menetapkan perangkat ke kain Google.

  1. Proses komisi dimulai dengan fungsi commissionDevice(). Pertama, CommissioningRequest ditentukan. Dengan konfigurasi default ini, perangkat hanya dipesan untuk fabric Android Lokal.
  2. Matter adalah titik entri untuk Home Mobile SDK. Pada panggilan berikutnya, .getCommissioningClient mendapatkan CommissioningClient oleh this (Activity).
  3. .commissionDevice() menerima CommissioningRequest.
  4. Terakhir, .addOnSuccessListener dipanggil untuk memproses CommissioningResult dan meluncurkan Aktivitas Perangkat Komisi Layanan Google Play (GPS).
private fun commissionDevice() {
    val request: CommissioningRequest = CommissioningRequest.builder().build()
    Matter.getCommissioningClient(this)
        .commissionDevice(request)
        .addOnSuccessListener { result ->
            commissioningLauncher.launch(IntentSenderRequest.Builder(result).build())
        }
}

Lokal Android Fabric dapat dimanfaatkan melalui setelan Android untuk menyederhanakan proses penugasan perangkat ke fabric lainnya.

Selanjutnya, Anda akan mempelajari cara menetapkan perangkat ke kain pengembangan.

Untuk ringkasan antarmuka pengguna selama proses Commissioning, lihat Google Home Sample App for Matter Guide.

4. Komisi untuk struktur pengembangan

Perangkat dapat ditugaskan ke lebih dari satu kain. Untuk mengelola penyambungan tepercaya, perangkat menyimpan FabricTable yang berisi berbagai anggota FabricInfo, misalnya:

  • Identifikasi kain
  • ID node yang ditetapkan oleh kain ke perangkat
  • ID Vendor
  • ID Kain
  • Kredensial operasional perangkat

Manajer domain administratif (ADM) menentukan kredensial kain. Dalam skenario sebelumnya, Layanan Google Play adalah ekosistem yang bertindak sebagai root certificate authority (CA) tepercaya. Saat Anda menetapkan perangkat ke kain Android Lokal, setiap perangkat akan menyertakan kumpulan kredensial kain yang sama, dan kumpulan CA yang sama.

Layanan Komisi Khusus

Untuk komisi kain Android Lokal, kami menggunakan parameter default untuk mem-build CommissioningRequest di CommissioningClient API:

val request: CommissioningRequest = CommissioningRequest.builder().build()

Jika ingin mengontrol dan mengelola perangkat baru dari aplikasi, Anda perlu membuat fabric pengembangan lokal dan mendapatkan kredensial operasional ke perangkat komisi. Dalam skenario ini, aplikasi Anda menjadi ekosistem unik dan independen yang menetapkan perangkat dengan kredensial node yang sesuai.

Anda dapat memberi tahu Home Mobile SDK bahwa Anda ingin menetapkan perangkat ke kain Anda sendiri dengan meneruskan layanan kustom ke CommissioningRequest:

class CommissioningRequest {
  static CommissioningRequest.Builder builder();

  class Builder {
    Builder setCommissioningService(@Nullable ComponentName commissioningService);

    CommissioningRequest build();
  }
}

Pada langkah berikutnya, kita akan memodifikasi fungsi commissionDevice() untuk menggunakan layanan kustom. Kita juga akan menambahkan Peluncur Aktivitas ke fragmen Beranda dan menggunakan objek LiveData untuk mengelola alur API.

Langkah 1: Buat Peluncur Aktivitas GPS

Pertama, mari kita buat Peluncur Aktivitas untuk menangani IntentSender dari CommissioningClient API.

  1. Buka HomeFragment di folder java/screens/home/.
  2. Ganti komentar // CODELAB: commissionDeviceLauncher declaration dengan deklarasi berikut:
    // The ActivityResult launcher that launches the "commissionDevice" activity in Google Play
// Services.
private lateinit var commissionDeviceLauncher: ActivityResultLauncher<IntentSenderRequest>
  3. Ganti komentar // CODELAB: commissionDeviceLauncher definition dengan kode berikut untuk mendaftarkan dan menangani hasil Aktivitas komisi:
    commissionDeviceLauncher =
    registerForActivityResult(ActivityResultContracts.StartIntentSenderForResult()) { result ->
      // Commission Device Step 5.
      // The Commission Device activity in GPS has completed.
      val resultCode = result.resultCode
      if (resultCode == Activity.RESULT_OK) {
        Timber.d("CommissionDevice: Success")
        // We now need to capture the device information for the app's fabric.
        // Once this completes, a call is made to the viewModel to persist the information
        // about that device in the app.
        showNewDeviceAlertDialog(result)
      } else {
        viewModel.commissionDeviceFailed(resultCode)
      }
    }    ```

Langkah 2: Buat objek LiveData

Callback berhasil dari .commissionDevice() API menyediakan IntentSender yang akan digunakan untuk meluncurkan Aktivitas Perangkat Komisi di Layanan Google Play. Di HomeViewModel, kita akan membuat dua objek LiveData untuk dilaporkan berdasarkan hasil panggilan API ini:

  • commissionDeviceStatus untuk melacak TaskStatus.
  • commissionDeviceIntentSender untuk menangani hasil panggilan .commissionDevice(). Objek LiveData ini akan meluncurkan ActivityLauncher yang baru saja kita buat dan menampilkan Aktivitas Perangkat Komisi GPS kepada pengguna.
  1. Di private fun setupObservers(), ganti komentar // CODELAB: commissionDeviceStatus dengan observer berikut:
    // The current status of the share device action.
viewModel.commissionDeviceStatus.observe(viewLifecycleOwner) { status ->
  Timber.d("commissionDeviceStatus.observe: status [${status}]")
}
  2. Selanjutnya, ganti komentar // CODELAB: commissionDeviceIntentSender dengan observer berikut:
    viewModel.commissionDeviceIntentSender.observe(viewLifecycleOwner) { sender ->
  Timber.d(
      "commissionDeviceIntentSender.observe is called with [${intentSenderToString(sender)}]")
  if (sender != null) {
    // Commission Device Step 4: Launch the activity described in the IntentSender that
    // was returned in Step 3 (where the viewModel calls the GPS API to commission
    // the device).
    Timber.d("CommissionDevice: Launch GPS activity to commission device")
    commissionDeviceLauncher.launch(IntentSenderRequest.Builder(sender).build())
    viewModel.consumeCommissionDeviceIntentSender()
  }
}

Langkah 3: Panggil API

Setelah kita menulis kode untuk menangani alur API, sekarang saatnya untuk memanggil API, meneruskan layanan kustom (yang akan kita tentukan pada langkah berikutnya), dan memposting ke objek LiveData.

  1. Buka HomeViewModel.kt di folder java/screens/home/.
  2. Ganti komentar // CODELAB: commissionDevice dengan commissionDeviceRequest berikut. setCommissioningService mengikat AppCommissioningService ke instance CommissioningService yang ditampilkan dalam fungsi callback. Saat Anda meneruskan layanan kustom, Home Mobile SDK akan terlebih dahulu menetapkan perangkat ke Google Fabric, lalu mengirim kembali payload orientasi ke AppCommissioningService.
    fun commissionDevice(context: Context) {
  _commissionDeviceStatus.postValue(TaskStatus.InProgress)

  val commissionDeviceRequest =
      CommissioningRequest.builder()
          .setCommissioningService(ComponentName(context, AppCommissioningService::class.java))
          .build()
  3. Panggil .getCommissioningClient(), lalu panggil .commissionDevice().
    Matter.getCommissioningClient(context)
    .commissionDevice(commissionDeviceRequest)

Untuk menyelesaikan fungsi commissionDevice, tambahkan addOnSuccessListener dan addOnFailureListener lalu posting ke objek LiveData:

      .addOnSuccessListener { result ->
        // Communication with fragment is via livedata
        _commissionDeviceIntentSender.postValue(result)
      }
      .addOnFailureListener { error ->
        Timber.e(error)
        _commissionDeviceStatus.postValue(
          TaskStatus.Failed("Failed to to get the IntentSender.", error)
      }
}

Setelah menggunakan pengirim, consumeCommissionDeviceIntentSender() harus dipanggil untuk mencegah pengirim menerima lagi setelah perubahan konfigurasi.

  /**
   * Consumes the value in [_commissionDeviceIntentSender] and sets it back to null. Needs to be
   * called to avoid re-processing the IntentSender after a configuration change (where the LiveData
   * is re-posted).
   */
  fun consumeCommissionDeviceIntentSender() {
    _commissionDeviceIntentSender.postValue(null)
  }

5. Membuat CommissioningService

Dalam fungsi commissionDevice(), kita meminta untuk mendapatkan CommissioningService dari CommissioningClient API. Dalam alur ini, CommissioningClient API menugaskan perangkat ke fabric Android Lokal terlebih dahulu, lalu menampilkan callback yang menyertakan objek CommissioningRequestMetadata:

public interface CommissioningService {
interface Callback {
    void onCommissioningRequested(CommissioningRequestMetadata metadata);
  }
}

Sekarang, kita harus mewarisi CommissioningService.Callback dan menyediakan fungsi yang diperlukan untuk menetapkan perangkat ke aplikasi contoh. Berikut adalah contoh penerapan CommissioningService dasar:

class MatterCommissioningService : Service(), CommissioningService.Callback {
   private val commissioningServiceDelegate =
     CommissioningService.Builder(this)
       .setCallback(this)
       .build()

   override fun onBind(intent: Intent) = commissioningServiceDelegate.asBinder()

   override fun onCommissioningRequested(metadata: CommissioningRequestMetadata) {
     // perform commissioning

     commissioningServiceDelegate
       .sendCommissioningComplete(CommissioningCompleteMetadata.builder().build())
   }
 }

Langkah 1: Pelajari AppCommissioningService kustom

Untuk membantu Anda memulai, kami telah menentukan struktur class dasar untuk CommissioningService kustom kami. Berikut adalah ringkasan singkat tentang fungsi layanan. Untuk mengikuti, buka AppCommissioningService di java/commissioning.

Kami telah menambahkan impor berikut untuk Home Mobile SDK API:

import com.google.android.gms.home.matter.commissioning.CommissioningCompleteMetadata
import com.google.android.gms.home.matter.commissioning.CommissioningRequestMetadata
import com.google.android.gms.home.matter.commissioning.CommissioningService

AppCommissioningService juga menyertakan library dari repo Matter (connectedhomeip):

import com.google.home_sample_app_for_matter.chip.ChipClient

Terakhir, layanan ini menyertakan impor untuk mendukung Hilt dan coroutine Kotlin.

Selanjutnya, kita membuat konstruktor dan menyiapkan beberapa hal, termasuk commissioningServiceDelegate, yang akan kita gunakan untuk memberi tahu Layanan Google Play saat komisi selesai.

private lateinit var commissioningServiceDelegate: CommissioningService
...
commissioningServiceDelegate = CommissioningService.Builder(this).setCallback(this).build()

Sekarang saatnya menambahkan fungsi komisi.

Langkah 2: Ganti onCommissioningRequest

Untuk menetapkan perangkat ke struktur pengembangan aplikasi, selesaikan langkah-langkah berikut:

  1. Buka AppCommissioningService di java/commissioning.
  2. Cari fungsi onCommissioningRequested(). Kami telah menyediakan pesan log yang mencetak CommissioningRequestMetadata. Ganti komentar // CODELAB: onCommissioningRequested() untuk memulai coroutine serviceScope dan dapatkan deviceId.
    // Perform commissioning on custom fabric for the sample app.
serviceScope.launch {
  val deviceId = devicesRepository.incrementAndReturnLastDeviceId()
  3. Lakukan komisi. Untuk langkah ini, kita dapat meneruskan informasi perangkat yang ditampilkan di objek CommissioningRequestMetadata. ChipClient menggunakan informasi metadata ini untuk membuat saluran yang aman antara aplikasi GHSA untuk Matter dan perangkat Anda.
    Timber.d("Commissioning: App fabric -> ChipClient.establishPaseConnection(): deviceId [${deviceId}]")
chipClient.awaitEstablishPaseConnection(
    deviceId,
    metadata.networkLocation.ipAddress.hostAddress!!,
    metadata.networkLocation.port,
    metadata.passcode)
Timber.d("Commissioning: App fabric -> ChipClient.commissionDevice(): deviceId [${deviceId}]")
chipClient.awaitCommissionDevice(deviceId, null)
  4. Gunakan commissioningServiceDelegate untuk memberi tahu Layanan Google Play bahwa komisi telah selesai. Di .sendCommissioningComplete(), teruskan CommissioningCompleteMetadata.
      Timber.d("Commissioning: Calling commissioningServiceDelegate.sendCommissioningComplete()")
  commissioningServiceDelegate
      .sendCommissioningComplete(
          CommissioningCompleteMetadata.builder().setToken(deviceId.toString()).build())
      .addOnSuccessListener {
          Timber.d("Commissioning: OnSuccess for commissioningServiceDelegate.sendCommissioningComplete()")
      }
      .addOnFailureListener { ex -> 
        Timber.e(ex, "Commissioning: Failed to send commissioning complete.", ex)
      }
}

Menjalankan aplikasi

Setelah semua kode yang diperlukan siap untuk diterapkan ke kain lokal, kini saatnya untuk mengujinya. Pilih perangkat Android Anda, lalu jalankan aplikasi. Dari Layar utama, ketuk Tambahkan Perangkat dan selesaikan langkah-langkah untuk menetapkan perangkat Anda.

Saat komisi selesai, perangkat Anda kini berpartisipasi dalam dua kain: kain Android Lokal dan kain pengembangan lokal. Setiap kain memiliki kumpulan kredensialnya sendiri dan ID kain 64-bit yang unik.

6. Perangkat kontrol

Komisi untuk kain pengembangan memungkinkan Anda menggunakan library dari repositori Matter (connectedhomeip) untuk mengontrol perangkat dari aplikasi contoh.

Kami telah membuat beberapa class helper untuk mempermudah akses ke Cluster perangkat dan mengirim perintah. Untuk mempelajari lebih lanjut, buka ClustersHelper di java/clusters. Helper Singleton ini mengimpor library berikut untuk mengakses informasi perangkat:

import chip.devicecontroller.ChipClusters
import chip.devicecontroller.ChipStructs

Kita dapat menggunakan class ini untuk mendapatkan Cluster Aktif/Nonaktif untuk perangkat, lalu memanggil .toggle:

suspend fun toggleDeviceStateOnOffCluster(deviceId: Long, endpoint: Int) {
  Timber.d("toggleDeviceStateOnOffCluster())")
  val connectedDevicePtr =
      try {
        chipClient.getConnectedDevicePointer(deviceId)
      } catch (e: IllegalStateException) {
        Timber.e("Can't get connectedDevicePointer.")
        return
      }
  return suspendCoroutine { continuation ->
    getOnOffClusterForDevice(connectedDevicePtr, endpoint)
        .toggle(
            object : ChipClusters.DefaultClusterCallback {
              override fun onSuccess() {
                continuation.resume(Unit)
              }
              override fun onError(ex: Exception) {
                Timber.e("readOnOffAttribute command failure: $ex")
                continuation.resumeWithException(ex)
              }
            })
  }
}

Beralih perangkat

Setelah Anda membuat perangkat, payload yang ditampilkan dalam CommissioningResult akan ditambahkan ke DataStore. Tindakan ini memberi aplikasi kami akses ke informasi perangkat yang dapat kami gunakan untuk mengirim perintah.

Aplikasi Matter berbasis peristiwa. Saat stack Matter diinisialisasi, layanan Cluster akan memproses pesan masuk. Setelah perangkat digunakan, klien Matter akan mengirim perintah melalui saluran operasional aman yang dibuat selama pengoperasian perangkat.

Di perangkat, paket divalidasi, didekripsi, lalu dikirim dengan callback. Fungsi callback mencakup EndpointId, ClusterId, dan AttributeId, yang dapat diakses dari attributePath. Misalnya, kode ini dapat diterapkan di perangkat Matter:

void MatterPostAttributeChangeCallback(const chip::app::ConcreteAttributePath & attributePath, uint8_t mask, uint8_t type,
                                       uint16_t size, uint8_t * value)
{
    // handle callback
    ClusterId clusterId     = attributePath.mClusterId;
    AttributeId attributeId = attributePath.mAttributeId;
}

Pada langkah berikutnya, Anda akan menggunakan Matter SDK dan ClustersHelper untuk mengalihkan perangkat.

  1. Buka DeviceViewModel di java/screens/device.
  2. Cari fungsi updateDeviceStateOn.
  3. Ganti komentar // CODELAB: toggle dengan kode untuk memanggil clustersHelper, lalu perbarui repositori perangkat:
    Timber.d("Handling real device")
    try {
      clustersHelper.setOnOffDeviceStateOnOffCluster(deviceUiModel.device.deviceId, isOn, 1)
      devicesStateRepository.updateDeviceState(deviceUiModel.device.deviceId, true, isOn)
    } catch (e: Throwable) {
      Timber.e("Failed setting on/off state")
    }

Fungsi ini dipanggil dari DeviceFragment:

// Change the on/off state of the device
binding.onoffSwitch.setOnClickListener {
  val isOn = binding.onoffSwitch.isChecked
  viewModel.updateDeviceStateOn(selectedDeviceViewModel.selectedDeviceLiveData.value!!, isOn)
}

Menjalankan aplikasi

Jalankan aplikasi untuk memuat ulang update Anda. Dari Layar utama, aktifkan dan nonaktifkan perangkat.

7. Berbagi perangkat dengan ekosistem lain

Berbagi perangkat disebut sebagai alur multi-admin dalam spesifikasi Matter.

Di langkah sebelumnya, kita telah mempelajari bahwa Home Mobile SDK memungkinkan perangkat dibuat ke Lokal Android dan juga ke kain pengembangan untuk aplikasi contoh. Ini adalah contoh alur multi-admin, di mana perangkat dapat ditugaskan ke lebih dari satu kain.

Anda kini mungkin ingin berbagi perangkat dengan lebih banyak kain, terutama jika ini adalah rumah tangga yang memiliki preferensi tersendiri untuk aplikasi dan platform.

Home Mobile SDK menyediakan fungsi ini di ShareDeviceRequest API, memungkinkan Anda untuk:

  1. Buka jendela komisi sementara untuk perangkat.
  2. Ubah status perangkat Anda, sehingga perangkat tersebut dapat dipesan ke kain lain.
  3. Mengontrol perangkat Anda dari aplikasi dan ekosistem lainnya.

Pada langkah berikutnya, Anda akan menggunakan Home Mobile SDK untuk berbagi perangkat.

Langkah 1: Buat Peluncur Aktivitas GPS

Serupa dengan Peluncur Aktivitas Komisi yang kami buat saat memesan untuk kain pengembangan, kami telah membuat Peluncur Aktivitas Perangkat Bersama untuk menangani IntentSender dari CommissioningClient API.

  1. Buka DeviceFragment di folder java/screens/device/.
  2. Ganti komentar // CODELAB: shareDeviceLauncher definition dengan kode berikut untuk mendaftarkan dan menangani hasil Aktivitas .shareDevice():
    shareDeviceLauncher =
    registerForActivityResult(ActivityResultContracts.StartIntentSenderForResult()) { result ->
      // Share Device Step 5.
      // The Share Device activity in GPS (step 4) has completed.
      val resultCode = result.resultCode
      if (resultCode == RESULT_OK) {
        Timber.d("ShareDevice: Success")
        viewModel.shareDeviceSucceeded(selectedDeviceViewModel.selectedDeviceLiveData.value!!)
      } else {
        viewModel.shareDeviceFailed(
            selectedDeviceViewModel.selectedDeviceLiveData.value!!, resultCode)
      }
    }

Langkah 2: Tinjau objek LiveData

Callback berhasil dari .shareDevice() API menyediakan IntentSender yang akan digunakan untuk meluncurkan Aktivitas Perangkat Bersama di Layanan Google Play. Di DeviceViewModel, kita telah membuat dua objek LiveData untuk dilaporkan berdasarkan panggilan API ini:

  • _shareDeviceStatus untuk melacak TaskStatus.
    // The current status of the share device action.
viewModel.shareDeviceStatus.observe(viewLifecycleOwner) { status ->
  val isButtonEnabled = status !is InProgress
  updateShareDeviceButton(isButtonEnabled)
  if (status is TaskStatus.Failed) {
    showAlertDialog(errorAlertDialog, status.message, status.cause!!.toString())
  }
}
  • _shareDeviceIntentSender untuk menangani hasil panggilan .sharedevice().
    viewModel.shareDeviceIntentSender.observe(viewLifecycleOwner) { sender ->
  Timber.d("shareDeviceIntentSender.observe is called with [${intentSenderToString(sender)}]")
  if (sender != null) {
    // Share Device Step 4: Launch the activity described in the IntentSender that
    // was returned in Step 3 (where the viewModel calls the GPS API to commission
    // the device).
    Timber.d("ShareDevice: Launch GPS activity to share device")
    shareDeviceLauncher.launch(IntentSenderRequest.Builder(sender).build())
    viewModel.consumeShareDeviceIntentSender()
  }
}

Pada langkah berikutnya, kita akan menggunakan objek LiveData ini dalam panggilan API .shareDevice().

Langkah 3: Panggil API

Sekarang saatnya memulai tugas berbagi perangkat.

  1. Buka DeviceViewModel.kt di folder java/screens/device/.
  2. Cari fungsi shareDevice(). Ganti komentar // CODELAB: shareDevice dengan ShareDeviceRequest. DeviceDescriptor memberikan informasi khusus tentang perangkat seperti ID Vendor, ID Produk, dan deviceType. Dalam contoh ini, kita melakukan hard code pada nilai.
      Timber.d("ShareDevice: Setting up the IntentSender")
  val shareDeviceRequest =
      ShareDeviceRequest.builder()
          .setDeviceDescriptor(DeviceDescriptor.builder().build())
          .setDeviceName("temp device name")
  3. Tetapkan CommissioningWindow dan parameter. Pada tahap ini, periode komisi sementara akan dibuka di perangkat.
              .setCommissioningWindow(
              CommissioningWindow.builder()
                  .setDiscriminator(Discriminator.forLongValue(DISCRIMINATOR))
                  .setPasscode(SETUP_PIN_CODE)
                  .setWindowOpenMillis(SystemClock.elapsedRealtime())
                  .setDurationSeconds(OPEN_COMMISSIONING_WINDOW_DURATION_SECONDS.toLong())
                  .build())
          .build()
  4. Panggil .getCommissioningClient(), hanya kali ini, gunakan .shareDevice() API. Callback berhasil dari commissioningClient.shareDevice() API menyediakan IntentSender yang akan digunakan untuk meluncurkan Activity Device Activity di Layanan Google Play.
    Matter.getCommissioningClient(activity)
    .shareDevice(shareDeviceRequest)
  5. Untuk menyelesaikan fungsi shareDevice, tambahkan addOnSuccessListener dan addOnFailureListener lalu posting ke objek LiveData:
          .addOnSuccessListener { result ->
        Timber.d("ShareDevice: Success getting the IntentSender: result [${result}]")
        // Communication with fragment is via livedata
        _backgroundWorkAlertDialogAction.postValue(BackgroundWorkAlertDialogAction.Hide)
        _shareDeviceIntentSender.postValue(result)
      }
      .addOnFailureListener { error ->
        Timber.e(error)
        _backgroundWorkAlertDialogAction.postValue(BackgroundWorkAlertDialogAction.Hide)
        _shareDeviceStatus.postValue(
            TaskStatus.Failed("Setting up the IntentSender failed", error))
      }

Setelah menggunakan pengirim, consumeShareDeviceIntentSender harus dipanggil untuk mencegah pengirim menerima lagi setelah perubahan konfigurasi.

  /**
   * Consumes the value in [_shareDeviceIntentSender] and sets it back to null. Needs to be called
   * to avoid re-processing an IntentSender after a configuration change where the LiveData is
   * re-posted.
   */
  fun consumeShareDeviceIntentSender() {
    _shareDeviceIntentSender.postValue(null)
  }

Menjalankan aplikasi

Untuk berbagi perangkat Matter dengan ekosistem lain, Anda harus menginstal platform lain di perangkat Android. Kami telah membuat instance aplikasi contoh lain yang dapat Anda gunakan sebagai komisioner target.

Setelah Anda menginstal target Commissioner di perangkat Android, verifikasi bahwa Anda dapat membagikan perangkat Matter. Aplikasi target komisaris diberi label GHSAFM-TC.

Perangkat Anda kini dapat berpartisipasi dalam tiga struktur:

  1. Fabric Android lokal.
  2. Fabric pengembangan Anda (aplikasi ini).
  3. Fabric ketiga yang baru saja Anda gunakan untuk berbagi perangkat.

8. Langkah Berikutnya

Selamat

Selamat, Anda telah berhasil menyelesaikan Codelab ini dan mempelajari cara melakukan komisi serta berbagi perangkat menggunakan Home Mobile SDK.

Jika Anda mengalami masalah dengan aplikasi contoh, coba selesaikan langkah-langkah ini untuk memverifikasi lingkungan Anda:

Jika ada pertanyaan tentang penggunaan aplikasi contoh atau menemukan bug kode, Anda dapat mengirimkan masalah ke Issue Tracker di repositori GitHub:

Untuk mendapatkan panduan resmi dari Google terkait pertanyaan teknis, gunakan Forum Developer Smart Home:

Untuk mendapatkan dukungan teknis dari komunitas, gunakan tag google-smart-home di Stack Overflow: