Crea un'app Android per le pratiche

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:

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

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 sviluppo
  • java/screens/home/HomeScreen e java/screens/home/HomeViewModel.kt: include la funzionalità di messa in servizio dell'SDK Home Mobile
  • java/screens/device/DeviceScreen e java/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.

  1. Il processo di messa in servizio inizia con la funzione commissionDevice(). Per prima cosa, viene definita una CommissioningRequest. Con questa configurazione predefinita, i dispositivi vengono commissionati solo al fabric Android locale.
  2. Matter è il punto di accesso per l'SDK Home Mobile. Nella prossima chiamata, .getCommissioningClient ottiene un CommissioningClient da this (attività).
  3. .commissionDevice() accetta i CommissioningRequest.
  4. Infine, .addOnSuccessListener viene chiamato per elaborare CommissioningResult 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.

  1. Apri HomeScreen nella cartella java/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 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

  1. Ancora in HomeScreen.kt nella cartella java/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 commissiona prima i dispositivi all'infrastruttura locale di 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(), 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:

  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 avviare la coroutine serviceScope e ottenere il 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 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
    }
    
  4. 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.

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

  1. Apri una finestra di messa in servizio temporanea per i dispositivi.
  2. Modifica lo stato dei dispositivi per poterli commissionare a un altro tessuto.
  3. 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.

  1. Apri DeviceScreen nella cartella java/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 = {
 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.

  1. Apri DeviceScreen.kt nella cartella java/screens/device/.
  2. Individua la funzione shareDevice(). Sostituisci il commento // CODELAB: shareDevice con ShareDeviceRequest. 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")
    
  3. 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()
    
  4. 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.

  1. Per completare la nostra funzione shareDevice, aggiungi addOnSuccessListener e addOnFailureListener. Se l'operazione riesce, launch viene chiamato il giorno 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, 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:

  1. Il fabric Android locale.
  2. La tua struttura di sviluppo (questa app).
  3. 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: