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