homebridge-tsvesync 1.3.3 → 1.3.7

package/src/accessories/light.accessory.ts

@@ -1,7 +1,7 @@
-import { CharacteristicValue, PlatformAccessory } from 'homebridge';
+import { CharacteristicValue, PlatformAccessory, Service } from 'homebridge';
 import { BaseAccessory } from './base.accessory';
 import { TSVESyncPlatform } from '../platform';
-import { DeviceCapabilities, VeSyncBulb } from '../types/device.types';
+import { DeviceCapabilities, VeSyncBulb, VeSyncDimmerSwitch, VeSyncLightDevice } from '../types/device.types';
 
 // Constants for color temperature
 const MIN_COLOR_TEMP = 140; // 7143K (cool)
@@ -9,17 +9,22 @@ const MAX_COLOR_TEMP = 500; // 2000K (warm)
 const DEFAULT_COLOR_TEMP = MIN_COLOR_TEMP;
 
 export class LightAccessory extends BaseAccessory {
-  protected readonly device: VeSyncBulb;
-  private readonly capabilities: DeviceCapabilities;
+  protected readonly device: VeSyncLightDevice;
+  private capabilities!: DeviceCapabilities;
+  private isDimmerDevice = false;
+  private indicatorService?: Service;
+  private indicatorColorState = { hue: 0, saturation: 0 };
+  private indicatorColorUpdateTimeout?: NodeJS.Timeout;
+  private lastDimmerRefresh = 0;
+  private static readonly DIMMER_REFRESH_DEBOUNCE_MS = 2000;
 
   constructor(
     platform: TSVESyncPlatform,
     accessory: PlatformAccessory,
-    device: VeSyncBulb
+    device: VeSyncLightDevice
   ) {
     super(platform, accessory, device);
     this.device = device;
-    this.capabilities = this.getDeviceCapabilities();
   }
 
   protected setupService(): void {
@@ -35,7 +40,9 @@ export class LightAccessory extends BaseAccessory {
     );
 
     // Set up optional characteristics based on device capabilities
-    const capabilities = this.getDeviceCapabilities();
+    this.isDimmerDevice = this.detectDimmer(this.device);
+    this.capabilities = this.getDeviceCapabilities();
+    const capabilities = this.capabilities;
 
     if (capabilities.hasBrightness) {
       this.setupCharacteristic(
@@ -58,6 +65,10 @@ export class LightAccessory extends BaseAccessory {
       this.platform.Characteristic.Name,
       async () => this.device.deviceName
     );
+
+    if (this.isDimmerDevice) {
+      this.setupIndicatorService();
+    }
   }
 
   private setupColorTemperature(): void {
@@ -92,9 +103,7 @@ export class LightAccessory extends BaseAccessory {
    * Update device states based on the latest details
    */
   protected async updateDeviceSpecificStates(details: any): Promise<void> {
-    const lightDetails = details as {
-      deviceStatus: string;
-      brightness?: number;
+    const lightDetails = details as VeSyncLightDevice & {
       colorTemp?: number;
       hue?: number;
       saturation?: number;
@@ -138,10 +147,41 @@ export class LightAccessory extends BaseAccessory {
         );
       }
     }
+
+    if (this.isDimmerDevice && this.indicatorService) {
+      const dimmer = lightDetails as VeSyncDimmerSwitch;
+      const isRgbOn = dimmer.rgbLightStatus === 'on';
+      this.updateIndicatorCharacteristic(
+        this.platform.Characteristic.On,
+        isRgbOn
+      );
+
+      const { hue, saturation } = this.rgbToHsv(
+        dimmer.rgbLightValue.red,
+        dimmer.rgbLightValue.green,
+        dimmer.rgbLightValue.blue
+      );
+      this.indicatorColorState = { hue, saturation };
+      this.updateIndicatorCharacteristic(this.platform.Characteristic.Hue, hue);
+      this.updateIndicatorCharacteristic(this.platform.Characteristic.Saturation, saturation);
+    }
   }
 
   protected getDeviceCapabilities(): DeviceCapabilities {
-    // Determine capabilities based on model
+    if (this.isDimmerDevice) {
+      return {
+        hasBrightness: true,
+        hasColorTemp: false,
+        hasColor: false,
+        hasSpeed: false,
+        hasHumidity: false,
+        hasAirQuality: false,
+        hasWaterLevel: false,
+        hasChildLock: false,
+        hasSwingMode: false,
+      };
+    }
+
     const model = this.device.deviceType.toUpperCase();
     return {
       hasBrightness: true, // All VeSync bulbs support brightness
@@ -170,6 +210,10 @@ export class LightAccessory extends BaseAccessory {
       }
       
       await this.persistDeviceState('deviceStatus', isOn ? 'on' : 'off');
+
+      if (this.isDimmerDevice) {
+        await this.refreshDimmerDetails();
+      }
     } catch (error) {
       this.handleDeviceError('set on state', error);
     }
@@ -181,34 +225,67 @@ export class LightAccessory extends BaseAccessory {
 
   private async setBrightness(value: CharacteristicValue): Promise<void> {
     try {
-      const success = await this.device.setBrightness(value as number);
-      
+      const target = Math.round(Number(value));
+
+      if (this.isDimmerDevice && target <= 0) {
+        const success = await this.device.turnOff();
+        if (!success) {
+          throw new Error('Failed to turn off device when setting brightness to 0');
+        }
+        await this.persistDeviceState('deviceStatus', 'off');
+        await this.persistDeviceState('brightness', 0);
+        await this.refreshDimmerDetails();
+        return;
+      }
+
+      const brightness = Math.min(100, Math.max(this.isDimmerDevice ? 1 : 0, target));
+
+      const success = await this.device.setBrightness(brightness);
+
       if (!success) {
-        throw new Error(`Failed to set brightness to ${value}`);
+        throw new Error(`Failed to set brightness to ${brightness}`);
+      }
+
+      await this.persistDeviceState('brightness', brightness);
+      if (this.isDimmerDevice && brightness > 0) {
+        await this.persistDeviceState('deviceStatus', 'on');
+      }
+
+      if (this.isDimmerDevice) {
+        await this.refreshDimmerDetails();
       }
-      
-      await this.persistDeviceState('brightness', value);
     } catch (error) {
       this.handleDeviceError('set brightness', error);
     }
   }
 
   private async getColorTemperature(): Promise<CharacteristicValue> {
-    return this.device.colorTemp || DEFAULT_COLOR_TEMP;
+    if (this.isDimmerDevice) {
+      return DEFAULT_COLOR_TEMP;
+    }
+
+    const bulb = this.device as VeSyncBulb;
+    return bulb.colorTemp || DEFAULT_COLOR_TEMP;
   }
 
   private async setColorTemperature(value: CharacteristicValue): Promise<void> {
     try {
-      if (!this.device.setColorTemperature) {
+      if (this.isDimmerDevice) {
         throw new Error('Device does not support color temperature');
       }
-      
-      const success = await this.device.setColorTemperature(value as number);
-      
+
+      const bulb = this.device as VeSyncBulb;
+
+      if (!bulb.setColorTemperature) {
+        throw new Error('Device does not support color temperature');
+      }
+
+      const success = await bulb.setColorTemperature(value as number);
+
       if (!success) {
         throw new Error(`Failed to set color temperature to ${value}`);
       }
-      
+
       await this.persistDeviceState('colorTemp', value);
     } catch (error) {
       this.handleDeviceError('set color temperature', error);
@@ -216,24 +293,40 @@ export class LightAccessory extends BaseAccessory {
   }
 
   private async getHue(): Promise<CharacteristicValue> {
-    return this.device.hue || 0;
+    if (this.isDimmerDevice) {
+      return 0;
+    }
+
+    const bulb = this.device as VeSyncBulb;
+    return bulb.hue || 0;
   }
 
   private async getSaturation(): Promise<CharacteristicValue> {
-    return this.device.saturation || 0;
+    if (this.isDimmerDevice) {
+      return 0;
+    }
+
+    const bulb = this.device as VeSyncBulb;
+    return bulb.saturation || 0;
   }
 
   private async setHue(value: CharacteristicValue): Promise<void> {
     try {
-      if (!this.device.setColor) {
+      if (this.isDimmerDevice) {
         throw new Error('Device does not support color');
       }
-      
-      const success = await this.device.setColor(
+
+      const bulb = this.device as VeSyncBulb;
+
+      if (!bulb.setColor) {
+        throw new Error('Device does not support color');
+      }
+
+      const success = await bulb.setColor(
         value as number,
-        this.device.saturation || 0
+        bulb.saturation || 0
       );
-      
+
       if (!success) {
         throw new Error(`Failed to set hue to ${value}`);
       }
@@ -246,22 +339,310 @@ export class LightAccessory extends BaseAccessory {
 
   private async setSaturation(value: CharacteristicValue): Promise<void> {
     try {
-      if (!this.device.setColor) {
+      if (this.isDimmerDevice) {
         throw new Error('Device does not support color');
       }
-      
-      const success = await this.device.setColor(
-        this.device.hue || 0,
+
+      const bulb = this.device as VeSyncBulb;
+
+      if (!bulb.setColor) {
+        throw new Error('Device does not support color');
+      }
+
+      const success = await bulb.setColor(
+        bulb.hue || 0,
         value as number
       );
-      
+
       if (!success) {
         throw new Error(`Failed to set saturation to ${value}`);
       }
-      
+
       await this.persistDeviceState('saturation', value);
     } catch (error) {
       this.handleDeviceError('set saturation', error);
     }
   }
-} 
+
+  private detectDimmer(device: VeSyncLightDevice): device is VeSyncDimmerSwitch {
+    return typeof (device as VeSyncDimmerSwitch).rgbColorSet === 'function';
+  }
+
+  private setupIndicatorService(): void {
+    const serviceName = `${this.device.deviceName} Indicator`;
+    const existing = this.accessory.getService(serviceName);
+    this.indicatorService = existing || this.accessory.addService(
+      this.platform.Service.Lightbulb,
+      serviceName,
+      'indicator'
+    );
+
+    const indicatorService = this.indicatorService;
+    if (!indicatorService) {
+      return;
+    }
+
+    this.setupCharacteristicForService(
+      indicatorService,
+      this.platform.Characteristic.On,
+      this.getIndicatorOn.bind(this),
+      this.setIndicatorOn.bind(this)
+    );
+
+    this.setupCharacteristicForService(
+      indicatorService,
+      this.platform.Characteristic.Hue,
+      this.getIndicatorHue.bind(this),
+      this.setIndicatorHue.bind(this)
+    );
+
+    this.setupCharacteristicForService(
+      indicatorService,
+      this.platform.Characteristic.Saturation,
+      this.getIndicatorSaturation.bind(this),
+      this.setIndicatorSaturation.bind(this)
+    );
+  }
+
+  private setupCharacteristicForService(
+    service: Service,
+    characteristic: any,
+    onGet?: () => Promise<CharacteristicValue>,
+    onSet?: (value: CharacteristicValue) => Promise<void>
+  ): void {
+    this.withService(service, () => {
+      this.setupCharacteristic(characteristic, onGet, onSet);
+    });
+  }
+
+  private updateIndicatorCharacteristic(
+    characteristic: any,
+    value: CharacteristicValue
+  ): void {
+    if (!this.indicatorService) {
+      return;
+    }
+
+    this.withService(this.indicatorService, () => {
+      this.updateCharacteristicValue(characteristic, value);
+    });
+  }
+
+  private withService<T>(service: Service, fn: () => T): T {
+    const currentService = this.service;
+    this.service = service;
+    try {
+      return fn();
+    } finally {
+      this.service = currentService;
+    }
+  }
+
+  private async getIndicatorOn(): Promise<CharacteristicValue> {
+    if (!this.isDimmerDevice) {
+      return false;
+    }
+    const dimmer = this.device as VeSyncDimmerSwitch;
+    return dimmer.rgbLightStatus === 'on';
+  }
+
+  private async setIndicatorOn(value: CharacteristicValue): Promise<void> {
+    if (!this.isDimmerDevice) {
+      return;
+    }
+
+    const isOn = Boolean(value);
+    const dimmer = this.device as VeSyncDimmerSwitch;
+    const success = isOn ? await dimmer.rgbColorOn() : await dimmer.rgbColorOff();
+
+    if (!success) {
+      throw new Error(`Failed to turn ${isOn ? 'on' : 'off'} indicator light`);
+    }
+
+    await this.refreshDimmerDetails();
+  }
+
+  private async getIndicatorHue(): Promise<CharacteristicValue> {
+    if (!this.isDimmerDevice) {
+      return 0;
+    }
+
+    const { hue } = this.rgbToHsv(
+      (this.device as VeSyncDimmerSwitch).rgbLightValue.red,
+      (this.device as VeSyncDimmerSwitch).rgbLightValue.green,
+      (this.device as VeSyncDimmerSwitch).rgbLightValue.blue
+    );
+    this.indicatorColorState.hue = hue;
+    return hue;
+  }
+
+  private async setIndicatorHue(value: CharacteristicValue): Promise<void> {
+    if (!this.isDimmerDevice) {
+      return;
+    }
+
+    this.indicatorColorState.hue = Number(value);
+    this.scheduleIndicatorColorUpdate();
+  }
+
+  private async getIndicatorSaturation(): Promise<CharacteristicValue> {
+    if (!this.isDimmerDevice) {
+      return 0;
+    }
+
+    const { saturation } = this.rgbToHsv(
+      (this.device as VeSyncDimmerSwitch).rgbLightValue.red,
+      (this.device as VeSyncDimmerSwitch).rgbLightValue.green,
+      (this.device as VeSyncDimmerSwitch).rgbLightValue.blue
+    );
+    this.indicatorColorState.saturation = saturation;
+    return saturation;
+  }
+
+  private async setIndicatorSaturation(value: CharacteristicValue): Promise<void> {
+    if (!this.isDimmerDevice) {
+      return;
+    }
+
+    this.indicatorColorState.saturation = Number(value);
+    this.scheduleIndicatorColorUpdate();
+  }
+
+  private scheduleIndicatorColorUpdate(): void {
+    if (this.indicatorColorUpdateTimeout) {
+      clearTimeout(this.indicatorColorUpdateTimeout);
+    }
+
+    this.indicatorColorUpdateTimeout = setTimeout(() => {
+      void this.pushIndicatorColor().catch(error => {
+        void this.handleDeviceError('set indicator color', error);
+      });
+    }, 250);
+  }
+
+  private async pushIndicatorColor(): Promise<void> {
+    if (!this.isDimmerDevice) {
+      return;
+    }
+
+    const [red, green, blue] = this.hsvToRgb(
+      this.indicatorColorState.hue,
+      this.indicatorColorState.saturation,
+      100
+    );
+
+    const dimmer = this.device as VeSyncDimmerSwitch;
+    const success = await dimmer.rgbColorSet(red, green, blue);
+
+    if (!success) {
+      throw new Error('Failed to update indicator color');
+    }
+
+    this.indicatorColorState = {
+      hue: this.indicatorColorState.hue,
+      saturation: this.indicatorColorState.saturation,
+    };
+
+    await this.refreshDimmerDetails();
+  }
+
+  private hsvToRgb(h: number, s: number, v: number): [number, number, number] {
+    let hue = h % 360;
+    if (hue < 0) {
+      hue += 360;
+    }
+    const saturation = Math.max(0, Math.min(100, s)) / 100;
+    const value = Math.max(0, Math.min(100, v)) / 100;
+
+    const c = value * saturation;
+    const x = c * (1 - Math.abs(((hue / 60) % 2) - 1));
+    const m = value - c;
+
+    let rPrime = 0;
+    let gPrime = 0;
+    let bPrime = 0;
+
+    if (hue < 60) {
+      rPrime = c;
+      gPrime = x;
+    } else if (hue < 120) {
+      rPrime = x;
+      gPrime = c;
+    } else if (hue < 180) {
+      gPrime = c;
+      bPrime = x;
+    } else if (hue < 240) {
+      gPrime = x;
+      bPrime = c;
+    } else if (hue < 300) {
+      rPrime = x;
+      bPrime = c;
+    } else {
+      rPrime = c;
+      bPrime = x;
+    }
+
+    const red = Math.round((rPrime + m) * 255);
+    const green = Math.round((gPrime + m) * 255);
+    const blue = Math.round((bPrime + m) * 255);
+
+    return [red, green, blue];
+  }
+
+  private rgbToHsv(r: number, g: number, b: number): { hue: number; saturation: number; value: number } {
+    const red = r / 255;
+    const green = g / 255;
+    const blue = b / 255;
+
+    const max = Math.max(red, green, blue);
+    const min = Math.min(red, green, blue);
+    const delta = max - min;
+
+    let hue = 0;
+    if (delta !== 0) {
+      if (max === red) {
+        hue = ((green - blue) / delta) % 6;
+      } else if (max === green) {
+        hue = (blue - red) / delta + 2;
+      } else {
+        hue = (red - green) / delta + 4;
+      }
+      hue *= 60;
+      if (hue < 0) {
+        hue += 360;
+      }
+    }
+
+    const saturation = max === 0 ? 0 : (delta / max) * 100;
+    const value = max * 100;
+
+    return {
+      hue: Math.round(hue),
+      saturation: Math.round(saturation),
+      value: Math.round(value),
+    };
+  }
+
+  private async refreshDimmerDetails(): Promise<void> {
+    if (!this.isDimmerDevice) {
+      return;
+    }
+
+    const dimmer = this.device as VeSyncDimmerSwitch;
+    try {
+      const now = Date.now();
+      if (
+        now - this.lastDimmerRefresh >= LightAccessory.DIMMER_REFRESH_DEBOUNCE_MS &&
+        typeof (dimmer as any).getDetails === 'function'
+      ) {
+        await (dimmer as any).getDetails();
+        this.lastDimmerRefresh = now;
+      }
+    } catch (error) {
+      this.platform.log.debug(
+        `${this.device.deviceName}: failed to refresh details after state change`,
+        error instanceof Error ? error : new Error(String(error))
+      );
+    }
+  }
+}

package/src/platform.ts

@@ -344,7 +344,27 @@ export class TSVESyncPlatform implements DynamicPlatformPlugin {
    * Update device states periodically
    */
   private async updateDeviceStates() {
-    await this.discoverDevices();
+    if (this.refreshInProgress) {
+      return;
+    }
+
+    this.refreshInProgress = true;
+
+    try {
+      await this.discoverDevices();
+
+      const syncTasks = Array.from(this.deviceAccessories.values()).map(async accessory => {
+        try {
+          await accessory.syncDeviceState();
+        } catch (error) {
+          this.logger.warn('Failed to sync device state during scheduled refresh', error as Error);
+        }
+      });
+
+      await Promise.all(syncTasks);
+    } finally {
+      this.refreshInProgress = false;
+    }
   }
 
   /**

package/src/types/device.types.ts

@@ -22,6 +22,7 @@ export interface VeSyncDeviceWithPower extends VeSyncBaseDevice {
   deviceStatus: string;
   turnOn(): Promise<boolean>;
   turnOff(): Promise<boolean>;
+  getDetails?: (...args: any[]) => any;
 }
 
 export interface VeSyncDeviceWithBrightness extends VeSyncDeviceWithPower {
@@ -84,8 +85,25 @@ export interface VeSyncFan extends VeSyncDeviceWithPower, VeSyncDeviceWithSpeed,
   setMode(mode: 'normal' | 'auto' | 'sleep' | 'turbo'): Promise<boolean>;
 }
 
+export interface VeSyncDimmerSwitch extends VeSyncDeviceWithBrightness {
+  rgbLightStatus: string;
+  indicatorLightStatus: string;
+  rgbLightValue: {
+    red: number;
+    green: number;
+    blue: number;
+  };
+  rgbColorSet(red: number, green: number, blue: number): Promise<boolean>;
+  rgbColorOn(): Promise<boolean>;
+  rgbColorOff(): Promise<boolean>;
+  indicatorLightOn(): Promise<boolean>;
+  indicatorLightOff(): Promise<boolean>;
+}
+
 export interface VeSyncBulb extends VeSyncDeviceWithPower, VeSyncDeviceWithBrightness, VeSyncDeviceWithColor {}
 
+export type VeSyncLightDevice = VeSyncBulb | VeSyncDimmerSwitch;
+
 export interface VeSyncOutlet extends VeSyncDeviceWithPower {
   power?: number;
   voltage?: number;

package/src/utils/device-factory.ts

@@ -9,11 +9,12 @@ import { OutletAccessory } from '../accessories/outlet.accessory';
 import { SwitchAccessory } from '../accessories/switch.accessory';
 import { BaseAccessory } from '../accessories/base.accessory';
 import { AirQualitySensorAccessory } from '../accessories/air-quality-sensor.accessory';
-import { 
+import {
   VeSyncAirPurifier,
   VeSyncHumidifier,
   VeSyncFan,
   VeSyncBulb,
+  VeSyncDimmerSwitch,
   VeSyncOutlet,
   VeSyncSwitch
 } from '../types/device.types';
@@ -38,7 +39,9 @@ const OUTLET_MODELS = [
   'ESW10-USA', 'wifi-switch-1.3'
 ];
 
-const SWITCH_MODELS = ['ESWD16', 'ESWL01', 'ESWL03'];
+const SWITCH_MODELS = ['ESWL01', 'ESWL03'];
+
+const DIMMER_MODELS = ['ESWD16'];
 
 export class DeviceFactory {
   private static modelMatches(deviceType: string, models: string[]): boolean {
@@ -66,6 +69,10 @@ export class DeviceFactory {
     return deviceType.startsWith('ESL') || deviceType === 'XYD0001';
   }
 
+  private static isDimmer(deviceType: string): boolean {
+    return this.modelMatches(deviceType, DIMMER_MODELS);
+  }
+
   private static isOutlet(deviceType: string): boolean {
     return this.modelMatches(deviceType, OUTLET_MODELS);
   }
@@ -96,6 +103,11 @@ export class DeviceFactory {
       return new FanAccessory(platform, accessory, device as VeSyncFan);
     }
 
+    // Dimmers
+    if (this.isDimmer(deviceType)) {
+      return new LightAccessory(platform, accessory, device as VeSyncDimmerSwitch);
+    }
+
     // Bulbs
     if (this.isBulb(deviceType)) {
       return new LightAccessory(platform, accessory, device as VeSyncBulb);
@@ -131,7 +143,7 @@ export class DeviceFactory {
       return Categories.FAN;
     }
 
-    if (this.isBulb(type)) {
+    if (this.isDimmer(type) || this.isBulb(type)) {
       return Categories.LIGHTBULB;
     }
 
@@ -179,4 +191,4 @@ export class DeviceFactory {
     platform.log.debug(`Not creating AQ sensor for ${device.deviceName} - no air quality support detected`);
     return null;
   }
-} 
+}