Cette page a été traduite par l'API Cloud Translation.

Exemples d'automatisations sur iOS
Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Voici quelques exemples d'automatisations pour vous montrer la variété des tâches pouvant être automatisées à l'aide de l'API Automation et vous inspirer d'autres idées.

Allumer un appareil lorsqu'un autre est allumé ou éteint

import GoogleHomeSDK
import GoogleHomeTypes

typealias OnOffTrait = Matter.OnOffTrait

...

let starterNode = starter(device1, OnOffLightDeviceType.self, OnOffTrait.self)
let device2State = stateReader(device2, OnOffLightDeviceType.self, OnOffTrait.self

automation (
  name: "Turn on a device",
  description:
    """
    Turn on a device when another device is turned on or off
    """
) {
 starterNode
 device2State
 condition {
   // Only send the command if device2 is off
   device2State.onOff.equals(false)
 }
 // Turn on device 2
 action(device2, OnOffLightDeviceType.self) {
   OnOffTrait.on()
 }
}

import GoogleHomeSDK
import GoogleHomeTypes

typealias TemperatureMeasurementTrait = Matter.TemperatureMeasurementTrait
typealias TimeTrait = Google.TimeTrait
typealias WindowCoveringTrait = Matter.WindowCoveringTrait

let temperatureMeasurement = stateReader(
  thermostatDevice,
  TemperatureSensorDeviceType.self,
  TemperatureMeasurementTrait.self
)
let time = stateReader(structure, TimeTrait.self)

automation (
  name: "Close window blinds",
  description:
    """
    Automatically close window blinds when the temperature outside drops below 60F and it's dark
    outside.
    """
) {
  select {
    starter(
      eveThermostat,
      TemperatureSensorDeviceType.self,
      TemperatureMeasurementTrait.self
    )
    starter(structure, TimeTrait.ScheduledEvent.self) {
      TimeTrait.ScheduledEvent.solarTime(SolarTime(type: .sunrise, offset: .seconds(0)))
    }
    starter(structure, TimeTrait.ScheduledEvent.self) {
      TimeTrait.ScheduledEvent.solarTime(SolarTime(type: .sunset, offset: .seconds(0)))
    }
  }
  temperatureMeasurement
  time
  let exp1 = temperatureMeasurement.measuredValue.lessThan(1555)  // 15 degrees C ~ 60 degrees F
  let exp2 =
    localTimeBetweenCondition != nil
    ? time.currentTime.between(localTimeBetweenCondition!.0, localTimeBetweenCondition!.1)
    : time.currentTime.between(time.sunriseTime, time.sunsetTime)
  condition {
    exp1.and(exp2.not())
  }
  parallel {
    for windowBlind in windowBlinds {
      action(windowBlind, WindowCoveringDeviceType.self) {
        WindowCoveringTrait.downOrClose()
      }
    }
  }
}

Si la porte de garage est laissée ouverte pendant plus de 10 minutes, envoyer une notification sur les téléphones des membres de la maison et diffuser un rappel pour qu'ils la ferment

import GoogleHomeSDK
import GoogleHomeTypes

typealias BooleanStateTrait = Matter.BooleanStateTrait

automation (
  name: "Broadcast reminder"
  description:
    """
    If garage door left open for more than 10 minutes,
    send a notification to household members phones
    and broadcast a reminder to close the garage door
    """
  )
{
    let garageSensorStarter = starter(
      garageDoorSensor,
      ContactSensorDeviceType.self,
      BooleanStateTrait.self
    )
    garageSensorStarter
    condition(
      for: .seconds(10 * 60)  // 10 minutes.
    ) {
      // stateValue - True means garage door is closed, False means open
      garageSensorStarter.stateValue.equals(false)
    }
    action(structure) {
      Google.AssistantBroadcastTrait.broadcast(msg: "Garage is open")
    }
    action(structure) {
      Google.NotificationTrait.sendNotifications(
        title: "Garage is open", body: nil, optInMemberEmailsArray: [])
    }
  }
}

Lorsque la porte du garage s'ouvre, allumer les lumières du porche et de l'allée

import GoogleHomeSDK
import GoogleHomeTypes

typealias OnOffTrait = Matter.OnOffTrait
typealias BooleanStateTrait = Matter.BooleanStateTrait

automation (
  name: "Turn on lights"
  description:
    """
    When the garage door opens, turn on porch and driveway lights
    """
) {
  let garageSensorStarter = starter(
    garageDoorSensor,
    ContactSensorDeviceType.self,
    BooleanStateTrait.self
  )
  garageSensorStarter
  condition {
    // stateValue - True means garage door is closed, False means open
    garageSensorStarter.stateValue.equals(false)
  }
  parallel {
    for light in drivewayLights {
      action(light, OnOffLightDeviceType.self) {
        OnOffTrait.on()
      }
    }
    for light in porchLights {
      action(light, OnOffLightDeviceType.self) {
        OnOffTrait.on()
      }
    }
  }
}

Si la télévision est allumée lorsque le cycle du four est terminé, les lumières du salon clignotent et l'enceinte connectée diffuse le message "Cycle du four terminé".

import GoogleHomeSDK
import GoogleHomeTypes

typealias OnOffTrait = Matter.OnOffTrait
typealias OperationalStateTrait = Matter.OperationalStateTrait

automation (
  name: "Broadcast oven cycle complete"
  description:
    """
    If TV is on when oven cycle completes,
    living room lights blink and smart speaker broadcasts \"Oven Cycle Complete\"
    """
) {
  let ovenCompletedEvent = starter(
    oven,
    OvenDeviceType.self,
    OvenCavityOperationalStateTrait.OperationCompletionEvent.self
  )
  ovenCompletedEvent
  condition {
    ovenCompletedEvent
      .completionErrorCode
      .equals(0x00)  // no error
  }

  let operationalState = stateReader(
    oven,
    OvenDeviceType.self,
    OvenCavityOperationalStateTrait.self
  )
  operationalState
  condition {
    operationalState.phaseList[operationalState.currentPhase.toUInt()].equals("pre-heated")
  }

  let tvOnOff = stateReader(
    tv,
    GoogleTVDeviceType.self,
    OnOffTrait.self
  )
  tvOnOff
  condition {
    tvOnOff.onOff.equals(true)
  }

  parallel {
    for speaker in speakers {
      action(speaker, SpeakerDeviceType.self) {
        Google.AssistantBroadcastTrait.broadcast(msg: "Oven Cycle Complete")
      }
    }
    for light in lights {
      action(light, OnOffLightDeviceType.self) {
        OnOffTrait.toggle()
      }
    }
  }
  delay(for: .seconds(30))
  parallel {
    for light in lights {
      action(light, OnOffLightDeviceType.self) {
        OnOffTrait.toggle()
      }
    }
  }
}

À 21h, si quelqu'un est à la maison, la télévision s'éteint, les lumières de la chambre des enfants s'atténuent et la température de la climatisation est réglée sur une certaine température

import GoogleHomeSDK
import GoogleHomeTypes
typealias OnOffTrait = Matter.OnOffTrait
typealias ThermostatTrait = Matter.ThermostatTrait

automation(
  name: "Turn AC on",
  description:
    """
    At 9pm, if someone is home, TV turns off, kids' bedroom lights dim,
    GE AC turns to [X#] degrees
    """
) {
  let timeStarter = starter(
    structure,
    Google.TimeTrait.ScheduledEvent.self
  ) {
    Google.TimeTrait.ScheduledEvent.clockTime(scheduledTime)
  }

  let stateReaderNode = stateReader(
    structure,
    Google.AreaPresenceStateTrait.self
  )
  timeStarter
  stateReaderNode
  condition {
    stateReaderNode
      .presenceState
      .equals(Google.AreaPresenceStateTrait.PresenceState.presenceStateOccupied)
  }
  parallel {
    action(tv, GoogleTVDeviceType.self) {
      OnOffTrait.off()
    }

    for light in kidBedroomLights {
      action(light, DimmableLightDeviceType.self) {
        LevelControlTrait.moveToLevel(
          level: dimmedLightLevel,
          transitionTime: 10,
          optionsMask: LevelControlTrait.OptionsBitmap(),
          optionsOverride: LevelControlTrait.OptionsBitmap()
        )
      }
    }
    let fahrenheit = Measurement(value: acTempInFahrenheit, unit: UnitTemperature.fahrenheit)
    let setpoint = Int16(fahrenheit.converted(to: .celsius).value)
    action(geAc, RoomAirConditionerDeviceType.self) {
      update(ThermostatTrait.self) {
        $0.setOccupiedCoolingSetpoint(setpoint * 100)
      }
    }
  }
}

Annoncer "Le linge est prêt" sur les enceintes de la chambre à coucher lorsque le cycle de la machine à laver est terminé

import GoogleHomeSDK
import GoogleHomeTypes

typealias OperationalStateTrait = Matter.OperationalStateTrait

automation(
  name: "Broadcast laundry is done",
  description:
    """
    Announce \"laundry is done\" on bedroom speakers when the laundry machine cycle completes
    """
) {
  let laundryWasherCompletionEvent = starter(
    laundryWasher,
    LaundryWasherDeviceType.self,
    OperationalStateTrait.OperationCompletionEvent.self
  )
  laundryWasherCompletionEvent
  condition {
    laundryWasherCompletionEvent
      .completionErrorCode
      .equals(0x00)
  }

  action(bedroomSpeaker, SpeakerDeviceType.self) {
    Google.AssistantBroadcastTrait.broadcast(msg: "laundry is done")
  }
}

Arrivée à la maison: si la serrure Aqara est déverrouillée et qu'il est après le coucher du soleil, la lumière du plafond s'allume, le thermostat tiers est réglé sur 26 °C, les prises intelligentes redémarrent, le téléviseur et la cafetière s'allument. L'enceinte intelligente dit "Bienvenue à la maison !"

import GoogleHomeSDK
import GoogleHomeTypes

typealias DoorLockTrait = Matter.DoorLockTrait
typealias ThermostatTrait = Matter.ThermostatTrait

automation(
  name: "Door unlock turn on appliances",
  description:
    """
    Home Arrival: If Aqara lock is unlocked and it is after sunset,
    ceiling light turns on,
    update the 3P thermostat setting to 26 degress, smart plugs restart power, TV and coffeemaker
    turn on. Smart speaker says \"Welcome Home!\"
     """
) {
  let doorLockEvent = starter(
    doorLock, DoorLockDeviceType.self,
    DoorLockTrait.LockOperationEvent.self
  )
  let doorIsUnlocked = doorLockEvent.lockOperationType.equals(.unlock)

  let timeCondition =
    localTimeBetweenCondition != nil
    ? time.currentTime.between(localTimeBetweenCondition!.0, localTimeBetweenCondition!.1)
    : time.currentTime.between(time.sunsetTime, time.sunriseTime)

  time
  doorLockEvent
  condition {
    doorIsUnlocked.and(timeCondition)
  }

  parallel {
    for light in allLights {
      action(light, DimmableLightDeviceType.self) {
        OnOffTrait.on()
      }
    }

    action(thermostat, ThermostatDeviceType.self) {
      update(ThermostatTrait.self) {
        $0.setOccupiedCoolingSetpoint(2600)
      }
    }
    action(plug, OnOffPluginUnitDeviceType.self) {
      OnOffTrait.on()
    }
    action(tv, GoogleTVDeviceType.self) {
      OnOffTrait.on()
    }
    action(coffeemaker, CooktopDeviceType.self) {
      OnOffTrait.on()
    }
    action(structure) {
      Google.AssistantBroadcastTrait.broadcast(msg: "Welcome Home!")
    }
  }
}

L'utilisateur peut créer une routine de mode Air frais qui démarre le ventilateur de plafond et l'aspirateur

import GoogleHomeSDK
import GoogleHomeTypes

typealias FanControlTrait = Matter.FanControlTrait

automation(
  name: "Fan and vaccum turn on",
  description:
    """
    User can create "Fresh Air Mode" routine which starts the ceiling fan,
    and vacuum
    """
) {
  manualStarter()

  parallel {
    action(fan, FanDeviceType.self) {
      update(FanControlTrait.self) {
        $0.setFanMode(.on)
      }
    }
    action(vacuum, RoboticVacuumCleanerDeviceType.self) {

      // 0 - idle, 1 - cleaning, 2 - mapping
      RvcRunModeTrait.changeToMode(newMode: 1)
    }
  }
}

Lorsque l'utilisateur allume les lumières de la chambre et qu'il est plus de 21 heures, l'ampoule de la chambre passe à une couleur chaude pour la détente, les volets se ferment à 15 heures et la climatisation se règle sur 2 degrés en dessous de la température ambiante pour rafraîchir la pièce. Google Nest Audio diffuse des "sons de pluie".

import GoogleHomeSDK
import GoogleHomeTypes

typealias OnOffTrait = Matter.OnOffTrait
typealias WindowCoveringTrait = Matter.WindowCoveringTrait

automation(
  name: "Bulbs warm color after 9pm",
  description:
    """
    When user turns on bedroom lights, and the time is after 9p, bedroom bulb adjusts
    to warm color to relax, 3P shades close,mini-split air conditioner adjusts
    down 2 degrees to cool the room. Google Nest Audio plays 'rain sounds'.
    """
) {
  select {
    for light in bedroomLights {
      let lightOnOffState = starter(
        light,
        OnOffLightDeviceType.self,
        OnOffTrait.self
      )
      lightOnOffState
      condition { lightOnOffState.onOff.equals(true) }
    }
  }
  let time = stateReader(structure, Google.TimeTrait.self)
  time
  condition {
    time.currentTime.between(
      betweenConditionTime.0,
      betweenConditionTime.1
    )
  }
  parallel {
    for light in colorControlBedroomLights {
      action(light, ColorTemperatureLightDeviceType.self) {
        ColorControlTrait.moveToColorTemperature(
          colorTemperatureMireds: 200,
          transitionTime: 10,
          optionsMask: 0,
          optionsOverride: 0
        )
      }
    }
    action(windowBlind, WindowCoveringDeviceType.self) {
      WindowCoveringTrait.downOrClose()
    }
    action(thermostatDevice, RoomAirConditionerDeviceType.self) {
      ThermostatTrait.setpointRaiseLower(
        mode: .cool,
        amount: 2
      )
    }
    action(speaker, SpeakerDeviceType.self) {
      Google.AssistantFulfillmentTrait.okGoogle(query: "Play rain sound.")
    }
  }
}

Allumez les lumières ou désactivez le mode Éco du thermostat lorsque vous déverrouillez la porte.

import GoogleHomeSDK
import GoogleHomeTypes

typealias DoorLockTrait = Matter.DoorLockTrait
typealias OnOffTrait = Matter.OnOffTrait
typealias ThermostatTrait = Matter.ThermostatTrait

 automation(
  name: "Unlock door, turn on lights or turn off thermostat",
  description:
    """
    Turn on lights or turn off thermostat eco mode when you unlock the door.
    """
) {
  let doorLockEvent = starter(
    doorLock,
    DoorLockDeviceType.self,
    DoorLockTrait.LockOperationEvent.self
  )
  doorLockEvent
  condition {
    doorLockEvent.lockOperationType.equals(.unlock)
  }
  parallel {
    for light in allLights {
      action(light, OnOffLightDeviceType.self) {
        OnOffTrait.on()
      }
      // Assume the thermostat is in eco mode, set to auto.
      action(thermostat, ThermostatDeviceType.self) {
        Google.SimplifiedThermostatTrait.setSystemMode(systemMode: .auto)
       }
    }
  }
}

À 21h, verrouillez la porte

import GoogleHomeSDK
import GoogleHomeTypes

typealias DoorLockTrait = Matter.DoorLockTrait

automation(
  name: "Lock the door",
  description: "At 9pm lock the door."
) {
  starter(structure, Google.TimeTrait.ScheduledEvent.self) {
    Google.TimeTrait.ScheduledEvent.clockTime(startTime)
  }
  action(doorLock, DoorLockDeviceType.self) {
    DoorLockTrait.lockDoor()
  }
}

Éteignez les lumières lorsque tout le monde est absent.

import GoogleHomeSDK
import GoogleHomeTypes

typealias OnOffTrait = Matter.OnOffTrait

automation(
  name: "Turn off light",
  description: "When everyone is away from home, turn off lights."
) {
  let homeAwayState = starter(structure, Google.AreaPresenceStateTrait.self)
  homeAwayState
  condition {
    homeAwayState.presenceState.equals(.presenceStateVacant)
  }

  parallel {
    for light in allLights {
      action(light, OnOffLightDeviceType.self) {
        OnOffTrait.off()
      }
    }
  }
}

Si un mouvement est détecté (capteur), diffusez un son d'alarme sur les enceintes intelligentes, allumez et éteignez régulièrement les lumières et le téléviseur pour dissuader les intrus.

import GoogleHomeSDK
import GoogleHomeTypes

typealias OccupancySensingTrait = Matter.OccupancySensingTrait
typealias OnOffTrait = Matter.OnOffTrait

automation(
  name: "Motion sensed, turn lights on and off to deter intruders",
  description:
    """
    If motion (sensor) is detected, broadcast alarm sound on smart speakers,
    turn lights on and off periodically and TV to deter intruders.
    """
) {
  let motionStarter =
    starter(motionSensor, OccupancySensorDeviceType.self, OccupancySensingTrait.self)
  let homeAwayState = stateReader(structure, Google.AreaPresenceStateTrait.self)
  motionStarter
  homeAwayState

  let exp1 = homeAwayState.presenceState.equals(.presenceStateVacant)
  let exp2 = motionStarter.occupancy.equals(.occupied)

  condition {
    exp1.and(exp2)
  }

  action(structure) {
    Google.AssistantBroadcastTrait.broadcast(msg: "ALARM! ALARM! ALARM!")
  }

  turnOnOff(lights: allLights, tv: tv, shouldTurnOn: true)
  delay(for: Duration.seconds(5))
  turnOnOff(lights: allLights, tv: tv, shouldTurnOn: false)
  delay(for: Duration.seconds(5))
  turnOnOff(lights: allLights, tv: tv, shouldTurnOn: true)
}

private func turnOnOff(
  lights: Set<HomeDevice>,
  tv: HomeDevice,
  shouldTurnOn: Bool
) -> ParallelFlow {
  parallel {
    for light in lights {
      action(light, OnOffLightDeviceType.self) {
        shouldTurnOn ? OnOffTrait.on() : OnOffTrait.off()
      }
    }
    action(tv, GoogleTVDeviceType.self) {
      shouldTurnOn ? OnOffTrait.on() : OnOffTrait.off()
    }
  }
}

Lampe dans sa chambre. Si il est plus de 22h et que l'utilisateur éteint la lampe, toutes les lumières de la pièce s'éteignent, les stores se ferment et la porte d'entrée se verrouille (serrure non Matter).

import GoogleHomeSDK
import GoogleHomeTypes

typealias WindowCoveringTrait = Matter.WindowCoveringTrait
typealias OnOffTrait = Matter.OnOffTrait
typealias DoorLockTrait = Matter.DoorLockTrait

automation(
  name: "After 10pm, turn all lights off, close shades, lock front door",
  description:
    """
    User has Lamp in their bedroom. If it is after 10pm and the user turns off the lamp,
    then all room lights turn off, shades close, front door locks (non-matter lock).
    """
) {
  let lampOnOffState = starter(Lamp, DimmableLightDeviceType.self, OnOffTrait.self)
  let time = stateReader(structure, Google.TimeTrait.self)
  lampOnOffState
  time
  let expr1 = lampOnOffState.onOff.equals(false)
  let expr2 = time.currentTime.between(
    localTimeBetweenCondition.0,
    localTimeBetweenCondition.1
  )

  condition {
    expr1.and(expr2)
  }

  parallel {
    for light in allLights {
      action(light, DimmableLightDeviceType.self) {
        OnOffTrait.off()
      }
    }
    action(windowBlind, WindowCoveringDeviceType.self) {
      WindowCoveringTrait.downOrClose()
    }
    action(doorLock, DoorLockDeviceType.self) {
      DoorLockTrait.lockDoor()
    }
  }
}

Si l'utilisateur dit "Hey Google, je ne peux pas dormir", diffusez des sons de vagues de l'océan, allumez le ventilateur, allumez la prise intérieure et baissez les stores tiers.

import GoogleHomeSDK
import GoogleHomeTypes

typealias FanControlTrait = Matter.FanControlTrait
typealias OnOffTrait = Matter.OnOffTrait
typealias WindowCoveringTrait = Matter.WindowCoveringTrait

automation(
  name: "Turn sleep sound, fan, indoor plug on",
  description:
    """
    If user says "Hey Google, I can't sleep",
    play ocean wave sounds, turn on the Fan,
    Indoor Plug turns on, and 3P shades roll down
    """
) {
  starter(structure, Google.VoiceStarterTrait.OkGoogleEvent.self) {
    Google.VoiceStarterTrait.OkGoogleEvent.query("I can't sleep")
  }
  parallel {
    action(speaker, SpeakerDeviceType.self) {
      Google.AssistantFulfillmentTrait.okGoogle(query: "Play ocean wave sounds")
    }
    action(fan, FanDeviceType.self) {
      update(FanControlTrait.self) {
        $0.setFanMode(.on)
      }
    }
    action(plug, OnOffPluginUnitDeviceType.self) {
      OnOffTrait.on()
    }
    action(shades, WindowCoveringDeviceType.self) {
      WindowCoveringTrait.downOrClose()
    }
  }
}

Si le capteur de présence ou d'occupation détecte que le salon est vide, le ventilateur s'éteint, la climatisation passe en mode Éco et le robot aspirateur démarre (une fois par jour maximum).

import GoogleHomeSDK
import GoogleHomeTypes

typealias OccupancySensingTrait = Matter.OccupancySensingTrait
typealias FanControlTrait = Matter.FanControlTrait

{

  let time = stateReader(structure, Google.TimeTrait.self)
  let timeCondition: TypedExpression<Bool>

  if let localTimeBetweenCondition {
    timeCondition = time.currentTime.between(
      localTimeBetweenCondition.0,
      localTimeBetweenCondition.1
    )
  } else {
    timeCondition = time.currentTime.between(time.sunriseTime, time.sunsetTime)
  }
  return automation(
    name: "No motion detected, turn off fan and turn on vacuum",
    description:
      """
      If presence/occupancy sensor detects that the living room is empty, fan turns off,
      AC goes into Eco mode and robot vacuum starts (max once per day)
      """
  ) {


{
    let occupancySensorStarter = starter(
      occupancySensor,
      OccupancySensorDeviceType.self,
      OccupancySensingTrait.self
    )

    occupancySensorStarter
    time
    condition {
      occupancySensorStarter.occupancy.notEquals(.occupied)
        .and(timeCondition)
    }
     suppress(for: .seconds(43200))  // 12 hours
    parallel {
      action(fan, FanDeviceType.self) {
        update(FanControlTrait.self) {
          $0.setFanMode(.off)
        }
      }
      action(thermostat, ThermostatDeviceType.self) {
        Google.SimplifiedThermostatTrait.setSystemMode(systemMode: .eco)
      }
      action(vacuum, RoboticVacuumCleanerDeviceType.self) {
        RvcRunModeTrait.changeToMode(newMode: 1)
      }
    }
  }
}

Si tout le monde est absent et que le capteur de porte ou de fenêtre s'ouvre, toutes les enceintes ou écrans connectés à Google Home diffusent l'alerte "Intrus ! Intrus ! Intrus !".

import GoogleHomeSDK
import GoogleHomeTypes

typealias DoorLockTrait = Matter.DoorLockTrait
typealias BooleanStateTrait = Matter.BooleanStateTrait

automation(
  name: "Broadcast intruder alert when door is open if no one is home",
  description:
    """
    If everyone is away and the door or window sensor opens, all Google Home-connected
    smart speaker or displays broadcast 'Intruder Alert, Intruder Alert, Intruder Alert'
    """
) {
  sequential {
    let areaPresenceState = starter(structure, Google.AreaPresenceStateTrait.self)
    areaPresenceState
    condition {
      areaPresenceState.presenceState.equals(.presenceStateVacant)
    }
    let doorLockState = stateReader(
      doorLock,
      DoorLockDeviceType.self,
      DoorLockTrait.self
    )
    // In a Contact Sensor device type, FALSE=open or no contact, TRUE=closed or contact.
    let contactSensorState = stateReader(
      contactSensor,
      ContactSensorDeviceType.self,
      BooleanStateTrait.self
    )
    doorLockState
    contactSensorState
    condition {
      let exp1 = doorLockState.lockState.equals(.unlocked)
      let exp2 = contactSensorState.stateValue.equals(false)
      return exp1.or(exp2)
    }
    action(structure) {
      Google.AssistantBroadcastTrait.broadcast(
        msg: "Intruder Alert, Intruder Alert, Intruder Alert"
      )
    }
  }
}
}

Lorsque les utilisateurs regardent des contenus multimédias sur leur Chromecast le soir, la duplication d'écran s'active et les volets connectés s'abaissent (automatisations)

import GoogleHomeSDK
import GoogleHomeTypes

typealias WindowCoveringTrait = Matter.WindowCoveringTrait

automation(
  name: "Lower blinds when media is played",
  description:
    """
    When users plays media on their Chromecast in the evening, Screen Mirror
    activates and smart blinds lower (Automations)
    """
) {
   select {
    sequential {
      playbackStarter
      time
      let isPlaying = playbackStarter.currentState.equals(.playing)
      condition {
        isPlaying.and(timeCondition)
      }
    }
    starter(structure, Google.VoiceStarterTrait.OkGoogleEvent.self) {
      Google.VoiceStarterTrait.OkGoogleEvent.query("resume my movie night")
    }
  }
  action(nanoleaf4dLight, OnOffLightDeviceType.self) {
    Google.ExtendedModeSelectTrait.changeModeSettings(
      updateModeSettings: [
        Google.ExtendedModeSelectTrait.ModeSetting(
          modeNameKey: "Light Mode",
          modeValueKey: "Screen Mirror"
        )
      ]
    )
  }

  parallel {
    for windowBlind in windowBlinds {
      action(windowBlind, WindowCoveringDeviceType.self) {
        WindowCoveringTrait.downOrClose()
      }
    }
  }
}

Lorsque l'utilisateur met Chromecast en pause, la duplication d'écran est mise en pause et les volets intelligents restent abaissés. L'utilisateur peut reprendre Chromecast en disant "Ok G" ou en le faisant manuellement à l'aide d'une télécommande ou de son téléphone.

import GoogleHomeSDK
import GoogleHomeTypes

typealias WindowCoveringTrait = Matter.WindowCoveringTrait

{
  let mediaPlayback = starter(tv, GoogleTVDeviceType.self, MediaPlaybackTrait.self)
  let time = stateReader(structure, Google.TimeTrait.self)
  let timeCondition: TypedExpression<Bool>
  if let localTimeBetweenCondition {
    timeCondition = time.currentTime.between(
      localTimeBetweenCondition.0,
      localTimeBetweenCondition.1
    )
  } else {
    timeCondition = time.currentTime.between(time.sunsetTime, time.sunriseTime)
  }
automation(
  name: "When Chromecast pauses, pause screen mirror",
  description:
    """
    When the user pauses Chromecast, Screen Mirror pauses and smart blinds stay lowered.
    The user can resume Chromecast using "Ok G" or by resuming Chromecast manually using
    a remote or their phone.
    """
) {
  mediaPlayback
  time
  let isPaused = mediaPlayback.currentState.equals(.paused)
  condition {
    isPaused.and(timeCondition)
  }

  action(nanoleaf4dLight, OnOffLightDeviceType.self) {
    Google.ExtendedModeSelectTrait.changeModeSettings(
      updateModeSettings: [
        Google.ExtendedModeSelectTrait.ModeSetting(
          modeNameKey: "Light Mode",
          modeValueKey: "Screen Mirror Pause"
        )
      ]
    )
  }

  parallel {
    for windowBlind in windowBlinds {
      action(windowBlind, WindowCoveringDeviceType.self) {
        WindowCoveringTrait.downOrClose()
        }
      }
    }
  }
}

Lorsque l'utilisateur arrête ou met fin à la lecture multimédia sur le Chromecast, l'appareil arrête la duplication d'écran et revient à son état d'origine avant la duplication d'écran (automatisations)

import GoogleHomeSDK
import GoogleHomeTypes

typealias WindowCoveringTrait = Matter.WindowCoveringTrait

{
  let playbackState = starter(tv, GoogleTVDeviceType.self, MediaPlaybackTrait.self)
  let time = stateReader(structure, Google.TimeTrait.self)
  let timeCondition: TypedExpression<Bool>
  if let localTimeBetweenCondition {
    timeCondition = time.currentTime.between(
      localTimeBetweenCondition.0,
      localTimeBetweenCondition.1
    )
  } else {
    timeCondition = time.currentTime.between(time.sunsetTime, time.sunriseTime)
  }
automation(
  name: "When media stops, screen mirroring stops",
  description:
    """
    When the user stops/ends media play on the Chromecast, the device stops screen mirroring
    and goes back to the original state that it was on before screen mirror (Automations)
    """
) {
  playbackState
  time
  let isNotPlaying = playbackState.currentState.equals(.notPlaying)

  condition {
    isNotPlaying.and(timeCondition)
  }

  action(nanoleaf4dLight, OnOffLightDeviceType.self) {
    Google.ExtendedModeSelectTrait.changeModeSettings(
      updateModeSettings: [
        Google.ExtendedModeSelectTrait.ModeSetting()
      ]
    )
  }

  parallel {
    for windowBlind in windowBlinds {
      action(windowBlind, WindowCoveringDeviceType.self) {
        WindowCoveringTrait.upOrOpen()
        }
      }
    }
  }
}

Si l'utilisateur éteint la smart TV de la chambre entre 22h et 6h du matin, les lumières passent au blanc chaud et commencent à s'éteindre progressivement. La bande lumineuse et les panneaux hexagonaux s'assombrissent.

import GoogleHomeSDK
import GoogleHomeTypes

typealias OnOffTrait = Matter.OnOffTrait
typealias LevelControlTrait = Matter.LevelControlTrait
typealias ColorControlTrait = Matter.ColorControlTrait

{
  var matterLights = Set<HomeDevice>()
  var smartHomeLights = Set<HomeDevice>()

  for light in bedroomColorTemperatureLights {
    if let device = await light.types.get(ColorTemperatureLightDeviceType.self) {
      if !device.traits.contains(Google.LightEffectsTrait.self),
        device.traits.contains(Matter.LevelControlTrait.self),
        device.traits[Matter.LevelControlTrait.self]?.supportsMoveWithOnOffCommand ?? false
      {
        matterLights.insert(light)
      } else if device.traits.contains(Google.LightEffectsTrait.self),
        device.traits[Google.LightEffectsTrait.self]?.supportsSleepEffectSetCommand ?? false
      {
        smartHomeLights.insert(light)
      }
    }
  }
automation(
  structureID: structure.id,
  name: "Change lights when Smart TV is off",
  description:
    """
    If user turns bedroom Smart TV off and time is between 10pm - 6am,
    lights change to Warm White and begin to slowly fade off over time,
    light strip and hexagon panels dim.
    """
) {
{
  let tvOnOffState = starter(
    tv,
    GoogleTVDeviceType.self,
    OnOffTrait.self
  )
  let time = stateReader(
    structure,
    Google.TimeTrait.self
  )
  tvOnOffState
  time

  let tvIsOn = tvOnOffState.onOff.equals(false)
  let timeCondition = time.currentTime.between(
    localTimeBetweenCondition.0,
    localTimeBetweenCondition.1
  )

  condition {
    tvIsOn.and(timeCondition)
  }

  parallel {
    for light in matterLights {
      action(light, ColorTemperatureLightDeviceType.self) {
        LevelControlTrait.moveWithOnOff(
          moveMode: .down,
          rate: 1,
          optionsMask: LevelControlTrait.OptionsBitmap.coupleColorTempToLevel,
          optionsOverride: LevelControlTrait.OptionsBitmap.coupleColorTempToLevel
        )
      }
    }

    for light in smartHomeLights {
      action(light, ColorTemperatureLightDeviceType.self) {
        Google.LightEffectsTrait.sleepEffectSet(durationSeconds: 30)
      }
    }

    for lightStrip in bedroomLightStripsAndHexagonPanels {
      action(lightStrip, DimmableLightDeviceType.self) {
        LevelControlTrait.moveWithOnOff(
          moveMode: .down,
          rate: 10,
          optionsMask: LevelControlTrait.OptionsBitmap(),
          optionsOverride: LevelControlTrait.OptionsBitmap()
          )
        }
      }
    }
  }
}

Leverage device discovery

Trait support