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

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

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

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

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

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

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

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

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

• स्ट्रक्चर name

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

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

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

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

• कनेक्टिविटी का स्टेटस
• डिवाइस का नाम
• कमरे की सदस्यता
• साथ काम करने वाले trait का सेट
• इस्तेमाल किए जा सकने वाले टाइप का सेट

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

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

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

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

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

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

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

• जनरेट किए गए डिवाइस टाइप में मौजूद किसी भी ट्रेट में बदलाव

Home APIs के साथ काम करने वाले किसी भी Matter डिवाइस टाइप का इस्तेमाल करें. पूरी सूची देखने के लिए, 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>), किसी ट्रेट से भेजे गए सभी इवेंट का फ़्लो दिखाता है:

   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 के इंस्टेंस होते हैं. इनमें उस इकाई का आईडी होता है जिसमें बदलाव किया गया है.

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

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

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