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

package/CHANGELOG.md

@@ -30,6 +30,11 @@ All notable changes to `@homebridge-plugins/homebridge-govee` will be documented
 - refactor: point the H7151 and H7111 at the handlers they were byte-for-byte copies of
 - refactor: build the ice maker size codes from the model rather than writing both orderings out by hand
 - 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/dehumidifier-H7150.js

@@ -8,7 +8,7 @@ import platformLang from '../utils/lang-en.js'
 import { logUnknownData } from '../utils/report-unknown.js'
 
 /*
-  H7150 and H7151
+  H7150, H7151 and H7152
   {
     "mode": {
       "options": [

package/lib/device/fan-H7100.js

@@ -10,6 +10,16 @@ import {
 import platformLang from '../utils/lang-en.js'
 import { logUnknownData } from '../utils/report-unknown.js'
 
+/*
+  The models on this handler and the modes each offers:
+
+  H7100, H7102, H7106 -> Sleep, Nature, Custom, Auto
+  H7101               -> Sleep, Nature, Turbo, Custom, Auto
+  H7111               -> Sleep, Nature, Custom, Auto
+  H1310, R1310        -> as the H7100, but its oscillation status message has
+                         never been confirmed, so it is not read back
+ */
+
 export default class GoveeFanH7100 {
   constructor(platform, accessory) {
     // Set up variables from the platform
@@ -267,7 +277,7 @@ export default class GoveeFanH7100 {
             this.cacheSpeed = this.autoSpeed
             // Cache auto so we can tell it apart from "user asked for max speed"
             this.service.updateCharacteristic(this.hapChar.RotationSpeed, 100)
-            this.accessory.log(`${platformLang.curSpeed} [auto]`)
+            this.accessory.log(`${platformLang.curSpeed} [auto -> 100%]`)
           }
           break
         }

package/lib/device/index.js

@@ -1,5 +1,6 @@
 import {
   deviceDehumidifierBasic,
+  deviceDiffuserBasic,
   deviceFanBasic,
   deviceHumidifierBasic,
   deviceIceMakerBasic,
@@ -7,11 +8,9 @@ import {
 } from './appliance-basic.js'
 import deviceCoolerSingle from './cooler-single.js'
 import deviceDehumidifierH7150 from './dehumidifier-H7150.js'
-import deviceDehumidifierH7152 from './dehumidifier-H7152.js'
 import deviceDiffuserH7161 from './diffuser-H7161.js'
 import deviceFanH1370 from './fan-H1370.js'
 import deviceFanH7100 from './fan-H7100.js'
-import deviceFanH7101 from './fan-H7101.js'
 import deviceFanH7105 from './fan-H7105.js'
 import deviceFanH7107 from './fan-H7107.js'
 import deviceHeater1A from './heater1a.js'
@@ -53,10 +52,11 @@ export default {
   deviceCoolerSingle,
   deviceDehumidifierH7150,
   deviceDehumidifierH7151: deviceDehumidifierH7150, // identical to the H7150
-  deviceDehumidifierH7152,
+  deviceDehumidifierH7152: deviceDehumidifierH7150, // same device, and this gives it proper speed feedback
   deviceDiffuserH7161,
   deviceDiffuserH7162: deviceDiffuserH7161, // identical to the H7161
   deviceDehumidifierBasic,
+  deviceDiffuserBasic,
   deviceFanBasic,
   deviceFanH1310: deviceFanH7100, // same fan, minus a confirmed swing status message
   deviceFanH1370,
@@ -64,10 +64,10 @@ export default {
   deviceFanH7100,
   deviceFanH7102: deviceFanH7100, // identical to the H7100
   deviceFanH7106: deviceFanH7100, // identical to the H7100
-  deviceFanH7101,
+  deviceFanH7101: deviceFanH7100, // identical to the H7100, with a turbo mode it is never sent
   deviceFanH7105,
   deviceFanH7107,
-  deviceFanH7111: deviceFanH7101, // same fan without the turbo mode, which is not sent
+  deviceFanH7111: deviceFanH7100, // same fan without the turbo mode, which is not sent
   deviceHeaterSingle,
   deviceHeater1A,
   deviceHeater1B,

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)