Membuat Aplikasi Android untuk Masalah

1. Selamat Datang

Dibangun dengan tujuan menyatukan standar IoT, Matter 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 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 API Home Mobile SDK, 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 melakukan komisi dan berbagi perangkat. Anda juga akan mempelajari cara menggunakan library Commissioning dan Cluster dari repo Matter (connectedhomeip).

Setelah Anda 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, 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 bertugas melakukan komisi 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 dari aplikasi contoh. Untuk membandingkan update selagi mengerjakan setiap langkah, Anda dapat mendownload kode sumber lengkap untuk rilis ini.

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

Dependensi

Kami akan memandu Anda mempelajari kode sumber yang diperlukan untuk berbagi dan melakukan komisi, 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/commissioning/AppCommissioningService: memungkinkan Anda memesan perangkat ke fabric pengembangan
  • java/screens/home/HomeScreen dan java/screens/home/HomeViewModel.kt: mencakup fungsi commissioning Home Mobile SDK
  • java/screens/device/DeviceScreen dan java/screens/device/DeviceViewModel: mencakup panggilan Share Device API

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

// CODELAB: add commissioningFunction()

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

3. Komisi untuk Google

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

Penting untuk memahami konsep berikut terkait commissioning Matter:

  • Fabric memungkinkan perangkat berkomunikasi satu sama lain.
  • Fabric mempertahankan sekumpulan kredensial unik bersama.
  • Ekosistem bertanggung jawab untuk menerbitkan root certificate tepercaya, menetapkan ID kain, dan menetapkan ID node unik. Ekosistem adalah layanan back-end komisioner, misalnya Home Graph untuk ekosistem Google Home.
  • Perangkat dapat ditugaskan ke lebih dari satu fabric (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 memesan perangkat ke kain 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 Commissioning

Berikut adalah contoh dasar yang menggunakan CommissioningClient API untuk melakukan commissioning pada perangkat ke kain 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 (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())
        }
}

Local Android Fabric dapat dimanfaatkan melalui setelan Android untuk menyederhanakan proses commissioning perangkat-nya ke fabric lain.

Selanjutnya, Anda akan mempelajari cara melakukan commissioning pada perangkat ke development fabric.

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

4. Komisi untuk {i> development fabric<i}

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 fabric ke perangkat
  • ID Vendor
  • ID Fabric
  • Kredensial operasional perangkat

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

Layanan Commissioning Kustom

Untuk melakukan commissioning ke Local Android fabric, 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 kain pengembangan lokal dan mendapatkan kredensial operasional untuk memesan perangkat. Dalam skenario ini, aplikasi Anda akan 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 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 mengubah 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/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 akan memicu tindakan "Perangkat Komisi" dengan mengklik tombol "+" di kanan bawah Layar utama. Panggilan kemudian dilakukan ke commissionDevice().

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

Langkah 3: Memanggil API

  1. Masih di HomeScreen.kt dalam 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 melakukan komisi pada perangkat ke fabric 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 CommissioningService

Dalam fungsi commissionDevice(), kita meminta untuk mendapatkan CommissioningService dari CommissioningClient API. Dalam alur ini, CommissioningClient API menugaskan perangkat ke Local Android fabric 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 komisi perangkat ke aplikasi contoh. 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 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 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 menambahkan fungsi commissioning.

Langkah 2: Ganti onCommissioningRequested

Untuk memesan perangkat ke fabric 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 yang 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 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 siap untuk ditugaskan ke kain lokal, 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 kini berpartisipasi dalam dua fabric: Local Android fabric, dan local development fabric. Setiap kain memiliki kumpulan kredensialnya sendiri dan ID kain 64-bit yang unik.

6. Mengontrol perangkat

Commissioning ke development fabric memungkinkan Anda menggunakan library dari repo Matter (connectedhomeip) untuk mengontrol perangkat dari aplikasi contoh.

Kami telah membuat beberapa class helper untuk mempermudah akses ke Cluster perangkat dan mengirimkan 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 untuk perangkat, payload yang ditampilkan dalam CommissioningResult akan ditambahkan ke DataStore. Tindakan ini memberi aplikasi kita akses ke informasi perangkat yang dapat digunakan untuk mengirimkan perintah.

Aplikasi Matter berbasis 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 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. 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 mempelajari bahwa Home Mobile SDK memungkinkan perangkat melakukan commissioning ke fabric Android Lokal dan juga ke fabric pengembangan untuk aplikasi contoh. Ini adalah contoh alur multi-admin, tempat perangkat dapat ditugaskan ke lebih dari satu fabric.

Sekarang, Anda mungkin ingin berbagi perangkat dengan lebih banyak bahan, terutama jika rumah tangga di mana orang-orang memiliki preferensinya sendiri terkait aplikasi dan platform.

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

  1. Buka jendela commissioning sementara untuk perangkat.
  2. Mengubah status perangkat Anda, memungkinkannya untuk ditugaskan 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 Commissioning Activity Launcher yang kami buat saat menugaskan komponen pengembangan, kami telah membuat Peluncur Aktivitas Berbagi Perangkat untuk menangani IntentSender dari CommissioningClient API.

  1. Buka DeviceScreen di folder java/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 "Share Device" dengan mengklik tombol "Share" di layar perangkat. Panggilan kemudian dilakukan ke deviceViewModel guna membuka Jendela Penyambungan untuk berbagi perangkat.

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

Setelah berhasil membuka jendela pemangkasan, deviceViewModel 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 melakukan panggilan berikut:

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

Langkah 3: Memanggil API

Sekarang saatnya memulai tugas berbagi perangkat.

  1. Buka DeviceScreen.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.
    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. Setelah berhasil, launch 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 berbagi perangkat Matter dengan ekosistem lain, Anda harus menginstal platform lain di perangkat Android. Kami telah membuat instance lain dari aplikasi contoh yang dapat Anda gunakan sebagai target komisioner.

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

Perangkat Anda sekarang dapat berpartisipasi dalam tiga jenis kain:

  1. Local Android fabric.
  2. Development fabric 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 dan berbagi perangkat menggunakan Home Mobile SDK.

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