1. Introduzione
Creato con l'obiettivo di unificare gli standard IoT, Matter connette i dispositivi per la smart home tra diversi ecosistemi, come Google Home, Zigbee, Bluetooth Mesh, Z-Wave e altri ancora.
I dispositivi mobili sono un punto di interazione centrale con quelli per la smart home. Se vuoi creare le tue app Android per supportare i dispositivi Matter, possiamo aiutarti a iniziare rapidamente.
L'app Google Home Sample App for Matter (GHSA for Matter) mostra le API Home Mobile SDK, consentendo agli utenti di commissionare e condividere i dispositivi. Puoi anche utilizzare l'app di esempio come strumento di apprendimento per comprendere meglio i concetti chiave di Matter, nonché come strumento per il debug e la risoluzione dei problemi delle interazioni con i dispositivi Matter.
Attività previste
In questo codelab, scaricherai il codice sorgente dell'app di esempio e imparerai a utilizzare l'SDK Home Mobile per commissionare e condividere i dispositivi. Imparerai inoltre a utilizzare le commissioni e le librerie di cluster dal repository Matter (connectedhomeip
).
Dopo aver scaricato l'app di esempio, esamineremo il codice sorgente in Android Studio e implementeremo le seguenti API SDK Home Mobile:
Scoprirai inoltre di più sulla messa in servizio, sui fabric Matter e su come controllare i dispositivi Matter.
Che cosa ti serve
Prima di iniziare, assicurati di completare questi passaggi:
- Leggi la guida di esempio sull'app Google Home per Matter.
- Scarica Android Studio.
- Avere un dispositivo Android O (8.1, livello API 27) o versioni successive per i test. Per assicurarti che il tuo dispositivo disponga della versione più recente del supporto Matter, consulta la guida Verificare moduli e servizi Matter.
- Utilizzare un dispositivo Matter con funzionalità di accensione e spegnimento. Per ridurre al minimo i problemi di ambiente, consigliamo vivamente di utilizzare per iniziare un dispositivo virtuale Matter (MVD). In caso di problemi, sarà molto più facile verificare se l'app di esempio viene utilizzata contro MVD. Di seguito sono riportate altre opzioni:
- Crea un dispositivo virtuale Matter con l'app
rootnode_dimmablelight_bCwGYSDpoe
. Quando crei un'integrazione Matter nella Console per gli sviluppatori di casa, usa0xFFF1
come ID fornitore e0x8000
come ID prodotto. - Crea un dispositivo Espressif con
all-clusters-app
. Quando crei un'integrazione Matter nella Console per gli sviluppatori per la casa, utilizza0xFFF1
come ID fornitore e0x8001
come ID prodotto.
- Crea un dispositivo virtuale Matter con l'app
- Scopri come configurare Google Play Services.
Non è necessario un hub, ad esempio Google Nest Hub (2a generazione), per la messa in servizio e il controllo dei dispositivi con l'app di esempio.
2. Configurazione
L'app iniziale del codelab si trova nel ramo codelab
. Per iniziare a utilizzare il codice sorgente del codelab, puoi scaricare il file ZIP.
Userai questo file ZIP codelab
per creare un esempio funzionante.
Versioni codelab
Il ramo codelab
è contrassegnato con la release 2.0.0 dell'app di esempio. Per confrontare gli aggiornamenti man mano che esegui ogni passaggio, puoi scaricare il codice sorgente completo per questa release.
Se vuoi clonare il repository GitHub, segui le istruzioni nel file README dell'app di esempio.
Dipendenze
Ti guideremo attraverso il codice sorgente necessario per condividere e mettere in servizio i dispositivi, ma potrebbe essere utile conoscere le seguenti dipendenze prima di iniziare. Tieni presente che queste dipendenze sono dichiarate nel file libs.versions.toml e il relativo utilizzo è specificato nel file build.gradle.kts
- SDK Home Mobile
- Le librerie dell'SDK Matter.
- Jetpack Compose. La UI è stata completamente implementata utilizzando Compose.
- Material Design. Per scoprire di più, consulta gli articoli MDC-103 Android: Material Theming with Color, Elevation and Type (Kotlin) e Material Theme Builder.
- Proto DataStore, utilizzato per mantenere i dati dell'app. I serializzatori e i repository Datastore sono archiviati in
java/data
, inclusi gli schemi per i dispositivi e le preferenze utente. Per scoprire di più su DataStore, consulta Utilizzo di Proto DataStore. - Blocca per rendere i dati persistenti e supportare l'inserimento delle dipendenze.
Codice sorgente
L'interfaccia utente e la maggior parte delle funzionalità sono già state create automaticamente.
Per questo codelab, aggiungeremo la funzionalità Matter ai seguenti file:
java/commissioning/AppCommissioningService
: ti consente di commissionare i dispositivi al tessuto di sviluppojava/screens/home/HomeScreen
ejava/screens/home/HomeViewModel.kt
: include la funzionalità di messa in servizio dell'SDK Home Mobilejava/screens/device/DeviceScreen
ejava/screens/device/DeviceViewModel
: include le chiamate API Share Device
Ogni file viene commentato con il blocco di codice che stai modificando, ad esempio:
// CODELAB: add commissioningFunction()
Ciò ti consente di individuare rapidamente la sezione corrispondente nel codelab.
3. Commissione a Google
Prima di poter controllare i dispositivi e consentirne la comunicazione tra loro all'interno della stessa struttura, è necessario che vengano commissionati da un Commissario, che in questo caso si tratta di questa applicazione di esempio, l'app di esempio Google Home per Matter.
È importante comprendere i seguenti concetti relativi alla messa in servizio di Matter:
- I fabric consentono ai dispositivi di comunicare tra loro.
- I fabric mantengono un set condiviso di credenziali univoche.
- Gli ecosistemi sono responsabili dell'emissione di certificati radice attendibili, dell'assegnazione degli ID fabric e dell'assegnazione degli ID nodo univoci. Un ecosistema è il servizio di back-end di un commissario, ad esempio l'Home Graph per l'ecosistema Google Home.
- I dispositivi possono essere commissionati a più di un fabric (funzionalità multi-amministratore).
Per effettuare la messa in servizio di un dispositivo, devi utilizzare l'API CommissioningClient. Una chiamata a .commissionDevice()
restituisce un IntentSender, che avvia l'attività corretta in Google Play Services:
interface CommissioningClient { Task<IntentSender> commissionDevice(CommissioningRequest request); }
Nelle sezioni successive, esamineremo il codice minimo richiesto per la messa in servizio dei dispositivi nel fabric Google.
Passaggio 1: Avvio attività
Per gestire IntentSender
da CommissioningClient
, puoi utilizzare 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) } }
Passaggio 2: messa in servizio della funzione
Ecco un esempio di base che utilizza l'API CommissioningClient per commissionare un dispositivo al fabric di Google.
- Il processo di messa in servizio inizia con la funzione
commissionDevice()
. Per prima cosa, viene definita unaCommissioningRequest
. Con questa configurazione predefinita, i dispositivi vengono commissionati solo al fabric Android locale. Matter
è il punto di accesso per l'SDK Home Mobile. Nella prossima chiamata,.getCommissioningClient
ottiene un CommissioningClient dathis
(attività)..commissionDevice()
accetta iCommissioningRequest
.- Infine,
.addOnSuccessListener
viene chiamato per elaborareCommissioningResult
e avviare l'attività di commissione del dispositivo di 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()) } }
L'infrastruttura Android locale può essere utilizzata tramite le impostazioni di Android per semplificare la procedura di messa in servizio dei dispositivi su altri fabric.
Ora imparerai come commissionare un dispositivo a un fabric di sviluppo.
Per una panoramica dell'interfaccia utente durante la procedura di messa in servizio, consulta la guida di esempio sull'app Google Home per Matter.
4. Commissione a un tessuto di sviluppo
I dispositivi possono essere commissionati per più di un fabric. Per gestire gli accoppiamenti attendibili, i dispositivi memorizzano un FabricTable
contenente vari membri FabricInfo
, ad esempio:
- Identificazione del tessuto
- ID nodo assegnato dal fabric al dispositivo
- ID fornitore
- ID fabric
- Credenziali operative del dispositivo
Il gestore del dominio amministrativo (ADM) definisce le credenziali del fabric. Nello scenario precedente, Google Play Services è l'ecosistema che agisce come autorità di certificazione radice (CA) attendibile. Quando commissioni i dispositivi al fabric Android locale, ogni dispositivo include lo stesso set di credenziali del fabric e lo stesso insieme di CA.
Servizi di messa in servizio personalizzati
Per effettuare la commissione per il fabric Android locale, abbiamo utilizzato i parametri predefiniti per creare CommissioningRequest
nell'API CommissioningClient:
val request: CommissioningRequest = CommissioningRequest.builder().build()
Se vuoi controllare e gestire nuovi dispositivi dalla tua app, devi creare un'infrastruttura di sviluppo locale e ottenere le credenziali operative per la messa in servizio dei dispositivi. In questo scenario, la tua app diventa un ecosistema unico e indipendente che assegna ai dispositivi le credenziali appropriate per i nodi.
Per comunicare all'SDK Home Mobile che vuoi commissionare i dispositivi alla tua struttura, invia un servizio personalizzato a CommissioningRequest:
class CommissioningRequest { static CommissioningRequest.Builder builder(); class Builder { Builder setCommissioningService(@Nullable ComponentName commissioningService); CommissioningRequest build(); } }
Nei passaggi successivi, modificheremo la funzione commissionDevice()
in modo che utilizzi un servizio personalizzato. Aggiungeremo anche un Avvio attività al frammento Home e utilizzeremo gli oggetti LiveData per gestire il flusso API.
Passaggio 1. Crea un Avvio attività GPS
Per prima cosa, creiamo un Avvio attività per gestire IntentSender
dall'API CommissioningClient.
- Apri
HomeScreen
nella cartellajava/screens/home/
. - Sostituisci il commento
// CODELAB: commissionDeviceLauncher definition
con il seguente codice per registrare e gestire il risultato dell'attività di messa in servizio: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) } }
Passaggio 2: attiva l'azione relativa alla commissione per i dispositivi
In questo passaggio, l'utente attiva l'azione "Commissione dispositivo" facendo clic sul pulsante "+" in basso a destra nella schermata Home. Viene quindi effettuata una chiamata al numero commissionDevice()
.
val onCommissionDevice = { ... commissionDevice(activity!!.applicationContext, commissionDeviceLauncher) }
Passaggio 3: chiama l'API
- Ancora in
HomeScreen.kt
nella cartellajava/screens/home/
. - Sostituisci il commento
// CODELAB: commissionDevice
con il seguentecommissionDeviceRequest
.setCommissioningService
associaAppCommissioningService
a un'istanzaCommissioningService
, restituita in una funzione di callback. Quando passi un servizio personalizzato, l'SDK Home Mobile commissiona prima i dispositivi all'infrastruttura locale di Android, quindi invia il payload di onboarding aAppCommissioningService
.val commissionDeviceRequest = CommissioningRequest.builder() .setCommissioningService(ComponentName( context, AppCommissioningService::class.java)) .build()
- Chiama il numero
.getCommissioningClient()
, quindi chiama.commissionDevice()
.
Matter.getCommissioningClient(context) .commissionDevice(commissionDeviceRequest)
Per completare la nostra funzione commissionDevice
, aggiungi addOnSuccessListener
e addOnFailureListener
:
.addOnSuccessListener { result -> commissionDeviceLauncher.launch(IntentSenderRequest.Builder(result).build()) } .addOnFailureListener { error -> Timber.e(error) }
5. Crea un CommissioningService
Nella funzione commissionDevice()
, abbiamo richiesto di ottenere un CommissioningService dall'API CommissioningClient. In questo flusso, l'API CommissioningClient commissiona i dispositivi al fabric Android locale, quindi restituisce un callback che include l'oggetto CommissioningRequestMetadata:
public interface CommissioningService { interface Callback { void onCommissioningRequested(CommissioningRequestMetadata metadata); } }
Ora dobbiamo ereditare CommissioningService.Callback e fornire la funzionalità necessaria per mettere in servizio i dispositivi alla nostra app di esempio. Ecco un esempio di implementazione di base di 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()) } }
Passaggio 1: esplora il servizio AppCommissioningService personalizzato
Per aiutarti a iniziare, abbiamo già definito la struttura di base delle classi per il nostro servizio CommissioningService personalizzato. Di seguito è riportata una breve panoramica delle funzionalità del servizio. Per continuare, apri AppCommissioningService
in java/commissioning
.
Abbiamo aggiunto le seguenti importazioni per le API dell'SDK Home Mobile:
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
include anche le librerie del repository Matter (connectedhomeip
):
import com.google.home_sample_app_for_matter.chip.ChipClient
Infine, il servizio include importazioni a supporto delle coroutine Hilt e Kotlin.
Dopodiché creiamo il costruttore e configuriamo alcune informazioni, fra cui commissioningServiceDelegate
, che utilizzeremo per comunicare a Google Play Services al termine della messa in servizio.
private lateinit var commissioningServiceDelegate: CommissioningService ... commissioningServiceDelegate = CommissioningService.Builder(this).setCallback(this).build()
È arrivato il momento di aggiungere le funzioni di messa in servizio.
Passaggio 2: override della richiesta di commissione
Per effettuare la messa in servizio dei dispositivi nell'infrastruttura di sviluppo dell'app, completa i seguenti passaggi:
- Apri
AppCommissioningService
injava/commissioning
. - Individua la funzione
onCommissioningRequested()
. Abbiamo fornito un messaggio di log che stampa ilCommissioningRequestMetadata
. Sostituisci il commento// CODELAB: onCommissioningRequested()
per avviare la coroutineserviceScope
e ottenere ildeviceId
.// Perform commissioning on custom fabric for the sample app. serviceScope.launch { val deviceId = devicesRepository.incrementAndReturnLastDeviceId()
- Eseguire la messa in servizio. Per questo passaggio, possiamo passare le informazioni sul dispositivo restituite nell'oggetto CommissioningRequestMetadata. Il
ChipClient
utilizza queste informazioni di metadati per creare un canale sicuro tra l'app GHSA per Matter e il tuo dispositivo.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 }
- Utilizza il
commissioningServiceDelegate
per comunicare a Google Play Services che la messa in servizio è stata completata. In.sendCommissioningComplete()
, passa il valore 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") }
Esegui l'app
Ora che tutto il codice richiesto è pronto per la messa in servizio della nostra struttura locale, è il momento di testarlo. Scegli il tuo dispositivo Android ed esegui l'app. Dalla schermata Home, tocca Aggiungi dispositivo e completa la procedura per la messa in servizio del dispositivo.
Al termine della messa in servizio, il tuo dispositivo ora è disponibile in due fabric: il fabric Android locale e il tuo fabric di sviluppo locale. Ogni fabric ha il proprio set di credenziali e un ID fabric univoco a 64 bit.
6. Controllare i dispositivi
La messa in servizio di un fabric di sviluppo consente di utilizzare le librerie del repository Matter (connectedhomeip
) per controllare i dispositivi dall'app di esempio.
Abbiamo creato alcune classi helper per semplificare l'accesso ai cluster dei dispositivi e l'invio di comandi. Per saperne di più, apri ClustersHelper
in java/clusters
. Questo helper Singleton importa le seguenti librerie per accedere alle informazioni del dispositivo:
import chip.devicecontroller.ChipClusters import chip.devicecontroller.ChipStructs
Possiamo utilizzare questa classe per ottenere il cluster di attivazione e disattivazione per un dispositivo, quindi chiamare .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) } }) } }
Attiva/disattiva un dispositivo
Dopo aver commissionato un dispositivo, il payload restituito in CommissioningResult viene aggiunto al DataStore. In questo modo la nostra app può accedere a informazioni del dispositivo che possiamo usare per inviare comandi.
Le app Matter sono basate su eventi. Quando lo stack Matter viene inizializzato, i servizi del cluster restano in ascolto dei messaggi in arrivo. Dopo la messa in servizio di un dispositivo, i client Matter inviano i comandi sul canale operativo sicuro che è stato stabilito durante la messa in servizio del dispositivo.
Sul dispositivo, i pacchetti vengono convalidati, decriptati e inviati con un callback. Le funzioni di callback includono EndpointId, ClusterId e AttributeId, accessibili da attributePath
. Ad esempio, questo codice può essere implementato su un dispositivo 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; }
Nei passaggi successivi, utilizzerai l'SDK Matter e ClustersHelper
per attivare/disattivare un dispositivo.
- Vai a
DeviceViewModel
injava/screens/device
. - Individua la funzione
updateDeviceStateOn
. - Sostituisci il commento
// CODELAB: toggle
con il codice per chiamareclustersHelper
, quindi aggiorna il repository del dispositivo: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") }
Questa funzione viene chiamata da DeviceScreen
:
// On/Off Switch click. val onOnOffClick: (value: Boolean) -> Unit = { value -> deviceViewModel.updateDeviceStateOn(deviceUiModel!!, value) }
Esegui l'app
Esegui l'app per ricaricare gli aggiornamenti. Dalla schermata Home, accendi e spegni il tuo dispositivo.
7. Condividere i dispositivi con altri ecosistemi
La condivisione di un dispositivo è definita come flusso multi-amministratore nella specifica Matter.
Nei passaggi precedenti, abbiamo appreso che l'SDK Home Mobile consente di commissionare i dispositivi al fabric Android locale e anche a un fabric di sviluppo per l'app di esempio. Questo è un esempio di flusso di più amministratori, in cui i dispositivi possono essere commissionati a più di un fabric.
Ora potresti voler condividere dispositivi con ancora più tessuti, soprattutto se si tratta di un nucleo familiare in cui le persone hanno le proprie preferenze per quanto riguarda le applicazioni e le piattaforme.
L'SDK Home Mobile fornisce questa funzionalità nell'API ShareDeviceRequest, consentendoti di:
- Apri una finestra di messa in servizio temporanea per i dispositivi.
- Modifica lo stato dei dispositivi per poterli commissionare a un altro tessuto.
- Controlla i tuoi dispositivi da altre app ed ecosistemi.
Nei passaggi successivi, utilizzerai l'SDK Home Mobile per condividere i dispositivi.
Passaggio 1. Crea un Avvio attività GPS
Analogamente a Commissioning Activity Launcher, che abbiamo creato quando abbiamo commissionato un fabric di sviluppo, abbiamo creato Share Device Activity Launcher per gestire IntentSender
dall'API CommissioningClient.
- Apri
DeviceScreen
nella cartellajava/screens/device/
. - Sostituisci il commento
// CODELAB: shareDeviceLauncher definition
con il seguente codice per registrare e gestire il risultato dell'attività.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) } }
Passaggio 2: attiva l'azione di condivisione del dispositivo
In questo passaggio, l'utente attiva l'azione "Condividi dispositivo" facendo clic sul pulsante "Condividi" sullo schermo del dispositivo. Viene quindi effettuata una chiamata al deviceViewModel
per aprire una finestra di accoppiamento per la condivisione del dispositivo.
// Share Device button click. val onShareDevice: () -> Unit = { deviceViewModel.openPairingWindow(deviceUiModel!!.device.deviceId) }
Dopo aver aperto correttamente la finestra di associazione, l'deviceViewModel
comunica questo fatto alla UI. La comunicazione tra ViewModel
e la UI avviene tramite oggetti StateFlow
.
// Communicate to the UI that the pairing window is open. // UI can then launch the GPS activity for device sharing. _pairingWindowOpenForDeviceSharing.value = true
Dopo aver visualizzato la modifica all'oggetto StateFlow, DeviceScreen effettua la seguente chiamata:
shareDevice(activity!!.applicationContext, shareDeviceLauncher, deviceViewModel)
Passaggio 3: chiama l'API
È arrivato il momento di avviare un'attività di condivisione del dispositivo.
- Apri
DeviceScreen.kt
nella cartellajava/screens/device/
. - Individua la funzione
shareDevice()
. Sostituisci il commento// CODELAB: shareDevice
conShareDeviceRequest
. L'DeviceDescriptor
fornisce informazioni specifiche sul dispositivo, come l'ID fornitore, l'ID prodotto e l'ID dispositivo. In questo esempio, i valori vengono codificati come hardcoded.val shareDeviceRequest = ShareDeviceRequest.builder() .setDeviceDescriptor(DeviceDescriptor.builder().build()) .setDeviceName("GHSAFM temp device name")
- Imposta CommissioningWindow e i parametri.
.setCommissioningWindow( CommissioningWindow.builder() .setDiscriminator(Discriminator.forLongValue(DISCRIMINATOR)) .setPasscode(SETUP_PIN_CODE) .setWindowOpenMillis(SystemClock.elapsedRealtime()) .setDurationSeconds(OPEN_COMMISSIONING_WINDOW_DURATION_SECONDS.toLong()) .build()) .build()
- Chiama
.getCommissioningClient()
, solo questa volta, utilizza l'API.shareDevice()
.Matter.getCommissioningClient(context) .shareDevice(shareDeviceRequest)
Il callback di successo dell'API commissioningClient.shareDevice()
fornisce il mittente di intent da utilizzare per avviare la condivisione dell'attività del dispositivo in Google Play Services.
- Per completare la nostra funzione
shareDevice
, aggiungiaddOnSuccessListener
eaddOnFailureListener
. Se l'operazione riesce,launch
viene chiamato il giornoshareDeviceLauncher
per avviare l'attività GPS per la condivisione del dispositivo..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()) }
Esegui l'app
Per condividere il tuo dispositivo Matter con altri ecosistemi, sul tuo dispositivo Android dovrai installare un'altra piattaforma. Abbiamo creato un'altra istanza dell'app di esempio che puoi utilizzare come commissario di destinazione.
Dopo aver installato il commissario target sul tuo dispositivo Android, verifica di poter condividere il dispositivo Matter. L'app del Commissioner target è etichettata come GHSAFM-TC.
I tuoi dispositivi possono ora essere realizzati in tre tipi di tessuto:
- Il fabric Android locale.
- La tua struttura di sviluppo (questa app).
- Il terzo fabric con cui hai appena condiviso il dispositivo.
8. Passaggi successivi
Complimenti
Congratulazioni, hai completato questo codelab e hai imparato a commissionare e condividere i dispositivi utilizzando l'SDK Home Mobile.
Se hai problemi con l'app di esempio, prova a completare i passaggi per verificare il tuo ambiente:
Se hai domande sull'utilizzo dell'app di esempio o scopri un bug del codice, puoi inviare problemi a Issue Tracker nel repository GitHub:
Per ricevere indicazioni ufficiali da Google in merito a domande tecniche, utilizza il Forum per gli sviluppatori di smart home:
Per ricevere assistenza tecnica dalla community, utilizza il tag google-smart-home
su Stack Overflow: