Créer une application Android pour Matter

1. Bienvenue

Conçu dans le but d'unifier les normes IoT, Matter connecte les appareils pour la maison connectée dans différents écosystèmes comme Google Home, Zigbee, Bluetooth Mesh, Z-Wave et plus encore.

Les appareils mobiles sont un point d'interaction central avec les appareils connectés. Si vous souhaitez créer vos propres applications Android pour prendre en charge les appareils Matter, nous pouvons vous aider à démarrer rapidement.

L'application exemple Google Home pour Matter (GHSA pour Matter) présente les API du SDK Home Mobile, qui permettent aux utilisateurs de configurer et de partager des appareils. Vous pouvez également utiliser l'application exemple comme outil d'apprentissage pour mieux comprendre les concepts clés de Matter, ainsi que comme outil de débogage et de dépannage des interactions avec les appareils Matter.

Objectifs de l'atelier

Dans cet atelier de programmation, vous allez télécharger le code source de l'application exemple et apprendre à utiliser le SDK Home Mobile pour mettre en service et partager des appareils. Vous apprendrez également à utiliser les bibliothèques de mise en service et de cluster du dépôt Matter (connectedhomeip).

Après avoir téléchargé l'application exemple, nous examinerons le code source dans Android Studio et implémenterons les API Home Mobile SDK suivantes :

Vous en saurez également plus sur les concepts de mise en service, les fabrics Matter et le contrôle des appareils Matter.

Prérequis

Avant de commencer, assurez-vous d'avoir effectué les étapes suivantes :

Vous n'avez pas besoin de hub, par exemple un Google Nest Hub (2e génération), pour mettre en service et contrôler des appareils avec l'application exemple.

2. Configuration

L'application de démarrage de l'atelier de programmation se trouve dans la branche codelab. Pour commencer à travailler avec le code source de l'atelier de programmation, vous pouvez télécharger le fichier ZIP.

Télécharger le fichier ZIP

Vous utiliserez ce fichier ZIP codelab pour créer un exemple fonctionnel.

Versions de l'atelier de programmation

La branche codelab est taguée avec la version 2.0.0 de l'application exemple. Pour comparer vos mises à jour à chaque étape, vous pouvez télécharger le code source complet de cette version.

Si vous souhaitez cloner le dépôt GitHub, suivez les instructions du fichier README de l'exemple d'application.

Dépendances

Nous vous guiderons à travers le code source requis pour partager et mettre en service des appareils, mais il peut être utile de connaître les dépendances suivantes avant de commencer. Notez que ces dépendances sont déclarées dans le fichier libs.versions.toml et que leur utilisation est spécifiée dans le fichier build.gradle.kts.

Code source

L'interface utilisateur et la plupart des fonctionnalités ont déjà été créées pour vous.

Pour cet atelier de programmation, nous allons ajouter la fonctionnalité Matter aux fichiers suivants :

  • java/com/google/homesampleapp/commissioning/AppCommissioningService : vous permet de mettre en service des appareils sur le réseau de développement.
  • java/com/google/homesampleapp/screens/home/HomeScreen et java/com/google/homesampleapp/screens/home/HomeViewModel.kt : incluent la fonctionnalité de mise en service du SDK Home Mobile
  • java/com/google/homesampleapp/screens/device/DeviceScreen et java/com/google/homesampleapp/screens/device/DeviceViewModel : incluent les appels d'API Share Device

Chaque fichier est commenté avec le bloc de code que vous allez modifier. Par exemple :

// CODELAB: add commissioningFunction()

Cela vous permet de localiser rapidement la section correspondante dans l'atelier de programmation.

3. Commission à Google

Avant de pouvoir contrôler des appareils et leur permettre de communiquer entre eux au sein d'un même réseau, ils doivent être mis en service par un commissaire, qui est dans ce cas cette application exemple, l'application exemple Google Home pour Matter.

Il est important de comprendre les concepts suivants concernant la mise en service Matter :

  • Les fabrics permettent aux appareils de communiquer entre eux.
  • Les fabrics conservent un ensemble partagé d'identifiants uniques.
  • Les écosystèmes sont responsables de l'émission de certificats racine de confiance, de l'attribution d'ID de structure et de l'attribution d'ID de nœud uniques. Un écosystème est le service de backend d'un commissaire, par exemple Home Graph pour l'écosystème Google Home.
  • Les appareils peuvent être mis en service dans plusieurs fabrics (fonctionnalité multi-administrateur).

Pour mettre en service un appareil, vous devez utiliser l'API CommissioningClient. Un appel à .commissionDevice() renvoie un IntentSender, qui lance l'activité appropriée dans les services Google Play :

interface CommissioningClient {
  Task<IntentSender> commissionDevice(CommissioningRequest request);
}

Dans les sections suivantes, nous allons passer en revue le code minimal requis pour mettre en service des appareils sur le réseau Google.

Étape 1 : Lanceur d'activités

Pour gérer le IntentSender à partir du CommissioningClient, vous pouvez utiliser 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)
    }
}

Étape 2 : Fonction de mise en service

Voici un exemple de base qui utilise l'API CommissioningClient pour mettre en service un appareil sur le réseau Google.

  1. Le processus de mise en service commence par la fonction commissionDevice(). Tout d'abord, un CommissioningRequest est défini. Avec cette configuration par défaut, les appareils ne sont mis en service que sur le réseau local Android.
  2. Matter est le point d'entrée du SDK Home Mobile. Lors du prochain appel, .getCommissioningClient obtient un CommissioningClient par this (Activity).
  3. .commissionDevice() accepte les CommissioningRequest.
  4. Enfin, .addOnSuccessListener est appelé pour traiter CommissioningResult et lancer l'activité Commission Device des services Google Play (GPS).
private fun commissionDevice() {
    val request: CommissioningRequest = CommissioningRequest.builder().build()
    Matter.getCommissioningClient(this)
        .commissionDevice(request)
        .addOnSuccessListener { result ->
            commissioningLauncher.launch(IntentSenderRequest.Builder(result).build())
        }
}

Le Local Android Fabric peut être utilisé via les paramètres Android pour simplifier le processus de mise en service de ses appareils sur d'autres fabrics.

Vous allez maintenant apprendre à mettre en service un appareil dans un tissu de développement.

Pour obtenir une présentation de l'interface utilisateur pendant le processus de mise en service, consultez le Guide de l'application Google Home Sample pour Matter.

4. Mise en service d'un tissu de développement

Les appareils peuvent être mis en service dans plusieurs fabrics. Pour gérer les associations vérifiées, les appareils stockent un FabricTable contenant différents membres FabricInfo, par exemple :

  • Identification de tissus
  • ID de nœud attribué à l'appareil par le tissu
  • ID du fournisseur
  • ID de structure
  • Identifiants opérationnels de l'appareil

Le gestionnaire de domaine administratif (ADM) définit les identifiants du réseau. Dans le scénario précédent, les services Google Play constituent l'écosystème qui fait office d'autorité de certification (CA) racine de confiance. Lorsque vous mettez en service des appareils dans le fabric Android local, chaque appareil inclut le même ensemble d'identifiants de fabric et le même ensemble d'AC.

Services de mise en service personnalisés

Pour mettre en service le tissu Local Android, nous avons utilisé les paramètres par défaut pour créer CommissioningRequest dans l'API CommissioningClient :

val request: CommissioningRequest = CommissioningRequest.builder().build()

Si vous souhaitez contrôler et gérer de nouveaux appareils depuis votre application, vous devez créer un tissu de développement local et obtenir les identifiants opérationnels pour mettre en service les appareils. Dans ce scénario, votre application devient un écosystème unique et indépendant qui attribue aux appareils les identifiants de nœud appropriés.

Vous pouvez informer le SDK Home Mobile que vous souhaitez mettre en service des appareils sur votre propre réseau en transmettant un service personnalisé à CommissioningRequest :

class CommissioningRequest {
  static CommissioningRequest.Builder builder();

  class Builder {
    Builder setCommissioningService(@Nullable ComponentName commissioningService);

    CommissioningRequest build();
  }
}

Au cours des prochaines étapes, nous allons modifier la fonction commissionDevice() pour utiliser un service personnalisé. Nous ajouterons également un lanceur d'activité au fragment Home et utiliserons des objets LiveData pour gérer le flux d'API.

Étape 1 : Créez un lanceur d'activité GPS

Commençons par créer un lanceur d'activité pour gérer IntentSender à partir de l'API CommissioningClient.

  1. Ouvrez HomeScreen dans le dossier java/com/google/homesampleapp/screens/home/.
  2. Remplacez le commentaire // CODELAB: commissionDeviceLauncher definition par le code suivant pour enregistrer et gérer le résultat de l'activité de mise en service :
    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)
    }
  }

Étape 2 : Déclenchez l'action de mise en service de l'appareil

Dans cette étape, l'utilisateur déclenche l'action "Commission Device" (Mettre en service l'appareil) en cliquant sur le bouton "+" en bas à droite de l'écran d'accueil. Un appel est ensuite effectué à commissionDevice().

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

Étape 3 : Appeler l'API

  1. Toujours dans HomeScreen.kt, dans le dossier java/com/google/homesampleapp/screens/home.
  2. Remplacez le commentaire // CODELAB: commissionDevice par le commentaire suivant : commissionDeviceRequest. setCommissioningService lie AppCommissioningService à une instance CommissioningService, renvoyée dans une fonction de rappel. Lorsque vous transmettez un service personnalisé, le SDK Home Mobile met d'abord les appareils en service sur le réseau local Android, puis renvoie la charge utile d'intégration à AppCommissioningService.
    val commissionDeviceRequest =
    CommissioningRequest.builder()
        .setCommissioningService(ComponentName(
            context, AppCommissioningService::class.java))
        .build()
  3. Appelez .getCommissioningClient(), puis .commissionDevice().
Matter.getCommissioningClient(context)
    .commissionDevice(commissionDeviceRequest)

Pour compléter notre fonction commissionDevice, ajoutez un addOnSuccessListener et un addOnFailureListener :

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

5. Créer un service de mise en service

Dans la fonction commissionDevice(), nous avons demandé à obtenir un CommissioningService à partir de l'API CommissioningClient. Dans ce flux, l'API CommissioningClient met en service les appareils sur le réseau local Android, puis renvoie un rappel qui inclut l'objet CommissioningRequestMetadata :

public interface CommissioningService {
interface Callback {
    void onCommissioningRequested(CommissioningRequestMetadata metadata);
  }
}

Nous devons maintenant hériter de CommissioningService.Callback et fournir la fonctionnalité requise pour mettre en service les appareils dans notre exemple d'application. Voici un exemple d'implémentation de base de 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())
   }
 }

Étape 1 : Explorez le service AppCommissioningService personnalisé

Pour vous aider à démarrer, nous avons déjà défini la structure de classe de base pour notre CommissioningService personnalisé. Voici un aperçu rapide des fonctionnalités du service. Pour suivre, ouvrez AppCommissioningService dans java/commissioning.

Nous avons ajouté les importations suivantes pour les 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 inclut également des bibliothèques du dépôt Matter (connectedhomeip) :

import com.google.homesampleapp.chip.ChipClient

Enfin, le service inclut des importations pour prendre en charge Hilt et les coroutines Kotlin.

Ensuite, nous créons le constructeur et configurons quelques éléments, y compris commissioningServiceDelegate, que nous utiliserons pour informer les services Google Play lorsque la mise en service est terminée.

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

Il est maintenant temps d'ajouter les fonctions de mise en service.

Étape 2 : Remplacez onCommissioningRequested

Pour mettre en service des appareils dans le tissu de développement de l'application, procédez comme suit :

  1. Ouvrez AppCommissioningService dans java/commissioning.
  2. Localisez la fonction onCommissioningRequested(). Nous avons fourni un message de journal qui affiche le CommissioningRequestMetadata. Remplacez le commentaire // CODELAB: onCommissioningRequested() pour démarrer la coroutine serviceScope et obtenir deviceId.
    // Perform commissioning on custom fabric for the sample app.
serviceScope.launch {
  val deviceId = devicesRepository.incrementAndReturnLastDeviceId()
  3. Effectuez la mise en service. Pour cette étape, nous pouvons transmettre les informations sur l'appareil renvoyées dans l'objet CommissioningRequestMetadata. ChipClient utilise ces informations de métadonnées pour créer un canal sécurisé entre l'application GHSA pour Matter et votre appareil.
    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. Utilisez commissioningServiceDelegate pour indiquer aux services Google Play que la mise en service est terminée. Dans .sendCommissioningComplete(), transmettez 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")
    }
}

Exécuter l'application

Maintenant que tout le code requis est en place pour la mise en service dans notre réseau local, il est temps de le tester. Choisissez votre appareil Android et exécutez l'application. Sur l'écran d'accueil, appuyez sur Ajouter un appareil et suivez la procédure pour mettre en service votre appareil.

Une fois la mise en service terminée, votre appareil participe désormais à deux fabrics : le fabric Android local et votre fabric de développement local. Chaque tissu possède son propre ensemble d'identifiants et un ID de tissu unique de 64 bits.

6. Contrôler des appareils

L'association à un réseau de développement vous permet d'utiliser les bibliothèques du dépôt Matter (connectedhomeip) pour contrôler les appareils à partir de l'application exemple.

Nous avons créé des classes d'assistance pour faciliter l'accès aux clusters d'appareils et l'envoi de commandes. Pour en savoir plus, ouvrez ClustersHelper dans java/clusters. Cet utilitaire Singleton importe les bibliothèques suivantes pour accéder aux informations sur l'appareil :

import chip.devicecontroller.ChipClusters
import chip.devicecontroller.ChipStructs

Nous pouvons utiliser cette classe pour obtenir le cluster On/Off d'un appareil, puis appeler .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)
              }
            })
  }
}

Activer/Désactiver un appareil

Une fois un appareil mis en service, la charge utile renvoyée dans CommissioningResult est ajoutée au DataStore. Cela permet à notre application d'accéder aux informations de l'appareil que nous pouvons utiliser pour envoyer des commandes.

Les applications Matter sont basées sur des événements. Lorsque la pile Matter est initialisée, les services de cluster écoutent les messages entrants. Une fois un appareil mis en service, les clients Matter envoient des commandes sur le canal opérationnel sécurisé établi lors de la mise en service de l'appareil.

Sur l'appareil, les paquets sont validés, déchiffrés, puis distribués avec un rappel. Les fonctions de rappel incluent EndpointId, ClusterId et AttributeId, accessibles depuis attributePath. Par exemple, ce code peut être implémenté sur un appareil 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;
}

Au cours des prochaines étapes, vous utiliserez le SDK Matter et ClustersHelper pour activer ou désactiver un appareil.

  1. Accédez à DeviceViewModel dans java/screens/device.
  2. Localisez la fonction updateDeviceStateOn.
  3. Remplacez le commentaire // CODELAB: toggle par le code permettant d'appeler clustersHelper, puis mettez à jour le dépôt de l'appareil :
    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")
    }

Cette fonction est appelée à partir de DeviceScreen :

// On/Off Switch click.
val onOnOffClick: (value: Boolean) -> Unit = { value ->
  deviceViewModel.updateDeviceStateOn(deviceUiModel!!, value)
}

Exécuter l'application

Exécutez l'application pour recharger vos mises à jour. Sur l'écran d'accueil, activez ou désactivez votre appareil.

7. Partager des appareils avec d'autres écosystèmes

Le partage d'un appareil est appelé flux multi-administrateur dans la spécification Matter.

Dans les étapes précédentes, nous avons appris que le SDK Home Mobile permet de mettre en service des appareils sur le réseau local Android et sur un réseau de développement pour l'application exemple. Il s'agit d'un exemple de flux multi-administrateur, dans lequel les appareils peuvent être mis en service sur plusieurs réseaux.

Vous pouvez désormais partager des appareils avec encore plus de tissus, en particulier si vous vivez dans une maison où chacun a ses propres préférences en matière d'applications et de plates-formes.

Le SDK Home Mobile fournit cette fonctionnalité dans l'API ShareDeviceRequest, ce qui vous permet de :

  1. Ouvrez une fenêtre de mise en service temporaire pour les appareils.
  2. Modifiez l'état de vos appareils pour qu'ils puissent être mis en service dans un autre réseau.
  3. Contrôlez vos appareils depuis d'autres applications et écosystèmes.

Au cours des prochaines étapes, vous utiliserez le SDK Home Mobile pour partager des appareils.

Étape 1 : Créez un lanceur d'activité GPS

Comme pour le lanceur d'activité de mise en service que nous avons créé lors de la mise en service sur un tissu de développement, nous avons créé un lanceur d'activité de partage d'appareil pour gérer IntentSender à partir de l'API CommissioningClient.

  1. Ouvrez DeviceScreen dans le dossier java/com/google/homesampleapp/screens/device/.
  2. Remplacez le commentaire // CODELAB: shareDeviceLauncher definition par le code suivant pour enregistrer et gérer le résultat de l'activité .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)
  }
}

Étape 2 : Déclenchez l'action de partage de l'appareil

Dans cette étape, l'utilisateur déclenche l'action "Partager l'appareil" en cliquant sur le bouton "Partager" sur l'écran de l'appareil. Un appel est ensuite effectué à deviceViewModel pour ouvrir une fenêtre d'association pour le partage d'appareils.

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

Une fois la fenêtre d'association ouverte, deviceViewModel communique cette information à l'UI. La communication entre le ViewModel et l'UI s'effectue via des objets StateFlow.

// Communicate to the UI that the pairing window is open.
// UI can then launch the GPS activity for device sharing.
_pairingWindowOpenForDeviceSharing.value = true

Lorsque DeviceScreen constate la modification de l'objet StateFlow, il effectue l'appel suivant :

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

Étape 3 : Appeler l'API

Il est maintenant temps de lancer une tâche de partage d'appareil.

  1. Ouvrez DeviceScreen.kt dans le dossier java/com/google/homesampleapp/screens/device/.
  2. Localisez la fonction shareDevice(). Remplacez le commentaire // CODELAB: shareDevice par ShareDeviceRequest. Le DeviceDescriptor fournit des informations spécifiques sur l'appareil, telles que son ID de fournisseur, son ID de produit et son type d'appareil. Dans cet exemple, nous codons en dur les valeurs.
    val shareDeviceRequest =
  ShareDeviceRequest.builder()
    .setDeviceDescriptor(DeviceDescriptor.builder().build())
    .setDeviceName("GHSAFM temp device name")
  3. Définissez les paramètres 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. Appelez .getCommissioningClient(), mais cette fois-ci, utilisez l'API .shareDevice().
    Matter.getCommissioningClient(context)
    .shareDevice(shareDeviceRequest)

Le rappel de réussite de l'API commissioningClient.shareDevice() fournit l'IntentSender à utiliser pour lancer le partage de l'activité de l'appareil dans les services Google Play.

  1. Pour terminer notre fonction shareDevice, ajoutez un addOnSuccessListener et un addOnFailureListener. En cas de réussite, launch est appelé sur shareDeviceLauncher pour lancer l'activité GPS pour le partage d'appareils.
        .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())
    }

Exécuter l'application

Pour partager votre appareil Matter avec d'autres écosystèmes, vous devez avoir installé une autre plate-forme sur votre appareil Android. Nous avons créé une autre instance de l'application exemple que vous pouvez utiliser comme commissaire cible.

Une fois le commissaire cible installé sur votre appareil Android, vérifiez que vous pouvez partager votre appareil Matter. L'application du commissaire cible est intitulée GHSAFM-TC.

Vos appareils peuvent désormais participer à trois tissus :

  1. Fabric Android local.
  2. Votre structure de développement (cette application).
  3. Ce troisième réseau avec lequel vous venez de partager l'appareil.

8. Étapes suivantes

Félicitations

Félicitations, vous avez terminé cet atelier de programmation et appris à mettre en service et à partager des appareils à l'aide du SDK Home Mobile.

Si vous rencontrez des problèmes avec l'application exemple, essayez de suivre les étapes pour valider votre environnement :

Si vous avez des questions sur l'utilisation de l'application exemple ou si vous découvrez un bug dans le code, vous pouvez envoyer des problèmes à l'outil de suivi des problèmes dans le dépôt GitHub :

Pour obtenir des conseils officiels de Google sur les questions techniques, utilisez le forum des développeurs pour la maison connectée :

Pour obtenir une assistance technique de la communauté, utilisez le tag google-smart-home sur Stack Overflow :