Gerätestatus auf Android-Geräten überwachen

In den Home APIs für Android können Änderungen am Status im Zuhause mithilfe von Flows in Kotlin beobachtet werden. Änderungen an Strukturen, Räumen, Gerätemetadaten und Gerätestatus in den Home APIs können mit jeder API beobachtet werden, die von der HomeObjectsFlow Schnittstelle erbt. Dazu wird der Flow erfasst.

Wenn ein Element in einer Sammlung hinzugefügt, gelöscht oder geändert wird, wird der aktuelle Snapshot der Sammlung zurückgegeben.

Es liegt in der Verantwortung des Entwicklers, die spezifischen Änderungen abzuleiten, indem er diesen Snapshot mit einer älteren Kopie vergleicht. Das id Feld, das für jeden übergeordneten Objekt typ in den Home APIs bereitgestellt wird, kann für diesen Zweck verwendet werden.

Flows verwenden

Im Folgenden finden Sie einige grundlegende Beispiele für das Erfassen von Flows in den Home APIs. Für die folgenden Beispiele muss eine Instanz von Home erstellt werden, bevor auf Sammlungen im Zuhause zugegriffen werden kann:

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

Änderungen an einer Struktur verfolgen

Die folgenden Änderungen an einer Struktur lösen diese Erfassung aus:

Name der Struktur

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

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

Änderungen an einem bestimmten Gerät verfolgen

Die folgenden Änderungen an einem Gerät lösen diese Erfassung aus:

Verbindungsstatus
Gerätename
Raum Zugehörigkeit
Die Menge der unterstützten Eigenschaften
Die Menge der unterstützten Typen

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

Änderungen an einer bestimmten Eigenschaft auf einem Gerät verfolgen

Verwenden Sie eine beliebige Eigenschaft, die vom Gerät und den Home APIs unterstützt wird. Eine vollständige Liste finden Sie unter Trait.

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

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

Änderungen an einem bestimmten Typ auf einem Gerät verfolgen

Die folgenden Änderungen an einem Gerätetyp lösen diese Erfassung aus:

Änderungen an einer beliebigen Eigenschaft innerhalb des generierten Gerätetyps

Verwenden Sie einen beliebigen Matter Gerätetyp, der von den Home APIs unterstützt wird. Eine vollständige Liste finden Sie unter DeviceType.

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

Änderungen an einem Raum in einer Struktur verfolgen

Die folgenden Änderungen an einem Raum lösen diese Erfassung aus:

Raum name
Strukturzugehörigkeit

Wenn Sie verfolgen möchten, wann Geräte zu einem Raum hinzugefügt oder daraus entfernt werden, verwenden Sie den devices() Flow.

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

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

Ereignisse abonnieren

In den Home APIs werden Ereignisse verwendet, um Änderungen am Status eines Geräts zu erkennen.

Wenn Sie Ereignisse auf einem bestimmten Gerät abonnieren möchten, rufen Sie eine der drei HomeDevice.events Funktionen auf, die jeweils einenFlow<Event> zurückgeben:

events(event: EventFactory<T>) gibt einen Flow für eine bestimmte Art von Ereignis zurück:

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

events(trait: TraitFactory<T>) gibt einen Flow aller Ereignisse zurück, die von einer Eigenschaft gesendet werden:
```
val eventflow = homeDevice.type(DoorLockDevice).first().events(DoorLock)
```
events() gibt einen Flow von Ereignissen zurück, die für das Objekt verfügbar sind:
```
val eventflow = homeDevice.type(DoorLockDevice).first().events()
```

Verwenden Sie die Funktion flow.collect(), um Ereignisse aus einem Flow zu nutzen:

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

Ereignisse zu Entitätsbeziehungen abonnieren

Sie können auf Ereignisse warten, die jedes Mal ausgegeben werden, wenn eine Entität (z. B. eine Struktur, ein Raum, ein Gerät oder eine Automatisierung) hinzugefügt, entfernt oder aktualisiert wird. Diese Ereignisse sind Instanzen von HomeObjectChangeEvent und enthalten die ID der geänderten Entität.

Rufen Sie die stream() Methode für den HomeObjectsFlow<T> auf, der von der entsprechenden Flow-Methode erzeugt wird, um einen Stream zu erhalten, der die gewünschten Ereignisse erzeugt:

*Tabelle: Ereignisstreams*
Entität	Schnittstelle	Flow-Methode
`Structure`	`HasStructures`	`structures()`
`Room`	`HasRooms`	`rooms()`
`HomeDevice`	`HasHomeDevices`	`devices()`
`Automation`	`HasAutomations`	`automations()`

So können Sie beispielsweise Änderungen an Geräten verarbeiten:

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