Android पर डिवाइस की स्थिति पर नज़र रखना

Android के लिए Home API में, Kotlin में फ़्लो का इस्तेमाल करके, होम में मौजूद डिवाइस की स्थिति में होने वाले बदलावों को देखा जा सकता है. Home API में, स्ट्रक्चर, कमरों, डिवाइस के मेटाडेटा, और डिवाइस की स्थिति में होने वाले बदलावों को, HomeObjectsFlow इंटरफ़ेस से इनहेरिट करने वाले किसी भी एपीआई की मदद से देखा जा सकता है. ऐसा फ़्लो से कलेक्ट करके किया जाता है.

जब किसी कलेक्शन में कोई आइटम जोड़ा, मिटाया या उसमें बदलाव किया जाता है, तो कलेक्शन का सबसे नया स्नैपशॉट दिखाया जाता है.

डेवलपर को इस स्नैपशॉट की तुलना, पुरानी कॉपी से करके, खास बदलावों का पता लगाना होता है. Home API में, हर पैरंट ऑब्जेक्ट टाइप के लिए दिया गया id फ़ील्ड, इस मकसद के लिए इस्तेमाल किया जा सकता है.

फ़्लो का इस्तेमाल करने का तरीका

यहां Home API में, फ़्लो से कलेक्ट करने के कुछ बुनियादी उदाहरण दिए गए हैं. यहां दिए गए उदाहरणों के लिए, होम में कलेक्शन ऐक्सेस करने से पहले, Home का कोई इंस्टेंस बनाना ज़रूरी है:

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

किसी स्ट्रक्चर में होने वाले बदलावों को ट्रैक करना

किसी स्ट्रक्चर में होने वाले इन बदलावों से, यह कलेक्शन ट्रिगर होता है:

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

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

किसी खास डिवाइस में होने वाले बदलावों को ट्रैक करना

किसी डिवाइस में होने वाले इन बदलावों से, यह कलेक्शन ट्रिगर होता है:

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

किसी डिवाइस पर मौजूद किसी खास Trait में होने वाले बदलावों को ट्रैक करना

डिवाइस और Home API के साथ काम करने वाले किसी भी Trait का इस्तेमाल करें. पूरी सूची देखने के लिए, देखें Trait.

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

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

किसी डिवाइस पर मौजूद किसी खास टाइप में होने वाले बदलावों को ट्रैक करना

किसी डिवाइस टाइप में होने वाले इन बदलावों से, यह कलेक्शन ट्रिगर होता है:

Matter के किसी भी ऐसे Matter डिवाइस टाइप का इस्तेमाल करें जो Home API के साथ काम करता हो. पूरी सूची देखने के लिए, DeviceTypeदेखें.

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

किसी स्ट्रक्चर में मौजूद किसी कमरे में होने वाले बदलावों को ट्रैक करना

किसी कमरे में होने वाले इन बदलावों से, यह कलेक्शन ट्रिगर होता है:

यह ट्रैक करने के लिए कि किसी कमरे में डिवाइस कब जोड़े या हटाए जाते हैं, devices() फ़्लो का इस्तेमाल करें.

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

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

इवेंट के लिए सदस्यता लेना

Home API में, डिवाइस की स्थिति में होने वाले बदलावों का पता लगाने के लिए, इवेंट का इस्तेमाल किया जाता है.

किसी खास डिवाइस पर इवेंट के लिए सदस्यता लेने के लिए, तीन HomeDevice में से किसी एक को कॉल करें.events फ़ंक्शन, जिनमें से हर एक Flow<Event> दिखाता है:

  1. events(event: EventFactory<T>) किसी खास तरह के इवेंट के लिए फ़्लो दिखाता है:

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

  2. events(trait: TraitFactory<T>) किसी Trait से भेजे गए सभी इवेंट का फ़्लो दिखाता है:

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

  3. events() ऑब्जेक्ट के लिए उपलब्ध इवेंट का फ़्लो दिखाता है:

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

किसी फ़्लो से इवेंट इस्तेमाल करने के लिए, flow.collect() फ़ंक्शन का इस्तेमाल करें:

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

इकाई के संबंध वाले इवेंट के लिए सदस्यता लेना

ऐसे इवेंट के लिए सुना जा सकता है जो हर बार तब एमिट होते हैं, जब कोई इकाई (जैसे कि स्ट्रक्चर, कमरा, डिवाइस या ऑटोमेशन) जोड़ी, हटाई या अपडेट की जाती है. ये इवेंट, HomeObjectChangeEvent के इंस्टेंस होते हैं. इनमें उस इकाई का आईडी होता है जिसमें बदलाव किया गया है.

अपनी पसंद के इवेंट जनरेट करने वाला स्ट्रीम पाने के लिए, संबंधित फ़्लो के तरीके से जनरेट किए गए stream() तरीके को HomeObjectsFlow<T> कॉल करें:

टेबल: इवेंट स्ट्रीम
इकाई इंटरफ़ेस फ़्लो का तरीका
Structure HasStructures structures()
Room HasRooms rooms()
HomeDevice HasHomeDevices devices()
Automation HasAutomations automations()

उदाहरण के लिए, यहां बताया गया है कि डिवाइसों में होने वाले बदलावों को कैसे मैनेज किया जा सकता है:

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