जटिल ऑटोमेशन के लिए Android DSL गाइड

ऑटोमेशन डीएसएल का इस्तेमाल करके, ऐसे ऑटोमेशन बनाए जा सकते हैं जो उनसे ज़्यादा जटिल होते हैं जिनके बारे में डीएसएल गाइड - Android पर बुनियादी ऑटोमेशन में बताया गया है.

एक के बाद एक कई कार्रवाइयां करना

कोई ऑटोमेशन एक से ज़्यादा काम कर सकता है. उदाहरण के लिए, action नोड की जगह, एक से ज़्यादा action नोड इस्तेमाल किए जा सकते हैं. ये नोड, एक के बाद एक क्रम में काम करते हैं:

automation {
  sequential {
    starter<_>(...)
    condition {...}
    action {...}
    action {...}
    action {...}
    }
}

एक के बाद एक कई कार्रवाइयां करना, जिनमें से कुछ एक साथ की जा सकती हैं

अगर parallel नोड में एक से ज़्यादा action नोड शामिल किए जाते हैं, तो कार्रवाइयां एक साथ की जाती हैं.

automation {
  sequential {
    starter<_>(...)
    condition {...}
    parallel {
      action {...}
      action {...}
      action {...}
    }
  }
}

अगर sequential नोड में ऐसे action नोड शामिल हैं जो parallel नोड के बाद आते हैं, तो वे तब तक इंतज़ार करते हैं, जब तक parallel नोड में शामिल सभी नोड काम करना पूरा नहीं कर लेते.

शर्तों के हिसाब से कार्रवाइयां करना

डिफ़ॉल्ट रूप से, कोई ऑटोमेशन नोड को एक के बाद एक क्रम में या एक साथ करता है. अगर आपको शर्तों के हिसाब से ब्रांचिंग लॉजिक की ज़रूरत है, तो रनटाइम की शर्तों के आधार पर अलग-अलग कार्रवाइयां या पाथ इस्तेमाल करें. इसके लिए, if-then-else स्टेटमेंट का इस्तेमाल करें. ये स्टेटमेंट, कंडिशनल कंट्रोल फ़्लो डीएसएल ब्लॉक का इस्तेमाल करके बनाए जाते हैं. जैसे: ifThen, elseIf, और orElse.

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

• condition नोड: अगर एक्सप्रेशन की वैल्यू false है, तो पूरे ऑटोमेशन (या मौजूदा एक्ज़ीक्यूशन पाथ) को काम करने से रोकता है.
• ifThen / elseIf / orElse: शर्तों की वैल्यू का आकलन क्रम से करता है. अगर किसी शर्त की वैल्यू false है, तो एक्ज़ीक्यूशन, अगले elseIf ब्रांच, orElse फ़ॉलबैक ब्रांच पर चला जाता है. अगर कोई शर्त पूरी नहीं होती है, तो ऑटोमेशन में शामिल अगले नोड पर चला जाता है.

शर्त के आधार पर कोई कार्रवाई करना

ifThen ब्लॉक, कंडिशनल एक्सप्रेशन की वैल्यू का आकलन करता है. अगर एक्सप्रेशन की वैल्यू true है, तो ब्लॉक में नेस्ट किए गए डीएसएल कार्रवाइयां या नोड किए जाते हैं. अगर इसकी वैल्यू false है, तो कार्रवाइयों को छोड़ दिया जाता है. साथ ही, ऑटोमेशन, क्रम में होने वाले फ़्लो में शामिल अगले नोड पर चला जाता है.

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

// When a door opens, turn on the light only if it is off,
// and always broadcast an announcement.
automation {
  sequential {
    val contactState = starter<_>(
      contactSensor,
      ContactSensorDevice,
      BooleanState,
    )
    val lightState = stateReader<_>(
      light,
      DimmableLightDevice,
      OnOff,
    )

    condition {
      // Door opened (contact sensor open)
      expression = contactState.stateValue equals false
    }

    // Conditionally turn on the light if it's off
    ifThen(lightState.onOff equals false) {
      action(light, DimmableLightDevice) { command(OnOff.on()) }
    }

    // Continue executing subsequent actions in the sequential flow
    action(structure) {
      command(AssistantBroadcast.broadcast("The door was opened."))
    }
  }
}

शर्त के आधार पर अलग-अलग कार्रवाइयां करना

अगर कोई शर्त पूरी होने पर कार्रवाइयों का एक सेट और शर्त पूरी न होने पर कार्रवाइयों का दूसरा सेट करना है, तो ifThen(...) { ... } के बाद, वैकल्पिक .orElse { ... } ब्लॉक को चेन करें:

// When the door is unlocked, turn on the entryway light if it is off;
// otherwise, broadcast a welcome message.
automation {
  sequential {
    val doorLockEvent = starter<_>(
      doorLock,
      DoorLockDevice,
      LockOperationEvent,
    )
    val lightState = stateReader<_>(
      light,
      DimmableLightDevice,
      OnOff,
    )

    condition {
      expression =
        doorLockEvent.lockOperationType equals LockOperationTypeEnum.Unlock
    }

    ifThen(lightState.onOff equals false) {
      action(light, DimmableLightDevice) { command(OnOff.on()) }
    }.orElse {
      action(structure) {
        command(AssistantBroadcast.broadcast("Welcome home!"))
      }
    }
  }
}

एक के बाद एक कई शर्तें चेन करना

एक के बाद एक कई शर्तों की वैल्यू का आकलन करने के लिए, एक या उससे ज़्यादा वैकल्पिक .elseIf(...) { ... } ब्लॉक को चेन किया जा सकता है. जिस पहली ब्रांच की शर्त की वैल्यू true होती है उसे लागू किया जाता है. साथ ही, बाकी सभी ब्रांच को छोड़ दिया जाता है. अगर किसी भी शर्त की वैल्यू true नहीं होती है, तो वैकल्पिक .orElse { ... } ब्लॉक लागू होता है. हालांकि, यह ब्लॉक तब लागू होता है, जब इसे जोड़ा गया हो:

// Adjust climate controls based on room temperature changes.
automation {
  sequential {
    val tempStarter = starter<_>(
      tempSensor,
      TemperatureSensorDevice,
      TemperatureMeasurement,
    )

    // If temperature is high (>= 28°C / 2800 mC), switch thermostat to Cool mode
    ifThen(tempStarter.measuredValue greaterThanOrEquals 2800) {
      action(thermostat, ThermostatDevice) {
        command(
          SimplifiedThermostat.setSystemMode(
            SimplifiedThermostatSystemModeEnum.Cool
          )
        )
      }
    }.elseIf(tempStarter.measuredValue lessThan 1800) {
      // If temperature is low (< 18°C / 1800 mC), switch to Heat mode
      action(thermostat, ThermostatDevice) {
        command(
          SimplifiedThermostat.setSystemMode(
            SimplifiedThermostatSystemModeEnum.Heat
          )
        )
      }
    }.orElse {
      // Otherwise, turn on the fan
      action(fan, FanDevice) {
        command(OnOff.on())
      }
    }
  }
}

नेस्ट किए गए कंडिशनल फ़्लो

कंडिशनल ब्लॉक को अन्य ifThen, elseIf, या orElse ब्लॉक में नेस्ट किया जा सकता है. साथ ही, इन्हें parallel, delayFor, और stateReader नोड के साथ भी जोड़ा जा सकता है.

ifThen, elseIf, और orElse ब्लॉक, अपने कॉन्टेंट को एक के बाद एक क्रम में लागू करते हैं. हर ब्रांच में, एक के बाद एक क्रम में लागू होने वाले कोई भी नोड शामिल किए जा सकते हैं. इनमें action, stateReader, parallel, delayFor, और नेस्ट किए गए ifThen ब्लॉक शामिल हैं.

विलंब

delayFor कीवर्ड का इस्तेमाल करके, ऑटोमेशन में पॉज़ जोड़े जा सकते हैं. यह कीवर्ड, java.time.Duration आर्ग्युमेंट लेता है. इससे यह तय किया जाता है कि एक्ज़ीक्यूशन जारी रखने से पहले, कितने समय के लिए पॉज़ लेना है. पॉज़ की अवधि पांच सेकंड से लेकर 24 घंटे तक हो सकती है.

उदाहरण के लिए, किसी लाइट को चार बार टॉगल करने के लिए. हर टॉगल के बीच पांच सेकंड का पॉज़ लें:

sequential {
  action(light, OnOffLightDevice) { command(OnOff.toggle()) }
  delayFor(Duration.ofSeconds(5))
  action(light, OnOffLightDevice) { command(OnOff.toggle()) }
  delayFor(Duration.ofSeconds(5))
  action(light, OnOffLightDevice) { command(OnOff.toggle()) }
  delayFor(Duration.ofSeconds(5))
  action(light, OnOffLightDevice) { command(OnOff.toggle()) }
}

ट्रिगर को दबाना

ट्रिगर को दबाने की सुविधा की मदद से, आपका ऑटोमेशन, शुरुआती ट्रिगरिंग इवेंट के बाद, तय समय के लिए starter को अनदेखा कर सकता है. उदाहरण के लिए, अगर ऑटोमेशन में ऐसा starter है जो हलचल का पता लगाने वाली सुविधा से ट्रिगर होता है. साथ ही, अगर आपने ट्रिगर को दबाने की अवधि पांच मिनट तय की है, तो starter ट्रिगर होने के बाद, अगले पांच मिनट तक ट्रिगर नहीं होगा. इससे ऑटोमेशन को बार-बार ट्रिगर होने से रोका जा सकता है.

अपने ऑटोमेशन पर ट्रिगर को दबाने की सुविधा लागू करने के लिए, suppressFor कीवर्ड का इस्तेमाल करें. इसके साथ, java.time.Duration आर्ग्युमेंट का इस्तेमाल करें. इससे यह तय किया जाता है कि अगले ट्रिगर का जवाब देने से पहले, कितने समय तक इंतज़ार करना है. ट्रिगर को दबाने की अवधि पांच सेकंड से लेकर 24 घंटे तक हो सकती है.

automation {
  sequential {
    val starterNode = starter<_>(device, OccupancySensor, MotionDetection)
    suppressFor(Duration.ofMinutes(30))
    action(light, OnOffLightDevice) { command(OnOff.toggle()) }
}

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

एक्ज़ीक्यूशन की संख्या सीमित करना

ऑटोमेशन को रन करने की संख्या सीमित की जा सकती है.

उदाहरण के लिए, हो सकता है कि आपको एक बार चलने वाला ऐसा ऑटोमेशन सेट अप करना हो जो आपके घर से बाहर रहने के दौरान, वैक्यूम को चलाए.

इसके लिए, ऑटोमेशन के maxExecutionCount मेटाडेटा फ़ील्ड को सेट करें. यहां एक ऐसे ऑटोमेशन का उदाहरण दिया गया है जो सिर्फ़ एक बार लागू किया जा सकता है:

automation {
  // The automation can only be executed once.
  maxExecutionCount = 1
  // When the door lock state changes
  sequential {
    val doorLockEvent = starter<_>(doorLock, DoorLockDevice, LockOperationEvent)
    // if the door is unlocked
    condition() {
      expression = (doorLockEvent.lockOperationType equals LockOperationTypeEnum.Unlock)
    }
    // turn the light on
    action(light, DimmableLightDevice) { command(OnOff.on()) }
  }
}

ऑटोमेशन, आखिरी बार लागू होने के बाद तुरंत मिट जाता है. ऐसा तब होता है, जब maxExecutionCount की वैल्यू पूरी हो जाती है. ऑटोमेशन का इतिहास, Google Home app (GHA) गतिविधि टैब में दिखता है. इसमें automation_id भी शामिल होता है.

किसी कार्रवाई में ट्रेट एट्रिब्यूट सेट करना

किसी ट्रेट एट्रिब्यूट की वैल्यू सेट करने के लिए:

1. action नोड में update नोड बनाएं. इसमें, काम का ट्रेट, update नोड के लिए आर्ग्युमेंट के तौर पर शामिल करें:

   action(deviceReference, deviceType) {
     update(trait) {
   
     }
   }

2. update नोड में, हर उस एट्रिब्यूट के लिए जिसे बदलना है, म्यूटेटर फ़ंक्शन का इस्तेमाल करें. साथ ही, इसे नई वैल्यू पास करें. म्यूटेटर फ़ंक्शन का नाम बनाने के लिए:
   1. एट्रिब्यूट के नाम का पहला अक्षर कैपिटल करें
   2. इसके पहले, set शब्द जोड़ें.
   उदाहरण के लिए, defaultMoveRate नाम के एट्रिब्यूट को अपडेट करने के लिए, setDefaultMoveRate नाम के म्यूटेटर फ़ंक्शन का इस्तेमाल करें.

ध्यान दें कि update नोड में एक से ज़्यादा म्यूटेटर फ़ंक्शन हो सकते हैं. यहां एक ऐसा उदाहरण दिया गया है जिसमें दो एट्रिब्यूट अपडेट किए गए हैं:

action(device, Fan) {
  update(FanControl) {
    setPercentSetting(50u)
    setRockSetting(FanControlCluster.RockBitmap.rockUpDown)
  }
}