Monitorare lo stato del dispositivo su Android

Nelle API Home per Android, l'osservazione delle modifiche allo stato della casa è resa possibile grazie all'utilizzo dei flussi in Kotlin. L'osservazione delle modifiche a strutture, stanze, metadati dei dispositivi e stato dei dispositivi nelle API Home può essere eseguita con qualsiasi API che eredita dall' HomeObjectsFlow interfaccia. Questa operazione viene eseguita raccogliendo dal flusso.

Quando un elemento di una raccolta viene aggiunto, eliminato o modificato, viene restituita l'ultima istantanea della raccolta.

Lo sviluppatore deve dedurre le modifiche specifiche confrontando questa istantanea con una copia precedente. A questo scopo, è possibile utilizzare il campo id fornito per ogni tipo di oggetto principale nelle API Home.

Come utilizzare i flussi

Di seguito sono riportati alcuni esempi di base di raccolta dai flussi nelle API Home. Per gli esempi seguenti, prima di accedere alle raccolte nella casa, è necessario creare un'istanza di Home:

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

Monitorare le modifiche a una struttura

Le seguenti modifiche a una struttura attivano questa raccolta:

Nome della struttura

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

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

Monitorare le modifiche a un dispositivo specifico

Le seguenti modifiche a un dispositivo attivano questa raccolta:

Stato della connettività
Nome del dispositivo
Appartenenza alla stanza
L'insieme di trait supportati
L'insieme di tipi supportati

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

Monitorare le modifiche a un trait specifico su un dispositivo

Utilizza qualsiasi trait supportato dal dispositivo e dalle API Home. Per un elenco completo, consulta Trait.

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

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

Monitorare le modifiche a un tipo specifico su un dispositivo

Le seguenti modifiche a un tipo di dispositivo attivano questa raccolta:

Modifiche a qualsiasi trait all'interno del tipo di dispositivo generato

Utilizza qualsiasi tipo di dispositivo Matter supportato dalle API Home. Per un elenco completo, consulta DeviceType.

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

Monitorare le modifiche a una stanza in una struttura

Le seguenti modifiche a una stanza attivano questa raccolta:

Nome della stanza
Appartenenza alla struttura

Per monitorare quando i dispositivi vengono aggiunti o rimossi da una stanza, utilizza il devices() flusso.

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

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

Iscriversi agli eventi

Nelle API Home, gli eventi vengono utilizzati per rilevare le modifiche allo stato di un dispositivo.

Per iscriverti agli eventi su un dispositivo specifico, chiama una delle tre HomeDevice.events funzioni, ognuna delle quali restituisce unFlow<Event>:

events(event: EventFactory<T>) restituisce un flusso per un tipo specifico di evento:

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

events(trait: TraitFactory<T>) restituisce un flusso di tutti gli eventi inviati da un trait:
```
val eventflow = homeDevice.type(DoorLockDevice).first().events(DoorLock)
```

events() restituisce un flusso di eventi disponibili per l'oggetto:

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

Per utilizzare gli eventi da un flusso, utilizza la funzione flow.collect():

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

Iscriversi agli eventi di relazione tra entità

Puoi ascoltare gli eventi che vengono emessi ogni volta che un'entità (ad esempio una struttura, una stanza, un dispositivo o un'automazione) viene aggiunta, rimossa o aggiornata. Questi eventi sono istanze di HomeObjectChangeEvent e contengono l'ID dell'entità modificata.

Per acquisire uno stream che produce gli eventi che ti interessano, chiama il stream() metodo su HomeObjectsFlow<T> prodotto dal metodo Flow corrispondente:

*Tabella: stream di eventi*
Entità	Interfaccia	Metodo Flow
`Structure`	`HasStructures`	`structures()`
`Room`	`HasRooms`	`rooms()`
`HomeDevice`	`HasHomeDevices`	`devices()`
`Automation`	`HasAutomations`	`automations()`

Ad esempio, ecco come puoi gestire le modifiche ai dispositivi:

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 -> {}
  }
}