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 Android per supportare i dispositivi Matter, possiamo aiutarti a iniziare rapidamente.

L'app Google Home di esempio per Matter (GHSA per Matter) presenta le API Home Mobile SDK, che consentono agli utenti di mettere in servizio e condividere 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 mettere in servizio e condividere i dispositivi. Imparerai inoltre a utilizzare le librerie di cluster e messa in servizio 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 inoltre di più sui concetti di messa in servizio, sui prodotti Matter e su come controllare i dispositivi Matter.

Che cosa ti serve

Prima di iniziare, assicurati di completare questi passaggi:

Non è necessario un hub, ad esempio Google Nest Hub (2a generazione), per mettere in servizio e controllare i dispositivi con l'app di esempio.

2. Configurazione

L'app iniziale del codelab si trova nella filiale codelab. Per iniziare a utilizzare il codice sorgente del codelab, puoi scaricare il file ZIP.

Utilizzerai questo file ZIP codelab per creare un esempio funzionante.

Versioni codelab

Il ramo codelab è codificato con la release 2.0.0 dell'app di esempio. Per confrontare gli aggiornamenti mentre esegui ogni passaggio, puoi scaricare il codice sorgente completato per questa release.

Se vuoi clonare il repository GitHub, segui le istruzioni riportate 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

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/com/google/homesampleapp/commissioning/AppCommissioningService: ti consente di commissionare dispositivi all'infrastruttura di sviluppo
  • java/com/google/homesampleapp/screens/home/HomeScreen e java/com/google/homesampleapp/screens/home/HomeViewModel.kt: include la funzionalità di messa in servizio 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 viene 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

Per poter controllare i dispositivi e consentire loro di comunicare tra loro all'interno della stessa struttura, è necessario che siano commissionati da un Commissioner, che in questo caso è questa applicazione di esempio, l'app Google Home di esempio per Matter.

È importante comprendere i seguenti concetti relativi alla messa in servizio di Matter:

  • L'infrastruttura consente 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 di ID fabric e dell'assegnazione di ID nodo univoci. Un ecosistema è il servizio di backend di un commissario, ad esempio l'Home Graph per l'ecosistema Google Home.
  • I dispositivi possono essere commissionati a più di un'infrastruttura (funzionalità di amministrazione multipla).

Per mettere in servizio 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, vedremo la quantità minima di codice necessario per commissionare dispositivi all'infrastruttura Google.

Passaggio 1: Avvio attività

Per gestire IntentSender da 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 messa in servizio

Di seguito è riportato un esempio base in cui viene utilizzata l'API CommissioningClient per commissionare un dispositivo all'infrastruttura Google.

  1. Il processo di messa in servizio inizia con la funzione commissionDevice(). Innanzitutto, devi definire un elemento CommissioningRequest. Con questa configurazione predefinita, i dispositivi vengono commissionati solo all'infrastruttura Android locale.
  2. Matter è il punto di accesso all'SDK Home Mobile. Nella chiamata successiva, .getCommissioningClient ottiene un CommissioningClient da this (attività).
  3. .commissionDevice() accetta i CommissioningRequest.
  4. Infine, .addOnSuccessListener viene chiamato a elaborare CommissioningResult e a lanciare l'Attività del dispositivo di commissione 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())
        }
}

Local Android Fabric può essere utilizzato tramite le impostazioni di Android per semplificare il processo di messa in servizio dei dispositivi su altri tessuti.

Ora imparerai come commissionare un dispositivo a un'infrastruttura di sviluppo.

Per una panoramica dell'interfaccia utente durante la procedura di messa in servizio, consulta la guida di esempio dell'app Google Home per Matter.

4. Commissione su un tessuto di sviluppo

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

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

Il gestore di domini amministrativi (ADM) definisce le credenziali dell'infrastruttura. Nello scenario precedente, Google Play Services è l'ecosistema che funge da autorità di certificazione radice attendibile (CA). Quando commissioni i dispositivi all'infrastruttura Android locale, ogni dispositivo include lo stesso set di credenziali dell'infrastruttura e lo stesso insieme di CA.

Servizi di messa in servizio personalizzati

Per la commissione nell'infrastruttura 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 commissionare i 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 commissionare dispositivi alla tua infrastruttura trasmettendo 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 da utilizzare un servizio personalizzato. Aggiungeremo anche un Avvio attività al frammento Home e useremo gli oggetti LiveData per gestire il flusso API.

Passaggio 1: crea un avvio attività GPS

Innanzitutto, creiamo un Avvio attività 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 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 del dispositivo relativa alla commissione

In questo passaggio, l'utente attiva il "dispositivo per la commissione" facendo clic sul segno "+" 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

  1. Ancora 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 trasmetti un servizio personalizzato, l'SDK Home Mobile prima commissiona i dispositivi all'infrastruttura locale di Android, poi invia il payload di onboarding a AppCommissioningService.
    val commissionDeviceRequest =
    CommissioningRequest.builder()
        .setCommissioningService(ComponentName(
            context, AppCommissioningService::class.java))
        .build()
  3. Chiama .getCommissioningClient(), poi chiama .commissionDevice().
Matter.getCommissioningClient(context)
    .commissionDevice(commissionDeviceRequest)

Per completare la funzione commissionDevice, aggiungi addOnSuccessListener e addOnFailureListener:

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

5. Crea un servizio di messa in servizio

Nella funzione commissionDevice(), abbiamo richiesto di ottenere un CommissioningService dall'API CommissioningClient. In questo flusso, l'API CommissioningClient commissiona prima i dispositivi nell'infrastruttura Android locale, poi 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 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 il servizio AppCommissioningService personalizzato

Per aiutarti a iniziare, abbiamo già definito la struttura di base delle classi per il nostro CommissioningService personalizzato. Di seguito è riportata una rapida panoramica delle funzionalità del servizio. Per continuare, 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 le importazioni per supportare Hilt e coroutine di Kotlin.

In seguito, creiamo il costruttore e configuriamo alcune cose, tra 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()

A questo punto occorre aggiungere le funzioni di messa in servizio.

Passaggio 2: esegui l'override di onCommissioningRequested

Per effettuare la commissione di dispositivi nella struttura 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 il CommissioningRequestMetadata. Sostituisci il commento // CODELAB: onCommissioningRequested() per iniziare la coroutine di serviceScope e ottenere la deviceId.
    // Perform commissioning on custom fabric for the sample app.
serviceScope.launch {
  val deviceId = devicesRepository.incrementAndReturnLastDeviceId()
  3. Eseguire la messa in servizio. Per questo passaggio, possiamo passare le informazioni del dispositivo restituite nell'oggetto CommissioningRequestMetadata. ChipClient utilizza queste informazioni dei 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
}
  4. Utilizza 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 essere commissionato nella 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 mettere in servizio il dispositivo.

Al termine della messa in servizio, il tuo dispositivo ora utilizza due tessuti: la struttura Android locale e la tua struttura di sviluppo locale. Ogni infrastruttura ha il proprio set di credenziali e un ID fabric a 64 bit univoco.

6. Controllare i dispositivi

La messa in servizio su un'infrastruttura 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 del dispositivo e l'invio di comandi. Per scoprire 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 usare 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)
              }
            })
  }
}

Attiva/disattiva un dispositivo

Dopo aver messo in servizio un dispositivo, il payload restituito in CommissioningResult viene aggiunto al Datastore. Questo consente alla nostra app di 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 cluster restano in ascolto dei messaggi in arrivo. Una volta messo in servizio un dispositivo, i client Matter inviano i comandi sul canale operativo sicuro 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.

  1. Vai a DeviceViewModel a 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, accendi e spegni il tuo dispositivo.

7. Condividere dispositivi con altri ecosistemi

Nella specifica Matter, la condivisione di un dispositivo è definita flusso con più amministratori.

Nei passaggi precedenti, abbiamo imparato che l'SDK Home Mobile consente di commissionare i dispositivi all'infrastruttura Android locale e anche a un fabric di sviluppo per l'app di esempio. Questo è un esempio di flusso con più amministratori, in cui i dispositivi possono essere commissionati a più di un'infrastruttura.

Potresti voler condividere dispositivi con ancora più tessuti, soprattutto se si tratta di un nucleo familiare in cui le persone hanno le loro preferenze quando si tratta di applicazioni e piattaforme.

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

  1. Apri una finestra di messa in servizio temporanea per i dispositivi.
  2. Modifica lo stato dei dispositivi, in modo da poterli commissionare a un'altra infrastruttura.
  3. Controlla i tuoi dispositivi da altri ecosistemi e app.

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

Passaggio 1: crea un avvio attività GPS

In modo analogo all'Avvio attività di commissione che abbiamo creato quando abbiamo commissionato una struttura di sviluppo, abbiamo creato un Avvio app di condivisione attività 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à di .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'opzione "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 l'apertura della finestra di associazione, deviceViewModel comunica questo fatto alla UI. La comunicazione tra ViewModel e la UI viene effettuata 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 visto 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. Il DeviceDescriptor fornisce informazioni specifiche sul dispositivo, ad esempio ID fornitore, ID prodotto e deviceType. In questo esempio, applichiamo l'hard-coding dei valori.
    val shareDeviceRequest =
  ShareDeviceRequest.builder()
    .setDeviceDescriptor(DeviceDescriptor.builder().build())
    .setDeviceName("GHSAFM temp device name")
  3. Imposta CommissioningWindow e parameters.
        .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(). Solo questa volta, usa l'API .shareDevice().
    Matter.getCommissioningClient(context)
    .shareDevice(shareDeviceRequest)

Il callback riuscito dell'API commissioningClient.shareDevice() fornisce il mittente di intent da utilizzare per avviare la condivisione dell'attività del dispositivo in Google Play Services.

  1. Per completare la funzione shareDevice, aggiungi addOnSuccessListener e addOnFailureListener. Se l'operazione riesce, launch viene chiamato il 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 dispositivo Matter con altri ecosistemi, devi avere un'altra piattaforma installata sul tuo dispositivo Android. Abbiamo creato un'altra istanza dell'app di esempio che puoi utilizzare come commissario target.

Dopo aver installato il commissario di destinazione sul tuo dispositivo Android, verifica di poter condividere il dispositivo Matter. L'app del commissario target è denominata GHSAFM-TC.

I tuoi dispositivi ora possono partecipare a tre tessuti:

  1. La struttura Android locale.
  2. Il tuo fabric di sviluppo (questa app).
  3. Il terzo tessuto con cui hai appena condiviso il dispositivo.

8. Passaggi successivi

Complimenti

Complimenti, hai completato questo codelab e hai imparato a mettere in servizio e condividere i dispositivi usando 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 i problemi a Issue Tracker nel repository GitHub:

Per ricevere indicazioni ufficiali di Google in merito a domande tecniche, utilizza il Forum degli sviluppatori per la smart home:

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