Monitorar o estado do dispositivo no Android

Nas APIs Home para Android, a observação de mudanças de estado na casa é feita possível com o uso de fluxos no Kotlin. A observação de mudanças em estruturas, ambientes, metadados e estado de dispositivos nas APIs Home pode ser feita com qualquer API que herde da HomeObjectsFlow interface. Isso é feito coletando do fluxo.

Quando um 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

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 coleções na casa:

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

Acompanhar mudanças em uma estrutura

As seguintes mudanças em uma estrutura acionam essa coleção:

Nome da estrutura

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

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

Acompanhar mudanças em um dispositivo específico

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

Estado de conectividade
Nome do dispositivo
Assinatura do ambiente
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" }!!

Acompanhar mudanças em uma característica específica em um dispositivo

Use qualquer característica compatível com o dispositivo e as APIs Home. Para 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}")
      }
    }

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

Acompanhar mudanças em um ambiente em uma estrutura

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

Área nome
Assinatura da estrutura

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

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 uma das três HomeDevice.events funções, cada uma das quais retorna umFlow<Event>:

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

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

events(trait: TraitFactory<T>) retorna um fluxo de todos os eventos enviados por uma característica:
```
val eventflow = homeDevice.type(DoorLockDevice).first().events(DoorLock)
```

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 entidades

É possível detectar eventos emitidos sempre que uma entidade (como uma estrutura, ambiente, 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 fluxo que produza os eventos desejados, chame o stream() método no HomeObjectsFlow<T> produzido pelo método de fluxo correspondente:

*Tabela: fluxos de eventos*
Entidade	Interface	Método de fluxo
`Structure`	`HasStructures`	`structures()`
`Room`	`HasRooms`	`rooms()`
`HomeDevice`	`HasHomeDevices`	`devices()`
`Automation`	`HasAutomations`	`automations()`

Por exemplo, veja como processar mudanças em 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 -> {}
  }
}