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 estructuras, habitaciones, metadatos de dispositivos y estado de dispositivos en las APIs de Home se puede realizar con cualquier API que herede de la HomeObjectsFlow interfaz. Esto se hace recopilando datos del 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.

El desarrollador debe 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 propósito.

Cómo usar flujos

A continuación, se muestran algunos ejemplos básicos de recopilación de datos 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)

Haz un seguimiento de los cambios en una estructura

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

• Nombre de la estructura name

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

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

Haz 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 la habitación
• El conjunto de características compatibles
• El conjunto de tipos compatibles

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

Haz un seguimiento de los cambios en una característica específica de un dispositivo

Usa cualquier característica 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}")
      }
    }

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

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

• Cambios en cualquier característica 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}")
}

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

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

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

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

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 una de las tres HomeDevice.events funciones, 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 una característica:

   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 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 contienen el ID de la entidad que cambió.

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

Por ejemplo, así 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 -> {}
  }
}