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 lain-lain.

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 for Matter) menampilkan Home Mobile SDK API, yang memungkinkan pengguna melakukan komisi dan berbagi perangkat. Anda juga dapat menggunakan aplikasi contoh sebagai alat pembelajaran untuk lebih memahami konsep penting 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 memesan dan membagikan perangkat. Anda juga akan mempelajari cara menggunakan library commissioning dan Cluster dari repositori Matter (connectedhomeip).

Setelah Anda 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 commissioning, 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 memerintahkan 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 diberi tag dengan rilis 2.0.0 aplikasi contoh. Untuk membandingkan update saat Anda mengerjakan setiap langkah, Anda bisa mendownload kode sumber yang sudah 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 berbagi dan melakukan commissioning perangkat, tetapi mungkin akan lebih baik jika 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 melakukan commissioning perangkat ke kain pengembangan
  • java/com/google/homesampleapp/screens/home/HomeScreen dan java/com/google/homesampleapp/screens/home/HomeViewModel.kt: mencakup fungsi commissioning Home Mobile SDK
  • java/com/google/homesampleapp/screens/device/DeviceScreen dan java/com/google/homesampleapp/screens/device/DeviceViewModel: menyertakan panggilan Share Device API

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

// CODELAB: add commissioningFunction()

Hal ini memungkinkan Anda menemukan bagian yang sesuai dalam codelab dengan cepat.

3. Komisi untuk Google

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

Penting untuk memahami konsep berikut tentang commissioning Matter:

  • {i>Fabric<i} memungkinkan perangkat untuk saling berkomunikasi.
  • Fabric menyimpan kumpulan kredensial unik yang digunakan bersama.
  • Ekosistem bertanggung jawab untuk menerbitkan root certificate tepercaya, menetapkan ID fabric, dan menetapkan ID node unik. Ekosistem adalah layanan back-end komisaris, misalnya Home Graph untuk ekosistem Google Home.
  • Perangkat dapat ditugaskan ke lebih dari satu jenis kain (fitur multi-admin).

Untuk melakukan commissioning pada 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 selanjutnya, kita akan membahas kode minimal yang diperlukan untuk membuat komisi perangkat ke Google fabric.

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 Commissioning

Berikut adalah contoh dasar yang menggunakan CommissioningClient API untuk melakukan commissioning perangkat ke fabric Google.

  1. Proses commissioning dimulai dengan fungsi commissionDevice(). Pertama, CommissioningRequest ditentukan. Dengan konfigurasi default ini, perangkat hanya ditugaskan ke fabric Android Lokal.
  2. Matter adalah titik entri untuk Home Mobile SDK. Pada panggilan berikutnya, .getCommissioningClient mendapatkan CommissioningClient oleh this (Aktivitas).
  3. .commissionDevice() menyetujui CommissioningRequest.
  4. Dan 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())
        }
}

Local Android Fabric dapat dimanfaatkan melalui setelan Android untuk menyederhanakan proses commissioning perangkatnya ke fabric lain.

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

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

4. Komisi untuk kain pengembangan

Perangkat dapat dipesan ulang ke lebih dari satu jenis kain. Untuk mengelola penyambungan tepercaya, perangkat akan 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

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

Layanan Commissioning Kustom

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

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

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

Anda dapat memberi tahu Home Mobile SDK bahwa Anda ingin membuat commissioning 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 Home 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: Picu tindakan perangkat komisi

Pada langkah ini, pengguna memicu "Perangkat Komisi" dengan mengklik ikon "+" di kanan bawah layar Utama. Panggilan kemudian akan 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 terlebih dahulu akan menugaskan perangkat ke kain lokal Android, lalu mengirim payload orientasi 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 Commissioning

Dalam fungsi commissionDevice(), kami meminta CommissioningService dari CommissioningClient API. Dalam alur ini, CommissioningClient API meminta 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 melakukan commissioning perangkat ke aplikasi contoh kita. Berikut adalah contoh implementasi dasar CommissioningService:

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. Berikut ini ikhtisar singkat tentang fungsi layanan. Untuk mengikutinya, 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.homesampleapp.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 commissioning selesai.

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

Sekarang saatnya untuk menambahkan fungsi commissioning.

Langkah 2: Ganti onCommissioningRequest

Untuk melakukan commissioning perangkat ke tahap 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 mendapatkan deviceId.
    // Perform commissioning on custom fabric for the sample app.
serviceScope.launch {
  val deviceId = devicesRepository.incrementAndReturnLastDeviceId()
  3. Melakukan commissioning. Untuk langkah ini, kita dapat meneruskan informasi perangkat yang ditampilkan dalam objek CommissioningRequestMetadata. ChipClient menggunakan informasi metadata ini untuk membuat saluran aman antara aplikasi GHSA for 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 commissioning sudah 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 siap untuk dikirim ke kain lokal kita, kini saatnya untuk mengujinya. Pilih perangkat Android Anda, lalu jalankan aplikasi. Dari Layar utama, ketuk Tambahkan Perangkat dan selesaikan langkah-langkah untuk melakukan commissioning pada perangkat Anda.

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

6. Mengontrol perangkat

Penetapan komisi untuk 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 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 melakukan commissioning pada perangkat, payload yang ditampilkan di CommissioningResult akan ditambahkan ke DataStore. Tindakan ini memberi aplikasi kita akses ke informasi perangkat yang bisa kita gunakan untuk mengirimkan perintah.

Aplikasi Matter didorong oleh peristiwa. Saat stack Matter diinisialisasi, layanan Cluster akan memproses pesan masuk. Setelah perangkat ditugaskan, klien Matter mengirimkan perintah melalui saluran operasional aman yang dibuat selama commissioning 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 beralih perangkat.

  1. Buka DeviceViewModel di java/screens/device.
  2. Cari fungsi updateDeviceStateOn.
  3. Ganti komentar // CODELAB: toggle dengan kode untuk memanggil clustersHelper, lalu update 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. Berbagi perangkat dengan ekosistem lain

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

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

Sekarang, Anda mungkin ingin berbagi perangkat dengan lebih banyak jenis kain, terutama jika ini adalah rumah tangga tempat orang-orang memiliki preferensi sendiri dalam hal aplikasi dan platform.

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

  1. Buka periode commissioning sementara untuk perangkat.
  2. Mengubah status perangkat, sehingga dapat dipesan ke kain lain.
  3. Kontrol perangkat Anda dari aplikasi dan ekosistem lain.

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

Langkah 1: Buat Peluncur Aktivitas GPS

Serupa dengan Peluncur Aktivitas Commissioning yang kami buat saat memesan bahan pengembangan, kami telah membuat Peluncur Aktivitas Perangkat Berbagi 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 bagikan perangkat

Di langkah ini, pengguna memicu "Bagikan Perangkat" tindakan dengan mengeklik "Bagikan" di layar perangkat. Panggilan kemudian dilakukan ke deviceViewModel guna membuka Jendela Penyambungan untuk berbagi perangkat.

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

Setelah berhasil membuka jendela pemisahan, deviceViewModel akan menyampaikan 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 membuat 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 melakukan hard code 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 kali ini, gunakan .shareDevice() API.
    Matter.getCommissioningClient(context)
    .shareDevice(shareDeviceRequest)

Callback berhasil dari commissioningClient.shareDevice() API menyediakan IntentSender yang akan digunakan untuk meluncurkan Share Device Activity di Layanan Google Play.

  1. Untuk menyelesaikan fungsi shareDevice, tambahkan addOnSuccessListener dan addOnFailureListener. Jika berhasil, launch akan dipanggil pada shareDeviceLauncher guna 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 ke ekosistem lain, Anda harus menginstal platform lain di perangkat Android. Kami telah membuat instance lain dari aplikasi contoh yang dapat Anda gunakan sebagai komisaris target.

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

Perangkat Anda kini dapat berpartisipasi dalam tiga kain:

  1. Fabric Local Android.
  2. Fabric pengembangan Anda (aplikasi ini).
  3. Kain 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 dan membagikan perangkat menggunakan Home Mobile SDK.

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

Jika Anda memiliki 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: