@homebridge-plugins/homebridge-govee 11.32.2-beta.2 → 11.32.2-beta.21

package/lib/platform.js

@@ -11,23 +11,25 @@ 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 { applyDeviceContext } from './utils/device-context.js'
+import { cloudListsWereFetched, planDeviceSetup, planRedundantAccessories } from './utils/device-merge.js'
+import { resolveDeviceType } from './utils/dispatch.js'
 import eveChars from './utils/eve-chars.js'
 import {
   base64ToHex,
   hasProperty,
-  parseDeviceId,
   parseError,
   pfxToCertAndKey,
   updateFailureError,
 } from './utils/functions.js'
 import platformLang from './utils/lang-en.js'
+import { logUnknownData } from './utils/report-unknown.js'
 import { parseDeviceUpdate } from './utils/response-parser.js'
 
 const require = createRequire(import.meta.url)
@@ -85,7 +87,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
@@ -103,269 +105,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 {
@@ -604,192 +343,45 @@ export default class {
         throwOnTimeout: true,
       })
 
-      // Initialise the devices
-      let bleSyncNeeded = false
-      let httpSyncNeeded = false
-      let lanDevicesWereInitialised = false
-      let httpDevicesWereInitialised = false
-      let openApiDevicesWereInitialised = false
-
-      if (httpDevices && httpDevices.length > 0) {
-        // We have some devices from HTTP client
-        httpDevices.forEach((httpDevice) => {
-          // Format device id
-          if (!httpDevice.device.includes(':')) {
-            // Eg converts abcd1234abcd1234 to AB:CD:12:34:AB:CD:12:34
-            // For sensors with an add-on sensor like H5178
-            // Eg converts abcd1234abcd1234_1 to AB:CD:12:34:AB:CD:12:34_1
-            httpDevice.device = httpDevice.device.replace(DEVICE_ID_FORMAT_REGEX, '$&:').toUpperCase()
-          }
-
-          // Check it's not a user-ignored device
-          if (this.ignoredDevices.includes(httpDevice.device)) {
-            return
-          }
-
-          // Skip Govee app device groups as these are not real devices (#1309)
-          if (['BaseGroup', 'SameModeGroup'].includes(httpDevice.sku)) {
-            this.log.debug('[%s] %s.', httpDevice.deviceName, platformLang.devIsGroup)
-            return
-          }
-
-          // Check it's not a matter-ignored device, if the config has been set
-          if (platformConsts.matterModels.includes(httpDevice.sku) && this.config.ignoreMatter) {
-            return
-          }
-
-          // Sets the flag to see if we need to set up the BLE/HTTP syncs
-          if (platformConsts.models.sensorLeak.includes(httpDevice.sku)) {
-            httpSyncNeeded = true
-          }
-          if (platformConsts.models.sensorThermo.includes(httpDevice.sku)) {
-            bleSyncNeeded = true
-            httpSyncNeeded = true
-          }
-
-          // Find any matching device from the LAN client
-          const lanDevice = lanDevices.find(el => el.device === httpDevice.device)
-
-          // Find any matching device from the OpenAPI client to merge capabilities
-          const matchingOpenApiDevice = openApiDevices.find(el => el.device === httpDevice.device)
-          const openApiMerge = matchingOpenApiDevice
-            ? {
-                openApiInfo: matchingOpenApiDevice.openApiInfo,
-                properties: matchingOpenApiDevice.properties,
-                supportCmds: matchingOpenApiDevice.supportCmds,
-              }
-            : {}
-
-          if (lanDevice) {
-            // Device exists in LAN data so add the http info to the object and initialise
-            this.initialiseDevice({
-              ...lanDevice,
-              httpInfo: httpDevice,
-              model: httpDevice.sku,
-              deviceName: httpDevice.deviceName,
-              isLanDevice: true,
-              ...openApiMerge,
-            })
-            lanDevicesWereInitialised = true
-            lanDevice.initialised = true
-          } else {
-            // Device doesn't exist in LAN data, but try to initialise as could be other device type
-            this.initialiseDevice({
-              device: httpDevice.device,
-              deviceName: httpDevice.deviceName,
-              model: httpDevice.sku,
-              httpInfo: httpDevice,
-              ...openApiMerge,
-            })
-          }
-          httpDevicesWereInitialised = true
-        })
-      }
-
-      if (openApiDevices && openApiDevices.length > 0) {
-        openApiDevices.forEach((openApiDevice) => {
-          // Skip Govee app device groups as these are not real devices (#1309)
-          if (['BaseGroup', 'SameModeGroup'].includes(openApiDevice.model)) {
-            this.log.debug('[%s] %s.', openApiDevice.deviceName, platformLang.devIsGroup)
-            return
-          }
-
-          if (this.ignoredDevices.includes(openApiDevice.device)) {
-            return
-          }
-
-          if (platformConsts.matterModels.includes(openApiDevice.model) && this.config.ignoreMatter) {
-            return
-          }
-
-          if (httpDevices.some(httpDevice => httpDevice.device === openApiDevice.device)) {
-            return
-          }
-
-          const lanDevice = lanDevices.find(el => el.device === openApiDevice.device)
-
-          if (lanDevice) {
-            this.initialiseDevice({
-              ...lanDevice,
-              deviceName: openApiDevice.deviceName,
-              model: openApiDevice.model,
-              openApiInfo: openApiDevice.openApiInfo,
-              properties: openApiDevice.properties,
-              supportCmds: openApiDevice.supportCmds,
-              isLanDevice: true,
-            })
-            lanDevicesWereInitialised = true
-            lanDevice.initialised = true
-          } else {
-            this.initialiseDevice(openApiDevice)
-          }
-
-          openApiDevicesWereInitialised = true
-        })
-      }
+      // Work out what to set up. Govee describes the same device through up to
+      // three lists, and how they combine is decided away from here so it can
+      // be tested rather than hoped about
+      const plan = planDeviceSetup({
+        httpDevices,
+        lanDevices,
+        openApiDevices,
+        ignoredDevices: this.ignoredDevices,
+        ignoreMatter: this.config.ignoreMatter,
+        deviceConf: this.deviceConf,
+      })
 
-      // Some LAN devices may exist outside the HTTP client
-      const pendingLANDevices = lanDevices.filter(el => !el.initialised)
-      if (pendingLANDevices.length > 0) {
-        // No devices from HTTP client, but LAN devices exist
-        pendingLANDevices.forEach((lanDevice) => {
-          // Check it's not a user-ignored device
-          if (this.ignoredDevices.includes(lanDevice.device)) {
-            return
-          }
+      plan.skippedGroups.forEach(name => this.log.debug('[%s] %s.', name, platformLang.devIsGroup))
+      plan.devices.forEach(device => this.initialiseDevice(device))
 
-          // Check it's not a matter-ignored device, if the config has been set, since a
-          // device skipped by the http/openapi loops for this reason still has an
-          // unmatched lan record, which would otherwise be added here and then removed
-          // again by the cleanup below on every restart (#1315)
-          if (this.config.ignoreMatter && platformConsts.matterModels.includes(lanDevice.sku)) {
-            return
-          }
+      const {
+        bleSyncNeeded,
+        httpSyncNeeded,
+        httpDevicesWereInitialised,
+        openApiDevicesWereInitialised,
+        lanDevicesWereInitialised,
+      } = plan
 
-          // Initialise the device into Homebridge
-          // Since LAN does not provide a name, we will use the configured label or device id
-          this.initialiseDevice({
-            device: lanDevice.device,
-            deviceName: this.deviceConf?.[lanDevice.device]?.label || lanDevice.device.replaceAll(':', ''),
-            model: lanDevice.sku || 'HXXXX', // In case the model is not provided
-            isLanDevice: true,
-            isLanOnly: true,
-          })
-          lanDevicesWereInitialised = true
-        })
-      }
-
-      if (!lanDevicesWereInitialised && !httpDevicesWereInitialised && !openApiDevicesWereInitialised) {
-        // No devices either from HTTP client nor LAN client
+      if (!plan.anyInitialised) {
         throw new Error(platformLang.noDevs)
       }
 
-      // Check for redundant Homebridge accessories
-      // Only treat 'not found in Govee' as a reason to remove an accessory when the
-      // configured cloud clients actually returned their device lists this session,
-      // otherwise a failed fetch would remove the accessory and destroy any HomeKit
-      // scenes and automations it is part of (#1264)
-      const cloudListsFetched = (!this.config.username || !!this.httpClient)
-        && (!!this.config.openApiDisable || !this.config.apiKey || !!this.openApiClient)
-      devicesInHB.forEach((accessory) => {
-        // Remove the accessory if it is now being ignored, or if it is a matter model
-        // and the user has enabled ignoreMatter (otherwise the cached accessory lingers
-        // even though the device is skipped during setup) (#1287)
-        const isIgnored = this.ignoredDevices.includes(accessory.context.gvDeviceId)
-          || (this.config.ignoreMatter && platformConsts.matterModels.includes(accessory.context.gvModel))
-
-        // Also remove it if the device no longer exists in Govee, but never based on
-        // an incomplete cloud list, and never for LAN-only devices which may simply
-        // have missed a scan window (#1264)
-        const isMissing = !httpDevices.some(el => el.device === accessory.context.gvDeviceId)
-          && !lanDevices.some(el => el.device === accessory.context.gvDeviceId)
-          && !openApiDevices.some(el => el.device === accessory.context.gvDeviceId)
-        const isLanOnly = accessory.context.hasLanControl && !accessory.context.firmware
-
-        if (isIgnored || (isMissing && cloudListsFetched && !isLanOnly)) {
-          this.removeAccessory(accessory)
-        }
-      })
+      // Let go of any cached accessory that no longer belongs. Removing one
+      // destroys the HomeKit scenes and automations it is part of, so the rules
+      // for this live next to their tests
+      planRedundantAccessories({
+        accessories: [...devicesInHB.values()],
+        httpDevices,
+        lanDevices,
+        openApiDevices,
+        ignoredDevices: this.ignoredDevices,
+        ignoreMatter: this.config.ignoreMatter,
+        cloudListsFetched: cloudListsWereFetched(this.config, this),
+      }).forEach(accessory => this.removeAccessory(accessory))
 
       // Set up the ble client sync needed for thermo sensor devices
       if (bleSyncNeeded) {
@@ -1094,204 +686,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
-        devInstance = deviceTypes[`deviceFan${device.model}`]
-        accessory = devicesInHB.get(uuid) || this.addAccessory(device)
-      } else if (platformConsts.models.heater1.includes(device.model)) {
-        // Device is a H7130
-        devInstance = deviceConf.tempReporting
-          ? 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}`]
-        accessory = devicesInHB.get(uuid) || this.addAccessory(device)
-      } else if (platformConsts.models.dehumidifier.includes(device.model)) {
-        // Device is a dehumidifier
-        devInstance = deviceTypes[`deviceDehumidifier${device.model}`]
-        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}`]
-        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}`]
-        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,
@@ -1301,169 +703,44 @@ export default class {
         return
       }
 
-      // Final check the accessory now exists in Homebridge
-      if (!accessory) {
-        throw new Error(platformLang.accNotFound)
+      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
       }
 
-      // Set the logging level for this device
-      this.applyAccessoryLogging(accessory)
-
-      // Add the temperatureSource config to the context if exists
-      if (deviceConf.temperatureSource) {
-        accessory.context.temperatureSource = deviceConf.temperatureSource
-      }
+      const devInstance = route.handler
 
-      // Add the openApiTempUnit config to the context if set to something other than auto
-      if (deviceConf.openApiTempUnit && deviceConf.openApiTempUnit !== 'auto') {
-        accessory.context.openApiTempUnit = deviceConf.openApiTempUnit
+      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 {
-        delete accessory.context.openApiTempUnit
+        accessory = cached || this.addAccessory(device)
       }
 
-      // Get a supported command list if provided, with their options
-      if (device.supportCmds && Array.isArray(device.supportCmds)) {
-        accessory.context.supportedCmds = device.supportCmds
-        accessory.context.supportedCmdsOpts = {}
-
-        device.supportCmds.forEach((cmd) => {
-          if (device?.properties?.[cmd]) {
-            accessory.context.supportedCmdsOpts[cmd] = device.properties[cmd]
-          }
-        })
-      }
-
-      // Add some initial context information which is changed later
-      accessory.context.hasAwsControl = false
-      accessory.context.useAwsControl = false
-      accessory.context.hasOpenApiControl = false
-      accessory.context.useOpenApiControl = false
-      accessory.context.hasBleControl = false
-      accessory.context.useBleControl = false
-      accessory.context.hasLanControl = device.isLanDevice
-      accessory.context.useLanControl = accessory.context.hasLanControl
-      accessory.context.firmware = false
-      accessory.context.hardware = false
-      accessory.context.image = false
-
-      // Overrides for when a custom IP is provided, for a light which is not BLE only
-      if (
-        deviceConf.customIPAddress
-        && accessory.context.hasLanControl
-        && accessory.context.hasAwsControl
-        && platformConsts.models.rgb.includes(device.model)
-      ) {
-        accessory.context.hasLanControl = true
-        accessory.context.useLanControl = true
-      }
-
-      // If the device is LAN-only, then sync the display name with the label in the configuration
-      if (device.isLanOnly) {
-        accessory.displayName = device.deviceName
+      // Final check the accessory now exists in Homebridge
+      if (!accessory) {
+        throw new Error(platformLang.accNotFound)
       }
 
-      // See if we have extra HTTP client info for this device
-      if (device.httpInfo) {
-        // Save the hardware and firmware versions
-        accessory.context.firmware = device.httpInfo.versionSoft
-        accessory.context.hardware = device.httpInfo.versionHard
-
-        // It's possible to show a nice little icon of the device in the Homebridge UI
-        if (device.httpInfo.deviceExt && device.httpInfo.deviceExt.extResources) {
-          try {
-            const parsed = JSON.parse(device.httpInfo.deviceExt.extResources)
-            if (parsed && parsed.skuUrl) {
-              accessory.context.image = parsed.skuUrl
-            }
-          } catch {
-            // Ignore malformed extResources
-          }
-        }
-
-        // HTTP info lets us see if AWS/BLE connection methods are available
-        if (device.httpInfo.deviceExt && device.httpInfo.deviceExt.deviceSettings) {
-          let parsed
-          try {
-            parsed = JSON.parse(device.httpInfo.deviceExt.deviceSettings)
-          } catch {
-            this.log.debugWarn('[%s] failed to parse deviceSettings, skipping AWS/BLE setup.', accessory.displayName)
-          }
-
-          // Check to see if AWS is possible
-          if (parsed) {
-            if (parsed.topic) {
-              accessory.context.hasAwsControl = true
-              accessory.context.awsTopic = parsed.topic
-
-              if (this.awsClient) {
-                accessory.context.useAwsControl = true
-                accessory.context.awsBrightnessNoScale = deviceConf.awsBrightnessNoScale
-                accessory.context.awsColourMode = deviceConf.awsColourMode || platformConsts.defaultValues.awsColourMode
-                awsDevices.push(device.device)
-
-                // Certain models need AWS polling
-                if (doAWSPolling) {
-                  awsDevicesToPoll.push(device.device)
-                }
-              }
-            }
-
-            // Check to see if BLE is possible
-            if (parsed.bleName) {
-              const providedBle = parsed.address ? parsed.address.toLowerCase() : device.device.substring(6).toLowerCase()
-              accessory.context.hasBleControl = !!parsed.bleName
-              accessory.context.bleAddress = deviceConf.customAddress
-                ? deviceConf.customAddress.toLowerCase()
-                : providedBle
-              accessory.context.bleName = parsed.bleName
-              accessory.context.bleWriteUuid = getDeviceCapabilities(accessory.context.gvModel).bleWriteUuid
-              if (this.bleClient) {
-                accessory.context.useBleControl = true
-              }
-            }
-
-            // Gateway subdevices (e.g. leak sensors paired to an H5044) include
-            // their gateway id and slot number, which we need to match real-time
-            // leak events relayed by the gateway over AWS (#1276)
-            if (hasProperty(parsed, 'sno') && parsed.gatewayInfo?.device) {
-              accessory.context.gatewaySno = parsed.sno
-              accessory.context.gatewayDevice = parsed.gatewayInfo.device
-            }
-
-            // Get a min and max temperature/humidity range to show in the homebridge-ui
-            if (hasProperty(parsed, 'temCali')) {
-              accessory.context.minTemp = parsed.temMin / 100
-              accessory.context.maxTemp = parsed.temMax / 100
-              accessory.context.offTemp = parsed.temCali
-            }
-            if (hasProperty(parsed, 'humCali')) {
-              accessory.context.minHumi = parsed.humMin / 100
-              accessory.context.maxHumi = parsed.humMax / 100
-              accessory.context.offHumi = parsed.humCali
-            }
-          }
-        }
-      }
+      // Set the logging level for this device
+      this.applyAccessoryLogging(accessory)
 
-      if (device.openApiInfo) {
-        accessory.context.hasOpenApiControl = true
-        accessory.context.useOpenApiControl = !!this.openApiClient
-        accessory.context.openApiCapabilities = device.openApiInfo.byInstance || {}
-
-        // Log what Govee says this device can do. Working out whether a model
-        // exposes something like a night light otherwise means reverse
-        // engineering its status messages, when the answer is right here
-        const instances = Object.entries(accessory.context.openApiCapabilities)
-          .map(([instance, capability]) => `${instance} (${capability?.type ?? 'unknown type'})`)
-        this.log.debug(
-          '[%s] openapi category [%s] capabilities [%s].',
-          accessory.displayName,
-          device.openApiInfo.category || 'unknown',
-          instances.join(', ') || 'none',
-        )
-      }
+      applyDeviceContext(this, accessory, device, deviceConf, {
+        awsDevices,
+        awsDevicesToPoll,
+        doAWSPolling: route.awsPolling,
+      })
 
-      // Create the instance for this device type
       accessory.control = new devInstance(this, accessory)
 
       // Log the device initialisation
@@ -2077,7 +1354,14 @@ export default class {
         this.log.warn('[%s] %s %s.', accessory.displayName, platformLang.devNotUpdated, parseError(err))
       }
     } else {
-      accessory.logDebugWarn(`[${params.source}] ${platformLang.unknownCommand}: ${JSON.stringify(params)}`)
+      // Nothing in the payload was understood. This is the most useful thing a
+      // user can send in when asking for a device or a function to be added, so
+      // it is reported in full rather than hidden behind debug logging.
+      logUnknownData(accessory, {
+        kind: 'payload',
+        source: params.source,
+        raw: params,
+      })
     }
   }
 }