Cómo supervisar el estado del dispositivo en Android

En las APIs de Home para Android, observar los cambios de estado en la casa es posible a través del uso de flujos en Kotlin. Observar los cambios en las estructuras, las habitaciones, los metadatos del dispositivo y el estado del dispositivo en las APIs de Home se puede hacer con cualquier API que herede de la interfaz HomeObjectsFlow. Para ello, se debe recopilar desde el flujo.

Cuando se agrega, borra o modifica cualquier elemento de una colección, se muestra 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 que se proporciona para cada tipo de objeto superior en las APIs de Home se puede usar para este fin.

Cómo usar los flujos

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

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

Realiza 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 colección:

• Estado de conectividad
• Nombre del dispositivo
• Membresía de habitación
• El conjunto de traits compatibles
• 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 atributo específico en un dispositivo

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

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

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

Los siguientes cambios en un tipo de dispositivo activan esta colecció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 sala de una estructura

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

• Nombre de la habitación
• Membresía de Structure

Para hacer un seguimiento de cuándo se agregan o quitan dispositivos de una habitación, usa el flujo 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 muestra unFlow<Event>:

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

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

2. events(trait: TraitFactory<T>) muestra un flujo de todos los eventos que envía un atributo:

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

3. events() muestra 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
  }
}

Suscríbete a eventos de relación de entidades

Puedes detectar 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 una transmisión que produzca los eventos que deseas, llama al método stream() en el HomeObjectsFlow<T> que produce el método de flujo 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 -> {}
  }
}