iOS डीएसएल गाइड

संग्रह की मदद से व्यवस्थित रहें अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.

ऑटोमेशन बनाने के लिए, अलग-अलग ऑटोमेशन डीएसएल नोड का इस्तेमाल कैसे किया जा सकता है, यह समझने के लिए नीचे दी गई गाइड का इस्तेमाल करें.

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

क्रम में चलने वाला फ़्लो

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

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

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
)

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

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

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

typealias TimeTrait = Google.TimeTrait

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

मैन्युअल स्टार्टर

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

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

• किसी खास तरह की जानकारी या डिवाइस टाइप की जानकारी न दें.
• ऐसा यूज़र इंटरफ़ेस (यूआई) एलिमेंट दें जो 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 नोड में ट्रैट एट्रिब्यूट की वैल्यू कैप्चर करें. 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)
}

शर्त की अवधि

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

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

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

ऐक्शन नोड

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

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