Surveiller l'état de l'appareil sur Android

Dans les API Home pour Android, l'observation des modifications de l'état de la maison est 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'interface HomeObjectsFlow. Pour ce faire, collectez les données à 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é à 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 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:

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.

device.trait(OnOff).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:

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 d'une structure

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

Pour suivre l'ajout ou la suppression d'appareils dans une pièce, 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.Fonctions events, chacune renvoyant un Flow<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 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 modifiée. Ces événements sont des instances de HomeObjectChangeEvent et portent l'ID de l'entité 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:

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 -> {}
  }
}