Cómo supervisar el estado del dispositivo en Android

En las APIs de Home para Android, la observación de los cambios de estado en la casa es posible gracias al uso de flujos en Kotlin. La observación de cambios en las estructuras, las habitaciones, los metadatos y el estado de los dispositivos en las APIs de Home se puede realizar con cualquier API que herede de la interfaz HomeObjectsFlow. Para ello, se recopilan datos del flujo.

Cuando se agrega, borra o modifica cualquier elemento de una colección, se devuelve la instantánea más reciente de la colección.

Depende del desarrollador deducir los cambios específicos comparando esta instantánea con una copia anterior. El campo id proporcionado para cada tipo de objeto superior en las APIs de Home se puede usar con este propósito.

Cómo usar los flujos

A continuación, se muestran algunos ejemplos básicos de recopilación de flujos en las APIs de Home. Para los siguientes ejemplos, se debe crear una instancia de Home antes de acceder a las colecciones de la casa:

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

Cómo hacer un seguimiento de los cambios en una estructura

Los siguientes cambios en una estructura activan esta colección:

• Nombre de la estructura

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

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

Realiza un seguimiento de los cambios en un dispositivo específico

Los siguientes cambios en un dispositivo activan esta recopilación:

• Estado de conectividad
• Nombre del dispositivo
• Membresía de la sala
• Es el conjunto de características compatibles.
• Es el conjunto de tipos admitidos.

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" }!!

Realiza un seguimiento de los cambios en un rasgo específico de un dispositivo

Usa cualquier atributo compatible con el dispositivo y las APIs de Home. Para obtener una lista completa, consulta Trait.

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

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

Realiza un seguimiento de los cambios en un tipo específico de un dispositivo

Los siguientes cambios en un tipo de dispositivo activan esta recopilación:

• Cambios en cualquier atributo dentro del tipo de dispositivo generado

Usa cualquier tipo de dispositivo Matter compatible con las APIs de Home. Para obtener una lista completa, consulta DeviceType.

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

Realiza un seguimiento de los cambios en una habitación de una estructura

Los siguientes cambios en una sala activan esta colección:

• Nombre de la sala
• Estructura la membresía

Para hacer un seguimiento de cuándo se agregan o quitan dispositivos de una habitación, usa el flujo de devices().

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

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

Suscríbete a eventos

En las APIs de Home, los eventos se usan para detectar cambios en el estado de un dispositivo.

Para suscribirte a eventos en un dispositivo específico, llama a uno de los tres HomeDevice.Funciones events, cada una de las cuales devuelve un Flow<Event>:

1. events(event: EventFactory<T>) devuelve un flujo para un tipo de evento específico:

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

2. events(trait: TraitFactory<T>) devuelve un flujo de todos los eventos enviados por un atributo:

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

3. events() devuelve un flujo de eventos disponibles para el objeto:

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

Para consumir eventos de un flujo, usa la función flow.collect():

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

Cómo suscribirse a eventos de relación de entidades

Puedes escuchar los eventos que se emiten cada vez que se agrega, quita o actualiza una entidad (como una estructura, una habitación, un dispositivo o una automatización). Estos eventos son instancias de HomeObjectChangeEvent y llevan el ID de la entidad que cambió.

Para adquirir un flujo que produzca los eventos que deseas, llama al método stream() en el HomeObjectsFlow<T> que produce el método Flow correspondiente:

Por ejemplo, a continuación, se muestra cómo puedes controlar los cambios en los dispositivos:

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