Membuat Aplikasi Android untuk Masalah

1. Selamat Datang

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

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

Aplikasi Contoh Google Home untuk Matter (GHSA untuk Matter) menampilkan API Home Mobile SDK, yang memungkinkan pengguna melakukan commissioning dan berbagi perangkat. Anda juga dapat menggunakan aplikasi contoh sebagai alat pembelajaran untuk lebih memahami konsep utama Matter, 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 mengaktifkan dan membagikan perangkat. Anda juga akan mempelajari cara menggunakan library commissioning dan Cluster dari repo Matter (connectedhomeip).

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

Anda juga akan mempelajari lebih lanjut konsep commissioning, fabric Matter, dan cara mengontrol perangkat Matter.

Yang Anda butuhkan

Sebelum memulai, pastikan untuk menyelesaikan langkah-langkah berikut:

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

2. Memulai persiapan

Aplikasi awal codelab terletak di cabang codelab. Untuk mulai menggunakan kode sumber codelab, Anda dapat mendownload file ZIP.

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

Versi codelab

Cabang codelab ditandai dengan rilis 2.0.0 aplikasi contoh. Untuk membandingkan update saat Anda menyelesaikan setiap langkah, Anda dapat mendownload kode sumber yang telah selesai untuk rilis ini.

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

Dependensi

Kami akan memandu Anda melalui kode sumber yang diperlukan untuk membagikan dan mengaktifkan perangkat, tetapi sebaiknya Anda mengetahui dependensi berikut sebelum memulai. Perhatikan bahwa dependensi ini dideklarasikan dalam file libs.versions.toml dan penggunaannya ditentukan dalam file build.gradle.kts

Kode sumber

Antarmuka pengguna dan sebagian besar fungsi telah dibuat untuk Anda.

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

  • java/com/google/homesampleapp/commissioning/AppCommissioningService: memungkinkan Anda menugaskan perangkat ke fabric pengembangan
  • java/com/google/homesampleapp/screens/home/HomeScreen dan java/com/google/homesampleapp/screens/home/HomeViewModel.kt: mencakup fungsi aktivasi Home Mobile SDK
  • java/com/google/homesampleapp/screens/device/DeviceScreen dan java/com/google/homesampleapp/screens/device/DeviceViewModel: mencakup panggilan Share Device API

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

// CODELAB: add commissioningFunction()

Dengan begitu, Anda dapat menemukan bagian yang sesuai dalam codelab dengan cepat.

3. Komisi untuk Google

Sebelum Anda dapat mengontrol perangkat dan mengizinkannya berkomunikasi satu sama lain dalam fabric yang sama, perangkat tersebut harus di-commissioning oleh Pengomisioner, yang dalam hal ini adalah aplikasi contoh ini, Aplikasi Contoh Google Home untuk Matter.

Penting untuk memahami konsep berikut tentang penyiapan Matter:

  • Kain memungkinkan perangkat saling berkomunikasi.
  • Fabric mempertahankan sekumpulan kredensial unik bersama.
  • Ekosistem bertanggung jawab untuk menerbitkan sertifikat root tepercaya, menetapkan ID fabric, dan menetapkan ID node unik. Ekosistem adalah layanan backend komisioner, misalnya Home Graph untuk ekosistem Google Home.
  • Perangkat dapat di-commissioning ke lebih dari satu fabric (fitur multi-admin).

Untuk mengaktifkan perangkat, Anda harus menggunakan CommissioningClient API. Panggilan ke .commissionDevice() menampilkan IntentSender, yang meluncurkan aktivitas yang tepat di Layanan Google Play:

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

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

Langkah 1: Peluncur Aktivitas

Untuk menangani IntentSender dari CommissioningClient, Anda dapat menggunakan ActivityResultLauncher:

val 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: Fungsi penyiapan

Berikut adalah contoh dasar yang menggunakan CommissioningClient API untuk mengaktifkan perangkat ke platform Google.

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

Android Fabric Lokal dapat dimanfaatkan melalui setelan Android untuk menyederhanakan proses penyiapan perangkatnya ke fabric lain.

Selanjutnya, Anda akan mempelajari cara menugaskan perangkat ke fabric pengembangan.

Untuk ringkasan antarmuka pengguna selama proses aktivasi, lihat Panduan Aplikasi Contoh Google Home untuk Matter.

4. Pemberian komisi ke fabric pengembangan

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

  • Identifikasi kain
  • ID Node yang ditetapkan oleh fabric ke perangkat
  • ID Vendor
  • ID Fabric
  • Kredensial operasional perangkat

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

Layanan Penyiapan Khusus

Untuk melakukan komisioning ke fabric Android Lokal, kami menggunakan parameter default untuk membuat CommissioningRequest di CommissioningClient API:

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

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

Anda dapat memberi tahu Home Mobile SDK bahwa Anda ingin menugaskan perangkat ke fabric 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 mengubah 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 HomeScreen di folder java/com/google/homesampleapp/screens/home/.
  2. Ganti komentar // CODELAB: commissionDeviceLauncher definition dengan kode berikut untuk mendaftarkan dan menangani hasil Aktivitas commissioning:
    val commissionDeviceLauncher =
  rememberLauncherForActivityResult(
    contract = ActivityResultContracts.StartIntentSenderForResult()
  ) { result ->
    // Commission Device Step 5.
    // The Commission Device activity in GPS (step 4) has completed.
    val resultCode = result.resultCode
    if (resultCode == Activity.RESULT_OK) {
      Timber.d("CommissionDevice: Success")
      // We let the ViewModel know that GPS commissioning has completed successfully.
      // The ViewModel knows that we still need to capture the device name and will\
      // update UI state to trigger the NewDeviceAlertDialog.
      homeViewModel.gpsCommissioningDeviceSucceeded(result)
    } else {
      homeViewModel.commissionDeviceFailed(resultCode)
    }
  }

Langkah 2: Aktifkan tindakan perangkat commissioning

Pada langkah ini, pengguna memicu tindakan "Siapkan Perangkat" dengan mengklik tombol "+" di kanan bawah Layar utama. Kemudian, panggilan dilakukan ke commissionDevice().

val onCommissionDevice = {
  ...
  commissionDevice(activity!!.applicationContext, commissionDeviceLauncher)
}

Langkah 3: Panggil API

  1. Masih di HomeScreen.kt dalam folder java/com/google/homesampleapp/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 mengaktifkan perangkat ke fabric lokal Android, lalu mengirimkan payload aktivasi kembali ke AppCommissioningService.
    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:

    .addOnSuccessListener { result ->
      commissionDeviceLauncher.launch(IntentSenderRequest.Builder(result).build())
    }
    .addOnFailureListener { error ->
      Timber.e(error)
    }

5. Membuat Layanan Pengoperasian

Dalam fungsi commissionDevice(), kita meminta untuk mendapatkan CommissioningService dari CommissioningClient API. Dalam alur ini, CommissioningClient API melakukan penyiapan 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 meng-commission perangkat ke aplikasi contoh kita. Berikut adalah contoh implementasi 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: Jelajahi AppCommissioningService kustom

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

Kami telah menambahkan impor berikut untuk API Home Mobile SDK:

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 mencakup library dari repo Matter (connectedhomeip):

import com.google.homesampleapp.chip.ChipClient

Terakhir, layanan ini mencakup 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 komisioning selesai.

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

Sekarang saatnya menambahkan fungsi commissioning.

Langkah 2: Ganti onCommissioningRequested

Untuk mengaktifkan perangkat ke fabric pengembangan aplikasi, selesaikan langkah-langkah berikut:

  1. Buka AppCommissioningService di java/commissioning.
  2. Cari fungsi onCommissioningRequested(). Kami telah memberikan pesan log yang mencetak CommissioningRequestMetadata. Ganti komentar // CODELAB: onCommissioningRequested() untuk memulai coroutine serviceScope dan mendapatkan deviceId.
    // Perform commissioning on custom fabric for the sample app.
serviceScope.launch {
  val deviceId = devicesRepository.incrementAndReturnLastDeviceId()
  3. Lakukan aktivasi. Untuk langkah ini, kita dapat meneruskan informasi perangkat yang ditampilkan dalam objek CommissioningRequestMetadata. ChipClient menggunakan informasi metadata ini untuk membuat saluran yang aman antara aplikasi GHSA untuk Matter dan perangkat Anda.
    try {
  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)
} catch (e: Exception) {
  Timber.e(e, "onCommissioningRequested() failed")
  // No way to determine whether this was ATTESTATION_FAILED or DEVICE_UNREACHABLE.
  commissioningServiceDelegate
      .sendCommissioningError(CommissioningError.OTHER)
      .addOnSuccessListener {
        Timber.d(
            "Commissioning: commissioningServiceDelegate.sendCommissioningError() succeeded")
      }
      .addOnFailureListener { e2 ->
        Timber.e(e2, "Commissioning: commissioningServiceDelegate.sendCommissioningError() failed")
      }
  return@launch
}
  4. Gunakan commissioningServiceDelegate untuk memberi tahu Layanan Google Play bahwa pemberian izin telah selesai. Di .sendCommissioningComplete(), teruskan CommissioningCompleteMetadata.
    commissioningServiceDelegate
    .sendCommissioningComplete(
        CommissioningCompleteMetadata.builder().setToken(deviceId.toString()).build())
    .addOnSuccessListener {
      Timber.d("Commissioning: commissioningServiceDelegate.sendCommissioningComplete() succeeded")
    }
    .addOnFailureListener { e ->
      Timber.e(e, "Commissioning: commissioningServiceDelegate.sendCommissioningComplete() failed")
    }
}

Menjalankan aplikasi

Setelah semua kode yang diperlukan tersedia untuk melakukan commissioning ke fabric lokal, saatnya mengujinya. Pilih perangkat Android Anda, lalu jalankan aplikasi. Dari Layar utama, ketuk Tambahkan Perangkat dan selesaikan langkah-langkah untuk mengaktifkan perangkat Anda.

Setelah commissioning selesai, perangkat Anda kini berpartisipasi dalam dua fabric: fabric Android Lokal, dan fabric pengembangan lokal Anda. Setiap fabric memiliki serangkaian kredensialnya sendiri dan ID fabric 64-bit yang unik.

6. Mengontrol perangkat

Proses aktivasi ke fabric pengembangan memungkinkan Anda menggunakan library dari repo Matter (connectedhomeip) untuk mengontrol perangkat dari aplikasi contoh.

Kami telah membuat beberapa class helper untuk mempermudah akses ke Klaster 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)
              }
            })
  }
}

Mengganti perangkat

Setelah Anda melakukan aktivasi perangkat, payload yang ditampilkan di CommissioningResult akan ditambahkan ke DataStore. Hal 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 dioperasikan, klien Matter 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 DeviceScreen:

// On/Off Switch click.
val onOnOffClick: (value: Boolean) -> Unit = { value ->
  deviceViewModel.updateDeviceStateOn(deviceUiModel!!, value)
}

Menjalankan aplikasi

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

7. Membagikan perangkat ke ekosistem lain

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

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

Sekarang, Anda dapat berbagi perangkat dengan lebih banyak orang, terutama jika ini adalah rumah tangga di mana orang memiliki preferensi mereka sendiri dalam hal aplikasi dan platform.

Home Mobile SDK menyediakan fungsi ini di ShareDeviceRequest API, sehingga Anda dapat:

  1. Buka jendela aktivasi sementara untuk perangkat.
  2. Ubah status perangkat Anda, sehingga perangkat tersebut dapat dioperasikan ke fabric lain.
  3. Mengontrol perangkat Anda dari aplikasi dan ekosistem lain.

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

Langkah 1: Buat Peluncur Aktivitas GPS

Mirip dengan Peluncur Aktivitas Penyiapan yang kami buat saat menyiapkan ke fabric pengembangan, kami telah membuat Peluncur Aktivitas Berbagi Perangkat untuk menangani IntentSender dari CommissioningClient API.

  1. Buka DeviceScreen di folder java/com/google/homesampleapp/screens/device/.
  2. Ganti komentar // CODELAB: shareDeviceLauncher definition dengan kode berikut untuk mendaftarkan dan menangani hasil Aktivitas .shareDevice():
    val shareDeviceLauncher = rememberLauncherForActivityResult(
  contract = ActivityResultContracts.StartIntentSenderForResult()
) { result ->
  // Commission Device Step 5.
  // The Share Device activity in GPS (step 4) has completed.
  val resultCode = result.resultCode
  if (resultCode == Activity.RESULT_OK) {
    deviceViewModel.shareDeviceSucceeded()
  } else {
    deviceViewModel.shareDeviceFailed(resultCode)
  }
}

Langkah 2: Picu tindakan berbagi perangkat

Pada langkah ini, pengguna memicu tindakan "Bagikan Perangkat" dengan mengklik tombol "Bagikan" di layar perangkat. Kemudian, panggilan dilakukan ke deviceViewModel untuk membuka Jendela Penyambungan untuk berbagi perangkat.

// Share Device button click.
val onShareDevice: () -> Unit = remember {
 {
   deviceViewModel.openPairingWindow(deviceUiModel!!.device.deviceId)
 }
}

Setelah berhasil membuka jendela penyambungan, deviceViewModel akan mengomunikasikan fakta tersebut ke UI. Komunikasi antara ViewModel dan UI dilakukan melalui objek StateFlow.

// Communicate to the UI that the pairing window is open.
// UI can then launch the GPS activity for device sharing.
_pairingWindowOpenForDeviceSharing.value = true

Setelah melihat perubahan pada objek StateFlow, DeviceScreen melakukan panggilan berikut:

shareDevice(activity!!.applicationContext, shareDeviceLauncher, deviceViewModel)

Langkah 3: Panggil API

Sekarang saatnya memulai tugas berbagi perangkat.

  1. Buka DeviceScreen.kt di folder java/com/google/homesampleapp/screens/device/.
  2. Cari fungsi shareDevice(). Ganti komentar // CODELAB: shareDevice dengan ShareDeviceRequest. DeviceDescriptor memberikan informasi spesifik tentang perangkat seperti ID Vendor, ID Produk, dan deviceType. Dalam contoh ini, kita meng-hardcode nilai.
    val shareDeviceRequest =
  ShareDeviceRequest.builder()
    .setDeviceDescriptor(DeviceDescriptor.builder().build())
    .setDeviceName("GHSAFM temp device name")
  3. Tetapkan CommissioningWindow dan parameter.
        .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 saja kali ini, gunakan API .shareDevice().
    Matter.getCommissioningClient(context)
    .shareDevice(shareDeviceRequest)

Callback keberhasilan commissioningClient.shareDevice() API menyediakan IntentSender yang akan digunakan untuk meluncurkan Bagikan Aktivitas Perangkat di Layanan Google Play.

  1. Untuk menyelesaikan fungsi shareDevice, tambahkan addOnSuccessListener dan addOnFailureListener. Jika berhasil, launch dipanggil di shareDeviceLauncher untuk meluncurkan aktivitas GPS untuk berbagi perangkat.
        .addOnSuccessListener { result ->
      Timber.d("ShareDevice: Success getting the IntentSender: result [${result}]")
      shareDeviceLauncher.launch(IntentSenderRequest.Builder(result).build())
    }
    .addOnFailureListener { error ->
      Timber.e(error)
      deviceViewModel.showMsgDialog("Share device failed", error.toString())
    }

Menjalankan aplikasi

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

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

Perangkat Anda kini dapat berpartisipasi dalam tiga fabric:

  1. Fabric Android lokal.
  2. Platform pengembangan Anda (aplikasi ini).
  3. Kain ketiga yang baru saja Anda ajak berbagi perangkat.

8. Langkah Berikutnya

Selamat

Selamat, Anda telah berhasil menyelesaikan Codelab ini dan mempelajari cara mengaktifkan dan membagikan perangkat menggunakan Home Mobile SDK.

Jika Anda mengalami masalah dengan aplikasi contoh, coba selesaikan langkah-langkah 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: