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 Gebäuden, 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 werden Daten aus dem Ablauf erfasst.

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

Der Entwickler muss die spezifischen Änderungen durch Vergleichen dieses Snapshots mit einer älteren Kopie ableiten. Das Feld id, das für jeden übergeordneten Objekttyp in den Home APIs bereitgestellt wird, kann für diesen Zweck verwendet werden.

Abläufe verwenden

Im Folgenden finden Sie einige einfache Beispiele für das Erfassen von Abläufen 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 einem Gebäude verfolgen

Die folgenden Änderungen an einem Gebäude lösen diese Erfassung aus:

• Name des Gebäudes

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
• Mitgliedschaft in Chatrooms
• Die unterstützten Eigenschaften
• Die 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 einem bestimmten Attribut auf einem Gerät verfolgen

Verwenden Sie ein beliebiges Attribut, das 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 einem Attribut 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 einem Gebäude nachverfolgen

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

• Name des Raums
• Gebäude-Mitgliedschaft

Wenn du nachverfolgen möchtest, wann Geräte einem Raum hinzugefügt oder daraus entfernt werden, verwende den devices()-Ablauf.

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 du Ereignisse auf einem bestimmten Gerät abonnieren möchtest, rufe eine der drei HomeDevice auf.events-Funktionen, die jeweils einenFlow<Event>zurückgeben:

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

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

2. events(trait: TraitFactory<T>) gibt einen Ablauf aller Ereignisse zurück, die von einem Merkmal gesendet wurden:

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

3. events() gibt einen Stream 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 Ablauf zu nutzen:

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

Ereignisse zu Entitätsbeziehungen abonnieren

Du kannst auf Ereignisse warten, die jedes Mal ausgelöst werden, wenn eine Entität (z. B. ein Gebäude, 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.

Wenn Sie einen Stream abrufen möchten, der die gewünschten Ereignisse erzeugt, rufen Sie die Methode stream() für den HomeObjectsFlow<T> auf, der von der entsprechenden Flow-Methode erzeugt wird:

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

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