Surveiller l'état de l'appareil sur Android

Dans les API Home pour Android, l'observation des changements d'état dans la maison est possible grâce à l'utilisation de flux en Kotlin. Vous pouvez observer les changements dans les structures, les pièces, les métadonnées des appareils et l'état des appareils dans les API Home avec n'importe quelle API héritant de l'interface HomeObjectsFlow. Pour ce faire, collectez à partir du flux.

Lorsqu'un élément d'une collection est ajouté, supprimé ou modifié, le dernier instantané de la collection est renvoyé.

Il incombe au développeur de déduire les modifications spécifiques en comparant cet instantané avec une copie plus ancienne. Le champ id fourni pour chaque type d'objet parent dans les API Home peut être utilisé à cette fin.

Utiliser les flux

Vous trouverez ci-dessous quelques exemples de base de collecte à partir de flux dans les API Home. Pour les exemples suivants, une instance de Home doit être créée avant d'accéder aux collections dans la page d'accueil :

val context = LocalContext.current
val homeManager = Home.getClient(context)

Suivre les modifications apportées à une structure

Les modifications suivantes apportées à une structure déclenchent cette collecte :

• Nom de la structure

homeManager.structures().map { it.firstOrNull() }.collect {
  println("Structure ${it.id} updated to ${it}")
}

val structure =  homeManager.structures().list().firstOrNull()!!

Suivre les modifications apportées à un appareil spécifique

Les modifications suivantes apportées à un appareil déclenchent cette collecte :

• État de la connectivité
• Nom de l'appareil
• Abonnement Room
• Ensemble de traits compatibles
• Ensemble des types acceptés

structure
  .devices()
  .map { devices -> device.filter { it.name == "Bedroom Lamp" }.single() }
  .collect {
    println("The bedroom lamp has changed!")
  }

val device = structure.devices().list().firstOrNull { it.name == "Bedroom Lamp" }!!

Suivre les modifications apportées à un trait spécifique sur un appareil

Utilisez n'importe quel trait compatible avec l'appareil et les API Home. Pour obtenir la liste complète, consultez Trait.

    val trait = device.type(DimmableLightDevice)?.map { it.trait(OnOff)}.first()

    trait?.collect {
      if (it != null) {
        println("Got new state update! ${it.onOff}")
      }
    }

Suivre les modifications apportées à un type spécifique sur un appareil

Les modifications suivantes apportées à un type d'appareil déclenchent cette collecte :

• Modifications apportées à un trait dans le type d'appareil généré

Utilisez n'importe quel type d'appareil Matter compatible avec les API Home. Pour obtenir la liste complète, consultez DeviceType.

device.type(DimmableLightDevice).collect { type ->
    println("Got new state update! ${type.trait(LevelControl)?.currentLevel}")
}

Suivre les modifications apportées à une pièce dans une structure

Les modifications suivantes apportées à un salon déclenchent cette collecte :

• Nom de la pièce
• Abonnement Structure

Pour savoir quand des appareils sont ajoutés à une pièce ou en sont supprimés, utilisez le flux devices().

structure.rooms().collect {
  println("Got a new updated set of rooms!")

  for (room in it) {
    println("Got room $room")
  }
}

S'abonner à des événements

Dans les API Home, les événements sont utilisés pour détecter les changements d'état d'un appareil.

Pour vous abonner à des événements sur un appareil spécifique, appelez l'une des trois méthodes HomeDevice.events fonctions, chacune renvoyant unFlow<Event> :

1. events(event: EventFactory<T>) renvoie un flux pour un type d'événement spécifique :

   val eventFlow = homeDevice.type(DoorLockDevice).first().events(DoorLock.DoorLockAlarmEvent)
   

2. events(trait: TraitFactory<T>) renvoie un flux de tous les événements envoyés par un trait :

   val eventflow = homeDevice.type(DoorLockDevice).first().events(DoorLock)
   

3. events() renvoie un flux d'événements disponibles pour l'objet :

   val eventflow = homeDevice.type(DoorLockDevice).first().events()
   

Pour consommer des événements à partir d'un flux, utilisez la fonction flow.collect() :

eventflow.collect { event ->
  if (event != null) {
    logger.atInfo().log("Received event %s", event)
    // do something
  }
}

S'abonner aux événements de relation entre entités

Vous pouvez écouter les événements émis chaque fois qu'une entité (telle qu'une structure, une pièce, un appareil ou une automatisation) est ajoutée, supprimée ou mise à jour. Ces événements sont des instances de HomeObjectChangeEvent et comportent l'ID de l'entité qui a été modifiée.

Pour acquérir un flux qui produit les événements souhaités, appelez la méthode stream() sur le HomeObjectsFlow<T> produit par la méthode Flow correspondante :

Voici, par exemple, comment gérer les modifications apportées aux appareils :

val devicesStream = home.devices().stream()

// Collect and react to device changes.
devicesStream.collect { deviceEvent ->
  when (deviceEvent) {
    is HomeObjectAddedEvent ->
      println("New device now available with id: ${deviceEvent.id}")
    is HomeObjectUpdatedEvent -> println("Device ${deviceEvent.id} has been updated")
    is HomeObjectRemovedEvent -> println("Device is removed from your account")
    else -> {}
  }
}