Monitorare lo stato del dispositivo su Android

Nelle API Home per Android, l'osservazione delle modifiche di stato nella home è resa possibile tramite l'uso di flussi in Kotlin. L'osservazione delle modifiche nelle strutture, nelle stanze, nei metadati dei dispositivi e nello stato dei dispositivi nelle API Home può essere effettuata con qualsiasi API che eredita dall'interfaccia HomeObjectsFlow. Ciò avviene tramite la raccolta dal flusso.

Quando un elemento di una raccolta viene aggiunto, eliminato o modificato, viene restituito l'ultimo snapshot della raccolta.

Spetta allo sviluppatore dedurre le modifiche specifiche confrontando questa istantanea con una copia precedente. A questo scopo è possibile utilizzare il campo id fornito per ciascun tipo di oggetto padre nelle API Home.

Come utilizzare i flussi

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

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

Tenere traccia delle modifiche apportate 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 apportate a un dispositivo specifico

Le seguenti modifiche a un dispositivo attivano questa raccolta:

• Stato della connettività
• Nome del dispositivo
• Abbonamento a Room
• Il set di trait supportati
• Il set 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" }!!

Tieni traccia delle modifiche apportate a una caratteristica specifica su un dispositivo

Utilizza qualsiasi tratto supportato dal dispositivo e dalle API Home. Per un elenco completo, vedi 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 caratteristica all'interno del tipo di dispositivo generato

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

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

Monitorare le modifiche apportate a una stanza in una struttura

I seguenti cambiamenti a una stanza attivano questa raccolta:

• Nome della stanza
• Abbonamento Structure

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

Iscriviti agli eventi

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

Per abbonarti agli eventi su un dispositivo specifico, chiama uno dei tre HomeDevice.Funzioni events, ognuna delle quali restituisce unFlow<Event>:

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

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

2. events(trait: TraitFactory<T>) restituisce un flusso di tutti gli eventi inviati da un tratto:

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

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

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

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

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

Iscriviti agli eventi di relazione tra entità

È possibile ascoltare gli eventi 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 un flusso che produce gli eventi che ti interessano, chiama il metodo stream() su HomeObjectsFlow<T> prodotto dal metodo Flow corrispondente:

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