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 पर जाएं.

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

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

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

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