Google używa technologii AI do tłumaczenia treści na Twój preferowany język. Tłumaczenia wygenerowane przez AI mogą zawierać błędy.

Przewodnik po korzystaniu z urządzenia do terapii światłem

Urządzenia oświetleniowe używają standardowych cech Matter do identyfikowania opraw oświetleniowych, przełączania stanów zasilania i regulowania poziomów jasności.

Najbardziej podstawowym typem urządzenia oświetleniowego jest OnOffLight, który jest implementowany za pomocą cech OnOff i Identify i opcjonalnie obsługuje cechy LevelControl i LightEffects.

Inne typy oświetlenia oferują dodatkowe możliwości i są implementowane z innymi cechami:

Typ urządzenia w interfejsach API Google Home	Cechy	Przykładowa aplikacja w języku Kotlin	Przypadek użycia
Światło o temperaturze kolorów `ColorTemperatureLightDevice` `home.matter.0000.types.010c` Urządzenie oświetleniowe, które można włączać i wyłączać oraz którego intensywność światła i temperaturę kolorów można regulować.	Wymagane cechy matter Identify matter OnOff matter LevelControl matter ColorControl Cechy opcjonalne google LightEffects google ExtendedColorControl	włączanie i wyłączanie, jasność	Jasny
Światło z możliwością przyciemniania `DimmableLightDevice` `home.matter.0000.types.0101` Urządzenie oświetleniowe, które można włączać i wyłączać, regulować jego intensywność oraz przełączać za pomocą powiązanego czujnika obecności.	Wymagane cechy matter Identify matter OnOff matter LevelControl Opcjonalne cechy google LightEffects	włączanie i wyłączanie, jasność	Jasny
Rozszerzone oświetlenie kolorowe `ExtendedColorLightDevice` `home.matter.0000.types.010d` Urządzenie oświetleniowe, które można włączać i wyłączać, regulować jego intensywność i temperaturę kolorów oraz przełączać za pomocą powiązanego czujnika obecności.	Wymagane cechy matter Identify matter OnOff matter LevelControl matter ColorControl Cechy opcjonalne google LightEffects google ExtendedColorControl	włączanie i wyłączanie, jasność	Jasny
Włączanie/wyłączanie światła `OnOffLightDevice` `home.matter.0000.types.0100` Urządzenie oświetleniowe, które można włączać i wyłączać.	Wymagane cechy matter Identify matter OnOff Opcjonalne cechy matter LevelControl google LightEffects	włączanie i wyłączanie, jasność	Jasny

Przed użyciem jakichkolwiek funkcji lub próbą aktualizacji atrybutów zawsze sprawdź, czy urządzenie obsługuje dany atrybut i polecenie. Więcej informacji znajdziesz w artykule Sterowanie urządzeniami naAndroid.

Wymagania wstępne

Zanim zaczniesz pracować z urządzeniami oświetleniowymi i krzywymi oświetlenia, upewnij się, że aplikacja inicjuje pakiet Home SDK i zawiera wymagane importy:

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

Znajdowanie urządzeń oświetleniowych

Aby znaleźć urządzenia oświetleniowe w domu, przefiltruj listę urządzeń według typu, np. OnOffLightDevice i 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()

Możesz też pobrać wszystkie urządzenia oświetleniowe różnych typów za pomocą jednego filtra:

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

Uzyskiwanie podstawowych informacji o urządzeniu

Wdrożone w przykładowej aplikacji na Androida

Atrybut BasicInformation zawiera informacje takie jak nazwa dostawcy, identyfikator dostawcy, identyfikator produktu, nazwa produktu (w tym informacje o modelu) i wersja oprogramowania urządzenia:

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

Identyfikowanie urządzenia oświetleniowego

Jeśli w pomieszczeniu jest kilka lamp, możesz pomóc użytkownikom zlokalizować konkretną oprawę, uruchamiając stan identyfikacji wizualnej, np. miganie światła przez kilka sekund. Wszystkie 4 typy urządzeń oświetleniowych wymagają cechy Identify.

Aby rozpocząć stan identyfikacji, wywołaj polecenie identify z czasem trwania identifyTime w sekundach. Przekazanie wartości 0 natychmiast zatrzymuje stan identyfikacji. Możesz też wywołać triggerEffect, aby uruchomić konkretny efekt wizualny, taki jak Blink lub 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
    )
  }
}

Sprawdzanie połączenia urządzenia oświetleniowego

Połączenie urządzenia jest sprawdzane na poziomie typu urządzenia, ponieważ niektóre urządzenia obsługują wiele typów urządzeń. Zwracany stan jest kombinacją stanów połączenia wszystkich cech na tym urządzeniu.

let lightConnectivity =
  dimmableLightDeviceType.metadata.sourceConnectivity
  .connectivityState

W przypadku różnych typów urządzeń, gdy nie ma połączenia z internetem, może być widoczny stan partiallyOnline. Niektóre standardowe cechy Matter mogą nadal być dostępne online dzięki lokalnemu routingowi, ale cechy działające w chmurze będą offline.

Uzyskiwanie adresu IP urządzenia

Aby znaleźć adres IP urządzenia, użyj atrybutu networkInterfaces zasobu GeneralDiagnosticsTrait. Adresy są zwracane jako obiekty Data, które można sformatować jako standardowe ciągi IPv4 lub IPv6 za pomocą platformy 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
}

Sterowanie urządzeniami oświetleniowymi

Urządzenia typu OnOffLight i DimmableLight używają standardowych cech Matter do identyfikowania opraw oświetleniowych, przełączania stanów zasilania i regulowania poziomów jasności.

Włączanie i wyłączanie światła

Użyj cechy OnOff, aby odczytać bieżący stan zasilania urządzenia OnOffLight lub DimmableLight i włączyć lub wyłączyć światło.

Zanim odczytasz atrybut onOff, sprawdź, czy urządzenie go obsługuje. Niektóre urządzenia działają jako punkty końcowe tylko do poleceń i nie zgłaszają stanu.

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

Gdy onOff jest true, światło jest włączone. Gdy onOff jest false, dioda jest wyłączona.

Aby zmienić stan zasilania światła, sprawdź, czy cecha obsługuje zamierzone polecenie, a następnie wywołaj on(), off() lub 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
}

Możesz też bezpośrednio wywołać funkcje on() i off(), aby ustawić konkretny stan:

onOffTrait.off()
onOffTrait.on()

Aby wyłączyć światło ze stopniowym przejściem wizualnym, wywołaj offWithEffect() i podaj wartość EffectIdentifierEnum:

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

Dostosowywanie poziomów jasności

DimmableLight wymaga cechy LevelControl, a OnOffLight może ją opcjonalnie obsługiwać. Użyj tej cechy, aby odczytywać i kontrolować poziom jasności światła.

Atrybut currentLevel podaje bieżący poziom jasności w skali od 0 do 254. Możesz też sprawdzić minLevel i maxLevel, aby określić prawidłowy zakres jasności obsługiwany przez sprzęt.

Aby ustawić jasność na określoną wartość, wywołaj moveToLevel(). Pamiętaj, że moveToLevel() zmienia bieżący poziom tylko wtedy, gdy światło jest już włączone, chyba że skonfigurujesz optionsOverride za pomocą executeIfOff. Aby automatycznie włączać światło po ustawieniu niezerowego poziomu jasności (lub wyłączać je po ustawieniu minimalnego poziomu), użyj moveToLevelWithOnOff().

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

W tym przykładzie odczytywany jest bieżący poziom jasności, a następnie używana jest komenda moveToLevelWithOnOff(), aby ustawić jasność ściemnianego światła na 75% (190u) w ciągu 1 sekundy (10u dziesiątych sekundy):

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

Możesz też zwiększać lub zmniejszać jasność względem bieżącego poziomu, wywołując stepWithOnOff() z StepModeEnum.Up lub StepModeEnum.Down i stepSize.

Kolor elementu sterującego

Atrybut ColorControl jest dostępny zarówno w ColorTemperatureLightDevice, jak i ExtendedColorLightDevice.

Ta cecha umożliwia dostosowanie temperatury kolorów w mikrostopniach odwrotnych lub miredach.

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

Możesz też ustawić kolor, używając współrzędnych chromatyczności CIE 1931 oraz 16-bitowych wartości odcienia i nasycenia.

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 to opcjonalna cecha Google w ExtendedColorLightDevice, która upraszcza sterowanie kolorami, akceptując nazwy kolorów, wartości RGB lub ujednolicone wartości HSV w reprezentacji zmiennoprzecinkowej, które łączą kolor i jasność w jedną jednostkę.

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

Zarządzanie krzywymi oświetlenia

Krzywa oświetlenia definiuje automatyczny harmonogram, który płynnie zmienia jasność i opcjonalną temperaturę kolorów docelowych świateł w ciągu dnia. Na przykład krzywa oświetlenia może stopniowo rozjaśniać światła rano i przyciemniać je do cieplejszego tonu wieczorem. Urządzenia oświetleniowe, które obsługują tylko jasność, takie jak lampy z możliwością ściemniania, podążają za krzywą jasności i ignorują temperaturę kolorów.

Cecha LightingCurve jest cechą Google Home platform na poziomie domu. Dostęp do niego można uzyskać z instancji Structure, a nie z poziomu poszczególnych urządzeń oświetleniowych.

Każdy harmonogram w cesze jest reprezentowany przez LightingCurveSetting, który łączy unikalny settingId z LightingCurveConfig. W tabeli poniżej opisano pola konfiguracji LightingCurveConfig:

Pole	Opis
`curvePointsList`	Sekwencja co najmniej 2 elementów `CurvePoint` z różnymi godzinami. Każdy punkt określa `time` (`CurveTimeOfDay` z `hours` od `0` do `23` i `minutes` od `0` do `59`), `brightnessPercent` (od `0` do `100`) i opcjonalnie `colorTemperature` w kelwinach. Jeśli dla dowolnego punktu określono parametr `colorTemperature`, musi on mieć wartość dodatnią dla wszystkich punktów.
`roomId`	Identyfikator pokoju docelowego (np. `room@{uuid}`). Stosuje krzywą oświetlenia do zgodnych lamp ze ściemniaczem i temperaturą kolorów w tym pokoju. Podaj `roomId` lub `devices`.
`devices`	Obiekt `TargetDevices` zawierający listę wpisów `TargetDevice`, z których każdy zawiera `id` i identyfikator urządzenia `type` (np. `home.matter.0000.types.0101` dla `DimmableLight` lub `home.matter.0000.types.010c` dla `ColorTemperatureLight`). Podaj `devices` lub `roomId`.
`daysOfWeekList`	Dni tygodnia, w których działa krzywa oświetlenia (`DayOfWeek`). Jeśli lista jest pusta, krzywa oświetlenia działa codziennie.
`adaptive`	Opcjonalna wartość logiczna wskazująca, czy krzywa oświetlenia jest adaptacyjna, co oznacza, że docelowe światło powraca do aktywnego poziomu krzywej, gdy zostanie włączone w czasie oczekiwania. Gdy funkcja `false` jest włączona, ręczna zmiana ustawień światła powoduje odłączenie go od krzywej oświetlenia na resztę dnia. Gdy `true`, światło, które zostanie wyłączone, a następnie ponownie włączone w czasie oczekiwania, zostanie ponownie dostosowane do krzywej oświetlenia, co spowoduje, że będzie odpowiadać bieżącej jasności i temperaturze kolorów krzywej i będzie podążać za krzywą od tego momentu.
`enabled`	Opcjonalna wartość logiczna wskazująca, czy ustawienie krzywej oświetlenia jest aktywne. Domyślna wartość podczas tworzenia nowego ustawienia to `true`. Jeśli w poleceniu aktualizacji pominięto parametr `enabled`, stan parametru `enabled` nie ulega zmianie.

Odczytywanie ustawień krzywej oświetlenia

Aby sprawdzić krzywe oświetlenia skonfigurowane dla budynku, pobierz cechę LightingCurve z Structure i odczytaj jej atrybut 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"
      )
    }
  }
}

Tworzenie ustawienia krzywej oświetlenia

Aby utworzyć nowy harmonogram krzywej oświetlenia w domu, utwórz obiekt LightingCurveConfig z co najmniej 2 wpisami CurvePoint, docelowymi światłami (określonymi przez roomId lub devices) i aktywnymi dniami tygodnia. Następnie przekaż konfigurację do createLightingCurveSetting(). Polecenie zwraca unikalny identyfikator settingId przypisany do nowego ustawienia krzywej oświetlenia.

Poniższy przykład tworzy krzywą oświetlenia w dni powszednie dla pomieszczenia. Zaczyna się od 30% jasności przy ciepłej barwie 2700 K o 7:00, następnie przechodzi do 80% przy chłodniejszej barwie 4000 K o 9:00, a potem przyciemnia się do 20% przy bardzo ciepłej barwie 2200 K o 21:00:

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

Aby kierować na konkretne urządzenia oświetleniowe, a nie na całe pomieszczenie, podaj parametr devices, używając 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
)

Aktualizowanie ustawienia krzywej oświetlenia

Aby zmodyfikować istniejącą krzywą oświetlenia, np. zmienić jej punkty, zaktualizować aktywne dni tygodnia lub włączyć albo wyłączyć harmonogram, wywołaj updateLightingCurveSetting() z docelowym settingId i zaktualizowanym LightingCurveConfig.

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

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

Usuwanie ustawienia krzywej oświetlenia

Aby usunąć ustawienie krzywej oświetlenia z domu, wywołaj deleteLightingCurveSetting() z settingId ustawienia, które chcesz usunąć.

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

  lightingCurve.deleteLightingCurveSetting(settingId = settingId)
}