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 divers é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'exemple d'application Google Home pour Matter (GHSA pour Matter) présente les API Home Mobile SDK, qui permettent aux utilisateurs de commander 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 commander et partager des appareils. Vous apprendrez également à utiliser les bibliothèques de mise en service et de cluster 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 Home Mobile SDK suivantes:

Vous en apprendrez également davantage 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 d'un 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 à 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 de l'atelier de programmation

La branche codelab comporte un tag correspondant à la version 2.0.0 de l'application exemple. Pour comparer vos mises à jour à chaque étape, vous pouvez télécharger le code source finalisé pour 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 allons vous guider à 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 ajouterons la fonctionnalité Matter aux fichiers suivants:

  • java/commissioning/AppCommissioningService: vous permet de mettre en service des appareils dans la structure de développement.
  • java/screens/home/HomeScreen et java/screens/home/HomeViewModel.kt: incluent la fonctionnalité de mise en service du SDK Home Mobile
  • java/screens/device/DeviceScreen et java/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

Pour que vous puissiez contrôler des appareils et les autoriser à communiquer entre eux au sein de la 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 responsables de l'émission de certificats racine de confiance, ainsi que de l'attribution d'ID de fabric et d'ID de nœuds uniques. Un écosystème est le service backend d'un commissaire, par exemple le Home Graph pour l'écosystème Google Home.
  • Les appareils peuvent être mis en service sur plusieurs data 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 passerons en revue le minimum de code requis pour commander des appareils dans la data fabric Google.

Étape 1: Lanceur d'activités

Pour gérer le IntentSender à partir de CommissioningClient, vous pouvez utiliser 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 de la data fabric 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 ne sont mis en service que sur la plate-forme 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é de l'appareil de 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 plate-forme Android Fabric locale peut être utilisée via les paramètres Android pour simplifier la mise en service de ses appareils sur d'autres data fabrics.

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

Pour découvrir l'interface utilisateur lors du processus de mise en service, consultez le guide exemple d'application Google Home pour Matter.

4. Engagement à une plate-forme de développement

Les appareils peuvent être mis en service sur plusieurs plates-formes. Pour gérer les associations approuvées, les appareils stockent un FabricTable contenant différents membres FabricInfo, par exemple:

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

L'administrateur de domaine administratif (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 commandez des appareils à la plate-forme Android locale, chaque appareil inclut le même ensemble d'identifiants de data fabric et le même ensemble d'autorités de certification.

Services de mise en service personnalisée

Pour effectuer une commission sur la plate-forme Android locale, 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 à partir de votre application, vous devez créer une structure de développement locale et obtenir les identifiants opérationnels nécessaires pour mettre les appareils en service. 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 à votre propre infrastructure en transmettant un service personnalisé à CommissioningRequest:

class CommissioningRequest {
  static CommissioningRequest.Builder builder();

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

    CommissioningRequest build();
  }
}

Dans les é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és pour gérer IntentSender à partir de l'API CommissioningClient.

  1. Ouvrez HomeScreen dans le dossier java/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 "Commission sur l'appareil"

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

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

Étape 3: Appelez l'API

  1. Toujours dans HomeScreen.kt, dans le dossier java/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 commissionne d'abord les appareils vers la plate-forme locale 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 terminer la fonction commissionDevice, ajoutez addOnSuccessListener et addOnFailureListener:

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

5. Créer un service CommissioningService

Dans la fonction commissionDevice(), nous avons demandé à obtenir un CommissioningService à partir de l'API CommissioningClient. Dans ce flux, l'API CommissioningClient envoie d'abord les appareils à la plate-forme Android locale, puis renvoie un rappel qui inclut l'objetCommissioningRequestMetadata:

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

Nous devons maintenant hériter du service CommissioningService.Callback et fournir la fonctionnalité requise pour commander des appareils à 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 le service AppCommissioningService personnalisé

Pour vous aider à démarrer, nous avons déjà défini la structure de classe de base pour notre service CommissioningService personnalisé. Voici un aperçu rapide de la fonctionnalité 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 les bibliothèques du dépôt Matter (connectedhomeip):

import com.google.home_sample_app_for_matter.chip.ChipClient

Enfin, le service inclut des importations pour prendre en charge 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()

Vous allez maintenant ajouter les fonctions de mise en service.

Étape 2: Ignorez 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 une mise en service. Pour cette étape, nous pouvons transmettre les informations sur l'appareil renvoyées dans l'objetCommissioningRequestMetadata. 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 tissu local, il est temps de le tester. Sélectionnez votre appareil Android, puis exécutez l'application. Depuis l'écran d'accueil, appuyez sur Ajouter un appareil, puis suivez les étapes pour mettre en service votre appareil.

Une fois la mise en service terminée, votre appareil fait désormais partie de deux fabrications: la plate-forme Android locale et votre plate-forme de développement local. Chaque structure possède son propre ensemble d'identifiants et un identifiant unique de structure 64 bits.

6. Contrôler des appareils

La mise en service d'une plate-forme 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 outil d'aide Singleton importe les bibliothèques suivantes pour accéder aux informations sur les appareils:

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

Après la mise en service d'un appareil, la charge utile renvoyée dans CommissioningResult est ajoutée à DataStore. Cela permet à notre application d'accéder à des informations sur 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 du 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é établi lors de la mise en service.

Sur l'appareil, les paquets sont validés, déchiffrés, puis distribués avec un rappel. Les fonctions de rappel incluent les éléments 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 prochaines étapes, vous utiliserez 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, activez et désactivez votre appareil.

7. Partagez 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 appris que le SDK Home Mobile permet de mettre des appareils en service sur la plate-forme Android locale, ainsi que sur une structure de développement pour l'application exemple. Il s'agit d'un exemple de parcours multi-administrateur, dans lequel les appareils peuvent être mis en service sur plusieurs plates-formes.

À présent, il peut être judicieux de partager des appareils avec encore plus de tissus, en particulier s'il s'agit d'un foyer où les utilisateurs ont leurs propres préférences concernant les applications et les plates-formes.

Le SDK Home Mobile fournit cette fonctionnalité dans l'API ShareDeviceRequest. Vous pouvez ainsi:

  1. Ouvrez une fenêtre de mise en service temporaire pour les appareils.
  2. Modifiez l'état de vos appareils pour les mettre en service sur une autre plate-forme.
  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

À l'instar du 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és de partage de l'appareil pour gérer les IntentSender de l'API CommissioningClient.

  1. Ouvrez DeviceScreen dans le dossier java/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 d'appareil

À cette étape, l'utilisateur déclenche l'action "Share Device" (Partager l'appareil) en cliquant sur le bouton "Share" (Partager) sur l'écran de l'appareil. Un appel est ensuite passé au deviceViewModel pour ouvrir une fenêtre d'association pour le partage d'appareil.

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

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

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

Vous devez maintenant lancer une tâche de partage d'appareil.

  1. Ouvrez DeviceScreen.kt dans le dossier java/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 de 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 la valeur CommissioningWindow et les 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 pour lancer le partage de l'activité de l'appareil dans les services Google Play.

  1. Pour terminer la 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'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 installer 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 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 nom GHSAFM-TC.

Vos appareils peuvent désormais participer à trois fabrications:

  1. Plate-forme Android locale
  2. Votre tissu de développement (cette application).
  3. Le troisième tissu 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, suivez 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 soumettre les problèmes à l'outil Issue Tracker du dépôt GitHub:

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

Pour bénéficier de l'assistance technique de la communauté, utilisez le tag google-smart-home sur Stack Overflow: