ऑटोमेशन बनाने के लिए, ऑटोमेशन डीएसएल के अलग-अलग नोड इस्तेमाल करने का तरीका जानने के लिए, यह गाइड पढ़ें.
सभी ऑटोमेशन डीएसएल को एक ही automation नोड में रखा जाता है. automation नोड, Kotlin भाषा के बाहरी कॉन्टेक्स्ट और एम्बेड किए गए डीएसएल कॉन्टेक्स्ट के बीच की सीमा तय करता है.
क्रम के मुताबिक फ़्लो
क्रम में चलने वाला फ़्लो, ऑटोमेशन फ़्लो का डिफ़ॉल्ट टाइप होता है.
यहां एक बुनियादी ऑटोमेशन डीएसएल टेंप्लेट दिया गया है. इसमें क्रम से चलने वाले फ़्लो का इस्तेमाल किया गया है. इसमें एक स्टार्टर, एक शर्त, और एक कार्रवाई शामिल है:
import com.google.home.automation.action
import com.google.home.automation.automation
import com.google.home.automation.condition
import com.google.home.automation.sequential
import com.google.home.automation.starter
...
automation {
sequential {
starter<_>(...)
condition {...}
action {...}
}
}
ज़्यादा नोड जोड़कर, इसे बेहतर बनाया जा सकता है.
नए
स्टार्टर नोड, उन शुरुआती स्थितियों के बारे में बताते हैं जो ऑटोमेशन को चालू करती हैं. उदाहरण के लिए, स्थिति या वैल्यू में बदलाव. किसी ऑटोमेशन में कम से कम एक स्टार्टर होना चाहिए. ऐसा न होने पर, उसकी पुष्टि नहीं हो पाएगी. किसी ऑटोमेशन में एक से ज़्यादा स्टार्टर जोड़ने के लिए, आपको select नोड का इस्तेमाल करना होगा.
खासियत एट्रिब्यूट के आधार पर स्टार्टर
किसी विशेषता एट्रिब्यूट पर आधारित स्टार्टर नोड का एलान करते समय, यह जानकारी दें:
- डिवाइस
- डिवाइस का टाइप, जिससे विशेषता जुड़ी है
- ट्रेट
starter<_>(thermostat, TemperatureSensorDevice, TemperatureMeasurement)
डिवाइस टाइप पैरामीटर ज़रूरी है, क्योंकि इससे यह तय किया जा सकता है कि ऑटोमेशन, डिवाइस में मौजूद किस डिवाइस टाइप को ट्रिगर करे. उदाहरण के लिए, किसी डिवाइस में
FanDevice
और
HeatingCoolingUnitDevice
दोनों हो सकते हैं.
इन दोनों में
OnOff
ट्रेट मौजूद होता है. डिवाइस का टाइप तय करने से, इस बारे में कोई भ्रम नहीं रहता कि डिवाइस का कौनसा हिस्सा ऑटोमेशन को ट्रिगर करता है.
इवेंट के आधार पर रूटीन शुरू करने वाला स्टार्टर
किसी इवेंट पर आधारित स्टार्टर नोड का एलान करते समय, यह जानकारी दें:
- डिवाइस
- डिवाइस का टाइप, जिससे विशेषता जुड़ी है
- इवेंट
starter<_>(doorBell, GoogleDoorbellDevice, DoorbellPressed)
पैरामीटर के साथ, स्ट्रक्चर और इवेंट पर आधारित स्टार्टर
कुछ इवेंट में पैरामीटर हो सकते हैं. इसलिए, इन पैरामीटर को भी स्टार्टर में शामिल करना ज़रूरी है.
उदाहरण के लिए, यह स्टार्टर Time ट्रेट के ScheduledTimeEvent का इस्तेमाल करके, सुबह 7:00 बजे ऑटोमेशन को चालू करता है:
val earlyMorning = starter<_>(structure, Time.ScheduledTimeEvent) {
parameter(Time.ScheduledTimeEvent.clockTime(
LocalTime.of(7, 0, 0, 0)))
}
मौसम के हिसाब से शुरू होने वाला रूटीन
मौसम की विशेषता का इस्तेमाल करके, स्टार्टर में मौसम की मौजूदा या अनुमानित स्थितियों के बारे में बताया जा सकता है:
val weatherState = starter<_>(structure, trait = Weather)
ऑटोमेशन के उदाहरण पेज पर, बारिश होने की संभावना होने पर ब्लाइंड बंद करें देखें.
मैन्युअल तरीके से शुरू होने वाला स्टार्टर
मैन्युअल स्टार्टर एक खास तरह का स्टार्टर होता है. इसकी मदद से, उपयोगकर्ता मैन्युअल तरीके से ऑटोमेशन को चला सकता है.
मैन्युअल स्टार्टर का एलान करते समय:
- किसी विशेषता या डिवाइस टाइप के बारे में न बताएं.
- कोई ऐसा यूज़र इंटरफ़ेस (यूआई) एलिमेंट उपलब्ध कराएं जो
Automation.execute()को कॉल करता हो.
किसी select फ़्लो में, मैन्युअल स्टार्टर को किसी अन्य स्टार्टर के साथ जोड़ने पर, मैन्युअल स्टार्टर अन्य स्टार्टर को बदल देता है:
select {
manualStarter()
starter<_>(thermostat, TemperatureSensorDevice, TemperatureMeasurement)
}
ध्यान दें कि मैन्युअल तरीके से शुरू होने वाले किसी भी स्टार्टर के बाद, condition नोड का आकलन किया जाएगा. साथ ही, condition एक्सप्रेशन के आधार पर, ऑटोमेशन को लागू होने से रोका जा सकता है.
अपने ऑटोमेशन को इस तरह से स्ट्रक्चर किया जा सकता है कि condition नोड, मैन्युअल स्टार्टर की मदद से चालू किए गए ऑटोमेशन को ब्लॉक न करें. इसके लिए, दूसरे स्टार्टर को उसके condition के साथ एक अलग क्रम वाले फ़्लो में रखें:
automation_graph {
sequential {
select {
sequential {
starter<_>(...)
condition {...}
}
sequential {
manualStarter()
}
}
action {...}
}
}
किसी एट्रिब्यूट की वैल्यू का रेफ़रंस देना
किसी एक्सप्रेशन में एट्रिब्यूट की वैल्यू का इस्तेमाल करने के लिए, इस सिंटैक्स का इस्तेमाल करें.
stateReader के साथ:
val time = stateReader<_>(structure, Structure, Time)
val currTime = time.currentTime
starter के साथ:
val starterNode = starter<_>(device1, LaundryWasherDevice, OnOff)
condition() {
expression = starterNode.onOff equals true
}
शर्त वाले नोड और एक्सप्रेशन
शर्त वाला नोड, फ़ैसले लेने की जगह को दिखाता है. इससे यह तय होता है कि ऑटोमेशन जारी रहेगा या नहीं. किसी ऑटोमेशन में कई condition नोड हो सकते हैं.
अगर किसी condition नोड के एक्सप्रेशन की वैल्यू false है, तो पूरा ऑटोमेशन बंद हो जाता है.
condition नोड में, अलग-अलग ऑपरेटर का इस्तेमाल करके, शर्त के कई मानदंडों को जोड़ा जा सकता है. हालांकि, इसके लिए ज़रूरी है कि एक्सप्रेशन का आकलन करने पर, एक बूलियन वैल्यू मिले. अगर नतीजे की वैल्यू true है, तो शर्त पूरी हो जाती है और ऑटोमेशन, अगले नोड को चलाना जारी रखता है. अगर यह false है, तो ऑटोमेशन उस समय काम करना बंद कर देता है.
एक्सप्रेशन, Kotlin में मौजूद एक्सप्रेशन की तरह ही बनाए जाते हैं. इनमें संख्याएं, वर्ण, स्ट्रिंग, और बूलियन जैसी प्रिमिटिव वैल्यू के साथ-साथ Enum वैल्यू भी शामिल हो सकती हैं. ब्रैकेट का इस्तेमाल करके सब-एक्सप्रेशन को ग्रुप करने से, उनके आकलन के क्रम को कंट्रोल किया जा सकता है.
यहां condition का एक उदाहरण दिया गया है, जिसमें कई सब-एक्सप्रेशन को एक एक्सप्रेशन में जोड़ा गया है:
condition() {
val expr1 = starterNode.lockState equals DlLockState.Unlocked
val expr2 = stateReaderNode.lockState equals true
val expr3 = occupancySensingDevice.occupied notEquals 0
val expr4 = timeStateReaderNode
.currentTime
.between(
timeStateReaderNode.sunsetTime,
timeStateReaderNode.sunriseTime)
expression = (expr1 and expr2) or (expr3 and expr4)
}
स्टार्टर की मदद से ऐक्सेस की गई किसी विशेषता की वैल्यू का रेफ़रंस दिया जा सकता है:
val starterNode = starter<_>(device, OnOff)
condition() { expression = starterNode.onOff equals true }
stateReader
condition नोड में, विशेषता एट्रिब्यूट की वैल्यू को रेफ़रंस के तौर पर इस्तेमाल करने का दूसरा तरीका, stateReader नोड का इस्तेमाल करना है.
इसके लिए, सबसे पहले stateReader नोड में trait एट्रिब्यूट की वैल्यू कैप्चर करें. stateReader, structure और trait को आर्ग्युमेंट के तौर पर लेता है:
import com.google.home.automation.stateReader
...
val filterMonitoringState = stateReader<_>(structure, ActivatedCarbonFilterMonitoring)
इसके बाद, condition नोड में stateReader का रेफ़रंस दें:
condition() {
expression =
filterMonitoringState.changeIndication
.equals(ChangeIndicationEnum.Warning)
}
तुलना और लॉजिकल ऑपरेटर का इस्तेमाल करके, condition नोड में कई stateReaders का इस्तेमाल किया जा सकता है:
val armState = stateReader<_>(doorLock, DoorLockDevice, ArmDisarm )
val doorLockState = stateReader<_>(doorLock, DoorLockDevice, DoorLock)
condition() {
expression =
(armState.armState equals true)
and
(doorLockState.lockState equals true)
}
शर्त की अवधि
किसी शर्त में बूलियन एक्सप्रेशन के अलावा, वह समयावधि भी तय की जा सकती है जिसके दौरान ऑटोमेशन को चलाने के लिए, एक्सप्रेशन का सही होना ज़रूरी है. उदाहरण के लिए, ऐसी शर्त तय की जा सकती है जो सिर्फ़ तब ट्रिगर हो, जब लाइट दस मिनट से चालू हो.
condition {
expression(lightStateReader.onOff == true)
forDuration(Duration.ofMinutes(10))
}
इसकी अवधि 5 सेकंड से लेकर 24 घंटे तक की हो सकती है.
ऐक्शन नोड
ऐक्शन नोड वह जगह है जहां ऑटोमेशन का काम होता है.
इस उदाहरण में, कार्रवाई AssistantBroadcast ट्रेट के broadcast() निर्देश को ट्रिगर करती है:
action(device, SpeakerDevice) {
command(AssistantBroadcast.broadcast("Intruder detected!"))
}
स्टेटमेंट इंपोर्ट करना
ऑटोमेशन डेवलप करते समय, यह हमेशा साफ़ तौर पर नहीं पता होता कि Home APIs के अलग-अलग एलिमेंट को अपने कोड में कैसे इंपोर्ट किया जाए.
ट्रेट के एट्रिब्यूट, ट्रेट के Companion ऑब्जेक्ट से इंपोर्ट किए जाते हैं:
import com.google.home.matter.standard.OnOff.Companion.onOff
किसी ट्रेट से तय किए गए डेटा स्ट्रक्चर, ट्रेट क्लास से इंपोर्ट किए जाते हैं. इस क्लास के नाम के आखिर में "-Trait" होता है:
import com.google.home.matter.standard.MediaPlaybackTrait.PlaybackStateEnum
Trait commands are imported from the trait's Companion object:
import com.google.home.matter.standard.Thermostat.Companion.setTemperatureSetpointHold