Monitorar o estado do dispositivo no Android

Nas APIs Home para Android, é possível observar mudanças no estado da casa usando fluxos em Kotlin. É possível observar mudanças em estruturas, ambientes, metadados de dispositivos e estados de dispositivos nas APIs Home com qualquer API que herde da interface HomeObjectsFlow. Isso é feito coletando do fluxo.

Quando qualquer item em uma coleção é adicionado, excluído ou modificado, o snapshot mais recente da coleção é retornado.

Cabe ao desenvolvedor deduzir as mudanças específicas comparando esse snapshot com uma cópia mais antiga. O campo id fornecido para cada tipo de objeto pai nas APIs Home pode ser usado para essa finalidade.

Como usar fluxos

Confira a seguir alguns exemplos básicos de coleta de fluxos nas APIs Home. Para os exemplos a seguir, uma instância de Home precisa ser criada antes de acessar as coleções na casa:

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

Rastrear mudanças em uma estrutura

As seguintes mudanças em uma estrutura acionam essa coleta:

• Nome da estrutura

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

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

Rastrear mudanças em um dispositivo específico

As seguintes mudanças em um dispositivo acionam essa coleta:

• Estado de conectividade
• Nome do dispositivo
• Participação em espaços
• O conjunto de características compatíveis
• O conjunto de tipos compatíveis.

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

Rastrear mudanças em um atributo específico em um dispositivo

Use qualquer atributo compatível com o dispositivo e as APIs Home. Para ver uma lista completa, consulte Trait.

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

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

Rastrear mudanças em um tipo específico em um dispositivo

As seguintes mudanças em um tipo de dispositivo acionam essa coleção:

• Mudanças em qualquer atributo no tipo de dispositivo gerado

Use qualquer tipo de dispositivo Matter compatível com as APIs Home. Para uma lista completa, consulte DeviceType.

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

Rastrear mudanças em um ambiente de uma estrutura

As seguintes mudanças em um espaço acionam essa coleção:

• Nome do ambiente
• Assinatura do Structure

Para monitorar quando os dispositivos são adicionados ou removidos de um ambiente, use o fluxo devices().

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

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

Inscrever-se em eventos

Nas APIs Home, os eventos são usados para detectar mudanças no estado de um dispositivo.

Para se inscrever em eventos em um dispositivo específico, chame um dos três HomeDevice.events, que retornam um Flow<Event>:

1. events(event: EventFactory<T>) retorna um fluxo para um tipo específico de evento:

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

2. events(trait: TraitFactory<T>) retorna um fluxo de todos os eventos enviados por um atributo:

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

3. events() retorna um fluxo de eventos disponíveis para o objeto:

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

Para consumir eventos de um fluxo, use a função flow.collect():

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

Inscrever-se em eventos de relação de entidade

É possível detectar eventos emitidos sempre que uma entidade (como uma estrutura, sala, dispositivo ou automação) é adicionada, removida ou atualizada. Esses eventos são instâncias de HomeObjectChangeEvent e carregam o ID da entidade que mudou.

Para adquirir um stream que produza os eventos que você quer, chame o método stream() no HomeObjectsFlow<T> produzido pelo método Flow correspondente:

Por exemplo, veja como lidar com mudanças nos 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 -> {}
  }
}