Nas APIs Home para Android, é possível observar mudanças de estado na casa
usando
fluxos
no Kotlin. É possível observar mudanças em estruturas, cômodos, metadados do dispositivo e
estado do dispositivo nas APIs Home com qualquer API que herda a
interface
HomeObjectsFlow
. Isso é feito com a
coleta do fluxo.
Quando qualquer item de 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
instantâneo 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 do Home
precisa ser criada antes
de acessar as coleções na casa:
val context = LocalContext.current
val homeManager = Home.getClient(context)
Rastrear alterações em uma estrutura
As seguintes mudanças em uma estrutura acionam essa coletânea:
- 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 coleção:
- Estado de conectividade
- Nome do dispositivo
- Assinatura do espaço
- O conjunto de características com suporte
- O conjunto de tipos com suporte
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 recurso específico em um dispositivo
Use qualquer recurso compatível com o dispositivo e as APIs Home. Para uma lista completa, consulte
Trait
.
device.trait(OnOff).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 recurso no tipo de dispositivo gerado
Use qualquer tipo de dispositivo Matter com suporte das APIs do Google Home. Para
ver uma lista completa, consulte DeviceType
.
device.type(DimmableLightDevice).collect { type ->
println("Got new state update! ${type.trait(LevelControl)?.currentLevel}")
}
Acompanhar as mudanças em uma sala em uma estrutura
As seguintes mudanças em uma sala acionam essa coletânea:
- nome da sala
- Assinatura Structure
Para acompanhar 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 assinar eventos em um dispositivo específico, chame uma das três
HomeDevice
.Funções events
, cada uma retornando 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 um atributo: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 entidade
É possível detectar eventos que são 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 contêm 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 de fluxo correspondente:
Entidade | Interface | Método de fluxo |
---|---|---|
Structure
|
HasStructures
|
structures()
|
Room
|
HasRooms
|
rooms()
|
HomeDevice
|
HasHomeDevices
|
devices()
|
Automation
|
HasAutomations
|
automations()
|
Por exemplo, veja como é possível 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 -> {} } }