homebridge-deconz 0.0.9 → 0.0.12

package/lib/DeconzService/Light.js

@@ -1,4 +1,4 @@
-// homebridge-deconz/lib/DeconzService/Sensor.js
+// homebridge-deconz/lib/DeconzService/Light.js
 // Copyright © 2022 Erik Baauw. All rights reserved.
 //
 // Homebridge plugin for deCONZ.
@@ -6,54 +6,39 @@
 'use strict'
 
 const homebridgeLib = require('homebridge-lib')
-const Deconz = require('../Deconz')
+const DeconzService = require('../DeconzService')
 
-const { dateToString } = Deconz.ApiClient
 const { timeout } = homebridgeLib
 const { xyToHsv, hsvToXy, ctToXy } = homebridgeLib.Colour
 
-class Light extends homebridgeLib.ServiceDelegate {
-  constructor (accessory, resource) {
-    super(accessory, {
-      id: resource.id,
-      name: resource.body.name,
-      subtype: resource.subtype,
-      Service: accessory.Services.hap.Lightbulb
-    })
-    this.id = resource.id
-    this.gateway = accessory.gateway
-    this.client = accessory.client
-    this.resource = resource
-    this.rtype = resource.rtype
-    this.rid = resource.rid
-    this.rpath = resource.rpath +
-      (resource.rtype === 'groups' ? '/action' : '/state')
-    this.capabilities = resource.capabilities
-
-    this.debug('%s: capabilities: %j', this.resource.rpath, this.capabilities)
-
-    this.targetState = {}
-    this.deferrals = []
+class Light extends DeconzService.LightsResource {
+  constructor (accessory, resource, params = {}) {
+    params.Service = accessory.Services.hap.Lightbulb
+    super(accessory, resource, params)
 
     this.addCharacteristicDelegate({
       key: 'on',
       Characteristic: this.Characteristics.hap.On,
       value: this.capabilities.on
         ? this.resource.body.state.on
-        : this.resource.body.state.all_on,
-      setter: async (value) => { return this.put({ on: value }) }
-    }).on('didSet', (value, fromHomekit) => {
-      this.checkAdaptiveLighting()
+        : this.resource.body.state.all_on
+    }).on('didSet', (value, fromHomeKit) => {
+      if (fromHomeKit) {
+        this.put({ on: value })
+        this.updateAdaptiveLighting()
+      }
     })
 
     if (!this.capabilities.on) {
       this.addCharacteristicDelegate({
         key: 'anyOn',
         Characteristic: this.Characteristics.my.AnyOn,
-        value: this.resource.body.state.any_on,
-        setter: async (value) => { return this.put({ on: value }) }
-      }).on('didSet', (value, fromHomekit) => {
-        this.checkAdaptiveLighting()
+        value: this.resource.body.state.any_on
+      }).on('didSet', (value, fromHomeKit) => {
+        if (fromHomeKit) {
+          this.put({ on: value })
+          this.updateAdaptiveLighting()
+        }
       })
     }
 
@@ -62,23 +47,21 @@ class Light extends homebridgeLib.ServiceDelegate {
         key: 'brightness',
         Characteristic: this.Characteristics.hap.Brightness,
         unit: '%',
-        value: this.resource.body.state.bri,
-        setter: async (value) => {
-          const bri = Math.round(value * 254.0 / 100.0)
-          return this.put({ bri: bri })
+        value: Math.round(this.resource.body.state.bri / 2.54)
+      }).on('didSet', (value, fromHomeKit) => {
+        if (fromHomeKit) {
+          const bri = Math.round(value * 2.54)
+          this.put({ bri: bri })
+          this.updateAdaptiveLighting()
         }
-      }).on('didSet', (value, fromHomekit) => {
-        this.checkAdaptiveLighting()
       })
 
       this.addCharacteristicDelegate({
         key: 'brightnessChange',
         Characteristic: this.Characteristics.my.BrightnessChange,
-        value: 0,
-        setter: async (value) => {
-          return this.put({ bri_inc: Math.round(value * 254.0 / 100.0) })
-        }
-      }).on('didSet', async () => {
+        value: 0
+      }).on('didSet', async (value) => {
+        this.put({ bri_inc: Math.round(value * 254.0 / 100.0) })
         await timeout(this.platform.config.waitTimeReset)
         this.values.brightnessChange = 0
       })
@@ -88,7 +71,13 @@ class Light extends homebridgeLib.ServiceDelegate {
     if (this.capabilities.ct || this.capabilities.xy || this.capabilities.hs) {
       this.addCharacteristicDelegate({
         key: 'colormode',
-        value: this.resource.body.state.colormode
+        value: this.resource.body.state.colormode,
+        silent: true
+      }).on('didSet', (value) => {
+        this.resource.body.colormode = value
+        if (value !== 'ct') {
+          this.checkAdaptiveLighting()
+        }
       })
     }
 
@@ -101,118 +90,70 @@ class Light extends homebridgeLib.ServiceDelegate {
           minValue: this.capabilities.ctMin,
           maxValue: this.capabilities.ctMax
         },
-        value: this.resource.body.state.ct,
-        setter: async (value) => {
-          const ct = Math.max(
-            this.capabilities.ctMin, Math.min(value, this.capabilities.ctMax)
-          )
-          return this.put({ ct: ct })
-        }
+        value: this.resource.body.state.ct
       }).on('didSet', (value, fromHomeKit) => {
+        this.checkAdaptiveLighting()
+        const ct = Math.max(
+          this.capabilities.ctMin, Math.min(value, this.capabilities.ctMax)
+        )
         if (fromHomeKit) {
-          this.values.activeTransitionCount = 0
+          this.put({ ct: ct })
+          this.values.colormode = 'ct'
         }
-        if (
-          this.capabilities.xy && !this.capabilities.computesXy &&
-          this.values.colormode === 'ct'
-        ) {
-          const { h, s } = xyToHsv(ctToXy(value), this.capabilities.gamut)
+        if (this.capabilities.xy && this.values.colormode === 'ct') {
+          const { h, s } = xyToHsv(ctToXy(ct), this.capabilities.gamut)
           this.values.hue = h
           this.values.saturation = s
         }
       })
-
-      if (this.capabilities.bri) {
-        this.addCharacteristicDelegate({
-          key: 'supportedTransitionConfiguration',
-          Characteristic: this.Characteristics.hap
-            .SupportedCharacteristicValueTransitionConfiguration,
-          silent: true
-        })
-        this.addCharacteristicDelegate({
-          key: 'transitionControl',
-          Characteristic: this.Characteristics.hap
-            .CharacteristicValueTransitionControl,
-          silent: true,
-          getter: async () => {
-            await this.initAdaptiveLighting()
-            return this.adaptiveLighting.generateControl()
-          },
-          setter: async (value) => {
-            await this.initAdaptiveLighting()
-            this.adaptiveLighting.parseControl(value)
-            const response = this.adaptiveLighting.generateControlResponse()
-            this.values.activeTransitionCount = 1
-            return response
-          }
-        })
-        this.addCharacteristicDelegate({
-          key: 'activeTransitionCount',
-          Characteristic: this.Characteristics.hap
-            .CharacteristicValueActiveTransitionCount,
-          value: 0
-        }).on('didSet', (value) => {
-          if (!value) {
-            this.adaptiveLighting.deactivate()
-          } else {
-            this.checkAdaptiveLighting()
-          }
-        })
-      }
     }
 
     if (this.capabilities.xy) {
       this.addCharacteristicDelegate({
         key: 'hue',
         Characteristic: this.Characteristics.hap.Hue,
-        unit: '°',
-        setter: async (value) => {
-          const xy = hsvToXy(value, this.values.saturation, this.capabilities.gamut)
-          return this.put({ xy: xy })
-        }
-      }).on('didSet', (value, fromHomekit) => {
-        if (fromHomekit) {
-          this.values.activeTransitionCount = 0
+        unit: '°'
+      }).on('didSet', (value, fromHomeKit) => {
+        if (fromHomeKit) {
+          const xy = hsvToXy(
+            value, this.values.saturation, this.capabilities.gamut
+          )
+          this.put({ xy: xy })
+          this.values.colormode = 'xy'
         }
       })
       this.addCharacteristicDelegate({
         key: 'saturation',
         Characteristic: this.Characteristics.hap.Saturation,
-        unit: '%',
-        setter: async (value) => {
+        unit: '%'
+      }).on('didSet', (value, fromHomeKit) => {
+        if (fromHomeKit) {
           const xy = hsvToXy(this.values.hue, value, this.capabilities.gamut)
-          return this.put({ xy: xy })
-        }
-      }).on('didSet', (value, fromHomekit) => {
-        if (fromHomekit) {
-          this.values.activeTransitionCount = 0
+          this.put({ xy: xy })
+          this.values.colormode = 'xy'
         }
       })
     } else if (this.capabilities.hs) {
       this.addCharacteristicDelegate({
         key: 'hue',
         Characteristic: this.Characteristics.hap.Hue,
-        unit: '°',
-        setter: async (value) => {
+        unit: '°'
+      }).on('didSet', (value, fromHomeKit) => {
+        if (fromHomeKit) {
           const hue = Math.round(this.hk.hue * 65535.0 / 360.0)
-          return this.put({ hue: hue })
-        }
-      }).on('didSet', (value, fromHomekit) => {
-        if (fromHomekit) {
-          this.values.activeTransitionCount = 0
+          this.put({ hue: hue })
+          this.values.colormode = 'hs'
         }
       })
       this.addCharacteristicDelegate({
         key: 'saturation',
         Characteristic: this.Characteristics.hap.Saturation,
-        unit: '%',
-        setter: async (value) => {
+        unit: '%'
+      }).on('didSet', (value, fromHomeKit) => {
+        if (fromHomeKit) {
           const sat = Math.round(this.hk.sat * 254.0 / 100.0)
-          return this.put({ sat: sat })
-        }
-      }).on('didSet', (value, fromHomekit) => {
-        if (fromHomekit) {
-          this.values.activeTransitionCount = 0
+          this.put({ sat: sat })
+          this.values.colormode = 'hs'
         }
       })
     }
@@ -220,36 +161,180 @@ class Light extends homebridgeLib.ServiceDelegate {
     if (this.capabilities.colorLoop) {
       this.addCharacteristicDelegate({
         key: 'colorLoop',
-        Characteristic: this.Characteristics.my.ColorLoop,
-        setter: async (value) => {
+        Characteristic: this.Characteristics.my.ColorLoop
+      }).on('didSet', (value, fromHomeKit) => {
+        if (fromHomeKit) {
           const effect = value ? 'colorloop' : 'none'
           const state = { effect: effect }
           if (value) {
             state.colorloopspeed = this.values.colorLoopSpeed
           }
-          return this.put(state)
+          this.put(state)
+          this.values.colormode = 'hs'
         }
       })
       this.addCharacteristicDelegate({
         key: 'colorLoopSpeed',
         Characteristic: this.Characteristics.my.ColorLoopSpeed,
         unit: 's',
-        value: 25,
+        value: 25
+      }).on('didSet', (value, fromHomeKit) => {
+        if (fromHomeKit) {
+          const effect = 'colorloop'
+          this.put({ effect: effect, colorloopspeed: value })
+          this.values.colormode = 'hs'
+        }
+      })
+    }
+
+    this.addCharacteristicDelegates()
+
+    if (this.capabilities.bri && this.capabilities.ct && !this.capabilities.hs) {
+      this.addCharacteristicDelegate({
+        key: 'supportedTransitionConfiguration',
+        Characteristic: this.Characteristics.hap
+          .SupportedCharacteristicValueTransitionConfiguration,
+        silent: true,
+        getter: async () => {
+          this.initAdaptiveLighting()
+          return this.adaptiveLighting.generateConfiguration()
+        }
+      })
+      this.addCharacteristicDelegate({
+        key: 'transitionControl',
+        Characteristic: this.Characteristics.hap
+          .CharacteristicValueTransitionControl,
+        silent: true,
+        getter: async () => {
+          return this.adaptiveLighting.generateControl()
+        },
         setter: async (value) => {
-          return this.put({ effect: 'colorloop', colorloopspeed: value })
+          const control = this.adaptiveLighting.parseControl(value)
+          this.context.transitionControl = value
+          const response = this.adaptiveLighting.generateControlResponse()
+          const parsedResponse = this.adaptiveLighting.parseControl(response)
+          this.vdebug(
+            'Adaptive Lighting: control update: %j => %j',
+            control, parsedResponse
+          )
+          this.values.activeTransitionCount = parsedResponse === '' ? 0 : 1
+          return response
+        }
+      })
+      this.addCharacteristicDelegate({
+        key: 'activeTransitionCount',
+        Characteristic: this.Characteristics.hap
+          .CharacteristicValueActiveTransitionCount,
+        silent: true,
+        value: 0
+      }).on('didSet', (value) => {
+        this.log('Adaptive Lighting: %sabled', value > 0 ? 'en' : 'dis')
+        if (value) {
+          this.updateAdaptiveLighting()
         }
       })
     }
 
-    this.addCharacteristicDelegate({
-      key: 'lastSeen',
-      Characteristic: this.Characteristics.my.LastSeen
-    })
+    if (this.resource.rtype === 'groups') {
+      this.sceneServices = []
+      for (const scene of this.resource.body.scenes) {
+        const service = new homebridgeLib.ServiceDelegate(accessory, {
+          name: this.resource.body.name + ' ' + scene.name,
+          Service: this.Services.hap.Switch,
+          subtype: this.subtype + '-S' + scene.id
+        })
+        service.addCharacteristicDelegate({
+          key: 'on',
+          Characteristic: this.Characteristics.hap.On,
+          value: false
+        }).on('didSet', async (value, fromHomeKit) => {
+          this.checkAdaptiveLighting()
+          if (fromHomeKit && value) {
+            try {
+              const path = this.resource.rpath + '/scenes/' + scene.id + '/recall'
+              this.debug('PUT %s', path)
+              await this.client.put(path)
+            } catch (error) { this.error(error) }
+            await timeout(this.platform.config.waitTimeReset)
+            service.values.on = false
+          }
+        })
+        this.sceneServices.push(service)
+      }
+    }
 
-    this.addCharacteristicDelegate({
-      key: 'statusFault',
-      Characteristic: this.Characteristics.hap.StatusFault
-    })
+    if (this.capabilities.effects != null) {
+      this.effectServices = []
+      this.addCharacteristicDelegate({
+        key: 'effect',
+        value: -1,
+        silent: true
+      }).on('didSet', (value) => {
+        for (const i in this.capabilities.effects) {
+          this.effectServices[i].values.on = value === i
+        }
+      })
+      for (const i in this.capabilities.effects) {
+        const effect = this.capabilities.effects[i]
+        const service = new homebridgeLib.ServiceDelegate(accessory, {
+          name: this.resource.body.name + ' ' + effect,
+          Service: this.Services.hap.Switch,
+          subtype: this.subtype + '-E' + i
+        })
+        service.addCharacteristicDelegate({
+          key: 'on',
+          Characteristic: this.Characteristics.hap.On
+        }).on('didSet', (value, fromHomeKit) => {
+          if (fromHomeKit) {
+            this.checkAdaptiveLighting()
+            this.values.effect = value ? i : -1
+            const newEffect = value
+              ? effect.toLowerCase()
+              : 'none'
+            this.put({ effect: newEffect })
+          }
+        })
+        this.effectServices.push(service)
+      }
+      // if (this.capabilities.effectSpeed) {
+      //   this.addCharacteristicDelegate({
+      //     key: 'effectSpeed',
+      //     Characteristic: this.Characteristics.my.EffectSpeed,
+      //     value: 50
+      //   }).on('didSet', (value) => {
+      //     this.setEffectSpeed(value)
+      //   })
+      //   this.hk.effectColours = []
+      //   for (let i = 0; i <= 5; i++) {
+      //     const service = new this.Service.Lightbulb(
+      //       this.name + ' Effect Color ' + (i + 1), this.subtype + '-C' + i
+      //     )
+      //     service.addCharacteristicDelegate({
+      //       key: 'on',
+      //       Characteristic: this.Characteristics.hap.On,
+      //       value: true
+      //     }).on('didSet', (value) => {
+      //       this.setEffectOn(i, value)
+      //     })
+      //     service.addCharacteristicDelegate({
+      //       key: 'hue',
+      //       Characteristic: this.Characteristics.hap.Hue,
+      //       value: i * 60
+      //     }).on('didSet', (value) => {
+      //       this.setEffectHue(i, value)
+      //     })
+      //     service.addCharacteristicDelegate({
+      //       key: 'saturation',
+      //       Characteristic: this.Characteristics.hap.Saturation,
+      //       value: 100
+      //     }).on('didSet', (value) => {
+      //       this.setEffectSat(i, value)
+      //     })
+      //     this.effectServices.push(service)
+      //   }
+      // }
+      // this.checkEffect(this.obj.state.effect)
+    }
 
     this.settings = {
       brightnessAdjustment: 1,
@@ -257,72 +342,42 @@ class Light extends homebridgeLib.ServiceDelegate {
       waitTimeUpdate: this.platform.config.waitTimeUpdate,
       wallSwitch: false
     }
-
-    this.update(this.resource.body)
-  }
-
-  update (body) {
-    for (const key in body) {
-      const value = body[key]
-      switch (key) {
-        case 'action':
-          // Copied to `state` by `Resource` during polling.
-          break
-        case 'state':
-          this.updateState(value)
-          break
-        case 'lastannounced':
-          // this.values.lastBoot = dateToString(value)
-          break
-        case 'lastseen':
-          this.values.lastSeen = dateToString(value)
-          break
-        case 'colorcapabilities':
-        case 'ctmax':
-        case 'ctmin':
-        case 'devicemembership':
-        case 'etag':
-        case 'id':
-        case 'lights':
-        case 'hascolor':
-        case 'manufacturername':
-        case 'modelid':
-        case 'name':
-        case 'powerup':
-        case 'scenes':
-        case 'swversion':
-        case 'type':
-        case 'uniqueid':
-          break
-        default:
-          this.warn('%s: unknown %s attribute', key, this.rtype)
-          break
-      }
-    }
   }
 
   updateState (state) {
+    let updateAdaptiveLighting = false
     for (const key in state) {
       const value = state[key]
+      this.resource.body.state[key] = value
       switch (key) {
         case 'all_on':
           this.values.on = value
+          updateAdaptiveLighting = true
           break
         case 'any_on':
           this.values.anyOn = value
-          break
-        case 'alert':
+          updateAdaptiveLighting = true
           break
         case 'bri':
-          this.values.brightness = Math.round(value * 100.0 / 254.0)
+          if (!this.recentlyUpdated) {
+            this.values.brightness = Math.round(value / 2.54)
+            updateAdaptiveLighting = true
+          }
           break
         case 'colormode':
           this.values.colormode = value
           break
         case 'ct':
-          this.values.colorTemperature = value
+          if (!this.recentlyUpdated && this.values.colormode === 'ct') {
+            this.values.colorTemperature = value
+          }
           break
         case 'effect':
+          this.values.colorLoop = value === 'colorloop'
+          if (this.capabilities.effects != null) {
+            const effectName = value[0].toUpperCase() + value.slice(1)
+            this.values.effect = '' + this.capabilities.effects.indexOf(effectName)
+          }
           break
         case 'hue':
           if (!this.capabilities.xy) {
@@ -332,137 +387,91 @@ class Light extends homebridgeLib.ServiceDelegate {
         case 'on':
           this.values.on = value
           break
-        case 'reachable':
-          this.values.statusFault = value
-            ? this.Characteristics.hap.StatusFault.NO_FAULT
-            : this.Characteristics.hap.StatusFault.GENERAL_FAULT
-          break
         case 'sat':
           if (!this.capabilities.xy) {
             this.values.hue = value
           }
           break
-        case 'scene':
-          break
         case 'xy':
-          if (this.values.colormode !== 'ct' || this.capabilities.computesXy) {
+          if (
+            !this.recentlyUpdated &&
+            (this.values.colormode !== 'ct' || this.capabilities.computesXy)
+          ) {
             const { h, s } = xyToHsv(value, this.capabilities.gamut)
             this.values.hue = h
             this.values.saturation = s
           }
           break
         default:
-          this.warn('state.%s: unknown %s attribute', key, this.rtype)
           break
       }
     }
+    if (updateAdaptiveLighting) {
+      this.updateAdaptiveLighting()
+    }
+    super.updateState(state)
   }
 
-  async identify () {
-    try {
-      if (this.capabilities.alert) {
-        if (this.capabilities.breathe) {
-          await this.put({ alert: 'breathe' })
-          await timeout(1500)
-          return this.put({ alert: 'stop' })
-        }
-        return this.put({ alert: 'select' })
-      }
-    } catch (error) { this.warn(error) }
-  }
-
-  async initAdaptiveLighting () {
+  initAdaptiveLighting () {
     if (this.adaptiveLighting == null) {
       this.adaptiveLighting = new homebridgeLib.AdaptiveLighting(
         this.brightnessDelegate, this.colorTemperatureDelegate
       )
-      this.values.supportedTransitionConfiguration =
-        this.adaptiveLighting.generateConfiguration()
-      if (
-        this.values.activeTransitionCount === 1 &&
-        this.values.transitionControl != null
-      ) {
-        this.adaptiveLighting.parseControl(this.values.transitionControl)
+      if (this.values.activeTransitionCount > 0) {
+        const control = this.adaptiveLighting.parseControl(
+          this.context.transitionControl
+        )
+        this.vdebug('Adaptive Lighting: restore control: %j', control)
+        this.adaptiveLighting.parseControl(this.context.transitionControl)
       }
+      this.log(
+        'Adaptive Lighting: %sabled',
+        this.values.activeTransitionCount > 0 ? 'en' : 'dis'
+      )
     }
   }
 
-  async checkAdaptiveLighting () {
-    if (this.adaptiveLighting == null || !this.values.on) {
+  async updateAdaptiveLighting () {
+    if (
+      this.adaptiveLighting == null || // not supported
+      this.values.activeTransitionCount === 0 || // disabled
+      !this.values.on // light is off
+    ) {
       return
     }
     const ct = this.adaptiveLighting.getCt(
       this.values.brightness * this.settings.brightnessAdjustment
     )
-    if (ct == null || ct === this.values.ct) {
+    if (ct == null) {
+      this.warn('assertion failed')
       return
     }
-    return this.put({ ct: ct })
-  }
-
-  // Collect changes into a combined request.
-  async put (state) {
-    return new Promise((resolve, reject) => {
-      for (const key in state) {
-        this.targetState[key] = state[key]
-      }
-      const d = { resolve: resolve, reject: reject }
-      this.deferrals.push(d)
-      if (this.updating) {
-        return
-      }
-      this.updating = true
-      if (this.settings.waitTimeUpdate > 0) {
-        setTimeout(() => {
-          this._put()
-        }, this.settings.waitTimeUpdate)
-      } else {
-        this._put()
-      }
-    })
+    this.debug(
+      '/%s/%d: adaptive lighting: {"state":{"ct": %d}}',
+      this.rtype, this.rid, ct
+    )
+    if (this.values.colormode === 'ct' && ct === this.values.colorTemperature) {
+      return
+    }
+    this.put({ ct: ct })
+    this.fromAdaptiveLighting = true
+    this.values.colormode = 'ct'
+    if (ct !== this.values.colorTemperature) {
+      this.values.colorTemperature = ct
+    } else if (this.capabilities.xy) { // colormode changed
+      const { h, s } = xyToHsv(ctToXy(ct), this.capabilities.gamut)
+      this.values.hue = h
+      this.values.saturation = s
+    }
+    this.fromAdaptiveLighting = false
   }
 
-  // Send the request (for the combined changes) to the gateway.
-  async _put () {
-    const targetState = this.targetState
-    const deferrals = this.deferrals
-    this.targetState = {}
-    this.deferrals = []
-    this.updating = false
-    if (
-      this.gateway.transitionTime !== this.gateway.defaultTransitionTime &&
-      targetState.transitiontime === undefined
-    ) {
-      targetState.transitiontime = this.gateway.transitionTime * 10
-      this.gateway.resetTransitionTime()
-    }
-    if (this.capabilities.noTransition) {
-      if (
-        (
-          targetState.on != null || targetState.bri != null ||
-          targetState.bri_inc != null
-        ) && (
-          targetState.xy != null || targetState.ct != null ||
-          targetState.hue != null || targetState.sat != null ||
-          targetState.effect != null
-        )
-      ) {
-        targetState.transitiontime = 0
-      }
+  checkAdaptiveLighting (key, value) {
+    if (this.adaptiveLighting == null || this.fromAdaptiveLighting) {
+      return
     }
-    this.client.put(this.rpath, targetState).then((obj) => {
-      this.recentlyUpdated = true
-      for (const d of deferrals) {
-        d.resolve(true)
-      }
-      setTimeout(() => {
-        this.recentlyUpdated = false
-      }, 500)
-    }).catch((error) => {
-      for (const d of deferrals) {
-        d.reject(error)
-      }
-    })
+    this.adaptiveLighting.deactivate()
+    this.values.activeTransitionCount = 0
   }
 }