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