@homebridge-plugins/homebridge-govee 11.32.2-beta.15 → 11.32.2-beta.16

package/CHANGELOG.md

@@ -32,6 +32,9 @@ All notable changes to `@homebridge-plugins/homebridge-govee` will be documented
 - refactor: build the switch and outlet tiles of a multi-socket device from one handler instead of two copies of it
 - fix: move the H7152 dehumidifier's speed slider when it reports a new speed, which until now only the H7150 and H7151 did
 - refactor: point the H7101 and H7111 fans at the H7100 handler they matched command for command
+- feat: give a diffuser model that has not been worked out yet the same starting handler the other appliances have, so it works for on and off
+- refactor: choose a device handler from a table, so adding a device type no longer means editing the platform
+- refactor: move the settings parsing into its own file, away from the code that talks to devices
 
 ## v11.32.1 (2026-08-02)
 

package/lib/device/appliance-basic.js

@@ -356,6 +356,16 @@ export const deviceDehumidifierBasic = makeBasicAppliance({
   currentStateOff: 0, // inactive
 })
 
+// Diffusers are power only, so there is no variable control to offer. They use
+// the same tile as the models already handled, so a new one looks the same
+export const deviceDiffuserBasic = makeBasicAppliance({
+  family: 'diffuser',
+  service: 'AirPurifier',
+  currentStateChar: 'CurrentAirPurifierState',
+  currentStateOn: 2, // purifying air
+  currentStateOff: 0, // inactive
+})
+
 export const devicePurifierBasic = makeBasicAppliance({
   family: 'purifier',
   service: 'AirPurifier',

package/lib/device/index.js

@@ -1,5 +1,6 @@
 import {
   deviceDehumidifierBasic,
+  deviceDiffuserBasic,
   deviceFanBasic,
   deviceHumidifierBasic,
   deviceIceMakerBasic,
@@ -55,6 +56,7 @@ export default {
   deviceDiffuserH7161,
   deviceDiffuserH7162: deviceDiffuserH7161, // identical to the H7161
   deviceDehumidifierBasic,
+  deviceDiffuserBasic,
   deviceFanBasic,
   deviceFanH1310: deviceFanH7100, // same fan, minus a confirmed swing status message
   deviceFanH1370,

package/lib/platform.js

@@ -11,18 +11,18 @@ import awsClient from './connection/aws.js'
 import httpClient from './connection/http.js'
 import lanClient from './connection/lan.js'
 import openApiClient from './connection/openapi.js'
-import deviceTypes from './device/index.js'
 import eveService from './fakegato/fakegato-history.js'
 import { BLE_UPDATE_TIMEOUT } from './utils/ble-protocol.js'
 import { buildCommand } from './utils/command-builder.js'
+import { applyUserConfig } from './utils/config-parser.js'
 import platformConsts from './utils/constants.js'
 import platformChars from './utils/custom-chars.js'
 import { getDeviceCapabilities } from './utils/device-capabilities.js'
+import { resolveDeviceType } from './utils/dispatch.js'
 import eveChars from './utils/eve-chars.js'
 import {
   base64ToHex,
   hasProperty,
-  parseDeviceId,
   parseError,
   pfxToCertAndKey,
   updateFailureError,
@@ -86,7 +86,7 @@ export default class {
 
       // Apply the user's configuration
       this.config = platformConsts.defaultConfig
-      this.applyUserConfig(config)
+      applyUserConfig(this, config)
 
       // Set up empty clients
       this.bleClient = false
@@ -104,269 +104,6 @@ export default class {
     }
   }
 
-  applyUserConfig(config) {
-    // These shorthand functions save line space during config parsing
-    const logDefault = (k, def) => {
-      this.log.warn('%s [%s] %s %s.', platformLang.cfgItem, k, platformLang.cfgDef, def)
-    }
-    const logDuplicate = (k) => {
-      this.log.warn('%s [%s] %s.', platformLang.cfgItem, k, platformLang.cfgDup)
-    }
-    const logIgnore = (k) => {
-      this.log.warn('%s [%s] %s.', platformLang.cfgItem, k, platformLang.cfgIgn)
-    }
-    const logIgnoreItem = (k) => {
-      this.log.warn('%s [%s] %s.', platformLang.cfgItem, k, platformLang.cfgIgnItem)
-    }
-    const logIncrease = (k, min) => {
-      this.log.warn('%s [%s] %s %s.', platformLang.cfgItem, k, platformLang.cfgLow, min)
-    }
-    const logQuotes = (k) => {
-      this.log.warn('%s [%s] %s.', platformLang.cfgItem, k, platformLang.cfgQts)
-    }
-    const logRemove = (k) => {
-      this.log.warn('%s [%s] %s.', platformLang.cfgItem, k, platformLang.cfgRmv)
-    }
-
-    // Begin applying the user's config
-    Object.entries(config).forEach((entry) => {
-      const [key, val] = entry
-      switch (key) {
-        case 'apiKey':
-        case 'code':
-        case 'password':
-        case 'username':
-          if (typeof val !== 'string' || val === '') {
-            logIgnore(key)
-          } else {
-            this.config[key] = val
-          }
-          break
-        case 'lanScanSubnets': {
-          // Comma-separated list of CIDR subnets to scan directly (for devices
-          // on a different subnet from Homebridge, which multicast can't reach)
-          if (typeof val !== 'string' || val.trim() === '') {
-            break
-          }
-          const subnets = val
-            .split(',')
-            .map(s => s.trim())
-            .filter(s => /^\d{1,3}(?:\.\d{1,3}){3}\/\d{1,2}$/.test(s))
-          if (subnets.length === 0) {
-            logIgnore(key)
-          } else {
-            this.config[key] = subnets
-          }
-          break
-        }
-        case 'awsDisable':
-        case 'bleDisable':
-        case 'colourSafeMode':
-        case 'disableDeviceLogging':
-        case 'ignoreMatter':
-        case 'lanDisable':
-          if (typeof val === 'string') {
-            logQuotes(key)
-          }
-          this.config[key] = val === 'false' ? false : !!val
-          break
-        case 'bleControlInterval':
-        case 'bleRefreshTime':
-        case 'httpRefreshTime':
-        case 'lanRefreshTime':
-        case 'lanScanInterval': {
-          if (typeof val === 'string') {
-            logQuotes(key)
-          }
-          const intVal = Number.parseInt(val, 10)
-          if (Number.isNaN(intVal)) {
-            logDefault(key, platformConsts.defaultValues[key])
-            this.config[key] = platformConsts.defaultValues[key]
-          } else if (intVal < platformConsts.minValues[key]) {
-            logIncrease(key, platformConsts.minValues[key])
-            this.config[key] = platformConsts.minValues[key]
-          } else {
-            this.config[key] = intVal
-          }
-          break
-        }
-        case 'dehumidifierDevices':
-        case 'fanDevices':
-        case 'heaterDevices':
-        case 'humidifierDevices':
-        case 'iceMakerDevices':
-        case 'kettleDevices':
-        case 'leakDevices':
-        case 'lightDevices':
-        case 'purifierDevices':
-        case 'diffuserDevices':
-        case 'switchDevices':
-        case 'thermoDevices':
-          if (Array.isArray(val) && val.length > 0) {
-            val.forEach((x) => {
-              if (!x.deviceId) {
-                logIgnoreItem(key)
-                return
-              }
-              const id = parseDeviceId(x.deviceId)
-              if (Object.keys(this.deviceConf).includes(id)) {
-                logDuplicate(`${key}.${id}`)
-                return
-              }
-              const entries = Object.entries(x)
-              if (entries.length === 1) {
-                logRemove(`${key}.${id}`)
-                return
-              }
-              this.deviceConf[id] = {}
-              entries.forEach((subEntry) => {
-                const [k, v] = subEntry
-                switch (k) {
-                  case 'adaptiveLightingShift':
-                  case 'brightnessStep':
-                  case 'lowBattThreshold': {
-                    if (typeof v === 'string') {
-                      logQuotes(`${key}.${k}`)
-                    }
-                    const intVal = Number.parseInt(v, 10)
-                    if (Number.isNaN(intVal)) {
-                      logDefault(`${key}.${id}.${k}`, platformConsts.defaultValues[k])
-                      this.deviceConf[id][k] = platformConsts.defaultValues[k]
-                    } else if (intVal < platformConsts.minValues[k]) {
-                      logIncrease(`${key}.${id}.${k}`, platformConsts.minValues[k])
-                      this.deviceConf[id][k] = platformConsts.minValues[k]
-                    } else {
-                      this.deviceConf[id][k] = intVal
-                    }
-                    break
-                  }
-                  case 'awsBrightnessNoScale':
-                  case 'hideLight':
-                  case 'hideModeGreenTea':
-                  case 'hideModeOolongTea':
-                  case 'hideModeCoffee':
-                  case 'hideModeBlackTea':
-                  case 'showCustomMode1':
-                  case 'showCustomMode2':
-                  case 'showExtraSwitch':
-                  case 'tempReporting':
-                    if (typeof v === 'string') {
-                      logQuotes(`${key}.${id}.${k}`)
-                    }
-                    this.deviceConf[id][k] = v === 'false' ? false : !!v
-                    break
-                  case 'awsColourMode':
-                  case 'openApiTempUnit':
-                  case 'showAs': {
-                    if (typeof v !== 'string' || !platformConsts.allowed[k].includes(v)) {
-                      logIgnore(`${key}.${id}.${k}`)
-                    } else {
-                      this.deviceConf[id][k] = v
-                    }
-                    break
-                  }
-                  case 'customAddress':
-                  case 'customIPAddress':
-                    if (typeof v !== 'string' || v === '') {
-                      logIgnore(`${key}.${id}.${k}`)
-                    } else {
-                      this.deviceConf[id][k] = v.replace(WHITESPACE_REGEX, '')
-                    }
-                    break
-                  case 'deviceId':
-                    break
-                  case 'diyMode':
-                  case 'diyModeTwo':
-                  case 'diyModeThree':
-                  case 'diyModeFour':
-                  case 'musicMode':
-                  case 'musicModeTwo':
-                  case 'scene':
-                  case 'sceneTwo':
-                  case 'sceneThree':
-                  case 'sceneFour':
-                  case 'segmented':
-                  case 'segmentedTwo':
-                  case 'segmentedThree':
-                  case 'segmentedFour':
-                  case 'temperatureSource':
-                  case 'videoMode':
-                  case 'videoModeTwo': {
-                    if (typeof v === 'string') {
-                      this.log.warn(`${key}.${id}.${k} incorrectly configured - please use the config screen to reconfigure this item:`)
-                      this.log.warn(`${key}.${id}.${k}: ${v}`)
-                    }
-                    if (typeof v === 'object') {
-                      // object - only allowed keys are 'sceneCode', 'bleCode' and 'showAs'
-                      const subEntries = Object.entries(v)
-                      if (subEntries.length > 0) {
-                        this.deviceConf[id][k] = {}
-                        subEntries.forEach((subSubEntry) => {
-                          const [k1, v1] = subSubEntry
-                          switch (k1) {
-                            case 'bleCode':
-                            case 'sceneCode':
-                              if (typeof v1 !== 'string' || v1 === '') {
-                                logIgnore(`${key}.${id}.${k}.${k1}`)
-                              } else {
-                                this.deviceConf[id][k][k1] = v1
-                              }
-                              break
-                            case 'showAs': {
-                              if (typeof v1 !== 'string' || !['default', 'switch'].includes(v1)) {
-                                logIgnore(`${key}.${id}.${k}.${k1}`)
-                              } else {
-                                this.deviceConf[id][k][k1] = v1
-                              }
-                              break
-                            }
-                            default:
-                              logIgnore(`${key}.${id}.${k}.${k1}`)
-                              break
-                          }
-                        })
-                      } else {
-                        logIgnore(`${key}.${id}.${k}`)
-                      }
-                    } else {
-                      logIgnore(`${key}.${id}.${k}`)
-                    }
-                    break
-                  }
-                  case 'ignoreDevice':
-                    if (typeof v === 'string') {
-                      logQuotes(`${key}.${id}.${k}`)
-                    }
-                    if (!!v && v !== 'false') {
-                      this.ignoredDevices.push(id)
-                    }
-                    break
-                  case 'label':
-                    if (typeof v !== 'string' || v === '') {
-                      logIgnore(`${key}.${id}.${k}`)
-                    } else {
-                      this.deviceConf[id][k] = v
-                    }
-                    break
-                  default:
-                    logRemove(`${key}.${id}.${k}`)
-                }
-              })
-            })
-          } else {
-            logIgnore(key)
-          }
-          break
-        case 'name':
-        case 'platform':
-          break
-        default:
-          logRemove(key)
-          break
-      }
-    })
-  }
-
   async pluginSetup() {
     // Plugin has finished initialising so now onto setup
     try {
@@ -1095,215 +832,14 @@ export default class {
     try {
       const deviceConf = this.deviceConf[device.device.toUpperCase()] || {}
       const uuid = this.api.hap.uuid.generate(device.device)
-      let accessory
-      let devInstance
-      let doAWSPolling = false
-      if (platformConsts.models.rgb.includes(device.model)) {
-        // Device is an LED strip/bulb
-        devInstance = deviceConf.showAs === 'switch'
-          ? deviceTypes.deviceLightSwitch
-          : deviceTypes.deviceLight
-        accessory = devicesInHB.get(uuid) || this.addAccessory(device)
-      } else if (platformConsts.models.switchSingle.includes(device.model)) {
-        // Device is a cloud enabled Wi-Fi switch
-        switch (deviceConf.showAs || platformConsts.defaultValues.showAs) {
-          case 'audio': {
-            if (devicesInHB.get(uuid)) {
-              this.removeAccessory(devicesInHB.get(uuid))
-            }
-            devInstance = deviceTypes.deviceTVSingle
-            accessory = this.addExternalAccessory(device, 34)
-            break
-          }
-          case 'box': {
-            if (devicesInHB.get(uuid)) {
-              this.removeAccessory(devicesInHB.get(uuid))
-            }
-            devInstance = deviceTypes.deviceTVSingle
-            accessory = this.addExternalAccessory(device, 35)
-            break
-          }
-          case 'stick': {
-            if (devicesInHB.get(uuid)) {
-              this.removeAccessory(devicesInHB.get(uuid))
-            }
-            devInstance = deviceTypes.deviceTVSingle
-            accessory = this.addExternalAccessory(device, 36)
-            break
-          }
-          case 'cooler': {
-            if (!deviceConf.temperatureSource) {
-              this.log.warn('[%s] %s.', device.deviceName, platformLang.heaterSimNoSensor)
-              if (devicesInHB.has(uuid)) {
-                this.removeAccessory(devicesInHB.get(uuid))
-              }
-              return
-            }
-            devInstance = deviceTypes.deviceCoolerSingle
-            accessory = devicesInHB.get(uuid) || this.addAccessory(device)
-            break
-          }
-          case 'heater': {
-            if (!deviceConf.temperatureSource) {
-              this.log.warn('[%s] %s.', device.deviceName, platformLang.heaterSimNoSensor)
-              if (devicesInHB.has(uuid)) {
-                this.removeAccessory(devicesInHB.get(uuid))
-              }
-              return
-            }
-            devInstance = deviceTypes.deviceHeater2Single
-            accessory = devicesInHB.get(uuid) || this.addAccessory(device)
-            break
-          }
-          case 'purifier': {
-            devInstance = deviceTypes.devicePurifierSingle
-            accessory = devicesInHB.get(uuid) || this.addAccessory(device)
-            break
-          }
-          case 'switch': {
-            devInstance = deviceTypes.deviceSwitchSingle
-            accessory = devicesInHB.get(uuid) || this.addAccessory(device)
-            break
-          }
-          case 'tap': {
-            devInstance = deviceTypes.deviceTapSingle
-            accessory = devicesInHB.get(uuid) || this.addAccessory(device)
-            break
-          }
-          case 'valve': {
-            devInstance = deviceTypes.deviceValveSingle
-            accessory = devicesInHB.get(uuid) || this.addAccessory(device)
-            break
-          }
-          default:
-            devInstance = deviceTypes.deviceOutletSingle
-            accessory = devicesInHB.get(uuid) || this.addAccessory(device)
-            break
-        }
-      } else if (platformConsts.models.switchDouble.includes(device.model)) {
-        // Device is an AWS enabled Wi-Fi double switch
-        switch (deviceConf.showAs || platformConsts.defaultValues.showAs) {
-          case 'switch': {
-            devInstance = deviceTypes.deviceSwitchDouble
-            accessory = devicesInHB.get(uuid) || this.addAccessory(device)
-            break
-          }
-          default: {
-            devInstance = deviceTypes.deviceOutletDouble
-            accessory = devicesInHB.get(uuid) || this.addAccessory(device)
-            break
-          }
-        }
-      } else if (platformConsts.models.switchTriple.includes(device.model)) {
-        // Device is an AWS enabled Wi-Fi double switch
-        switch (deviceConf.showAs || platformConsts.defaultValues.showAs) {
-          case 'switch': {
-            devInstance = deviceTypes.deviceSwitchTriple
-            accessory = devicesInHB.get(uuid) || this.addAccessory(device)
-            break
-          }
-          default: {
-            devInstance = deviceTypes.deviceOutletTriple
-            accessory = devicesInHB.get(uuid) || this.addAccessory(device)
-            break
-          }
-        }
-      } else if (platformConsts.models.sensorLeak.includes(device.model)) {
-        // Device is a leak sensor
-        devInstance = deviceTypes.deviceSensorLeak
-        accessory = devicesInHB.get(uuid) || this.addAccessory(device)
-      } else if (platformConsts.models.sensorPresence.includes(device.model)) {
-        // Device is a presence sensor
-        devInstance = deviceTypes.deviceSensorPresence
-        accessory = devicesInHB.get(uuid) || this.addAccessory(device)
-      } else if (platformConsts.models.sensorThermo.includes(device.model)) {
-        // Device is a thermo-hygrometer sensor
-        devInstance = deviceConf.showExtraSwitch
-          ? deviceTypes.deviceSensorThermoSwitch
-          : deviceTypes.deviceSensorThermo
-        accessory = devicesInHB.get(uuid) || this.addAccessory(device)
-      } else if (platformConsts.models.sensorThermo4.includes(device.model)) {
-        // Device is a thermo-hygrometer sensor with 4 prongs and AWS support
-        devInstance = deviceTypes.deviceSensorThermo4
-        accessory = devicesInHB.get(uuid) || this.addAccessory(device)
-      } else if (platformConsts.models.sensorMonitor.includes(device.model)) {
-        devInstance = deviceTypes.deviceSensorMonitor
-        doAWSPolling = true
-        accessory = devicesInHB.get(uuid) || this.addAccessory(device)
-      } else if (platformConsts.models.sensorCO2.includes(device.model)) {
-        // Device is a CO2 + temperature + humidity monitor (H5140)
-        devInstance = deviceTypes.deviceSensorCO2
-        doAWSPolling = true
-        accessory = devicesInHB.get(uuid) || this.addAccessory(device)
-      } else if (platformConsts.models.fan.includes(device.model)) {
-        // Device is a fan. Models whose speeds have not been worked out yet fall
-        // back to the basic handler, which offers on and off and asks for what
-        // it needs rather than leaving the device unsupported altogether
-        devInstance = deviceTypes[`deviceFan${device.model}`] || deviceTypes.deviceFanBasic
-        accessory = devicesInHB.get(uuid) || this.addAccessory(device)
-      } else if (platformConsts.models.heater1.includes(device.model)) {
-        // Some of these heaters report the room temperature and some do not,
-        // and the two need different tiles in HomeKit - a plain fan against a
-        // heater with a temperature readout. Rather than leave the owner to
-        // work that out and tick a box, take Govee's own word for it where the
-        // device says so, and otherwise use what a previous run learnt from the
-        // readings themselves. The setting still wins if it has been set, so
-        // nobody who has already configured this sees their tile change.
-        const reportsTemperature = device.openApiInfo?.byInstance?.sensorTemperature
-          ? true
-          : devicesInHB.get(uuid)?.context?.supportsAmbientTemp
-        devInstance = (deviceConf.tempReporting ?? reportsTemperature)
-          ? deviceTypes.deviceHeater1B
-          : deviceTypes.deviceHeater1A
-        doAWSPolling = true
-        accessory = devicesInHB.get(uuid) || this.addAccessory(device)
-      } else if (platformConsts.models.heater2.includes(device.model)) {
-        // Device is a H7131/H7132
-        devInstance = deviceTypes.deviceHeater2
-        doAWSPolling = true
-        accessory = devicesInHB.get(uuid) || this.addAccessory(device)
-      } else if (platformConsts.models.humidifier.includes(device.model)) {
-        // Device is a humidifier
-        doAWSPolling = true
-        devInstance = deviceTypes[`deviceHumidifier${device.model}`] || deviceTypes.deviceHumidifierBasic
-        accessory = devicesInHB.get(uuid) || this.addAccessory(device)
-      } else if (platformConsts.models.dehumidifier.includes(device.model)) {
-        // Device is a dehumidifier
-        devInstance = deviceTypes[`deviceDehumidifier${device.model}`] || deviceTypes.deviceDehumidifierBasic
-        doAWSPolling = true
-        accessory = devicesInHB.get(uuid) || this.addAccessory(device)
-      } else if (platformConsts.models.purifier.includes(device.model)) {
-        // Device is a purifier
-        devInstance = deviceTypes[`devicePurifier${device.model}`] || deviceTypes.devicePurifierBasic
-        doAWSPolling = true
-        accessory = devicesInHB.get(uuid) || this.addAccessory(device)
-      } else if (platformConsts.models.diffuser.includes(device.model)) {
-        // Device is a diffuser
-        devInstance = deviceTypes[`deviceDiffuser${device.model}`]
-        doAWSPolling = true
-        accessory = devicesInHB.get(uuid) || this.addAccessory(device)
-      } else if (platformConsts.models.sensorButton.includes(device.model)) {
-        // Device is a button
-        devInstance = deviceTypes.deviceSensorButton
-        accessory = devicesInHB.get(uuid) || this.addAccessory(device)
-      } else if (platformConsts.models.sensorContact.includes(device.model)) {
-        // Device is a contact sensor
-        devInstance = deviceTypes.deviceSensorContact
-        accessory = devicesInHB.get(uuid) || this.addAccessory(device)
-      } else if (platformConsts.models.kettle.includes(device.model)) {
-        // Device is a kettle
-        devInstance = deviceTypes.deviceKettle
-        accessory = devicesInHB.get(uuid) || this.addAccessory(device)
-      } else if (platformConsts.models.iceMaker.includes(device.model)) {
-        // Device is an ice maker
-        devInstance = deviceTypes[`deviceIceMaker${device.model}`] || deviceTypes.deviceIceMakerBasic
-        accessory = devicesInHB.get(uuid) || this.addAccessory(device)
-      } else if (platformConsts.models.template.includes(device.model)) {
-        // Device is a work-in-progress
-        devInstance = deviceTypes.deviceTemplate
-        accessory = devicesInHB.get(uuid) || this.addAccessory(device)
-      } else {
-        // Device is not in any supported model list but could be implemented into the plugin
+      const cached = devicesInHB.get(uuid)
+
+      // Which handler this device gets is decided by the dispatch table, so
+      // adding a device type does not mean editing this file
+      const route = resolveDeviceType(device, deviceConf, cached?.context)
+
+      if (!route) {
+        // Not in any supported model list, but it could be added to the plugin
         this.log.warn(
           '[%s] %s:\n%s',
           device.deviceName,
@@ -1313,6 +849,31 @@ export default class {
         return
       }
 
+      if (route.skip === 'needsTemperatureSource') {
+        // Standing in for a heater or cooler needs a temperature from somewhere
+        // else, and without one there is nothing to show
+        this.log.warn('[%s] %s.', device.deviceName, platformLang.heaterSimNoSensor)
+        if (cached) {
+          this.removeAccessory(cached)
+        }
+        return
+      }
+
+      const devInstance = route.handler
+      const doAWSPolling = route.awsPolling
+
+      let accessory
+      if (route.externalCategory) {
+        // A television has to be published as its own accessory rather than as
+        // a tile on the bridge, so any tile from a previous setting goes first
+        if (cached) {
+          this.removeAccessory(cached)
+        }
+        accessory = this.addExternalAccessory(device, route.externalCategory)
+      } else {
+        accessory = cached || this.addAccessory(device)
+      }
+
       // Final check the accessory now exists in Homebridge
       if (!accessory) {
         throw new Error(platformLang.accNotFound)

package/lib/utils/config-parser.js

@@ -0,0 +1,280 @@
+import platformConsts from './constants.js'
+import { parseDeviceId } from './functions.js'
+import platformLang from './lang-en.js'
+
+const WHITESPACE_REGEX = /\s+/g
+
+/**
+ * Reads the user's settings, warns about anything that will not be used, and
+ * fills in the defaults for the rest.
+ *
+ * Lifted out of the platform unchanged. It was the largest single thing in
+ * there and had nothing to do with talking to devices, so a change to how a
+ * device works no longer means opening the same file as a change to how a
+ * setting is read.
+ *
+ * It writes `config`, `deviceConf` and `ignoredDevices` onto the platform
+ * rather than returning them, which is how it always worked.
+ */
+export function applyUserConfig(platform, config) {
+  // These shorthand functions save line space during config parsing
+  const logDefault = (k, def) => {
+    platform.log.warn('%s [%s] %s %s.', platformLang.cfgItem, k, platformLang.cfgDef, def)
+  }
+  const logDuplicate = (k) => {
+    platform.log.warn('%s [%s] %s.', platformLang.cfgItem, k, platformLang.cfgDup)
+  }
+  const logIgnore = (k) => {
+    platform.log.warn('%s [%s] %s.', platformLang.cfgItem, k, platformLang.cfgIgn)
+  }
+  const logIgnoreItem = (k) => {
+    platform.log.warn('%s [%s] %s.', platformLang.cfgItem, k, platformLang.cfgIgnItem)
+  }
+  const logIncrease = (k, min) => {
+    platform.log.warn('%s [%s] %s %s.', platformLang.cfgItem, k, platformLang.cfgLow, min)
+  }
+  const logQuotes = (k) => {
+    platform.log.warn('%s [%s] %s.', platformLang.cfgItem, k, platformLang.cfgQts)
+  }
+  const logRemove = (k) => {
+    platform.log.warn('%s [%s] %s.', platformLang.cfgItem, k, platformLang.cfgRmv)
+  }
+
+  // Begin applying the user's config
+  Object.entries(config).forEach((entry) => {
+    const [key, val] = entry
+    switch (key) {
+      case 'apiKey':
+      case 'code':
+      case 'password':
+      case 'username':
+        if (typeof val !== 'string' || val === '') {
+          logIgnore(key)
+        } else {
+          platform.config[key] = val
+        }
+        break
+      case 'lanScanSubnets': {
+        // Comma-separated list of CIDR subnets to scan directly (for devices
+        // on a different subnet from Homebridge, which multicast can't reach)
+        if (typeof val !== 'string' || val.trim() === '') {
+          break
+        }
+        const subnets = val
+          .split(',')
+          .map(s => s.trim())
+          .filter(s => /^\d{1,3}(?:\.\d{1,3}){3}\/\d{1,2}$/.test(s))
+        if (subnets.length === 0) {
+          logIgnore(key)
+        } else {
+          platform.config[key] = subnets
+        }
+        break
+      }
+      case 'awsDisable':
+      case 'bleDisable':
+      case 'colourSafeMode':
+      case 'disableDeviceLogging':
+      case 'ignoreMatter':
+      case 'lanDisable':
+        if (typeof val === 'string') {
+          logQuotes(key)
+        }
+        platform.config[key] = val === 'false' ? false : !!val
+        break
+      case 'bleControlInterval':
+      case 'bleRefreshTime':
+      case 'httpRefreshTime':
+      case 'lanRefreshTime':
+      case 'lanScanInterval': {
+        if (typeof val === 'string') {
+          logQuotes(key)
+        }
+        const intVal = Number.parseInt(val, 10)
+        if (Number.isNaN(intVal)) {
+          logDefault(key, platformConsts.defaultValues[key])
+          platform.config[key] = platformConsts.defaultValues[key]
+        } else if (intVal < platformConsts.minValues[key]) {
+          logIncrease(key, platformConsts.minValues[key])
+          platform.config[key] = platformConsts.minValues[key]
+        } else {
+          platform.config[key] = intVal
+        }
+        break
+      }
+      case 'dehumidifierDevices':
+      case 'fanDevices':
+      case 'heaterDevices':
+      case 'humidifierDevices':
+      case 'iceMakerDevices':
+      case 'kettleDevices':
+      case 'leakDevices':
+      case 'lightDevices':
+      case 'purifierDevices':
+      case 'diffuserDevices':
+      case 'switchDevices':
+      case 'thermoDevices':
+        if (Array.isArray(val) && val.length > 0) {
+          val.forEach((x) => {
+            if (!x.deviceId) {
+              logIgnoreItem(key)
+              return
+            }
+            const id = parseDeviceId(x.deviceId)
+            if (Object.keys(platform.deviceConf).includes(id)) {
+              logDuplicate(`${key}.${id}`)
+              return
+            }
+            const entries = Object.entries(x)
+            if (entries.length === 1) {
+              logRemove(`${key}.${id}`)
+              return
+            }
+            platform.deviceConf[id] = {}
+            entries.forEach((subEntry) => {
+              const [k, v] = subEntry
+              switch (k) {
+                case 'adaptiveLightingShift':
+                case 'brightnessStep':
+                case 'lowBattThreshold': {
+                  if (typeof v === 'string') {
+                    logQuotes(`${key}.${k}`)
+                  }
+                  const intVal = Number.parseInt(v, 10)
+                  if (Number.isNaN(intVal)) {
+                    logDefault(`${key}.${id}.${k}`, platformConsts.defaultValues[k])
+                    platform.deviceConf[id][k] = platformConsts.defaultValues[k]
+                  } else if (intVal < platformConsts.minValues[k]) {
+                    logIncrease(`${key}.${id}.${k}`, platformConsts.minValues[k])
+                    platform.deviceConf[id][k] = platformConsts.minValues[k]
+                  } else {
+                    platform.deviceConf[id][k] = intVal
+                  }
+                  break
+                }
+                case 'awsBrightnessNoScale':
+                case 'hideLight':
+                case 'hideModeGreenTea':
+                case 'hideModeOolongTea':
+                case 'hideModeCoffee':
+                case 'hideModeBlackTea':
+                case 'showCustomMode1':
+                case 'showCustomMode2':
+                case 'showExtraSwitch':
+                case 'tempReporting':
+                  if (typeof v === 'string') {
+                    logQuotes(`${key}.${id}.${k}`)
+                  }
+                  platform.deviceConf[id][k] = v === 'false' ? false : !!v
+                  break
+                case 'awsColourMode':
+                case 'openApiTempUnit':
+                case 'showAs': {
+                  if (typeof v !== 'string' || !platformConsts.allowed[k].includes(v)) {
+                    logIgnore(`${key}.${id}.${k}`)
+                  } else {
+                    platform.deviceConf[id][k] = v
+                  }
+                  break
+                }
+                case 'customAddress':
+                case 'customIPAddress':
+                  if (typeof v !== 'string' || v === '') {
+                    logIgnore(`${key}.${id}.${k}`)
+                  } else {
+                    platform.deviceConf[id][k] = v.replace(WHITESPACE_REGEX, '')
+                  }
+                  break
+                case 'deviceId':
+                  break
+                case 'diyMode':
+                case 'diyModeTwo':
+                case 'diyModeThree':
+                case 'diyModeFour':
+                case 'musicMode':
+                case 'musicModeTwo':
+                case 'scene':
+                case 'sceneTwo':
+                case 'sceneThree':
+                case 'sceneFour':
+                case 'segmented':
+                case 'segmentedTwo':
+                case 'segmentedThree':
+                case 'segmentedFour':
+                case 'temperatureSource':
+                case 'videoMode':
+                case 'videoModeTwo': {
+                  if (typeof v === 'string') {
+                    platform.log.warn(`${key}.${id}.${k} incorrectly configured - please use the config screen to reconfigure this item:`)
+                    platform.log.warn(`${key}.${id}.${k}: ${v}`)
+                  }
+                  if (typeof v === 'object') {
+                    // object - only allowed keys are 'sceneCode', 'bleCode' and 'showAs'
+                    const subEntries = Object.entries(v)
+                    if (subEntries.length > 0) {
+                      platform.deviceConf[id][k] = {}
+                      subEntries.forEach((subSubEntry) => {
+                        const [k1, v1] = subSubEntry
+                        switch (k1) {
+                          case 'bleCode':
+                          case 'sceneCode':
+                            if (typeof v1 !== 'string' || v1 === '') {
+                              logIgnore(`${key}.${id}.${k}.${k1}`)
+                            } else {
+                              platform.deviceConf[id][k][k1] = v1
+                            }
+                            break
+                          case 'showAs': {
+                            if (typeof v1 !== 'string' || !['default', 'switch'].includes(v1)) {
+                              logIgnore(`${key}.${id}.${k}.${k1}`)
+                            } else {
+                              platform.deviceConf[id][k][k1] = v1
+                            }
+                            break
+                          }
+                          default:
+                            logIgnore(`${key}.${id}.${k}.${k1}`)
+                            break
+                        }
+                      })
+                    } else {
+                      logIgnore(`${key}.${id}.${k}`)
+                    }
+                  } else {
+                    logIgnore(`${key}.${id}.${k}`)
+                  }
+                  break
+                }
+                case 'ignoreDevice':
+                  if (typeof v === 'string') {
+                    logQuotes(`${key}.${id}.${k}`)
+                  }
+                  if (!!v && v !== 'false') {
+                    platform.ignoredDevices.push(id)
+                  }
+                  break
+                case 'label':
+                  if (typeof v !== 'string' || v === '') {
+                    logIgnore(`${key}.${id}.${k}`)
+                  } else {
+                    platform.deviceConf[id][k] = v
+                  }
+                  break
+                default:
+                  logRemove(`${key}.${id}.${k}`)
+              }
+            })
+          })
+        } else {
+          logIgnore(key)
+        }
+        break
+      case 'name':
+      case 'platform':
+        break
+      default:
+        logRemove(key)
+        break
+    }
+  })
+}

package/lib/utils/dispatch.js

@@ -0,0 +1,159 @@
+import deviceTypes from '../device/index.js'
+import platformConsts from './constants.js'
+
+/**
+ * Works out which handler a device should get.
+ *
+ * This used to be a long chain of `else if` inside the platform, which meant
+ * adding a device type involved editing the file that also does config parsing,
+ * discovery and connection setup. It is a table now, read top to bottom, so a
+ * new type is a row.
+ *
+ * Only the choice lives here. Creating the accessory stays with the platform,
+ * because that talks to Homebridge - so this returns what to build rather than
+ * building it, and can be tested on its own.
+ */
+
+/**
+ * How a model list picks its handler.
+ *
+ * - `handler`  one handler for every model in the list
+ * - `prefix`   look for a handler named after the model, eg `deviceFanH7100`
+ * - `fallback` used when `prefix` finds nothing, so a model nobody has worked
+ *              out still gets power rather than being left unsupported
+ * - `choose`   for the few lists where the answer depends on the device or the
+ *              owner's settings
+ * - `awsPolling` these devices need their status asking for over AWS
+ */
+const routes = [
+  {
+    list: 'rgb',
+    choose: ({ deviceConf }) => (deviceConf.showAs === 'switch' ? 'deviceLightSwitch' : 'deviceLight'),
+  },
+  { list: 'switchSingle', choose: chooseSingleSwitch },
+  {
+    list: 'switchDouble',
+    choose: ({ deviceConf }) => (showAs(deviceConf) === 'switch' ? 'deviceSwitchDouble' : 'deviceOutletDouble'),
+  },
+  {
+    list: 'switchTriple',
+    choose: ({ deviceConf }) => (showAs(deviceConf) === 'switch' ? 'deviceSwitchTriple' : 'deviceOutletTriple'),
+  },
+  { list: 'sensorLeak', handler: 'deviceSensorLeak' },
+  { list: 'sensorPresence', handler: 'deviceSensorPresence' },
+  {
+    list: 'sensorThermo',
+    choose: ({ deviceConf }) => (deviceConf.showExtraSwitch ? 'deviceSensorThermoSwitch' : 'deviceSensorThermo'),
+  },
+  { list: 'sensorThermo4', handler: 'deviceSensorThermo4' },
+  { list: 'sensorMonitor', handler: 'deviceSensorMonitor', awsPolling: true },
+  { list: 'sensorCO2', handler: 'deviceSensorCO2', awsPolling: true },
+  { list: 'fan', prefix: 'deviceFan', fallback: 'deviceFanBasic' },
+  { list: 'heater1', choose: chooseHeater, awsPolling: true },
+  { list: 'heater2', handler: 'deviceHeater2', awsPolling: true },
+  { list: 'humidifier', prefix: 'deviceHumidifier', fallback: 'deviceHumidifierBasic', awsPolling: true },
+  { list: 'dehumidifier', prefix: 'deviceDehumidifier', fallback: 'deviceDehumidifierBasic', awsPolling: true },
+  { list: 'purifier', prefix: 'devicePurifier', fallback: 'devicePurifierBasic', awsPolling: true },
+  { list: 'diffuser', prefix: 'deviceDiffuser', fallback: 'deviceDiffuserBasic', awsPolling: true },
+  { list: 'sensorButton', handler: 'deviceSensorButton' },
+  { list: 'sensorContact', handler: 'deviceSensorContact' },
+  { list: 'kettle', handler: 'deviceKettle' },
+  { list: 'iceMaker', prefix: 'deviceIceMaker', fallback: 'deviceIceMakerBasic' },
+  { list: 'template', handler: 'deviceTemplate' },
+]
+
+function showAs(deviceConf) {
+  return deviceConf.showAs || platformConsts.defaultValues.showAs
+}
+
+/**
+ * A single socket can be shown as all sorts of things, because people use them
+ * for all sorts of things. Three of those are televisions, which Homebridge has
+ * to publish as their own accessory rather than as a tile on the bridge.
+ */
+function chooseSingleSwitch({ deviceConf }) {
+  switch (showAs(deviceConf)) {
+    case 'audio':
+      return { handler: 'deviceTVSingle', externalCategory: 34 }
+    case 'box':
+      return { handler: 'deviceTVSingle', externalCategory: 35 }
+    case 'stick':
+      return { handler: 'deviceTVSingle', externalCategory: 36 }
+    case 'cooler':
+      // Standing in for a cooler means reading a temperature from somewhere
+      // else, and without that there is nothing to show
+      return deviceConf.temperatureSource
+        ? { handler: 'deviceCoolerSingle' }
+        : { skip: 'needsTemperatureSource' }
+    case 'heater':
+      return deviceConf.temperatureSource
+        ? { handler: 'deviceHeater2Single' }
+        : { skip: 'needsTemperatureSource' }
+    case 'purifier':
+      return 'devicePurifierSingle'
+    case 'switch':
+      return 'deviceSwitchSingle'
+    case 'tap':
+      return 'deviceTapSingle'
+    case 'valve':
+      return 'deviceValveSingle'
+    default:
+      return 'deviceOutletSingle'
+  }
+}
+
+/**
+ * Some of these heaters report the room temperature and some do not, and the
+ * two need different tiles - a plain fan against a heater with a temperature
+ * readout. Rather than leave the owner to work that out and tick a box, take
+ * Govee's own word for it where the device says so, and otherwise use what a
+ * previous run learnt from the readings themselves. An owner who has already
+ * set the option still wins, so nobody's tile changes under them.
+ */
+function chooseHeater({ device, deviceConf, cachedContext }) {
+  const reportsTemperature = device.openApiInfo?.byInstance?.sensorTemperature
+    ? true
+    : cachedContext?.supportsAmbientTemp
+  return (deviceConf.tempReporting ?? reportsTemperature)
+    ? 'deviceHeater1B'
+    : 'deviceHeater1A'
+}
+
+function normalise(answer) {
+  return typeof answer === 'string' ? { handler: answer } : answer
+}
+
+/**
+ * Decide what to build for a device.
+ *
+ * @param {object} device the device as Govee describes it
+ * @param {object} [deviceConf] this device's settings
+ * @param {object} [cachedContext] the context of the accessory from a previous
+ *   run, where there is one - some choices depend on what was learnt before
+ * @returns {object|null} `{ handler, handlerKey, awsPolling, externalCategory,
+ *   skip }`, or null when the model is not one we handle
+ */
+export function resolveDeviceType(device, deviceConf = {}, cachedContext = undefined) {
+  const route = routes.find(entry => platformConsts.models[entry.list]?.includes(device.model))
+  if (!route) {
+    return null
+  }
+
+  const chosen = route.choose
+    ? normalise(route.choose({ device, deviceConf, cachedContext }))
+    : { handler: route.handler ?? (deviceTypes[`${route.prefix}${device.model}`] ? `${route.prefix}${device.model}` : route.fallback) }
+
+  if (chosen.skip) {
+    return { skip: chosen.skip, list: route.list }
+  }
+
+  return {
+    list: route.list,
+    handlerKey: chosen.handler,
+    handler: deviceTypes[chosen.handler],
+    awsPolling: !!route.awsPolling,
+    externalCategory: chosen.externalCategory,
+  }
+}
+
+export { routes }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@homebridge-plugins/homebridge-govee",
   "alias": "Govee",
   "type": "module",
-  "version": "11.32.2-beta.15",
+  "version": "11.32.2-beta.16",
   "description": "Homebridge plugin to integrate Govee devices into HomeKit.",
   "author": {
     "name": "bwp91",