यहां Android पर, ऑटोमेशन डीएसएल के बुनियादी सिद्धांतों के बारे में खास जानकारी दी गई है.
ऑटोमेशन कॉम्पोनेंट
ऑटोमेशन में ये बुनियादी कॉम्पोनेंट होते हैं. आम तौर पर, इनका आकलन इस क्रम में किया जाता है:
- स्टार्टर — यह उन शुरुआती शर्तों को तय करता है जिनसे ऑटोमेशन चालू होता है. जैसे, किसी विशेषता में बदलाव. ऑटोमेशन के लिए, स्टार्टर होना ज़रूरी है.
- शर्त — ऑटोमेशन चालू होने के बाद, आकलन करने के लिए कोई भी अतिरिक्त शर्त. ऑटोमेशन की कार्रवाइयों को आगे बढ़ाने के लिए, शर्त में मौजूद एक्सप्रेशन का आकलन
trueके तौर पर होना चाहिए. - कार्रवाई — ये ऐसे निर्देश या स्टेटस अपडेट होते हैं जो सभी शर्तें पूरी होने पर किए जाते हैं.
उदाहरण के लिए, मान लें कि आपके पास एक ऐसा ऑटोमेशन है जो सूर्यास्त से लेकर सूर्योदय के बीच, कमरे में टीवी चालू होने पर लाइटें धीमी कर देता है. इस उदाहरण में:
- स्टार्टर — टीवी चालू किया गया. यह टीवी की खासियत में बदलाव है.
- शर्त— टीवी जिस घर में है वहां के मौजूदा समय का आकलन किया जाता है.
- कार्रवाई — टीवी वाले कमरे की लाइटें धीमी हो जाती हैं.
कमरे में टीवी चालू होने पर, ऑटोमेशन चालू हो जाएगा. हालांकि, ऑटोमेशन सिर्फ़ तब काम करेगा, जब "समय सूर्यास्त और सूर्योदय के बीच हो" वाली शर्त पूरी हो.
बुनियादी स्ट्रक्चर के अलावा, Home API में मौजूद ऑटोमेशन में मेटाडेटा भी होता है. जैसे, नाम और ब्यौरा. इसका इस्तेमाल डेवलपर और उपयोगकर्ता, ऑटोमेशन की पहचान करने के लिए कर सकते हैं.
नोड
Home API में, ऑटोमेशन का लॉजिकल स्ट्रक्चर नोड से मिलकर बना होता है. नोड, अमूर्त और दोबारा इस्तेमाल की जा सकने वाली इकाइयां होती हैं. ये इकाइयां, किसी इकाई के व्यवहार या एक्ज़ीक्यूशन फ़्लो को दिखाती हैं. हर नोड में इनपुट वैरिएबल हो सकते हैं. साथ ही, ऐसे आउटपुट वैरिएबल भी हो सकते हैं जिनका इस्तेमाल अन्य नोड कर सकते हैं.
| नोड | नोड प्रकार | Kotlin को लागू करना | ब्यौरा |
|---|---|---|---|
| Starter | व्यवहारजन्य |
StarterNodeDsl
|
किसी ट्रेट की स्थिति (कोई भी एट्रिब्यूट) बदलने पर, ऑटोमेशन शुरू करता है. |
| StateReader | व्यवहारजन्य |
StateReaderNodeDsl
|
यह फ़ंक्शन, किसी ट्रेट एट्रिब्यूट को पढ़ता है और आपको इसकी वैल्यू कैप्चर करने की अनुमति देता है, ताकि इसका इस्तेमाल स्थिति वाले नोड में किया जा सके. |
| कार्रवाई | व्यवहारजन्य |
ActionNodeDsl
|
ट्रेट के निर्देश शुरू करता है. |
| सीक्वेंशियल | एक्ज़ीक्यूशन फ़्लो |
SequentialFlow
|
यह नेस्ट किए गए ऐक्शन नोड को क्रम से लागू करता है. यह डिफ़ॉल्ट रूप से लागू होने वाला व्यवहार है. |
| पैरलल | एक्ज़ीक्यूशन फ़्लो |
ParallelFlow
|
यह नेस्ट किए गए ऐक्शन नोड को एक साथ एक्ज़ीक्यूट करता है. |
| शर्त | एक्ज़ीक्यूशन फ़्लो |
ConditionNodeDsl
|
लॉजिकल एक्सप्रेशन के आकलन के आधार पर, शर्तों के हिसाब से एक्ज़ीक्यूशन फ़्लो में बदलाव करना. शर्तें, किसी स्टार्टर (स्टार्टर से जुड़ी खास शर्तें) से जुड़ी हो सकती हैं या ग्लोबल हो सकती हैं (सभी स्टार्टर पर लागू होती हैं). |
| चुनें | एक्ज़ीक्यूशन फ़्लो |
SelectFlow
|
इससे एक से ज़्यादा स्टार्टर को ऑटोमेशन चालू करने की अनुमति मिलती है. |
| Expression | मान |
Expression
|
यह किसी ट्रेट के एट्रिब्यूट की वैल्यू, कोई कॉन्स्टेंट या कोई लिटरल वैल्यू हो सकती है. साथ ही, इसका आकलन सूची, संख्या, बूलियन या स्ट्रिंग के तौर पर किया जाना चाहिए. |
व्यवहार से जुड़े नोड
स्टार्टर और ऐक्शन जैसे नोड, व्यवहार से जुड़े नोड होते हैं. स्टार्टर, डिवाइस के एट्रिब्यूट में हुए बदलावों के आधार पर ऑटोमेशन चालू करते हैं. कार्रवाइयों से डिवाइसों को निर्देश दिए जाते हैं या एट्रिब्यूट अपडेट किए जाते हैं.
आम तौर पर, व्यवहार से जुड़े नोड, डिवाइस की विशेषताओं और आउटपुट की स्थिति से जुड़े होते हैं. इनका इस्तेमाल अन्य नोड में इनपुट के तौर पर किया जाता है.
एक्ज़ीक्यूशन फ़्लो नोड
कुछ नोड, एक्ज़ीक्यूशन फ़्लो को दिखाते हैं. जैसे, सीक्वेंशियल और पैरलल. इनमें से हर नोड में, व्यवहार से जुड़े नोड होते हैं. ये नोड, ऑटोमेशन को तय करते हैं.
उदाहरण के लिए, सीक्वेंशियल फ़्लो में ऐसे नोड हो सकते हैं जो सीक्वेंशियल क्रम में काम करते हैं. आम तौर पर, ये स्टार्टर, शर्त, और कार्रवाई होते हैं.
पैरलल फ़्लो में, एक ही समय पर कई ऐक्शन नोड काम कर सकते हैं. जैसे, एक ही समय पर कई लाइटें चालू करना. पैरलल फ़्लो के बाद आने वाले नोड तब तक एक्ज़ीक्यूट नहीं होंगे, जब तक पैरलल फ़्लो की सभी शाखाएं पूरी नहीं हो जातीं.
एक्ज़ीक्यूशन फ़्लो का दूसरा टाइप, कंडीशन फ़्लो होता है. यह एक्सप्रेशन के आकलन के आधार पर, एक्ज़ीक्यूशन फ़्लो को बदल सकता है.
उदाहरण के लिए, मान लें कि आपके पास एक ऑटोमेशन है, जो रात होने पर कोई कार्रवाई करता है. कंडीशन नोड, दिन के समय की जांच करता है. इसके बाद, उस आकलन के आधार पर सही एक्ज़ीक्यूशन पाथ को फ़ॉलो करता है.
चुने गए फ़्लो का इस्तेमाल तब किया जाता है, जब आपको एक से ज़्यादा ऐसे स्टार्टर चाहिए जो ऑटोमेशन को चालू कर सकें. select फ़्लो में दो या उससे ज़्यादा स्टार्टर शामिल करने पर, उनमें से कोई भी स्टार्टर ऑटोमेशन को चालू कर सकता है.
उदाहरण के लिए, ऐसा ऑटोमेशन लिखा जा सकता है जो सूर्यास्त के समय पर्दे नीचे कर दे. ऐसा तब होगा, जब तापमान किसी तय सीमा से ज़्यादा हो जाए या रोशनी किसी तय सीमा से ज़्यादा हो जाए. इनमें से हर एक स्थिति को तीन अलग-अलग स्टार्टर हैंडल करते हैं. साथ ही, इन तीनों को select फ़्लो में रैप किया जाता है.
नेस्ट किए गए फ़्लो
जटिल ऑटोमेशन में, एक्ज़ीक्यूशन फ़्लो नोड को नेस्ट भी किया जा सकता है. उदाहरण के लिए, आपके पास ऐसा सीक्वेंशियल फ़्लो हो सकता है जो पैरलल फ़्लो को एक्ज़ीक्यूट करता है.
डीएसएल नोड को नेस्ट किया जा सकता है और अलग-अलग तरीकों से जोड़ा जा सकता है, ताकि आपकी खास ज़रूरतों को पूरा किया जा सके. इसके लिए, यहां दी गई टेबल में बताई गई पाबंदियों का पालन करना होगा. Builder कॉलम, Kotlin के टाइपसेफ़ बिल्डर के दस्तावेज़ से लिंक होता है. इसमें यह बताया गया है कि हर तरह के नोड में किस तरह की चीज़ों का इस्तेमाल किया जा सकता है.
| नोड | इसमें इस तरह के नोड टाइप और डेटा शामिल हो सकते हैं | यह इनमें से किसी एक नोड टाइप में होना चाहिए |
|---|---|---|
| Starter | एक्सप्रेशन | क्रम से, चुनें |
| ManualStarter | क्रम से, चुनें | |
| StateReader | एक्सप्रेशन (आम तौर पर, इसमें ट्रेट एट्रिब्यूट की वैल्यू शामिल होती है) | कार्रवाई, शर्त |
| कार्रवाई | कमांड, इकाई, एक्सप्रेशन | पैरलल, चुनें, सीक्वेंशियल |
| सीक्वेंशियल | पैरलल, चुनें, सीक्वेंशियल | |
| पैरलल | कार्रवाई | क्रम में |
| शर्त | एक्सप्रेशन | पैरलल, सीक्वेंशियल |
| चुनें | Condition, Sequential, Starter, ManualStarter | सीक्वेंशियल होना चाहिए और फ़्लो में पहला नोड होना चाहिए |
ऑटोमेशन डीएसएल
Home API में, ऑटोमेशन को ऑटोमेशन डीएसएल (डोमेन के हिसाब से तय की गई भाषा) का इस्तेमाल करके तय किया जाता है. ऑटोमेशन डीएसएल को Kotlin डीएसएल (डोमेन के लिए खास तौर पर बनी लैंग्वेज) के तौर पर लागू किया जाता है. इसमें Kotlin के टाइप-सेफ़ बिल्डर का इस्तेमाल किया जाता है. इसे खास तौर पर ऑटोमेशन टेंप्लेट तय करने के लिए डिज़ाइन किया गया है.
ऑटोमेशन को कंपाइल करने पर, Kotlin टाइप-सेफ़ बिल्डर, Kotlin डेटा क्लास जनरेट करते हैं. इसके बाद, इन्हें प्रोटोकॉल बफ़र JSON में क्रम से लगाया जाता है. इसका इस्तेमाल, Google की ऑटोमेशन सेवाओं को कॉल करने के लिए किया जाता है.
ऑटोमेशन डीएसएल, ऑटोमेशन बनाने की प्रोसेस को आसान और बेहतर बनाता है. यह डिवाइस एपीआई में मौजूद Matter स्टैंडर्ड ट्रेट और smart home ट्रेट के एक ही डेटा मॉडल का इस्तेमाल करता है.
ऑटोमेशन डीएसएल, किसी ऑटोमेशन के लॉजिक को भी तय करता है. हालांकि, यह लॉजिक किसी उपयोगकर्ता के घर में मौजूद डिवाइसों के खास इंस्टेंस के बजाय, डिवाइसों के ऐब्स्ट्रैक्ट टाइप के हिसाब से तय किया जाता है. इससे डेवलपर को ऐसे इनपुट पैरामीटर देने की अनुमति मिलती है जिनका इस्तेमाल रनटाइम में किया जा सकता है. इससे डिवाइस के असल इंस्टेंस के साथ-साथ, अन्य अहम पैरामीटर वैल्यू के बारे में भी जानकारी मिलती है.
डीएसएल का सिंटैक्स, Kotlin के सिंटैक्स जैसा ही होता है. साथ ही, यह टाइप-सेफ़ भी होता है. हालांकि, Automation DSL में लिखा गया ऑटोमेशन, Kotlin में लिखे गए ऑटोमेशन की तुलना में ज़्यादा आसान और छोटा होता है.
उदाहरण
यहां ऑटोमेशन का एक उदाहरण दिया गया है. इसमें Automation DSL का इस्तेमाल करके, किसी डिवाइस को चालू करने का तरीका बताया गया है:
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 नोड में किया जा सके.