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()!!

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

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

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

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 देखें.

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

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

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

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

Home API के साथ काम करने वाले किसी भी 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() तरीका कॉल करें जो उस इवेंट को जनरेट करता है:

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

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