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, salas, metadados de dispositivos e estado do dispositivo nas APIs Home com qualquer API que herde da interface HomeObjectsFlow. 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 este snapshot com uma cópia mais antiga. O campo id fornecido para cada tipo de objeto principal nas APIs Home pode ser usado para essa finalidade.

Como usar fluxos

A seguir, apresentamos alguns exemplos básicos de coleta de fluxos nas APIs Home. Nos 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)

Rastrear mudanças em uma estrutura

As seguintes mudanças em uma estrutura acionam esta 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 da conectividade
• Nome do dispositivo
• Assinatura do espaço
• 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 uma característica específica de 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}")
      }
    }

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

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

• Mudanças em qualquer característica no tipo de dispositivo gerado

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

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

Rastrear mudanças em um quarto em uma estrutura

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

• Nome da sala
• Assinatura Structure

Para acompanhar quando 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 assinar eventos em um dispositivo específico, chame uma das três HomeDevice.Funções events, cada uma retornando 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 traço:

   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

Você pode 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 desejados, 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 -> {}
  }
}