Crea un'app Android per le pratiche

1. Ti diamo il benvenuto

Creato con l'obiettivo di unificare gli standard IoT, Matter connette i dispositivi per la smart home in vari ecosistemi come Google Home, Zigbee, Bluetooth Mesh, Z-Wave e altri ancora.

I dispositivi mobili sono un punto di interazione centrale con i dispositivi per la smart home. Se vuoi creare le tue app per Android per supportare i dispositivi Matter, possiamo aiutarti a iniziare rapidamente.

L'app di esempio Google Home per Matter (GHSA per Matter) mostra le API Home Mobile SDK, consentendo agli utenti di eseguire il provisioning 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 eseguire il debug e risolvere i problemi relativi alle interazioni con i dispositivi Matter.

In questo lab proverai a:

In questo codelab, scaricherai il codice sorgente dell'app di esempio e imparerai a utilizzare l'SDK Home Mobile per eseguire il provisioning e condividere i dispositivi. Scoprirai anche come utilizzare le librerie di commissioning e cluster dal repository Matter (connectedhomeip).

Dopo aver scaricato l'app di esempio, esamineremo il codice sorgente in Android Studio e implementeremo le seguenti API Home Mobile SDK:

Scoprirai di più anche sui concetti di commissioning, sui tessuti Matter e su come controllare i dispositivi Matter.

Che cosa ti serve

Prima di iniziare, assicurati di completare i seguenti passaggi:

Non hai bisogno di un hub, ad esempio Google Nest Hub (2ª gen.), per eseguire il provisioning e controllare i dispositivi con l'app di esempio.

2. Configurazione

L'app iniziale del codelab si trova nel ramo codelab. Per iniziare a lavorare con il codice sorgente del codelab, puoi scaricare il file ZIP.

Utilizzerai questo file ZIP codelab per creare un esempio funzionante.

Versioni del codelab

Il ramo codelab è taggato con la release 2.0.0 dell'app di esempio. Per confrontare gli aggiornamenti man mano che procedi con ogni passaggio, puoi scaricare il codice sorgente completato per questa release.

Se vuoi clonare il repository GitHub, segui le istruzioni nel file README dell'app di esempio.

Dipendenze

Ti guideremo nel codice sorgente necessario per condividere e commissionare i dispositivi, ma prima di iniziare potrebbe essere utile conoscere le seguenti dipendenze. Tieni presente che queste dipendenze sono dichiarate nel file libs.versions.toml e il loro utilizzo è specificato nel file build.gradle.kts

Codice sorgente

L'interfaccia utente e la maggior parte delle funzionalità sono già state create per te.

Per questo codelab, aggiungeremo la funzionalità Matter ai seguenti file:

  • java/com/google/homesampleapp/commissioning/AppCommissioningService: consente di eseguire il provisioning dei dispositivi nel fabric di sviluppo
  • java/com/google/homesampleapp/screens/home/HomeScreen e java/com/google/homesampleapp/screens/home/HomeViewModel.kt: include la funzionalità di commissioning dell'SDK Home Mobile
  • java/com/google/homesampleapp/screens/device/DeviceScreen e java/com/google/homesampleapp/screens/device/DeviceViewModel: include le chiamate API Share Device

Ogni file è commentato con il blocco di codice che modificherai, ad esempio:

// CODELAB: add commissioningFunction()

In questo modo puoi individuare rapidamente la sezione corrispondente nel codelab.

3. Commissione a Google

Prima di poter controllare i dispositivi e consentire loro di comunicare tra loro all'interno dello stesso tessuto, devono essere commissionati da un commissario, che in questo caso è questa applicazione di esempio, l'app Google Home Sample per Matter.

È importante comprendere i seguenti concetti relativi al provisioning di Matter:

  • I tessuti consentono ai dispositivi di comunicare tra loro.
  • I tessuti mantengono un insieme condiviso di credenziali uniche.
  • Gli ecosistemi sono responsabili dell'emissione di certificati radice attendibili, dell'assegnazione di ID fabric e di ID nodo unici. Un ecosistema è il servizio di backend di un commissario, ad esempio Home Graph per l'ecosistema Google Home.
  • I dispositivi possono essere commissionati a più di un tessuto (funzionalità multi-amministratore).

Per eseguire il provisioning 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 il provisioning dei dispositivi nel tessuto Google.

Passaggio 1: Avvio attività

Per gestire l'IntentSender dall'CommissioningClient, puoi utilizzare un 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: funzione di provisioning

Di seguito è riportato un esempio di base che utilizza l'API CommissioningClient per eseguire il provisioning di un dispositivo nel tessuto Google.

  1. La procedura di commissioning inizia con la funzione commissionDevice(). Innanzitutto, viene definito un CommissioningRequest. Con questa configurazione predefinita, i dispositivi vengono commissionati solo al tessuto Android locale.
  2. Matter è il punto di accesso per l'SDK Home Mobile. Nella chiamata successiva, .getCommissioningClient ottiene un CommissioningClient entro this (attività).
  3. .commissionDevice() accetta i CommissioningRequest.
  4. Infine, viene chiamato .addOnSuccessListener per elaborare CommissioningResult e avviare l'attività Commission Device 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())
        }
}

Il tessuto Android locale può essere utilizzato tramite le impostazioni di Android per semplificare la procedura di commissioning dei suoi dispositivi ad altri tessuti.

Ora imparerai come eseguire il provisioning di un dispositivo in un fabric di sviluppo.

Per una panoramica dell'interfaccia utente durante la procedura di commissioning, consulta la Guida all'app di esempio Google Home per Matter.

4. Commissione a un tessuto di sviluppo

I dispositivi possono essere commissionati a più di un tessuto. Per gestire gli accoppiamenti attendibili, i dispositivi memorizzano un FabricTable contenente vari membri FabricInfo, ad esempio:

  • Identificazione del tessuto
  • ID nodo assegnato al dispositivo dall'infrastruttura
  • ID fornitore
  • ID fabric
  • Credenziali operative del dispositivo

L'amministratore di dominio amministrativo (ADM) definisce le credenziali del fabric. Nello scenario precedente, Google Play Services è l'ecosistema che funge da autorità di certificazione (CA) radice attendibile. Quando esegui il provisioning dei dispositivi nell'infrastruttura Android locale, ogni dispositivo include lo stesso insieme di credenziali dell'infrastruttura e lo stesso insieme di CA.

Servizi di messa in servizio personalizzati

Per eseguire il commissioning nel tessuto 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 fabric di sviluppo locale e ottenere le credenziali operative per il provisioning dei dispositivi. In questo scenario, la tua app diventa un ecosistema unico e indipendente che assegna ai dispositivi le credenziali del nodo appropriate.

Puoi comunicare all'SDK Home Mobile che vuoi eseguire il provisioning dei dispositivi nel tuo tessuto passando 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() per utilizzare un servizio personalizzato. Aggiungeremo anche un Activity Launcher al fragment Home e utilizzeremo gli oggetti LiveData per gestire il flusso dell'API.

Passaggio 1: crea un launcher di attività GPS

Innanzitutto, creiamo un Activity Launcher per gestire IntentSender dall'API CommissioningClient.

  1. Apri HomeScreen nella cartella java/com/google/homesampleapp/screens/home/.
  2. Sostituisci il commento // CODELAB: commissionDeviceLauncher definition con il seguente codice per registrare e gestire il risultato dell'attività di provisioning:
    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 di commissione del dispositivo

In questo passaggio, l'utente attiva l'azione "Commissiona dispositivo" facendo clic sul pulsante "+" in basso a destra della schermata Home. Viene quindi effettuata una chiamata al numero commissionDevice().

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

Passaggio 3: chiama l'API

  1. Sempre in HomeScreen.kt nella cartella java/com/google/homesampleapp/screens/home.
  2. Sostituisci il commento // CODELAB: commissionDevice con il seguente commissionDeviceRequest. setCommissioningService associa AppCommissioningService a un'istanza CommissioningService, restituita in una funzione di callback. Quando passi un servizio personalizzato, l'SDK Home Mobile esegue prima il provisioning dei dispositivi nel fabric locale Android, quindi invia il payload di onboarding a AppCommissioningService.
    val commissionDeviceRequest =
    CommissioningRequest.builder()
        .setCommissioningService(ComponentName(
            context, AppCommissioningService::class.java))
        .build()
  3. Chiama il numero .getCommissioningClient(), poi chiama il numero .commissionDevice().
Matter.getCommissioningClient(context)
    .commissionDevice(commissionDeviceRequest)

Per completare la funzione commissionDevice, aggiungi un addOnSuccessListener e un addOnFailureListener:

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

5. Crea un servizio di commissioning

Nella funzione commissionDevice(), abbiamo richiesto di ottenere un CommissioningService dall'API CommissioningClient. In questo flusso, l'API CommissioningClient esegue il provisioning dei dispositivi nel tessuto 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 il provisioning dei dispositivi nella 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 AppCommissioningService personalizzato

Per aiutarti a iniziare, abbiamo già definito la struttura di base della classe per il nostro CommissioningService personalizzato. Ecco una breve panoramica delle funzionalità del servizio. Per seguire la procedura, apri AppCommissioningService in java/commissioning.

Abbiamo aggiunto le seguenti importazioni per le 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 include anche le librerie del repository Matter (connectedhomeip):

import com.google.homesampleapp.chip.ChipClient

Infine, il servizio include importazioni per supportare Hilt e le coroutine Kotlin.

Successivamente, creiamo il costruttore e configuriamo alcune cose, tra cui commissioningServiceDelegate, che utilizzeremo per comunicare a Google Play Services quando il provisioning è completato.

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

Ora è il momento di aggiungere le funzioni di configurazione.

Passaggio 2: esegui l'override di onCommissioningRequested

Per eseguire il provisioning dei dispositivi nel fabric di sviluppo dell'app, completa i seguenti passaggi:

  1. Apri AppCommissioningService in java/commissioning.
  2. Individua la funzione onCommissioningRequested(). Abbiamo fornito un messaggio di log che stampa CommissioningRequestMetadata. Sostituisci il commento // CODELAB: onCommissioningRequested() per avviare la coroutine serviceScope e ottenere deviceId.
    // Perform commissioning on custom fabric for the sample app.
serviceScope.launch {
  val deviceId = devicesRepository.incrementAndReturnLastDeviceId()
  3. Esegui la configurazione. Per questo passaggio, possiamo trasmettere le informazioni sul dispositivo restituite nell'oggetto CommissioningRequestMetadata. ChipClient utilizza queste informazioni sui metadati per creare un canale sicuro tra l'app GHSA for 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
}
  4. Utilizza commissioningServiceDelegate per comunicare a Google Play Services che la configurazione è stata completata. In .sendCommissioningComplete(), trasmetti 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 è in posizione per il commissioning al nostro tessuto locale, è il momento di testarlo. Scegli il tuo dispositivo Android ed esegui l'app. Nella schermata Home, tocca Aggiungi dispositivo e completa i passaggi per il provisioning del dispositivo.

Al termine della configurazione, il dispositivo partecipa a due tessuti: il tessuto Android locale e il tessuto di sviluppo locale. Ogni fabric ha il proprio insieme di credenziali e un ID fabric univoco a 64 bit.

6. Controllare i dispositivi

Il provisioning in un fabric di sviluppo ti 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 di 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 On/Off 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)
              }
            })
  }
}

Attivare/disattivare un dispositivo

Dopo aver eseguito il provisioning di un dispositivo, il payload restituito in CommissioningResult viene aggiunto a DataStore. In questo modo, la nostra app può accedere alle informazioni del dispositivo che possiamo utilizzare per inviare comandi.

Le app Matter sono basate su eventi. Quando lo stack Matter viene inizializzato, i servizi del cluster ascoltano i messaggi in arrivo. Una volta eseguito il provisioning di un dispositivo, i client Matter inviano comandi sul canale operativo sicuro stabilito durante il provisioning del dispositivo.

Sul dispositivo, i pacchetti vengono convalidati, decriptati e poi 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 Matter SDK e ClustersHelper per attivare/disattivare un dispositivo.

  1. Vai a DeviceViewModel in java/screens/device.
  2. Individua la funzione updateDeviceStateOn.
  3. Sostituisci il commento // CODELAB: toggle con il codice per chiamare clustersHelper, quindi aggiorna il repository dei dispositivi:
    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, attiva e disattiva il dispositivo.

7. Condividere i dispositivi con altri ecosistemi

La condivisione di un dispositivo è definita flusso multi-amministratore nella specifica Matter.

Nei passaggi precedenti abbiamo appreso che l'SDK Home Mobile consente di eseguire il provisioning dei dispositivi nel fabric Android locale e anche in un fabric di sviluppo per l'app di esempio. Questo è un esempio di flusso multi-amministratore, in cui i dispositivi possono essere sottoposti a provisioning in più di un fabric.

Ora potresti voler condividere i dispositivi con ancora più tessuti, soprattutto se si tratta di una casa in cui le persone hanno le proprie preferenze in fatto di applicazioni e piattaforme.

L'SDK Home Mobile fornisce questa funzionalità nell'API ShareDeviceRequest, che ti consente di:

  1. Apri una finestra di provisioning temporaneo per i dispositivi.
  2. Modifica lo stato dei tuoi dispositivi, consentendo di commissionarli a un altro tessuto.
  3. Controllare i dispositivi da altre app ed ecosistemi.

Nei passaggi successivi, utilizzerai l'SDK Home Mobile per condividere i dispositivi.

Passaggio 1: crea un launcher di attività GPS

Analogamente al launcher di attività di provisioning creato durante il provisioning in un tessuto di sviluppo, abbiamo creato un launcher di attività di condivisione del dispositivo per gestire IntentSender dall'API CommissioningClient.

  1. Apri DeviceScreen nella cartella java/com/google/homesampleapp/screens/device/.
  2. 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 = remember {
 {
   deviceViewModel.openPairingWindow(deviceUiModel!!.device.deviceId)
 }
}

Dopo aver aperto correttamente la finestra di accoppiamento, deviceViewModel comunica questo fatto all'interfaccia utente. 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

Ora è il momento di avviare un'attività di condivisione del dispositivo.

  1. Apri DeviceScreen.kt nella cartella java/com/google/homesampleapp/screens/device/.
  2. Individua la funzione shareDevice(). Sostituisci il commento // CODELAB: shareDevice con ShareDeviceRequest. DeviceDescriptor fornisce informazioni specifiche sul dispositivo, come ID fornitore, ID prodotto e tipo di dispositivo. In questo esempio, codifichiamo i valori in modo permanente.
    val shareDeviceRequest =
  ShareDeviceRequest.builder()
    .setDeviceDescriptor(DeviceDescriptor.builder().build())
    .setDeviceName("GHSAFM temp device name")
  3. Imposta i CommissioningWindow.
        .setCommissioningWindow(
        CommissioningWindow.builder()
            .setDiscriminator(Discriminator.forLongValue(DISCRIMINATOR))
            .setPasscode(SETUP_PIN_CODE)
            .setWindowOpenMillis(SystemClock.elapsedRealtime())
            .setDurationSeconds(OPEN_COMMISSIONING_WINDOW_DURATION_SECONDS.toLong())
            .build())
    .build()
  4. Chiama .getCommissioningClient(), ma questa volta utilizza l'API .shareDevice().
    Matter.getCommissioningClient(context)
    .shareDevice(shareDeviceRequest)

Il callback di successo dell'API commissioningClient.shareDevice() fornisce l'IntentSender da utilizzare per avviare Condividi attività del dispositivo nei servizi Google Play.

  1. Per completare la funzione shareDevice, aggiungi un addOnSuccessListener e un addOnFailureListener. In caso di esito positivo, launch viene chiamato su shareDeviceLauncher 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, devi installare un'altra piattaforma sul tuo dispositivo Android. Abbiamo creato un'altra istanza dell'app di esempio che puoi utilizzare come commissario target.

Una volta installato il commissario di destinazione sul tuo dispositivo Android, verifica di poter condividere il tuo dispositivo Matter. L'app del commissario di destinazione è etichettata GHSAFM-TC.

Ora i tuoi dispositivi possono partecipare a tre tessuti:

  1. Il tessuto Local Android.
  2. Il tuo tessuto di sviluppo (questa app).
  3. Questo terzo tessuto con cui hai appena condiviso il dispositivo.

8. Passaggi successivi

Complimenti

Congratulazioni, hai completato correttamente questo codelab e hai imparato a eseguire il provisioning e la condivisione dei dispositivi utilizzando l'SDK Home Mobile.

Se hai problemi con l'app di esempio, prova a completare i passaggi per verificare l'ambiente:

Se hai domande sull'utilizzo dell'app di esempio o se scopri un bug nel codice, puoi inviare i problemi a Issue Tracker nel repository GitHub:

Per ricevere indicazioni ufficiali da Google su domande tecniche, utilizza il forum per sviluppatori di smart home:

Per ricevere assistenza tecnica dalla community, utilizza il tag google-smart-home su Stack Overflow: