Surveiller l'état de l'appareil sur Android

Dans les API Home pour Android, l'observation des modifications apportées à l'état de la maison est rendue possible grâce à l'utilisation de flux en Kotlin. L'observation des modifications apportées aux structures, aux pièces, aux métadonnées des appareils et à l'état des appareils dans les API Home peut être effectuée avec n'importe quelle API héritant de l' HomeObjectsFlow interface. Pour ce faire, vous devez collecter à partir du flux.

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

Il appartient 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 des flux

Voici 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 de la maison :

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

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

État de la connectivité
Nom de l'appareil
Abonnement à une pièce
Ensemble de traits compatibles traits
Ensemble de types compatibles types

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

Modifications apportées à un trait du type d'appareil généré

Utilisez n'importe quel Matter type d'appareil 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 à une pièce déclenchent cette collection :

Nom de la pièce
Abonnement à une structure

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

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 permettent de détecter les modifications apportées à l'état d'un appareil.

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

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

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

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)
```

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 à des événements de relation d'entité

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 contiennent l'ID de l'entité qui a changé.

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

*Tableau : Flux d'événements*
Entité	Interface	Méthode de flux
`Structure`	`HasStructures`	`structures()`
`Room`	`HasRooms`	`rooms()`
`HomeDevice`	`HasHomeDevices`	`devices()`
`Automation`	`HasAutomations`	`automations()`

Par exemple, voici 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 -> {}
  }
}