homebridge-tsvesync 1.0.13 → 1.0.14

package/src/accessories/humidifier.accessory.ts

@@ -5,14 +5,16 @@ import { DeviceCapabilities, VeSyncHumidifier } from '../types/device.types';
 
 export class HumidifierAccessory extends BaseAccessory {
   protected readonly device: VeSyncHumidifier;
+  private readonly capabilities: DeviceCapabilities;
 
   constructor(
     platform: TSVESyncPlatform,
     accessory: PlatformAccessory,
-    device: VeSyncHumidifier,
+    device: VeSyncHumidifier
   ) {
     super(platform, accessory, device);
     this.device = device;
+    this.capabilities = this.getDeviceCapabilities();
   }
 
   protected setupService(): void {
@@ -56,7 +58,7 @@ export class HumidifierAccessory extends BaseAccessory {
       this.setupCharacteristic(
         this.platform.Characteristic.RotationSpeed,
         this.getRotationSpeed.bind(this),
-        this.setRotationSpeed.bind(this)
+        this.handleSetRotationSpeed.bind(this)
       );
     }
 
@@ -82,61 +84,80 @@ export class HumidifierAccessory extends BaseAccessory {
     );
   }
 
-  protected updateDeviceSpecificStates(details: any): void {
-    const capabilities = this.getDeviceCapabilities();
+  /**
+   * Update device states based on the latest details
+   */
+  protected async updateDeviceSpecificStates(details: any): Promise<void> {
+    const humidifierDetails = details as {
+      deviceStatus: string;
+      humidity: number;
+      targetHumidity: number;
+      speed: number;
+      childLock: boolean;
+      waterLevel: number;
+    };
 
-    // Update humidity states
-    if (details.humidity !== undefined) {
+    // Update active state
+    const isActive = humidifierDetails.deviceStatus === 'on';
+    this.updateCharacteristicValue(
+      this.platform.Characteristic.Active,
+      isActive ? 1 : 0
+    );
+
+    // Update current state
+    this.updateCharacteristicValue(
+      this.platform.Characteristic.CurrentHumidifierDehumidifierState,
+      isActive ? 2 : 0
+    );
+
+    // Update target state
+    this.updateCharacteristicValue(
+      this.platform.Characteristic.TargetHumidifierDehumidifierState,
+      1 // Always HUMIDIFIER for these devices
+    );
+
+    // Update current humidity
+    if (humidifierDetails.humidity !== undefined) {
       this.updateCharacteristicValue(
         this.platform.Characteristic.CurrentRelativeHumidity,
-        details.humidity
+        humidifierDetails.humidity
       );
     }
 
-    if (details.targetHumidity !== undefined) {
+    // Update target humidity
+    if (humidifierDetails.targetHumidity !== undefined) {
       this.updateCharacteristicValue(
         this.platform.Characteristic.RelativeHumidityHumidifierThreshold,
-        details.targetHumidity
+        humidifierDetails.targetHumidity
       );
     }
 
-    // Update speed if available
-    if (capabilities.hasSpeed && details.speed !== undefined) {
-      const normalizedSpeed = (details.speed / this.device.maxSpeed) * 100;
+    // Update rotation speed if supported
+    if (this.capabilities.hasSpeed) {
       this.updateCharacteristicValue(
         this.platform.Characteristic.RotationSpeed,
-        normalizedSpeed
+        humidifierDetails.speed
       );
     }
 
-    // Update water level if available
-    if (capabilities.hasWaterLevel && details.waterLevel !== undefined) {
+    // Update child lock if supported
+    if (this.capabilities.hasChildLock) {
       this.updateCharacteristicValue(
-        this.platform.Characteristic.WaterLevel,
-        details.waterLevel
+        this.platform.Characteristic.LockPhysicalControls,
+        humidifierDetails.childLock ? 1 : 0
       );
     }
 
-    // Update child lock if available
-    if (capabilities.hasChildLock && details.childLock !== undefined) {
+    // Update water level if supported
+    if (this.capabilities.hasWaterLevel && humidifierDetails.waterLevel !== undefined) {
       this.updateCharacteristicValue(
-        this.platform.Characteristic.LockPhysicalControls,
-        details.childLock ? 1 : 0
+        this.platform.Characteristic.WaterLevel,
+        humidifierDetails.waterLevel
       );
     }
 
-    // Update active state
-    const isActive = details.deviceStatus === 'on';
-    this.updateCharacteristicValue(
-      this.platform.Characteristic.Active,
-      isActive ? 1 : 0
-    );
-
-    // Update current state
-    this.updateCharacteristicValue(
-      this.platform.Characteristic.CurrentHumidifierDehumidifierState,
-      isActive ? 2 : 0 // 0 = INACTIVE, 2 = HUMIDIFYING
-    );
+    // Update polling state based on active status
+    this.updatePollingState(isActive);
   }
 
   protected getDeviceCapabilities(): DeviceCapabilities {
@@ -209,23 +230,15 @@ export class HumidifierAccessory extends BaseAccessory {
     }
   }
 
-  private async getRotationSpeed(): Promise<CharacteristicValue> {
-    return (this.device.speed / this.device.maxSpeed) * 100;
+  private async handleSetRotationSpeed(value: CharacteristicValue): Promise<void> {
+    const speed = Math.round((value as number / 100) * this.device.maxSpeed);
+    await this.withRetry(async () => {
+      await this.device.changeFanSpeed(speed);
+    }, 'set rotation speed');
   }
 
-  private async setRotationSpeed(value: CharacteristicValue): Promise<void> {
-    try {
-      const speed = Math.round((value as number / 100) * this.device.maxSpeed);
-      const success = await this.device.setSpeed(speed);
-      
-      if (!success) {
-        throw new Error(`Failed to set speed to ${speed}`);
-      }
-      
-      await this.persistDeviceState('speed', speed);
-    } catch (error) {
-      this.handleDeviceError('set rotation speed', error);
-    }
+  private async getRotationSpeed(): Promise<CharacteristicValue> {
+    return (this.device.speed / this.device.maxSpeed) * 100;
   }
 
   private async getWaterLevel(): Promise<CharacteristicValue> {

package/src/accessories/light.accessory.ts

@@ -10,14 +10,16 @@ const DEFAULT_COLOR_TEMP = MIN_COLOR_TEMP;
 
 export class LightAccessory extends BaseAccessory {
   protected readonly device: VeSyncBulb;
+  private readonly capabilities: DeviceCapabilities;
 
   constructor(
     platform: TSVESyncPlatform,
     accessory: PlatformAccessory,
-    device: VeSyncBulb,
+    device: VeSyncBulb
   ) {
     super(platform, accessory, device);
     this.device = device;
+    this.capabilities = this.getDeviceCapabilities();
   }
 
   protected setupService(): void {
@@ -84,48 +86,60 @@ export class LightAccessory extends BaseAccessory {
     );
   }
 
-  protected updateDeviceSpecificStates(details: any): void {
-    const capabilities = this.getDeviceCapabilities();
+  /**
+   * Update device states based on the latest details
+   */
+  protected async updateDeviceSpecificStates(details: any): Promise<void> {
+    const lightDetails = details as {
+      deviceStatus: string;
+      brightness: number;
+      colorTemp?: number;
+      hue?: number;
+      saturation?: number;
+    };
 
-    // Update on/off state
-    const isOn = details.deviceStatus === 'on';
+    // Update active state
+    const isActive = lightDetails.deviceStatus === 'on';
     this.updateCharacteristicValue(
       this.platform.Characteristic.On,
-      isOn
+      isActive
     );
 
-    // Update brightness if available
-    if (capabilities.hasBrightness && details.brightness !== undefined) {
+    // Update brightness if supported
+    if (this.capabilities.hasBrightness && lightDetails.brightness !== undefined) {
       this.updateCharacteristicValue(
         this.platform.Characteristic.Brightness,
-        details.brightness
+        lightDetails.brightness
       );
     }
 
-    // Update color temperature if available
-    if (capabilities.hasColorTemp && details.colorTemp !== undefined) {
+    // Update color temperature if supported
+    if (this.capabilities.hasColorTemp && lightDetails.colorTemp !== undefined) {
       this.updateCharacteristicValue(
         this.platform.Characteristic.ColorTemperature,
-        details.colorTemp
+        lightDetails.colorTemp
       );
     }
 
-    // Update color if available
-    if (capabilities.hasColor) {
-      if (details.hue !== undefined) {
+    // Update color if supported
+    if (this.capabilities.hasColor) {
+      if (lightDetails.hue !== undefined) {
         this.updateCharacteristicValue(
           this.platform.Characteristic.Hue,
-          details.hue
+          lightDetails.hue
         );
       }
 
-      if (details.saturation !== undefined) {
+      if (lightDetails.saturation !== undefined) {
         this.updateCharacteristicValue(
           this.platform.Characteristic.Saturation,
-          details.saturation
+          lightDetails.saturation
         );
       }
     }
+
+    // Update polling state based on active status
+    this.updatePollingState(isActive);
   }
 
   protected getDeviceCapabilities(): DeviceCapabilities {

package/src/accessories/outlet.accessory.ts

@@ -22,6 +22,11 @@ export class OutletAccessory extends BaseAccessory {
   protected readonly device: VeSyncOutlet;
   private powerService?: Service;
 
+  // Custom characteristics for power monitoring
+  private readonly POWER_UUID = '7B2B25B0-DB50-4351-9A8B-5B9F3E3E3E3E';
+  private readonly VOLTAGE_UUID = '7B2B25B1-DB50-4351-9A8B-5B9F3E3E3E3E';
+  private readonly ENERGY_UUID = '7B2B25B2-DB50-4351-9A8B-5B9F3E3E3E3E';
+
   constructor(
     platform: TSVESyncPlatform,
     accessory: PlatformAccessory,
@@ -122,34 +127,48 @@ export class OutletAccessory extends BaseAccessory {
     }
   }
 
-  protected updateDeviceSpecificStates(details: any): void {
-    // Update on/off state
-    const isOn = details.deviceStatus === 'on';
+  /**
+   * Update device states based on the latest details
+   */
+  protected async updateDeviceSpecificStates(details: any): Promise<void> {
+    const outletDetails = details as {
+      deviceStatus: string;
+      power?: number;
+      voltage?: number;
+      energy?: number;
+    };
+
+    // Update active state
+    const isActive = outletDetails.deviceStatus === 'on';
     this.updateCharacteristicValue(
       this.platform.Characteristic.On,
-      isOn
+      isActive
     );
 
-    // Update outlet in use
+    // Update outlet in use (always true when device is on)
     this.updateCharacteristicValue(
       this.platform.Characteristic.OutletInUse,
-      isOn && (details.power ? details.power > 0 : true)
+      isActive
     );
 
-    // Update power consumption if available
-    if (this.powerService) {
-      if (details.power !== undefined) {
-        this.powerService.updateCharacteristic(POWER_CHARACTERISTIC.UUID, details.power);
+    // Update power monitoring characteristics if available
+    const powerService = this.accessory.getService('Power Monitor');
+    if (powerService) {
+      if (outletDetails.power !== undefined) {
+        powerService.updateCharacteristic(this.POWER_UUID, outletDetails.power);
       }
 
-      if (details.voltage !== undefined) {
-        this.powerService.updateCharacteristic(VOLTAGE_CHARACTERISTIC.UUID, details.voltage);
+      if (outletDetails.voltage !== undefined) {
+        powerService.updateCharacteristic(this.VOLTAGE_UUID, outletDetails.voltage);
       }
 
-      if (details.energy !== undefined) {
-        this.powerService.updateCharacteristic(ENERGY_CHARACTERISTIC.UUID, details.energy);
+      if (outletDetails.energy !== undefined) {
+        powerService.updateCharacteristic(this.ENERGY_UUID, outletDetails.energy);
       }
     }
+
+    // Update polling state based on active status
+    this.updatePollingState(isActive);
   }
 
   protected getDeviceCapabilities(): DeviceCapabilities {

package/src/types/device.types.ts

@@ -34,7 +34,7 @@ export interface VeSyncDeviceWithColor extends VeSyncDeviceWithBrightness {
 export interface VeSyncDeviceWithSpeed extends VeSyncDeviceWithPower {
   speed: number;
   maxSpeed: number;
-  setSpeed(value: number): Promise<boolean>;
+  changeFanSpeed(value: number): Promise<boolean>;
 }
 
 export interface VeSyncDeviceWithRotation extends VeSyncDeviceWithPower {