Android DSL के कॉन्सेप्ट

यहां Android पर, ऑटोमेशन डीएसएल के बुनियादी कॉन्सेप्ट के बारे में खास जानकारी दी गई है.

ऑटोमेशन कॉम्पोनेंट

ऑटोमेशन में ये बुनियादी कॉम्पोनेंट होते हैं. आम तौर पर, इनका आकलन इस क्रम में किया जाता है:

1. स्टार्टर — ऑटोमेशन को चालू करने वाली शुरुआती शर्तों के बारे में बताता है. जैसे, किसी ट्रीट में बदलाव. ऑटोमेशन में स्टार्टर होना ज़रूरी है.
2. शर्त — ऑटोमेशन चालू होने के बाद, आकलन करने के लिए कोई और शर्त. ऑटोमेशन की कार्रवाइयां शुरू करने के लिए, शर्त में मौजूद एक्सप्रेशन का आकलन true के तौर पर होना चाहिए.
3. कार्रवाई — सभी शर्तें पूरी होने पर, किए जाने वाले निर्देश या स्टेटस अपडेट.

उदाहरण के लिए, हो सकता है कि आपके पास एक ऐसा ऑटोमेशन हो जो सूर्यास्त और सूर्योदय के बीच, किसी कमरे में टीवी चालू होने पर लाइटों की रोशनी कम कर दे. इस उदाहरण में:

1. स्टार्टर — टीवी चालू था, जो टीवी के ट्रैट की स्थिति में बदलाव है.
2. स्थिति— टीवी जिस होम में है उसकी मौजूदा समय का आकलन किया जाता है.
3. कार्रवाई — टीवी वाले कमरे की लाइटें धीमी हो जाती हैं.

रूम में टीवी चालू होने पर ऑटोमेशन चालू हो जाएगा. हालांकि, ऑटोमेशन सिर्फ़ तब लागू होगा, जब "समय, सूर्यास्त और सूर्योदय के बीच हो" शर्त पूरी हो.

बुनियादी स्ट्रक्चर के अलावा, Home API में ऑटोमेशन में नाम और ब्यौरा जैसे मेटाडेटा भी शामिल होते हैं. इनका इस्तेमाल, डेवलपर और उपयोगकर्ताओं के लिए उनकी पहचान करने के लिए किया जा सकता है.

नोड

Home API में, ऑटोमेशन के लॉजिकल स्ट्रक्चर में nodes होते हैं. नोड, ऐसी यूनिट होती हैं जिन्हें फिर से इस्तेमाल किया जा सकता है. ये इकाई के व्यवहार या टास्क को पूरा करने के तरीके को दिखाती हैं. हर नोड में इनपुट वैरिएबल के साथ-साथ आउटपुट वैरिएबल भी हो सकते हैं. इनका इस्तेमाल दूसरे नोड कर सकते हैं.

व्यवहार से जुड़े नोड

स्टार्टर और कार्रवाइयां जैसे नोड, व्यवहार के नोड होते हैं. डिवाइस एट्रिब्यूट में हुए बदलावों के आधार पर, स्टार्टर ऑटोमेशन को चालू करते हैं. कार्रवाइयां, डिवाइस को निर्देश देती हैं या एट्रिब्यूट अपडेट करती हैं.

आम तौर पर, व्यवहार से जुड़े नोड, डिवाइस के ट्रैट और आउटपुट ट्रैट की स्थिति से जुड़े होते हैं, ताकि उन्हें दूसरे नोड में इनपुट के तौर पर इस्तेमाल किया जा सके.

एक्ज़ीक्यूशन फ़्लो नोड

कुछ नोड, क्रम से और पैरलल तरीके से होने वाले फ़्लो दिखाते हैं. इनमें से हर नोड में, ऑटोमेशन तय करने वाले व्यवहार वाले नोड होते हैं.

उदाहरण के लिए, सीक्वेंशियल फ़्लो में ऐसे नोड हो सकते हैं जो क्रम से चलते हैं. आम तौर पर, ये स्टार्टर, शर्त, और कार्रवाई होती हैं.

पार्रलल फ़्लो में, एक ही समय पर कई ऐक्शन नोड लागू हो सकते हैं. जैसे, एक ही समय पर कई लाइटें चालू करना. पैरलल फ़्लो के बाद वाले नोड तब तक लागू नहीं होंगे, जब तक पैरलल फ़्लो की सभी शाखाएं पूरी नहीं हो जातीं.

शर्त वाला फ़्लो, एक और तरह का एक्सीक्यूशन फ़्लो है. यह किसी एक्सप्रेशन के आकलन के आधार पर, एक्सीक्यूशन फ़्लो को बदल सकता है.

उदाहरण के लिए, हो सकता है कि आपके पास ऐसा ऑटोमेशन हो जो रात होने पर कोई कार्रवाई करता हो. शर्त वाला नोड, दिन का समय देखता है. इसके बाद, उस आकलन के आधार पर, सही तरीके से लागू होने का पाथ फ़ॉलो करता है.

चुनिंदा फ़्लो तब काम आता है, जब आपको एक से ज़्यादा स्टार्टर चाहिए, जो आपके ऑटोमेशन को चालू कर सकें. जब किसी select फ़्लो में दो या उससे ज़्यादा स्टार्टर शामिल किए जाते हैं, तो उनमें से कोई भी स्टार्टर ऑटोमेशन को चालू कर सकता है.

उदाहरण के लिए, आपके पास ऐसा ऑटोमेशन लिखने का विकल्प है जो सूर्यास्त के समय, ब्लिंड को नीचे कर दे. ऐसा तब किया जा सकता है, जब तापमान किसी तय थ्रेशोल्ड से ज़्यादा हो या रोशनी किसी तय थ्रेशोल्ड से ज़्यादा हो. इनमें से हर स्थिति को तीन अलग-अलग स्टार्टर मैनेज करते हैं. साथ ही, इन तीनों को select फ़्लो में रैप किया जाएगा.

नेस्ट किए गए फ़्लो

जटिल ऑटोमेशन में, एक्सीक्यूशन फ़्लो नोड को नेस्ट भी किया जा सकता है. उदाहरण के लिए, आपके पास एक क्रम वाला फ़्लो हो सकता है जो एक साथ कई फ़्लो को लागू करता है.

आपकी ज़रूरतों के हिसाब से डीएसएल नोड को नेस्ट किया जा सकता है और अलग-अलग तरीकों से जोड़ा जा सकता है. हालांकि, ऐसा करने के लिए, नीचे दी गई टेबल में बताई गई सीमाओं का पालन करना ज़रूरी है. बिल्डर कॉलम, Kotlin के टाइपसेफ़ बिल्डर दस्तावेज़ से लिंक होता है. इसमें यह जानकारी दी जाती है कि हर तरह के नोड में किस तरह के डेटा का इस्तेमाल किया जा सकता है.

ऑटोमेशन डीएसएल

Home के एपीआई में, ऑटोमेशन को ऑटोमेशन डीएसएल (डोमेन के हिसाब से बनी भाषा) का इस्तेमाल करके तय किया जाता है. ऑटोमेशन डीएसएल को Kotlin डीएसएल (डोमेन के हिसाब से बनी भाषा) के तौर पर लागू किया जाता है. इसके लिए, Kotlin के टाइप-सेफ़ बिल्डर का इस्तेमाल किया जाता है. इसे खास तौर पर, ऑटोमेशन टेंप्लेट तय करने के लिए डिज़ाइन किया गया है.

ऑटोमेशन कोड को कंपाइल करने पर, Kotlin टाइप-सेफ़ बिल्डर, Kotlin डेटा क्लास जनरेट करते हैं. इसके बाद, उन्हें प्रोटोकॉल बफ़र JSON में सीरियलाइज़ किया जाता है. इसका इस्तेमाल, Google की ऑटोमेशन सेवाओं को कॉल करने के लिए किया जाता है.

ऑटोमेशन डीएसएल, ऑटोमेशन बनाने की प्रोसेस को आसान और बेहतर बनाता है. यह डिवाइस एपीआई में मौजूद Matter स्टैंडर्ड ट्रैट और smart home ट्रैट के उसी डेटा मॉडल का इस्तेमाल करता है.

ऑटोमेशन डीएसएल, उपयोगकर्ता के होम में मौजूद डिवाइस के इंस्टेंस के बजाय, डिवाइस के अलग-अलग टाइप के हिसाब से ऑटोमेशन के लॉजिक को भी तय करता है. इससे डेवलपर को इनपुट पैरामीटर देने की सुविधा मिलती है. इनका इस्तेमाल रनटाइम के दौरान, डिवाइस के असल इंस्टेंस के साथ-साथ अन्य अहम पैरामीटर वैल्यू की जानकारी देने के लिए किया जा सकता है.

डीएसएल सिंटैक्स, Kotlin के सिंटैक्स से मिलता-जुलता है और यह भी टाइप-सेफ़ है. हालांकि, ऑटोमेशन डीएसएल में लिखा गया ऑटोमेशन, Kotlin में लिखे गए उसी ऑटोमेशन से आसान और ज़्यादा संक्षिप्त होता है.

उदाहरण

यहां किसी डिवाइस को चालू करने वाले ऑटोमेशन का उदाहरण दिया गया है. इसे ऑटोमेशन डीएसएल का इस्तेमाल करके लिखा गया है:

val automation = automation {
  name = "MyFirstAutomation"
  description = "If light1 is on, turn on light2."
  isActive = true
  sequential {
    val onOffTrait = starter<_>(device1, OnOffLightDevice, OnOff)
    condition() { expression = onOffTrait.onOff equals true }
    action(device2, OnOffLightDevice) { command(OnOff.on()) }
  }
}

यह ऑटोमेशन बहुत आसान है: जब device1, लाइट चालू होती है (onOff एट्रिब्यूट true में बदल जाता है), तो device2 को चालू करने के लिए on() कमांड भेजता है.

ऑटोमेशन, sequential नोड का इस्तेमाल करता है. इससे पता चलता है कि इसके नोड, क्रम से चलेंगे.

sequential नोड में, starter, condition, और action जैसे व्यवहार से जुड़े नोड होते हैं. starter नोड का आउटपुट, condition नोड में इस्तेमाल करने के लिए किसी वैरिएबल को असाइन किया जाता है.