Créer une application Android pour Matter

1. Bienvenue

Conçu dans le but d'unifier les normes IoT, Matter connecte les appareils connectés de différents écosystèmes tels que Google Home, Zigbee, Bluetooth Mesh, Z-Wave et plus encore.

Les appareils mobiles constituent un point d'interaction central avec les appareils connectés. Si vous souhaitez créer vos propres applications Android compatibles avec les appareils Matter, nous pouvons vous aider à vous lancer rapidement.

L'application exemple Google Home pour Matter (GHSA pour Matter) présente les API du SDK Home Mobile, qui permettent aux utilisateurs de mettre en service 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 pour déboguer et résoudre les problèmes liés aux 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 à partir du dépôt Matter (connectedhomeip).

Une fois que vous aurez téléchargé l'application exemple, nous examinerons le code source dans Android Studio et implémenterons les API du SDK Home Mobile suivantes:

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

Prérequis

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

Vous n'avez pas besoin de hub, comme Google Nest Hub (2e génération), pour mettre en service et contrôler les 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 à utiliser le code source de l'atelier de programmation, vous pouvez télécharger le fichier ZIP.

Télécharger le fichier ZIP

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

Versions des ateliers de programmation

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

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

Dépendances

Nous allons vous guider à travers le code source requis pour partager et mettre en service les appareils. Toutefois, 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 pour la structure 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: inclut les appels d'API Share Device

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

// CODELAB: add commissioningFunction()

Vous pouvez ainsi localiser rapidement la section correspondante dans l'atelier de programmation.

3. Commission vers Google

Avant de pouvoir contrôler des appareils et leur permettre de communiquer entre eux au sein d'une même structure, ils doivent être commandés par un commissaire. Dans le cas présent, il s'agit de l'application exemple Google Home pour Matter.

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

  • Les tissus permettent aux appareils de communiquer entre eux.
  • Les Fabrics gèrent un ensemble partagé d'identifiants uniques.
  • Les écosystèmes sont chargés d'émettre des certificats racine de confiance, d'attribuer des ID de tissu et d'attribuer des ID de nœud uniques. Un écosystème est le service backend d'un commissaire, comme le Home Graph pour l'écosystème Google Home.
  • Les appareils peuvent être mis en service sur plusieurs modèles (fonctionnalité multi-administrateur).

Pour mettre un appareil en service, 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 examinerons le code minimal requis pour mettre en service des appareils dans la structure Google.

Étape 1: Lanceur d'activités

Pour gérer IntentSender à partir de 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 la structure Google.

  1. Le processus de mise en service commence par la fonction commissionDevice(). Tout d'abord, un élément CommissioningRequest est défini. Avec cette configuration par défaut, les appareils sont mis en service uniquement pour la structure Android locale.
  2. Matter est le point d'entrée du SDK Home Mobile. Dans l'appel suivant, .getCommissioningClient obtient un CommissioningClient par this (Activity).
  3. .commissionDevice() accepte les CommissioningRequest.
  4. Enfin, .addOnSuccessListener est appelé pour traiter CommissioningResult et lancer l'activité Appareil de la commission 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())
        }
}

La structure Android locale peut être exploitée via les paramètres Android pour simplifier le processus de mise en service de ses appareils sur d'autres tissus.

Vous allez maintenant apprendre à mettre en service un appareil pour une structure de développement.

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

4. Commission à une structure de développement

Les appareils peuvent être mis en service pour plusieurs tissus. Pour gérer les associations de confiance, les appareils stockent un FabricTable contenant divers membres FabricInfo, par exemple:

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

Le gestionnaire de domaine d'administration (ADM) définit les identifiants de la structure. Dans le scénario précédent, les services Google Play constituent l'écosystème qui agit en tant qu'autorité de certification racine de confiance. Lorsque vous mettez des appareils en service dans la structure Android locale, chaque appareil inclut le même ensemble d'identifiants de la structure et le même ensemble d'autorités de certification.

Services de mise en service personnalisés

Pour mettre en service la structure Android locale, nous avons utilisé les paramètres par défaut afin de 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 une structure de développement local et obtenir les identifiants opérationnels nécessaires à la mise en service des 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 indiquer au SDK Home Mobile que vous souhaitez mettre en service des appareils pour votre propre structure en transmettant un service personnalisé à CommissioningRequest:

class CommissioningRequest {
  static CommissioningRequest.Builder builder();

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

    CommissioningRequest build();
  }
}

Au cours des étapes suivantes, nous allons modifier la fonction commissionDevice() pour utiliser un service personnalisé. Nous allons également ajouter un lanceur d'activités au fragment Home et utiliser des objets LiveData pour gérer le flux de l'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 "Commissions sur l'appareil"

À cette étape, l'utilisateur déclenche l'action "Commission Device" (Appareil de la commission). en cliquant sur le signe "+" en bas à droite de l'écran d'accueil. Un appel est ensuite passé à commissionDevice().

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

Étape 3: Appelez l'API

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

Pour terminer notre fonction commissionDevice, ajoutez addOnSuccessListener et 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 auprès de l'API CommissioningClient. Dans ce flux, l'API CommissioningClient commande d'abord les appareils à la structure Android locale, 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 des appareils dans notre application exemple. 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 l'AppCommissioningService personnalisé

Pour vous aider à démarrer, nous avons déjà défini la structure de classe de base de notre service 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 du 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 inclut également des bibliothèques du dépôt Matter (connectedhomeip):

import com.google.homesampleapp.chip.ChipClient

Enfin, le service inclut des importations compatibles avec Hilt et les coroutines Kotlin.

Nous allons ensuite créer le constructeur et configurer quelques éléments, y compris commissioningServiceDelegate, que nous utiliserons pour indiquer aux services Google Play une fois la mise en service 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: Ignorer onCommissioningRequested

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

  1. Ouvrir AppCommissioningService dans java/commissioning.
  2. Recherchez la fonction onCommissioningRequested(). Nous avons fourni un message de journal qui affiche CommissioningRequestMetadata. Remplacez le commentaire // CODELAB: onCommissioningRequested() pour démarrer la coroutine serviceScope et obtenir le 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. Le ChipClient utilise ces 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 le 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 de notre structure locale, il est temps de le tester. Sélectionnez votre appareil Android et exécutez l'application. Sur l'écran d'accueil, appuyez sur Ajouter un appareil, puis suivez les étapes pour mettre votre appareil en service.

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

6. Contrôler des appareils

La mise en service d'une structure de développement vous permet d'utiliser les bibliothèques du dépôt Matter (connectedhomeip) pour contrôler les appareils 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 outil d'aide Singleton importe les bibliothèques suivantes pour accéder aux informations de 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

Lorsque vous mettez un appareil en service, la charge utile renvoyée dans CommissioningResult est ajoutée au DataStore. Notre application peut ainsi accéder aux informations provenant de l'appareil que nous pouvons utiliser pour envoyer des commandes.

Les applications Matter sont basées sur des événements. Une fois la pile Matter initialisée, les services de cluster écoutent les messages entrants. Une fois qu'un appareil est mis en service, les clients Matter envoient des commandes via le canal opérationnel sécurisé qui a été é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 à partir de 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 étapes suivantes, vous allez utiliser le SDK Matter et ClustersHelper pour activer/désactiver un appareil.

  1. Accédez à DeviceViewModel dans java/screens/device.
  2. Recherchez la fonction updateDeviceStateOn.
  3. Remplacez le commentaire // CODELAB: toggle par le code pour 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 actualiser vos mises à jour. Depuis l'écran d'accueil, allumez et éteignez 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.

Au cours des étapes précédentes, nous avons découvert que le SDK Home Mobile permet de mettre en service des appareils pour la structure Android locale, ainsi que pour la structure de développement de l'application exemple. Il s'agit d'un exemple de flux multi-administrateur, dans lequel les appareils peuvent être mis en service sur plusieurs modèles.

Désormais, vous souhaiterez peut-être partager des appareils avec encore plus de tissus, surtout s'il s'agit d'un foyer où les utilisateurs ont leurs propres préférences en matière d'applications et de plates-formes.

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

  1. Ouvrez une période de mise en service temporaire pour les appareils.
  2. Modifier l'état de vos appareils afin qu'ils puissent être mis en service sur un autre tissu.
  3. Contrôlez vos appareils depuis d'autres applications et écosystèmes.

Au cours des étapes suivantes, vous allez utiliser le SDK Home Mobile pour partager des appareils.

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

Semblable au lanceur d'activités de mise en service que nous avons créé lorsque nous avons fait appel à une structure de développement, nous avons créé un lanceur d'activité "Partager l'activité de l'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

À 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 passé à deviceViewModel afin d'ouvrir une fenêtre d'association pour le partage d'appareil.

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

Une fois la fenêtre d'association ouverte, deviceViewModel le communique à l'UI. La communication entre ViewModel et l'interface utilisateur 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

Après avoir constaté la modification de l'objet StateFlow, DeviceScreen effectue l'appel suivant:

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

Étape 3: Appelez 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. Recherchez la fonction shareDevice(). Remplacez le commentaire // CODELAB: shareDevice par ShareDeviceRequest. Le DeviceDescriptor fournit des informations spécifiques sur l'appareil, telles que son ID fournisseur, son ID produit et son type d'appareil. Dans cet exemple, nous codons les valeurs en dur.
    val shareDeviceRequest =
  ShareDeviceRequest.builder()
    .setDeviceDescriptor(DeviceDescriptor.builder().build())
    .setDeviceName("GHSAFM temp device name")
  3. Définissez CommissioningWindow et vos paramètres.
        .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 addOnSuccessListener et addOnFailureListener. En cas de réussite, launch est appelé sur shareDeviceLauncher pour lancer l'activité GPS pour le partage d'appareil.
        .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 installer une autre plate-forme sur votre appareil Android. Nous avons créé une autre instance de l'application exemple que vous pouvez utiliser en tant que commissaire cible.

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

Vos appareils peuvent désormais participer aux trois fabricants suivants:

  1. Plate-forme Android locale
  2. Votre structure de développement (cette application).
  3. La troisième structure avec laquelle 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 ci-dessous pour vérifier votre environnement:

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

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

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