Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Guide de l'appareil d'éclairage

Les appareils d'éclairage utilisent des caractéristiques Matter standards pour identifier les luminaires, activer/désactiver l'alimentation et régler les niveaux de luminosité.

Le type d'appareil d'éclairage le plus basique est OnOffLight, qui est implémenté avec les traits OnOff et Identify, et qui accepte éventuellement les traits LevelControl et LightEffects.

D'autres types d'éclairage offrent des fonctionnalités supplémentaires et sont implémentés avec différents traits :

Type d'appareil pour les API Home	Caractéristiques	Exemple d'application Kotlin	Cas d'utilisation
Lumière à température de couleur `ColorTemperatureLightDevice` `home.matter.0000.types.010c` Appareil d'éclairage pouvant être allumé ou éteint, et dont l'intensité lumineuse et la température de couleur peuvent être ajustées.	Traits obligatoires matter Identify matter OnOff matter LevelControl matter ColorControl Caractéristiques facultatives google LightEffects google ExtendedColorControl	Allumer, éteindre, luminosité	Léger
Lampe avec variateur d'intensité `DimmableLightDevice` `home.matter.0000.types.0101` Un appareil d'éclairage qui peut être allumé ou éteint, dont l'intensité lumineuse peut être réglée et qui peut être contrôlé par un capteur de présence associé.	Traits obligatoires matter Identify matter OnOff matter LevelControl Caractéristiques facultatives google LightEffects	Allumer, éteindre, luminosité	Léger
Lumière de couleur étendue `ExtendedColorLightDevice` `home.matter.0000.types.010d` Dispositif d'éclairage pouvant être allumé ou éteint, dont l'intensité lumineuse et la température de couleur peuvent être ajustées, et qui peut être activé par un capteur de présence associé.	Traits obligatoires matter Identify matter OnOff matter LevelControl matter ColorControl Caractéristiques facultatives google LightEffects google ExtendedColorControl	Allumer, éteindre, luminosité	Léger
Voyant marche/arrêt `OnOffLightDevice` `home.matter.0000.types.0100` Un appareil d'éclairage qui peut être allumé ou éteint.	Traits requis matter Identify matter OnOff Caractéristiques facultatives matter LevelControl google LightEffects	Allumer, éteindre, luminosité	Léger

Assurez-vous toujours qu'un appareil prend en charge les attributs et les commandes nécessaires avant d'utiliser une fonctionnalité ou de tenter de mettre à jour des attributs. Pour en savoir plus, consultez Contrôler les appareils surAndroid.

Prérequis

Avant d'utiliser des appareils d'éclairage et des courbes d'éclairage, assurez-vous que votre application initialise le SDK Home et inclut les importations requises :

import com.google.home.HomeDevice
import com.google.home.Structure
import com.google.home.google.DayOfWeek
import com.google.home.google.ExtendedColorControl
import com.google.home.google.ExtendedColorControlTrait
import com.google.home.google.LightingCurve
import com.google.home.google.LightingCurveTrait
import com.google.home.matter.standard.ColorControl
import com.google.home.matter.standard.ColorControlTrait
import com.google.home.matter.standard.ColorTemperatureLightDevice
import com.google.home.matter.standard.DimmableLightDevice
import com.google.home.matter.standard.ExtendedColorLightDevice
import com.google.home.matter.standard.GeneralDiagnostics
import com.google.home.matter.standard.Identify
import com.google.home.matter.standard.IdentifyTrait
import com.google.home.matter.standard.LevelControl
import com.google.home.matter.standard.LevelControlTrait
import com.google.home.matter.standard.OnOff
import com.google.home.matter.standard.OnOffLightDevice
import com.google.home.matter.standard.OnOffTrait
import com.google.home.matter.standard.RootNodeDevice
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.flow.firstOrNull

Rechercher des appareils d'éclairage

Pour trouver des appareils d'éclairage dans une structure, filtrez la liste des appareils par type d'appareil, par exemple OnOffLightDevice et DimmableLightDevice.

// Get all On/Off Light devices in the structure
val onOffLights: List<HomeDevice> =
  home.devices().list().filter { it.has(OnOffLightDevice) }

// Get all Dimmable Light devices in the structure
val dimmableLights: List<HomeDevice> =
  home.devices().list().filter { it.has(DimmableLightDevice) }

// Retrieve a specific device type instance to access its traits
val onOffLightDevice: OnOffLightDevice? =
  onOffLights.firstOrNull()?.type(OnOffLightDevice)?.firstOrNull()

val dimmableLightDevice: DimmableLightDevice? =
  dimmableLights.firstOrNull()?.type(DimmableLightDevice)?.firstOrNull()

Vous pouvez également récupérer tous les appareils d'éclairage de plusieurs types d'appareils d'éclairage dans un seul filtre :

// Get a list of devices with similar device types (lights)
val lightDevices =
  home.devices().map { devices ->
    devices.filter {
      it.has(DimmableLightDevice) ||
        it.has(OnOffLightDevice) ||
        it.has(ColorTemperatureLightDevice) ||
        it.has(ExtendedColorLightDevice)
    }
  }

Obtenir des informations de base sur un appareil

Implémenté dans l'application exemple pour Android

Le trait BasicInformation inclut des informations telles que le nom du fournisseur, l'ID du fournisseur, l'identifiant produit, le nom du produit (y compris les informations sur le modèle) et la version logicielle d'un appareil :

// Get device basic information. All general information traits are on the RootNodeDevice type.
    device.type(RootNodeDevice).first().standardTraits.basicInformation?.let { basicInformation ->
        println("vendorName ${basicInformation.vendorName}")
        println("vendorId ${basicInformation.vendorId}")
        println("productId ${basicInformation.productId}")
        println("productName ${basicInformation.productName}")
        println("softwareVersion ${basicInformation.softwareVersion}")
    }

Identifier un appareil d'éclairage

Lorsqu'une pièce contient plusieurs lumières, vous pouvez aider les utilisateurs à localiser un appareil physique spécifique en déclenchant un état d'identification visuelle, par exemple en faisant clignoter la lumière pendant quelques secondes. Les quatre types d'appareils d'éclairage nécessitent le trait Identify.

Appelez la commande identify avec une durée identifyTime en secondes pour démarrer l'état d'identification. La transmission de 0 arrête immédiatement l'état d'identification. Vous pouvez également appeler triggerEffect pour exécuter un effet visuel spécifique, tel que Blink ou Breathe.

suspend fun identifyLight(lightDevice: DimmableLightDevice) {
  val identifyTrait = lightDevice.standardTraits.identify ?: return

  // Blink the light for 10 seconds so the user can locate it
  if (identifyTrait.supports(Identify.Command.Identify)) {
    identifyTrait.identify(identifyTime = 10u)
  }

  // Or trigger a specific visual identification effect
  if (identifyTrait.supports(Identify.Command.TriggerEffect)) {
    identifyTrait.triggerEffect(
      effectIdentifier = IdentifyTrait.EffectIdentifierEnum.Blink,
      effectVariant = IdentifyTrait.EffectVariantEnum.Default
    )
  }
}

Vérifier la connectivité d'un appareil d'éclairage

La connectivité d'un appareil est en fait vérifiée au niveau du type d'appareil, car certains appareils sont compatibles avec plusieurs types d'appareils. L'état renvoyé est une combinaison des états de connectivité de tous les traits de cet appareil.

let lightConnectivity =
  dimmableLightDeviceType.metadata.sourceConnectivity
  .connectivityState

Un état partiallyOnline peut être observé dans le cas de types d'appareils mixtes lorsqu'il n'y a pas de connectivité Internet. Les caractéristiques standards Matter peuvent toujours être en ligne en raison du routage local, mais les caractéristiques dans le cloud seront hors connexion.

Obtenir l'adresse IP de l'appareil

Pour trouver l'adresse IP de l'appareil, utilisez l'attribut networkInterfaces de GeneralDiagnosticsTrait. Les adresses sont renvoyées sous forme d'objets Data, que vous pouvez formater en chaînes IPv4 ou IPv6 standards à l'aide du framework Network :

func getIpAddresses(trait: Matter.GeneralDiagnosticsTrait) -> [String] {
  let interfaces = trait.attributes.networkInterfaces ?? []
  var ipAddresses: [String] = []

  for interface in interfaces {
    for data in interface.iPv4Addresses {
      if let ipv4 = IPv4Address(data) {
        ipAddresses.append(String(describing: ipv4))
      }
    }
    for data in interface.iPv6Addresses {
      if let ipv6 = IPv6Address(data) {
        ipAddresses.append(String(describing: ipv6))
      }
    }
  }

  return ipAddresses
}

Contrôler les appareils d'éclairage

Les types d'appareils OnOffLight et DimmableLight utilisent des caractéristiques Matter standards pour identifier les luminaires, activer/désactiver l'alimentation et régler les niveaux de luminosité.

Allumer ou éteindre une lumière

Utilisez le trait OnOff pour lire l'état d'alimentation actuel d'un OnOffLight ou d'un DimmableLight, et pour allumer ou éteindre la lumière.

Avant de lire l'attribut onOff, vérifiez que l'appareil le prend en charge. Certains appareils fonctionnent comme des points de terminaison de commande uniquement et ne signalent pas l'état.

// Check if the OnOff trait supports the onOff attribute.
if (onOffTrait.supports(OnOff.Attribute.onOff)) {
  println("onOffTrait supports onOff state")
} else {
  println("onOffTrait is for a command only device!")
}

Lorsque onOff est true, le voyant est allumé. Lorsque onOff est false, le voyant est éteint.

Pour modifier l'état d'alimentation de la lumière, vérifiez que le trait est compatible avec la commande prévue, puis appelez on(), off() ou toggle().

// Check if the OnOff trait supports the toggle command.
if (onOffTrait.supports(OnOff.Command.Toggle)) {
  println("onOffTrait supports toggle command")
} else {
  println("onOffTrait does not support stateful toggle command")
}

// Calling a command on a trait.
try {
  onOffTrait.toggle()
} catch (e: HomeException) {
  // Code for handling the exception
}

Vous pouvez également appeler directement on() et off() pour définir un état explicite :

onOffTrait.off()
onOffTrait.on()

Pour éteindre une lumière avec une transition visuelle progressive, appelez offWithEffect() et spécifiez une valeur EffectIdentifierEnum :

// Turn off the light using the DyingLight effect.
onOffTrait.offWithEffect(
  effectIdentifier = OnOffTrait.EffectIdentifierEnum.DyingLight,
  effectVariant = 0u,
)

Ajuster la luminosité

Un DimmableLight nécessite le trait LevelControl, et un OnOffLight peut éventuellement l'accepter. Utilisez cet attribut pour lire et contrôler le niveau de luminosité d'une lumière.

L'attribut currentLevel indique le niveau de luminosité actuel sur une échelle de 0 à 254. Vous pouvez également inspecter minLevel et maxLevel pour déterminer la plage de luminosité valide compatible avec le matériel.

Pour définir la luminosité sur une valeur spécifique, appelez moveToLevel(). Notez que moveToLevel() ne modifie le niveau actuel que lorsque la lumière est déjà allumée, sauf si vous configurez optionsOverride avec executeIfOff. Pour allumer automatiquement la lumière lorsque vous définissez un niveau de luminosité non nul (ou l'éteindre lorsque vous définissez le niveau au minimum), utilisez moveToLevelWithOnOff().

// Change the brightness of the light to 50%
levelControlTrait.moveToLevel(
  level = 127u.toUByte(),
  transitionTime = null,
  optionsMask = LevelControlTrait.OptionsBitmap(),
  optionsOverride = LevelControlTrait.OptionsBitmap(),
)

L'exemple suivant lit le niveau de luminosité actuel et utilise moveToLevelWithOnOff() pour régler une lumière à intensité variable sur une luminosité de 75 % (190u) sur une transition d'une seconde (10u dixièmes de seconde) :

suspend fun setLightBrightness(lightDevice: DimmableLightDevice) {
  val levelControl = lightDevice.standardTraits.levelControl ?: return

  // Read the current brightness level (0 to 254)
  val currentLevel: UByte? = levelControl.currentLevel
  println("Current brightness level: $currentLevel")

  // Move to ~75% brightness (190 out of 254) and turn on the light if it is off
  if (levelControl.supports(LevelControl.Command.MoveToLevelWithOnOff)) {
    levelControl.moveToLevelWithOnOff(
      level = 190u,
      transitionTime = 10u,
      optionsMask = LevelControlTrait.OptionsBitmap(),
      optionsOverride = LevelControlTrait.OptionsBitmap()
    )
  }
}

Vous pouvez également augmenter ou diminuer la luminosité par rapport au niveau actuel en appelant stepWithOnOff() avec StepModeEnum.Up ou StepModeEnum.Down et un stepSize.

Couleur de la commande

Le trait ColorControl est disponible sur ColorTemperatureLightDevice et ExtendedColorLightDevice.

Ce trait vous permet d'ajuster la température de couleur en microdegrés réciproques ou mireds.

val colorControlTrait =
  colorTempLightDevice.standardTraits.colorControl ?: return
// Read the current color temperature and hardware limits in mireds
// (Mireds = 1,000,000 / Kelvin; e.g., 370 mireds ≈ 2700K warm white, 250 mireds = 4000K cool white)
val currentMireds = colorControlTrait.colorTemperatureMireds
val minMireds = colorControlTrait.colorTempPhysicalMinMireds ?: 153u // ~6500K (coolest)
val maxMireds = colorControlTrait.colorTempPhysicalMaxMireds ?: 500u // 2000K (warmest)
// Clamp target (370 mireds ≈ 2700K) to the device's physical bounds
val targetMireds = 370u.toUShort().coerceIn(minMireds, maxMireds)
if (
  colorControlTrait.supports(
    ColorControl.Command.MoveToColorTemperature
  )
) {
  colorControlTrait.moveToColorTemperature(
    colorTemperatureMireds = targetMireds,
    transitionTime = 20u, // 2.0 seconds (in 0.1s units)
    optionsMask = ColorControlTrait.OptionsBitmap(),
    optionsOverride = ColorControlTrait.OptionsBitmap()
  )
}

Vous pouvez également définir la couleur à l'aide des coordonnées de chromaticité CIE 1931 et des valeurs de teinte et de saturation 16 bits.

val colorControlTrait =
  extendedColorLightDevice.standardTraits.colorControl ?: return
// 1. Move to CIE 1931 xy chromaticity coordinates (scaled 0..65279)
// Example: x = 0.3127 (20493), y = 0.3290 (21561) for D65 white point
if (colorControlTrait.supports(ColorControl.Command.MoveToColor)) {
  colorControlTrait.moveToColor(
    colorX = 20493u,
    colorY = 21561u,
    transitionTime = 10u, // 1.0 second (in 0.1s units)
    optionsMask = ColorControlTrait.OptionsBitmap(),
    optionsOverride = ColorControlTrait.OptionsBitmap()
  )
}
val currentX = colorControlTrait.currentX
val currentY = colorControlTrait.currentY
// 2. Move to 16-bit Enhanced Hue (0..65534) and 8-bit Saturation (0..254)
if (
  colorControlTrait.supports(
    ColorControl.Command.EnhancedMoveToHueAndSaturation
  )
) {
  colorControlTrait.enhancedMoveToHueAndSaturation(
    enhancedHue = 43690u, // ~240° (Blue) on the 0..65534 scale
    saturation = 254u,    // Full saturation
    transitionTime = 15u, // 1.5 seconds (in 0.1s units)
    optionsMask = ColorControlTrait.OptionsBitmap(),
    optionsOverride = ColorControlTrait.OptionsBitmap()
  )
}
// 3. Start a hardware color loop across the device's hue range
if (colorControlTrait.supports(ColorControl.Command.ColorLoopSet)) {
  colorControlTrait.colorLoopSet(
    updateFlags =
      ColorControlTrait.UpdateFlagsBitmap(
        updateAction = true,
        updateDirection = true,
        updateTime = true,
        updateStartHue = true
      ),
    action =
      ColorControlTrait.ColorLoopActionEnum
        .ActivateFromColorLoopStartEnhancedHue,
    direction = ColorControlTrait.ColorLoopDirectionEnum.Increment,
    time = 30u, // 30 seconds per full cycle
    startHue = 0u,
    optionsMask = ColorControlTrait.OptionsBitmap(),
    optionsOverride = ColorControlTrait.OptionsBitmap()
  )
}

ExtendedColorControl est un trait Google facultatif sur ExtendedColorLightDevice qui simplifie le contrôle des couleurs en acceptant les noms de couleurs, les valeurs RVB ou les valeurs HSV à virgule flottante unifiées qui combinent la couleur et la luminosité dans une seule unité.

val extendedColorControlTrait =
  extendedColorLightDevice.googleTraits.extendedColorControl ?: return
// 1. Set color by name
if (
  extendedColorControlTrait.supports(
    ExtendedColorControl.Command.MoveToColorName
  )
) {
  extendedColorControlTrait.moveToColorName(colorName = "Lavender")
}
val currentColorName = extendedColorControlTrait.currentName
// 2. Set color using 8-bit RGB values (0..255 per channel)
// Automatically coordinates brightness (LevelControl) and color (ColorControl)
if (
  extendedColorControlTrait.supports(
    ExtendedColorControl.Command.MoveToColorRgb
  )
) {
  extendedColorControlTrait.moveToColorRgb(
    red = 255u,
    green = 128u,
    blue = 0u
  )
}
val currentRed = extendedColorControlTrait.currentRed
val currentGreen = extendedColorControlTrait.currentGreen
val currentBlue = extendedColorControlTrait.currentBlue
// 3. Set color and brightness together using floating-point HSV
// hue: 0.0f..360.0f, saturation: 0.0f..1.0f, value (brightness): 0.0f..1.0f
if (
  extendedColorControlTrait.supports(
    ExtendedColorControl.Command.MoveToColorHsv
  )
) {
  extendedColorControlTrait.moveToColorHsv(
    hue = 210.0f,
    saturation = 0.85f,
    value = 0.75f
  )
}
val currentHue = extendedColorControlTrait.currentHue
val currentSaturation = extendedColorControlTrait.currentSaturation
val currentValue = extendedColorControlTrait.currentValue

Gérer les courbes d'éclairage

Une courbe d'éclairage définit une programmation automatisée qui fait passer en douceur la luminosité et la température de couleur facultative des lumières cibles tout au long de la journée. Par exemple, une courbe d'éclairage peut augmenter progressivement la luminosité le matin et la réduire à un ton plus chaud le soir. Les types d'appareils d'éclairage qui ne sont compatibles qu'avec la luminosité, comme les ampoules à intensité variable, suivent la courbe de luminosité et ignorent la température de couleur.

La caractéristique LightingCurve est une caractéristique Google Home platform au niveau de la structure. Vous y accédez depuis une instance Structure plutôt que depuis un appareil d'éclairage individuel.

Chaque programmation de l'attribut est représentée par un LightingCurveSetting, qui associe un settingId unique à un LightingCurveConfig. Le tableau suivant décrit les champs de configuration de LightingCurveConfig :

Champ	Description
`curvePointsList`	Séquence d'au moins deux éléments `CurvePoint` avec des horaires distincts. Chaque point spécifie un `time` (`CurveTimeOfDay` avec `hours` de `0` à `23` et `minutes` de `0` à `59`), un `brightnessPercent` (`0` à `100`) et un `colorTemperature` facultatif en Kelvin. Si `colorTemperature` est spécifié pour un point, il doit s'agir d'une valeur positive pour tous les points.
`roomId`	ID de la pièce cible (par exemple, `room@{uuid}`). Applique la courbe d'éclairage aux ampoules compatibles avec variateur et température de couleur dans cette pièce. Indiquez `roomId` ou `devices`.
`devices`	Objet `TargetDevices` contenant une liste d'entrées `TargetDevice`, chacune avec un `id` d'appareil et un ID `type` d'appareil (tel que `home.matter.0000.types.0101` pour `DimmableLight` ou `home.matter.0000.types.010c` pour `ColorTemperatureLight`). Spécifiez `devices` ou `roomId`.
`daysOfWeekList`	Jours de la semaine où la courbe d'éclairage est exécutée (`DayOfWeek`). Si la liste est vide, la courbe d'éclairage est exécutée tous les jours.
`adaptive`	Valeur booléenne facultative indiquant si la courbe d'éclairage est adaptative, ce qui signifie qu'un éclairage cible reprend le niveau de courbe actif lorsqu'il est allumé pendant la période de planification. Lorsque l'option `false` est activée, toute modification manuelle d'une lumière la désengage de la courbe d'éclairage pour le reste de la journée. Lorsque `true`, une lumière qui est éteinte puis rallumée pendant la période de planification se réengage avec la courbe d'éclairage, ce qui l'amène à se conformer à la luminosité et à la température des couleurs actuelles de la courbe, et à suivre la courbe à partir de là.
`enabled`	Valeur booléenne facultative indiquant si le paramètre de courbe d'éclairage est actif. La valeur par défaut est `true` lors de la création d'un paramètre. Lorsque `enabled` est omis d'une commande de mise à jour, l'état de `enabled` ne change pas.

Lire les paramètres de la courbe d'éclairage

Pour inspecter les courbes d'éclairage configurées pour une structure, récupérez la caractéristique LightingCurve de Structure et lisez son attribut lightingCurveSettingsList.

suspend fun readLightingCurves(structure: Structure) {
  val lightingCurve = structure.trait(LightingCurve).firstOrNull() ?: return

  for (setting in lightingCurve.lightingCurveSettingsList) {
    val settingId = setting.settingId
    val config = setting.config
    println("Setting ID: $settingId, enabled: ${config?.enabled}")
    config?.curvePointsList?.forEach { point ->
      println(
        "  Time: ${point.time?.hours}:${point.time?.minutes}, " +
          "Brightness: ${point.brightnessPercent}%, " +
          "ColorTemp: ${point.colorTemperature}K"
      )
    }
  }
}

Créer un paramètre de courbe d'éclairage

Pour créer une programmation de courbe d'éclairage sur une structure, créez un LightingCurveConfig avec au moins deux entrées CurvePoint, des lumières cibles (spécifiées par roomId ou devices) et les jours actifs de la semaine. Transmettez ensuite la configuration à createLightingCurveSetting(). La commande renvoie l'settingId unique attribué au nouveau paramètre de courbe d'éclairage.

L'exemple suivant crée une courbe d'éclairage pour les jours de la semaine dans une pièce. Elle passe d'une luminosité de 30% à une température chaude de 2 700 K à 7h à 80% à une température plus froide de 4 000 K à 9h, puis diminue à 20% à une température très chaude de 2 200 K à 21h :

suspend fun createRoomLightingCurve(
  structure: Structure,
  targetRoomId: String
): String? {
  val lightingCurve = structure.trait(LightingCurve).firstOrNull() ?: return null

  val curvePoints = listOf(
    LightingCurveTrait.CurvePoint(
      time = LightingCurveTrait.CurveTimeOfDay(hours = 7, minutes = 0),
      brightnessPercent = 30,
      colorTemperature = 2700
    ),
    LightingCurveTrait.CurvePoint(
      time = LightingCurveTrait.CurveTimeOfDay(hours = 9, minutes = 0),
      brightnessPercent = 80,
      colorTemperature = 4000
    ),
    LightingCurveTrait.CurvePoint(
      time = LightingCurveTrait.CurveTimeOfDay(hours = 21, minutes = 0),
      brightnessPercent = 20,
      colorTemperature = 2200
    )
  )

  val config = LightingCurveTrait.LightingCurveConfig(
    curvePointsList = curvePoints,
    roomId = targetRoomId,
    daysOfWeekList = listOf(
      DayOfWeek.MONDAY,
      DayOfWeek.TUESDAY,
      DayOfWeek.WEDNESDAY,
      DayOfWeek.THURSDAY,
      DayOfWeek.FRIDAY
    ),
    adaptive = true,
    enabled = true
  )

  // Returns the newly created settingId
  return lightingCurve.createLightingCurveSetting(config = config)
}

Pour cibler des appareils d'éclairage spécifiques plutôt qu'une pièce entière, indiquez le paramètre devices à l'aide de LightingCurveTrait.TargetDevices :

val targetDevices = LightingCurveTrait.TargetDevices(
  devicesList = listOf(
    LightingCurveTrait.TargetDevice(
      id = dimmableLight.id.id,
      type = DimmableLightDevice.TYPE_ID
    )
  )
)

val deviceCurveConfig = LightingCurveTrait.LightingCurveConfig(
  curvePointsList = curvePoints,
  devices = targetDevices,
  daysOfWeekList = listOf(DayOfWeek.SATURDAY, DayOfWeek.SUNDAY),
  adaptive = true,
  enabled = true
)

val settingId = lightingCurve.createLightingCurveSetting(
  config = deviceCurveConfig
)

Mettre à jour un paramètre de courbe d'éclairage

Pour modifier une courbe d'éclairage existante (par exemple, modifier ses points de courbe, mettre à jour les jours actifs de la semaine, ou activer et désactiver la programmation), appelez updateLightingCurveSetting() avec la cible settingId et un LightingCurveConfig mis à jour.

suspend fun updateLightingCurve(
  structure: Structure,
  settingId: String,
  updatedConfig: LightingCurveTrait.LightingCurveConfig
) {
  val lightingCurve = structure.trait(LightingCurve).firstOrNull() ?: return

  lightingCurve.updateLightingCurveSetting(
    settingId = settingId,
    config = updatedConfig
  )
}

Supprimer un paramètre de courbe d'éclairage

Pour supprimer un paramètre de courbe d'éclairage d'une structure, appelez deleteLightingCurveSetting() avec l'settingId du paramètre que vous souhaitez supprimer.

suspend fun deleteLightingCurve(
  structure: Structure,
  settingId: String
) {
  val lightingCurve = structure.trait(LightingCurve).firstOrNull() ?: return

  lightingCurve.deleteLightingCurveSetting(settingId = settingId)
}