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 वैल्यू भी शामिल हो सकती हैं. सब एक्सप्रेशन को पैरंटheses के साथ ग्रुप करने से, यह कंट्रोल किया जा सकता है कि उनका आकलन किस क्रम में किया जाए.

यहां 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 नोड में, ट्रेट एट्रिब्यूट की वैल्यू कैप्चर करें. stateReader, structure और ट्रेट को आर्ग्युमेंट के तौर पर लेता है:

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")
}