@homebridge-plugins/homebridge-ewelink 12.7.0 → 12.7.1-beta.0

package/CHANGELOG.md

@@ -1,15 +1,27 @@
 # Change Log
 
-All notable changes to homebridge-ewelink will be documented in this file.
+All notable changes to `@homebridge-plugins/homebridge-ewelink` will be documented in this file.
 
-### v12.7.0 (2025-09-19)
+## v12.8.0 (2025-12-05)
+
+### Changes
+
+- feat: add support for Virtual Switch (UIID 264) and Virtual Button (UIID 265)
+- support more devices
+- update readme badges (use `shields.io`)
+- update workflows and npm publish via oidc
+- updated dependencies
+
+## v12.7.0 (2025-09-19)
+
+### Changes
 
 - dependency updates
 - added new devices
 
 ## v12.6.2 (2025-07-24)
 
-### Other Changes
+### Changes
 
 - dependency updates
 

package/README.md

@@ -8,11 +8,9 @@
 Homebridge plugin to integrate eWeLink devices into HomeKit
 
 [![npm](https://img.shields.io/npm/v/@homebridge-plugins/homebridge-ewelink/latest?label=latest)](https://www.npmjs.com/package/@homebridge-plugins/homebridge-ewelink)
-[![npm](https://img.shields.io/npm/v/@homebridge-plugins/homebridge-ewelink/beta?label=beta)](https://github.com/homebridge-plugins/homebridge-ewelink/wiki/Beta-Version)
-
-[![verified-by-homebridge](https://badgen.net/badge/homebridge/verified/purple)](https://github.com/homebridge/homebridge/wiki/Verified-Plugins)
-[![hoobs-certified](https://badgen.net/badge/HOOBS/certified/yellow?label=hoobs)](https://plugins.hoobs.org/plugin/homebridge-ewelink)
-
+[![npm](https://img.shields.io/npm/v/@homebridge-plugins/homebridge-ewelink/beta?label=beta)](https://github.com/homebridge-plugins/homebridge-ewelink/wiki/Beta-Version)<br>
+[![verified-by-homebridge](https://img.shields.io/badge/homebridge-verified-blueviolet?color=%23491F59&style=flat)](https://github.com/homebridge/homebridge/wiki/Verified-Plugins)
+[![hoobs-certified](https://img.shields.io/badge/hoobs-certified-yellow)](https://plugins.hoobs.org/plugin/homebridge-ewelink)<br>
 [![npm](https://img.shields.io/npm/dt/@homebridge-plugins/homebridge-ewelink)](https://www.npmjs.com/package/@homebridge-plugins/homebridge-ewelink)
 [![Discord](https://img.shields.io/discord/432663330281226270?color=728ED5&logo=discord&label=hb-discord)](https://discord.com/channels/432663330281226270/742733745743855627)
 

package/lib/device/air-conditioner.js

@@ -0,0 +1,512 @@
+import platformConsts from '../utils/constants.js'
+import { hasProperty, parseError } from '../utils/functions.js'
+
+export default class {
+  constructor(platform, accessory) {
+    // Set up variables from the platform
+    this.hapChar = platform.api.hap.Characteristic
+    this.hapServ = platform.api.hap.Service
+    this.hapErr = platform.api.hap.HapStatusError
+    this.lang = platform.lang
+    this.log = platform.log
+    this.platform = platform
+
+    // Set up variables from the accessory
+    this.name = accessory.displayName
+    this.accessory = accessory
+
+    // Initially set the online flag as true (to be then updated as false if necessary)
+    this.isOnline = true
+
+    // Set up custom variables for this device type
+    const deviceConf = platform.deviceConf[accessory.context.eweDeviceId] || {}
+    this.tempOffset = deviceConf.offset || platformConsts.defaultValues.offset
+    this.tempOffsetFactor = deviceConf.offsetFactor
+
+    // Set the correct logging variables for this accessory
+    switch (deviceConf.overrideLogging) {
+      case 'standard':
+        this.enableLogging = true
+        this.enableDebugLogging = false
+        break
+      case 'debug':
+        this.enableLogging = true
+        this.enableDebugLogging = true
+        break
+      case 'disable':
+        this.enableLogging = false
+        this.enableDebugLogging = false
+        break
+      default:
+        this.enableLogging = !platform.config.disableDeviceLogging
+        this.enableDebugLogging = platform.config.debug
+        break
+    }
+
+    // Add the heater cooler service if it doesn't already exist
+    this.service = this.accessory.getService(this.hapServ.HeaterCooler)
+      || this.accessory.addService(this.hapServ.HeaterCooler)
+
+    // Set custom properties of the current temperature characteristic
+    this.service.getCharacteristic(this.hapChar.CurrentTemperature).setProps({
+      minStep: 0.1,
+    })
+    this.cacheTemp = this.service.getCharacteristic(this.hapChar.CurrentTemperature).value
+
+    // Add the set handler to the active characteristic
+    this.service
+      .getCharacteristic(this.hapChar.Active)
+      .onSet(async value => this.internalActiveUpdate(value))
+
+    // Add the set handler to the target heater cooler state characteristic
+    this.service
+      .getCharacteristic(this.hapChar.TargetHeaterCoolerState)
+      .setProps({
+        minValue: 0,
+        maxValue: 2,
+        validValues: [0, 1, 2], // Auto, Heat, Cool
+      })
+      .onSet(async value => this.internalModeUpdate(value))
+
+    // Add the set handler to the cooling threshold temperature characteristic
+    this.service
+      .getCharacteristic(this.hapChar.CoolingThresholdTemperature)
+      .setProps({
+        minValue: 16,
+        maxValue: 32,
+        minStep: 1,
+      })
+      .onSet(async value => this.internalTempUpdate(value, 'cool'))
+
+    // Add the set handler to the heating threshold temperature characteristic
+    this.service
+      .getCharacteristic(this.hapChar.HeatingThresholdTemperature)
+      .setProps({
+        minValue: 16,
+        maxValue: 32,
+        minStep: 1,
+      })
+      .onSet(async value => this.internalTempUpdate(value, 'heat'))
+
+    // Add the set handler to the rotation speed characteristic (for fan speed)
+    this.service
+      .getCharacteristic(this.hapChar.RotationSpeed)
+      .setProps({
+        minValue: 0,
+        maxValue: 100,
+        minStep: 25,
+      })
+      .onSet(async value => this.internalSpeedUpdate(value))
+
+    // Add the get handlers only if the user hasn't disabled the disableNoResponse setting
+    if (!platform.config.disableNoResponse) {
+      this.service.getCharacteristic(this.hapChar.Active).onGet(() => {
+        if (!this.isOnline) {
+          throw new this.hapErr(-70402)
+        }
+        return this.service.getCharacteristic(this.hapChar.Active).value
+      })
+      this.service.getCharacteristic(this.hapChar.TargetHeaterCoolerState).onGet(() => {
+        if (!this.isOnline) {
+          throw new this.hapErr(-70402)
+        }
+        return this.service.getCharacteristic(this.hapChar.TargetHeaterCoolerState).value
+      })
+      this.service.getCharacteristic(this.hapChar.CurrentHeaterCoolerState).onGet(() => {
+        if (!this.isOnline) {
+          throw new this.hapErr(-70402)
+        }
+        return this.service.getCharacteristic(this.hapChar.CurrentHeaterCoolerState).value
+      })
+      this.service.getCharacteristic(this.hapChar.CurrentTemperature).onGet(() => {
+        if (!this.isOnline) {
+          throw new this.hapErr(-70402)
+        }
+        return this.service.getCharacteristic(this.hapChar.CurrentTemperature).value
+      })
+      this.service.getCharacteristic(this.hapChar.CoolingThresholdTemperature).onGet(() => {
+        if (!this.isOnline) {
+          throw new this.hapErr(-70402)
+        }
+        return this.service.getCharacteristic(this.hapChar.CoolingThresholdTemperature).value
+      })
+      this.service.getCharacteristic(this.hapChar.HeatingThresholdTemperature).onGet(() => {
+        if (!this.isOnline) {
+          throw new this.hapErr(-70402)
+        }
+        return this.service.getCharacteristic(this.hapChar.HeatingThresholdTemperature).value
+      })
+      this.service.getCharacteristic(this.hapChar.RotationSpeed).onGet(() => {
+        if (!this.isOnline) {
+          throw new this.hapErr(-70402)
+        }
+        return this.service.getCharacteristic(this.hapChar.RotationSpeed).value
+      })
+    }
+
+    // Initialise these caches now since they aren't determined by the initial externalUpdate()
+    this.cacheTarg = this.service.getCharacteristic(this.hapChar.CoolingThresholdTemperature).value
+    this.cacheMode = 'cool'
+    this.cacheSpeed = 50
+
+    // Pass the accessory to Fakegato to set up with Eve
+    this.accessory.eveService = new platform.eveService('custom', this.accessory, {
+      log: () => {},
+    })
+
+    // Output the customised options to the log
+    const normalLogging = this.enableLogging ? 'standard' : 'disable'
+    const opts = JSON.stringify({
+      logging: this.enableDebugLogging ? 'debug' : normalLogging,
+      offset: this.tempOffset,
+      offsetFactor: this.tempOffsetFactor,
+    })
+    this.log('[%s] %s %s.', this.name, this.lang.devInitOpts, opts)
+  }
+
+  async internalActiveUpdate(value) {
+    try {
+      const newValue = value === 1 ? 'on' : 'off'
+
+      // Don't continue if the value is the same as before
+      const prevState = this.service.getCharacteristic(this.hapChar.Active).value === 1 ? 'on' : 'off'
+      if (prevState === newValue) {
+        return
+      }
+
+      // Send the request to the platform sender function
+      await this.platform.sendDeviceUpdate(this.accessory, {
+        power: newValue,
+      })
+
+      // Update the current state characteristic
+      this.service.updateCharacteristic(
+        this.hapChar.CurrentHeaterCoolerState,
+        value === 1
+          ? (this.cacheMode === 'heat'
+              ? this.hapChar.CurrentHeaterCoolerState.HEATING
+              : this.hapChar.CurrentHeaterCoolerState.COOLING)
+          : this.hapChar.CurrentHeaterCoolerState.INACTIVE,
+      )
+
+      // Cache the new state and log if appropriate
+      if (this.enableLogging) {
+        this.log('[%s] %s [%s].', this.name, this.lang.curState, newValue)
+      }
+    } catch (err) {
+      // Catch any errors during the process
+      const eText = parseError(err)
+      this.log.warn('[%s] %s %s.', this.name, this.lang.cantCtl, eText)
+
+      // Throw a 'no response' error and set a timeout to revert this after 2 seconds
+      const prevStateValue = this.service.getCharacteristic(this.hapChar.Active).value
+      setTimeout(() => {
+        this.service.updateCharacteristic(this.hapChar.Active, prevStateValue)
+      }, 2000)
+      throw new this.hapErr(-70402)
+    }
+  }
+
+  async internalModeUpdate(value) {
+    try {
+      let newMode
+      switch (value) {
+        case 0: // Auto
+          newMode = 'auto'
+          break
+        case 1: // Heat
+          newMode = 'heat'
+          break
+        case 2: // Cool
+          newMode = 'cool'
+          break
+        default:
+          return
+      }
+
+      // Don't continue if the value is the same as before
+      if (this.cacheMode === newMode) {
+        return
+      }
+
+      // Send the request to the platform sender function
+      await this.platform.sendDeviceUpdate(this.accessory, {
+        mode: newMode,
+      })
+
+      // Update the current state characteristic if device is on
+      if (this.service.getCharacteristic(this.hapChar.Active).value === 1) {
+        this.service.updateCharacteristic(
+          this.hapChar.CurrentHeaterCoolerState,
+          value === 1
+            ? this.hapChar.CurrentHeaterCoolerState.HEATING
+            : value === 2
+              ? this.hapChar.CurrentHeaterCoolerState.COOLING
+              : this.hapChar.CurrentHeaterCoolerState.IDLE,
+        )
+      }
+
+      // Cache the new mode and log if appropriate
+      this.cacheMode = newMode
+      if (this.enableLogging) {
+        this.log('[%s] %s [%s].', this.name, this.lang.curMode, newMode)
+      }
+    } catch (err) {
+      // Catch any errors during the process
+      const eText = parseError(err)
+      this.log.warn('[%s] %s %s.', this.name, this.lang.cantCtl, eText)
+
+      // Throw a 'no response' error and set a timeout to revert this after 2 seconds
+      setTimeout(() => {
+        const prevValue = this.cacheMode === 'heat' ? 1 : this.cacheMode === 'cool' ? 2 : 0
+        this.service.updateCharacteristic(this.hapChar.TargetHeaterCoolerState, prevValue)
+      }, 2000)
+      throw new this.hapErr(-70402)
+    }
+  }
+
+  async internalTempUpdate(value, mode) {
+    try {
+      // Only update if this is the active mode or auto mode
+      if (this.cacheMode !== mode && this.cacheMode !== 'auto') {
+        return
+      }
+
+      // Don't continue if the value is the same as before
+      if (this.cacheTarg === value) {
+        return
+      }
+
+      // Send the request to the platform sender function
+      await this.platform.sendDeviceUpdate(this.accessory, {
+        temperature: value,
+      })
+
+      // Cache the new target temperature and log if appropriate
+      this.cacheTarg = value
+      if (this.enableLogging) {
+        this.log('[%s] %s [%s°C].', this.name, this.lang.tarTemp, value)
+      }
+    } catch (err) {
+      // Catch any errors during the process
+      const eText = parseError(err)
+      this.log.warn('[%s] %s %s.', this.name, this.lang.cantCtl, eText)
+
+      // Throw a 'no response' error and set a timeout to revert this after 2 seconds
+      setTimeout(() => {
+        if (mode === 'cool') {
+          this.service.updateCharacteristic(this.hapChar.CoolingThresholdTemperature, this.cacheTarg)
+        } else {
+          this.service.updateCharacteristic(this.hapChar.HeatingThresholdTemperature, this.cacheTarg)
+        }
+      }, 2000)
+      throw new this.hapErr(-70402)
+    }
+  }
+
+  async internalSpeedUpdate(value) {
+    try {
+      // Map HomeKit 0-100 to eWeLink wind speed values
+      // Assuming 101 = low, 102 = medium, 103 = high
+      let windSpeed
+      if (value === 0) {
+        windSpeed = 0
+      } else if (value <= 33) {
+        windSpeed = 101
+      } else if (value <= 66) {
+        windSpeed = 102
+      } else {
+        windSpeed = 103
+      }
+
+      // Don't continue if the value is the same as before
+      if (this.cacheSpeed === windSpeed) {
+        return
+      }
+
+      // Send the request to the platform sender function
+      await this.platform.sendDeviceUpdate(this.accessory, {
+        wind_speed: windSpeed,
+      })
+
+      // Cache the new speed and log if appropriate
+      this.cacheSpeed = windSpeed
+      if (this.enableLogging) {
+        this.log('[%s] %s [%s].', this.name, this.lang.curSpeed, value)
+      }
+    } catch (err) {
+      // Catch any errors during the process
+      const eText = parseError(err)
+      this.log.warn('[%s] %s %s.', this.name, this.lang.cantCtl, eText)
+
+      // Map cached speed back to HomeKit value
+      let prevValue = 50
+      if (this.cacheSpeed === 101) {
+        prevValue = 25
+      } else if (this.cacheSpeed === 102) {
+        prevValue = 50
+      } else if (this.cacheSpeed === 103) {
+        prevValue = 75
+      }
+
+      // Throw a 'no response' error and set a timeout to revert this after 2 seconds
+      setTimeout(() => {
+        this.service.updateCharacteristic(this.hapChar.RotationSpeed, prevValue)
+      }, 2000)
+      throw new this.hapErr(-70402)
+    }
+  }
+
+  async externalUpdate(params) {
+    try {
+      // Check to see if the provided params are valid for this model
+      if (
+        !hasProperty(params, 'power')
+        && !hasProperty(params, 'mode')
+        && !hasProperty(params, 'temperature')
+        && !hasProperty(params, 'indoor_temperature')
+        && !hasProperty(params, 'wind_speed')
+      ) {
+        throw new Error(this.lang.paramsNotRecd)
+      }
+
+      // Update the active characteristic
+      if (hasProperty(params, 'power')) {
+        const newState = params.power === 'on' ? 1 : 0
+        this.service.updateCharacteristic(this.hapChar.Active, newState)
+
+        // Update the current state
+        this.service.updateCharacteristic(
+          this.hapChar.CurrentHeaterCoolerState,
+          newState === 1
+            ? (this.cacheMode === 'heat'
+                ? this.hapChar.CurrentHeaterCoolerState.HEATING
+                : this.hapChar.CurrentHeaterCoolerState.COOLING)
+            : this.hapChar.CurrentHeaterCoolerState.INACTIVE,
+        )
+
+        // Log the change if appropriate
+        if (params.updateSource && this.enableLogging) {
+          this.log('[%s] %s [%s].', this.name, this.lang.curState, params.power)
+        }
+      }
+
+      // Update the mode characteristic
+      if (hasProperty(params, 'mode')) {
+        let targetState
+        switch (params.mode) {
+          case 'auto':
+            targetState = 0
+            break
+          case 'heat':
+            targetState = 1
+            break
+          case 'cool':
+            targetState = 2
+            break
+          default:
+            return
+        }
+
+        this.cacheMode = params.mode
+        this.service.updateCharacteristic(this.hapChar.TargetHeaterCoolerState, targetState)
+
+        // Update current state if device is on
+        if (this.service.getCharacteristic(this.hapChar.Active).value === 1) {
+          this.service.updateCharacteristic(
+            this.hapChar.CurrentHeaterCoolerState,
+            targetState === 1
+              ? this.hapChar.CurrentHeaterCoolerState.HEATING
+              : targetState === 2
+                ? this.hapChar.CurrentHeaterCoolerState.COOLING
+                : this.hapChar.CurrentHeaterCoolerState.IDLE,
+          )
+        }
+
+        // Log the change if appropriate
+        if (params.updateSource && this.enableLogging) {
+          this.log('[%s] %s [%s].', this.name, this.lang.curMode, params.mode)
+        }
+      }
+
+      // Update the target temperature
+      if (hasProperty(params, 'temperature')) {
+        this.cacheTarg = params.temperature
+        this.service.updateCharacteristic(this.hapChar.CoolingThresholdTemperature, params.temperature)
+        this.service.updateCharacteristic(this.hapChar.HeatingThresholdTemperature, params.temperature)
+
+        // Log the change if appropriate
+        if (params.updateSource && this.enableLogging) {
+          this.log('[%s] %s [%s°C].', this.name, this.lang.tarTemp, params.temperature)
+        }
+      }
+
+      // Update the current temperature
+      if (hasProperty(params, 'indoor_temperature')) {
+        let newTemp = Number(params.indoor_temperature)
+
+        // Apply any configured offset
+        if (this.tempOffsetFactor) {
+          newTemp *= this.tempOffsetFactor
+        }
+        newTemp += this.tempOffset
+        newTemp = Math.round(newTemp * 10) / 10
+
+        this.cacheTemp = newTemp
+        this.service.updateCharacteristic(this.hapChar.CurrentTemperature, newTemp)
+        this.accessory.eveService.addEntry({
+          time: Math.round(Date.now() / 1000),
+          temp: newTemp,
+        })
+
+        // Log the change if appropriate
+        if (params.updateSource && this.enableLogging) {
+          this.log('[%s] %s [%s°C].', this.name, this.lang.curTemp, newTemp)
+        }
+      }
+
+      // Update the fan speed
+      if (hasProperty(params, 'wind_speed')) {
+        // Map eWeLink wind speed to HomeKit rotation speed
+        let rotationSpeed = 50
+        if (params.wind_speed === 0) {
+          rotationSpeed = 0
+        } else if (params.wind_speed === 101) {
+          rotationSpeed = 25
+        } else if (params.wind_speed === 102) {
+          rotationSpeed = 50
+        } else if (params.wind_speed === 103) {
+          rotationSpeed = 75
+        }
+
+        this.cacheSpeed = params.wind_speed
+        this.service.updateCharacteristic(this.hapChar.RotationSpeed, rotationSpeed)
+
+        // Log the change if appropriate
+        if (params.updateSource && this.enableLogging) {
+          this.log('[%s] %s [%s].', this.name, this.lang.curSpeed, rotationSpeed)
+        }
+      }
+    } catch (err) {
+      // Catch any errors during the process
+      const eText = parseError(err)
+      this.log.warn('[%s] %s %s.', this.name, this.lang.cantUpd, eText)
+    }
+  }
+
+  async currentState() {
+    const toReturn = {}
+    toReturn.services = ['heater-cooler']
+    toReturn.heater_cooler = {
+      state: this.service.getCharacteristic(this.hapChar.Active).value === 1 ? 'on' : 'off',
+      mode: this.cacheMode,
+      target_temp: this.cacheTarg,
+      current_temp: this.cacheTemp,
+    }
+    return toReturn
+  }
+
+  markStatus(isOnline) {
+    this.isOnline = isOnline
+  }
+}

package/lib/device/index.js

@@ -1,3 +1,4 @@
+import deviceAirConditioner from './air-conditioner.js'
 import deviceCurtain from './curtain.js'
 import deviceDiffuser from './diffuser.js'
 import deviceFan from './fan.js'
@@ -26,9 +27,11 @@ import deviceSwitchSingleInched from './switch-single-inched.js'
 import deviceSwitchSingle from './switch-single.js'
 import deviceTemplate from './template.js'
 import deviceThermostat from './thermostat.js'
+import deviceVirtual from './virtual.js'
 import zb from './zigbee/index.js'
 
 export default {
+  deviceAirConditioner,
   deviceCurtain,
   deviceDiffuser,
   deviceFan,
@@ -56,6 +59,7 @@ export default {
   deviceSwitchSingleInched,
   deviceTemplate,
   deviceThermostat,
+  deviceVirtual,
   sim,
   zb,
 }

package/lib/device/virtual.js

@@ -0,0 +1,270 @@
+import { hasProperty, parseError } from '../utils/functions.js'
+
+export default class {
+  constructor(platform, accessory) {
+    // Set up variables from the platform
+    this.hapChar = platform.api.hap.Characteristic
+    this.hapServ = platform.api.hap.Service
+    this.hapErr = platform.api.hap.HapStatusError
+    this.lang = platform.lang
+    this.log = platform.log
+    this.platform = platform
+
+    // Set up variables from the accessory
+    this.name = accessory.displayName
+    this.accessory = accessory
+
+    // Initially set the online flag as true (to be then updated as false if necessary)
+    this.isOnline = true
+
+    // Set up custom variables for this device type
+    const deviceConf = platform.deviceConf[accessory.context.eweDeviceId] || {}
+
+    // Set the correct logging variables for this accessory
+    switch (deviceConf.overrideLogging) {
+      case 'standard':
+        this.enableLogging = true
+        this.enableDebugLogging = false
+        break
+      case 'debug':
+        this.enableLogging = true
+        this.enableDebugLogging = true
+        break
+      case 'disable':
+        this.enableLogging = false
+        this.enableDebugLogging = false
+        break
+      default:
+        this.enableLogging = !platform.config.disableDeviceLogging
+        this.enableDebugLogging = platform.config.debug
+        break
+    }
+
+    // Check device params to determine if it's a button or switch
+    this.isButton = hasProperty(accessory.context.eweParams, 'key')
+
+    if (this.isButton) {
+      // Virtual Button - use StatelessProgrammableSwitch
+      this.service = this.accessory.getService(this.hapServ.StatelessProgrammableSwitch)
+        || this.accessory.addService(this.hapServ.StatelessProgrammableSwitch)
+
+      // Set up the button with single, double, and long press
+      this.service.getCharacteristic(this.hapChar.ProgrammableSwitchEvent).setProps({
+        minValue: 0,
+        maxValue: 2,
+        validValues: [0, 1, 2], // Single, Double, Long press
+      })
+
+      // Remove switch service if it exists from previous setup
+      if (this.accessory.getService(this.hapServ.Switch)) {
+        this.accessory.removeService(this.accessory.getService(this.hapServ.Switch))
+      }
+    } else {
+      // Virtual Switch - use standard Switch service
+      this.service = this.accessory.getService(this.hapServ.Switch)
+        || this.accessory.addService(this.hapServ.Switch)
+
+      // Add the set handler to the switch on/off characteristic
+      this.service
+        .getCharacteristic(this.hapChar.On)
+        .onSet(async value => this.internalStateUpdate(value))
+
+      // Add the get handler only if the user hasn't disabled the disableNoResponse setting
+      if (!platform.config.disableNoResponse) {
+        this.service.getCharacteristic(this.hapChar.On).onGet(() => {
+          if (!this.isOnline) {
+            throw new this.hapErr(-70402)
+          }
+          return this.service.getCharacteristic(this.hapChar.On).value
+        })
+      }
+
+      // Remove button service if it exists from previous setup
+      if (this.accessory.getService(this.hapServ.StatelessProgrammableSwitch)) {
+        this.accessory.removeService(this.accessory.getService(this.hapServ.StatelessProgrammableSwitch))
+      }
+    }
+
+    // Pass the accessory to Fakegato to set up with Eve
+    this.accessory.eveService = new platform.eveService('switch', this.accessory, {
+      log: () => {},
+    })
+
+    // Output the customised options to the log
+    const normalLogging = this.enableLogging ? 'standard' : 'disable'
+    const opts = JSON.stringify({
+      logging: this.enableDebugLogging ? 'debug' : normalLogging,
+      type: this.isButton ? 'button' : 'switch',
+    })
+    this.log('[%s] %s %s.', this.name, this.lang.devInitOpts, opts)
+  }
+
+  async internalStateUpdate(value) {
+    try {
+      // This is only for virtual switches, not buttons
+      if (this.isButton) {
+        return
+      }
+
+      const newValue = value ? 'on' : 'off'
+
+      // Don't continue if the value is the same as before
+      const prevState = this.service.getCharacteristic(this.hapChar.On).value
+      if (prevState === value) {
+        return
+      }
+
+      // Send the request to the platform sender function
+      await this.platform.sendDeviceUpdate(this.accessory, {
+        switches: [
+          {
+            outlet: 0,
+            switch: newValue,
+          },
+        ],
+      })
+
+      // Cache the new state and log if appropriate
+      if (this.enableLogging) {
+        this.accessory.eveService.addEntry({
+          time: Math.round(Date.now() / 1000),
+          status: value ? 1 : 0,
+        })
+        this.log('[%s] %s [%s].', this.name, this.lang.curState, newValue)
+      }
+    } catch (err) {
+      // Catch any errors during the process
+      const eText = parseError(err)
+      this.log.warn('[%s] %s %s.', this.name, this.lang.cantCtl, eText)
+
+      // Throw a 'no response' error and set a timeout to revert this after 2 seconds
+      setTimeout(() => {
+        this.service.updateCharacteristic(this.hapChar.On, this.cacheState === 'on')
+      }, 2000)
+      throw new this.hapErr(-70402)
+    }
+  }
+
+  async externalUpdate(params) {
+    try {
+      if (this.isButton) {
+        // Handle button press events
+        if (hasProperty(params, 'key')) {
+          // Map key values to HomeKit button events
+          let buttonEvent
+          switch (params.key) {
+            case 0:
+              buttonEvent = this.hapChar.ProgrammableSwitchEvent.SINGLE_PRESS
+              break
+            case 1:
+              buttonEvent = this.hapChar.ProgrammableSwitchEvent.DOUBLE_PRESS
+              break
+            case 2:
+              buttonEvent = this.hapChar.ProgrammableSwitchEvent.LONG_PRESS
+              break
+            default:
+              // Unknown key value, default to single press
+              buttonEvent = this.hapChar.ProgrammableSwitchEvent.SINGLE_PRESS
+          }
+
+          // Update the button event characteristic
+          this.service.updateCharacteristic(this.hapChar.ProgrammableSwitchEvent, buttonEvent)
+
+          // Log the button press if appropriate
+          if (params.updateSource && this.enableLogging) {
+            const pressType = params.key === 0 ? 'single' : params.key === 1 ? 'double' : 'long'
+            this.log('[%s] %s [%s press].', this.name, this.lang.curState, pressType)
+          }
+        }
+
+        // Handle trigger time if provided
+        if (hasProperty(params, 'trigTime')) {
+          this.lastTriggerTime = params.trigTime
+          if (this.enableDebugLogging) {
+            this.log('[%s] Button triggered at %s.', this.name, new Date(Number.parseInt(params.trigTime)).toLocaleString())
+          }
+        }
+      } else {
+        // Handle virtual switch updates
+        if (hasProperty(params, 'switches') && Array.isArray(params.switches)) {
+          params.switches.forEach((outlet) => {
+            // Check this is the primary outlet
+            if (outlet.outlet !== 0) {
+              return
+            }
+
+            // Check we have a valid switch value
+            if (!hasProperty(outlet, 'switch')) {
+              return
+            }
+
+            const newState = outlet.switch === 'on'
+            const prevState = this.service.getCharacteristic(this.hapChar.On).value
+            if (prevState === newState) {
+              return
+            }
+
+            this.service.updateCharacteristic(this.hapChar.On, newState)
+            this.cacheState = outlet.switch
+
+            // Add Eve history entry
+            this.accessory.eveService.addEntry({
+              time: Math.round(Date.now() / 1000),
+              status: newState ? 1 : 0,
+            })
+
+            // Log the change if appropriate
+            if (params.updateSource && this.enableLogging) {
+              this.log('[%s] %s [%s].', this.name, this.lang.curState, outlet.switch)
+            }
+          })
+        }
+
+        // Also handle single switch param for compatibility
+        if (hasProperty(params, 'switch')) {
+          const newState = params.switch === 'on'
+          const prevState = this.service.getCharacteristic(this.hapChar.On).value
+          if (prevState !== newState) {
+            this.service.updateCharacteristic(this.hapChar.On, newState)
+            this.cacheState = params.switch
+
+            // Add Eve history entry
+            this.accessory.eveService.addEntry({
+              time: Math.round(Date.now() / 1000),
+              status: newState ? 1 : 0,
+            })
+
+            // Log the change if appropriate
+            if (params.updateSource && this.enableLogging) {
+              this.log('[%s] %s [%s].', this.name, this.lang.curState, params.switch)
+            }
+          }
+        }
+      }
+    } catch (err) {
+      // Catch any errors during the process
+      const eText = parseError(err)
+      this.log.warn('[%s] %s %s.', this.name, this.lang.cantUpd, eText)
+    }
+  }
+
+  async currentState() {
+    const toReturn = {}
+    if (this.isButton) {
+      toReturn.services = ['button']
+      toReturn.button = {
+        last_trigger: this.lastTriggerTime || 'none',
+      }
+    } else {
+      toReturn.services = ['switch']
+      toReturn.switch = {
+        state: this.cacheState || 'off',
+      }
+    }
+    return toReturn
+  }
+
+  markStatus(isOnline) {
+    this.isOnline = isOnline
+  }
+}

package/lib/platform.js

@@ -1106,6 +1106,26 @@ export default class {
         this.applyAccessoryLogging(accessory)
         accessory.control = new deviceTypes.deviceThermostat(this, accessory)
         /** */
+      } else if (platformConsts.devices.airConditioner.includes(uiid)) {
+        /**
+         ***************
+         AIR CONDITIONERS
+         ****************
+         */
+        accessory = devicesInHB.get(uuid) || this.addAccessory(device, `${device.deviceid}SWX`)
+        this.applyAccessoryLogging(accessory)
+        accessory.control = new deviceTypes.deviceAirConditioner(this, accessory)
+        /** */
+      } else if (platformConsts.devices.virtual.includes(uiid)) {
+        /**
+         ***************
+         VIRTUAL DEVICES
+         ****************
+         */
+        accessory = devicesInHB.get(uuid) || this.addAccessory(device, `${device.deviceid}SWX`)
+        this.applyAccessoryLogging(accessory)
+        accessory.control = new deviceTypes.deviceVirtual(this, accessory)
+        /** */
       } else if (
         device.showAs === 'thermostat'
         && platformConsts.devices.sensorAmbient.includes(uiid)

package/lib/utils/constants.js

@@ -285,7 +285,7 @@ export default {
       212,
     ],
     switchSingle: [1, 6, 14, 24, 27, 225, 226, 1009, 1256, 7004, 7005, 7010, 7032],
-    switchSCM: [77, 78, 81, 107, 112, 138, 160, 191, 209],
+    switchSCM: [77, 78, 81, 107, 112, 138, 160, 191, 209, 264],
     switchSCMPower: [182, 190],
     switchSinglePower: [5, 32],
     switchMulti: [
@@ -329,7 +329,9 @@ export default {
     sensorAmbient: [15, 181],
     sensorTempHumi: [18],
     thermostat: [127],
+    airConditioner: [151],
     panel: [133, 195],
+    virtual: [265],
     fan: [34],
     humidifier: [19],
     diffuser: [25],

package/package.json

@@ -3,7 +3,7 @@
   "displayName": "Homebridge eWeLink",
   "alias": "eWeLink",
   "type": "module",
-  "version": "12.7.0",
+  "version": "12.7.1-beta.0",
   "description": "Homebridge plugin to integrate eWeLink devices into HomeKit.",
   "author": {
     "name": "bwp91",
@@ -61,14 +61,14 @@
     "lint:fix": "npm run lint -- --fix"
   },
   "dependencies": {
-    "@homebridge/plugin-ui-utils": "^2.1.0",
-    "axios": "^1.12.2",
+    "@homebridge/plugin-ui-utils": "^2.1.2",
+    "axios": "^1.13.2",
     "node-persist": "^4.0.4",
-    "p-queue": "^8.1.1",
+    "p-queue": "^9.0.1",
     "websocket-as-promised": "^3.0.1",
     "ws": "^8.18.3"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^5.4.1"
+    "@antfu/eslint-config": "^6.4.2"
   }
 }