iOS डीएसएल गाइड

ऑटोमेशन बनाने के लिए, ऑटोमेशन डीएसएल के अलग-अलग नोड इस्तेमाल करने का तरीका जानने के लिए, यह गाइड पढ़ें.

सभी ऑटोमेशन डीएसएल को एक ही automation नोड में रखा जाता है. automation नोड, Swift भाषा के बाहरी कॉन्टेक्स्ट और एम्बेड किए गए डीएसएल कॉन्टेक्स्ट के बीच की सीमा बनाता है.

क्रम के मुताबिक फ़्लो

क्रम में चलने वाला फ़्लो, ऑटोमेशन फ़्लो का डिफ़ॉल्ट टाइप होता है.

यहां एक बुनियादी ऑटोमेशन डीएसएल टेंप्लेट दिया गया है. इसमें क्रम से चलने वाले फ़्लो का इस्तेमाल किया गया है. इसमें एक स्टार्टर, एक शर्त, और एक कार्रवाई शामिल है:

import GoogleHomeSDK
import GoogleHomeTypes

automation (
...
) {
  starter(...)
  condition {...}
  action {...}
}

ज़्यादा नोड जोड़कर, इसे बेहतर बनाया जा सकता है.

नए

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

खासियत एट्रिब्यूट के आधार पर स्टार्टर

किसी विशेषता एट्रिब्यूट पर आधारित स्टार्टर नोड का एलान करते समय, यह जानकारी दें:

• डिवाइस
• डिवाइस का टाइप, जिससे विशेषता जुड़ी है
• ट्रेट

starter(
  thermostat,
  Matter.TemperatureSensorDeviceType.self,
  Matter.TemperatureMeasurementTrait.self
)

डिवाइस टाइप पैरामीटर ज़रूरी है, क्योंकि इससे यह तय किया जा सकता है कि ऑटोमेशन, डिवाइस में मौजूद किस डिवाइस टाइप को ट्रिगर करे. उदाहरण के लिए, किसी डिवाइस में FanDeviceType और HeatingCoolingUnitDeviceType दोनों हो सकते हैं. इन दोनों में OnOffTrait ट्रेट मौजूद होता है. डिवाइस का टाइप तय करने से, इस बारे में कोई भ्रम नहीं रहता कि डिवाइस का कौनसा हिस्सा ऑटोमेशन को ट्रिगर करता है.

इवेंट के आधार पर रूटीन शुरू करने वाला स्टार्टर

किसी इवेंट पर आधारित स्टार्टर नोड का एलान करते समय, यह जानकारी दें:

• डिवाइस
• डिवाइस का टाइप, जिससे विशेषता जुड़ी है
• इवेंट

starter(
  doorbell,
  Google.GoogleDoorbellDeviceType.self,
  Google.DoorbellPressTrait.DoorbellPressedEvent
)

पैरामीटर के साथ, स्ट्रक्चर और इवेंट पर आधारित स्टार्टर

कुछ इवेंट में पैरामीटर हो सकते हैं. इसलिए, इन पैरामीटर को भी स्टार्टर में शामिल करना ज़रूरी है.

उदाहरण के लिए, यह स्टार्टर TimeTrait के ScheduledEvent का इस्तेमाल करके, सुबह 7:00 बजे ऑटोमेशन को चालू करता है:

typealias TimeTrait = Google.TimeTrait

let earlyMorning = starter(
  structure,
  TimeTrait.ScheduledEvent.self
) {
  TimeTrait.ScheduledEvent.clockTime(TimeOfDay(hours: 7, minutes: 0))
}

मौसम के हिसाब से शुरू होने वाला रूटीन

मौसम की विशेषता का इस्तेमाल करके, स्टार्टर में मौसम की मौजूदा या अनुमानित स्थितियों के बारे में बताया जा सकता है:

let weatherState = starter<_>(structure, trait = Weather)

ऑटोमेशन के उदाहरण पेज पर, बारिश होने की संभावना होने पर ब्लाइंड बंद करें देखें.

मैन्युअल तरीके से शुरू होने वाला स्टार्टर

मैन्युअल स्टार्टर एक खास तरह का स्टार्टर होता है. इसकी मदद से, उपयोगकर्ता मैन्युअल तरीके से ऑटोमेशन को चला सकता है.

मैन्युअल स्टार्टर का एलान करते समय:

• किसी विशेषता या डिवाइस टाइप के बारे में न बताएं.
• कोई ऐसा यूज़र इंटरफ़ेस (यूआई) एलिमेंट उपलब्ध कराएं जो Automation.execute() को कॉल करता हो.

किसी select फ़्लो में, मैन्युअल स्टार्टर को किसी अन्य स्टार्टर के साथ जोड़ने पर, मैन्युअल स्टार्टर अन्य स्टार्टर को बदल देता है:

select {
  manualStarter()
  starter(
    thermostat,
    Matter.TemperatureSensorDeviceType.self,
    Matter.TemperatureMeasurementTrait.self
  )
}

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

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

import GoogleHomeSDK
import GoogleHomeTypes

automation (
...
) {

  select {
    sequential {
      starter(...)
      condition {...}
    }
    sequential {
      manualStarter()
    }
  }
  action {...}

}

किसी एट्रिब्यूट की वैल्यू का रेफ़रंस देना

किसी एक्सप्रेशन में एट्रिब्यूट की वैल्यू का इस्तेमाल करने के लिए, इस सिंटैक्स का इस्तेमाल करें.

stateReader के साथ:

typealias TimeTrait = Google.TimeTrait

let time = stateReader(structure, TimeTrait.self)
time
let currTime = time.currentTime

starter के साथ:

typealias LaundryWasherDeviceType = Matter.LaundryWasherDeviceType
typealias OnOffTrait = Google.OnOffTrait

let starterNode = starter(device1, LaundryWasherDeviceType.self, OnOffTrait.self)
starterNode
condition {
  starterNode.onOff.equals(true)
}

शर्त वाले नोड और एक्सप्रेशन

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

condition नोड में, अलग-अलग ऑपरेटर का इस्तेमाल करके, शर्त के कई मानदंडों को जोड़ा जा सकता है. हालांकि, इसके लिए ज़रूरी है कि एक्सप्रेशन का आकलन करने पर, सिर्फ़ एक बूलियन वैल्यू मिले. अगर नतीजे की वैल्यू true है, तो शर्त पूरी हो जाती है और ऑटोमेशन अगले नोड को लागू करना जारी रखता है. अगर यह false है, तो ऑटोमेशन उस समय ट्रिगर होना बंद हो जाता है.

एक्सप्रेशन, Swift में मौजूद एक्सप्रेशन की तरह ही बनाए जाते हैं. इनमें संख्याएं, वर्ण, स्ट्रिंग, और बूलियन जैसी प्रिमिटिव वैल्यू के साथ-साथ Enum वैल्यू भी शामिल हो सकती हैं. ब्रैकेट का इस्तेमाल करके सब-एक्सप्रेशन को ग्रुप करने से, उनके आकलन के क्रम को कंट्रोल किया जा सकता है.

यहां condition का एक उदाहरण दिया गया है, जिसमें कई सब-एक्सप्रेशन को एक एक्सप्रेशन में जोड़ा गया है:

condition {
  let exp1 = starterNode.lockState.equals(.unlocked)
  let exp2 = stateReaderNode.lockState.equals(true)
  let exp3 = occupancySensingDevice.occupied.notEquals(0)
  (exp1.and(exp2)).or(exp3)
}

स्टार्टर की मदद से ऐक्सेस की गई किसी विशेषता की वैल्यू का रेफ़रंस दिया जा सकता है:

typealias OnOffTrait = Matter.OnOffTrait

let starterNode = starter(device, OnOffTrait.self)
starterNode
condition {
  starterNode.onOff.equals(true)
}
val starterNode = starter<_>(device, OnOff)
condition() { expression = starterNode.onOff equals true }

stateReader

condition नोड में, विशेषता एट्रिब्यूट की वैल्यू को रेफ़रंस के तौर पर इस्तेमाल करने का दूसरा तरीका, stateReader नोड का इस्तेमाल करना है.

इसके लिए, सबसे पहले stateReader नोड में trait एट्रिब्यूट की वैल्यू कैप्चर करें. stateReader, structure और trait को आर्ग्युमेंट के तौर पर लेता है:

typealias ActivatedCarbonFilterMonitoringTrait = Matter.ActivatedCarbonFilterMonitoringTrait

let filterMonitoringState = stateReader(structure, ActivatedCarbonFilterMonitoringTrait.self)

इसके बाद, condition नोड में stateReader का रेफ़रंस दें:

condition {
filterMonitoringState.changeIndication.equals(.warning)
}

तुलना और लॉजिकल ऑपरेटर का इस्तेमाल करके, condition नोड में कई stateReaders इस्तेमाल किए जा सकते हैं:

typealias ArmDisarm = Google.ArmDisarmTrait
typealias DoorLockDevice = Matter.DoorLockDeviceType
typealias DoorLock = Matter.DoorLockTrait

let armState = stateReader(doorLock, DoorLockDevice.self, ArmDisarm )
let doorLockState = stateReader(doorLock, DoorLockDevice.self, DoorLock)
armState
doorLockState
condition {
  let exp1 = armState.armState
  let exp2 = doorLockState.lockState
  exp1.and(exp2)
}

शर्त की अवधि

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

condition(for: .seconds(600)) {
lightStateReader.onOff.equals(true)
}

इसकी अवधि एक से 30 मिनट तक हो सकती है.

ऐक्शन नोड

ऐक्शन नोड वह जगह है जहां ऑटोमेशन का काम होता है. इस उदाहरण में, कार्रवाई AssistantBroadcastTrait के broadcast() कमांड को ट्रिगर करती है:

action(speaker, SpeakerDeviceType.self) {
  Google.AssistantBroadcastTrait.broadcast(msg: "Oven Cycle Complete")
}