homebridge-tsvesync 1.0.13 → 1.0.14

package/src/accessories/air-purifier.accessory.ts

@@ -4,17 +4,22 @@ import { TSVESyncPlatform } from '../platform';
 import { DeviceCapabilities, VeSyncAirPurifier } from '../types/device.types';
 
 export class AirPurifierAccessory extends BaseAccessory {
+  private readonly capabilities: DeviceCapabilities;
   protected readonly device: VeSyncAirPurifier;
 
   constructor(
     platform: TSVESyncPlatform,
     accessory: PlatformAccessory,
-    device: VeSyncAirPurifier,
+    device: VeSyncAirPurifier
   ) {
     super(platform, accessory, device);
     this.device = device;
+    this.capabilities = this.getDeviceCapabilities();
   }
 
+  /**
+   * Set up the air purifier service
+   */
   protected setupService(): void {
     // Get or create the air purifier service
     this.service = this.accessory.getService(this.platform.Service.AirPurifier) ||
@@ -68,7 +73,7 @@ export class AirPurifierAccessory extends BaseAccessory {
       this.setupCharacteristic(
         this.platform.Characteristic.RotationSpeed,
         this.getRotationSpeed.bind(this),
-        this.setRotationSpeed.bind(this)
+        this.handleSetRotationSpeed.bind(this)
       );
     }
 
@@ -98,88 +103,114 @@ export class AirPurifierAccessory extends BaseAccessory {
     );
   }
 
-  protected updateDeviceSpecificStates(details: any): void {
-    const capabilities = this.getDeviceCapabilities();
+  /**
+   * Get device capabilities
+   */
+  protected getDeviceCapabilities(): DeviceCapabilities {
+    return {
+      hasSpeed: true,
+      hasAirQuality: true,
+      hasChildLock: true,
+      hasBrightness: false,
+      hasColorTemp: false,
+      hasColor: false,
+      hasHumidity: false,
+      hasWaterLevel: false,
+      hasSwingMode: false,
+    };
+  }
 
-    if (capabilities.hasAirQuality) {
-      const airQualityService = this.accessory.getService(this.platform.Service.AirQualitySensor);
-      if (airQualityService) {
-        // Ensure we have a valid number for air quality
-        const airQuality = typeof details.airQuality === 'number' && !isNaN(details.airQuality) 
-          ? details.airQuality 
-          : 0;
-
-        airQualityService.updateCharacteristic(
-          this.platform.Characteristic.AirQuality,
-          this.convertAirQualityToHomeKit(airQuality)
-        );
-        
-        // Ensure PM2.5 value is a valid number
-        const pm25Value = typeof details.pm25 === 'number' && !isNaN(details.pm25)
-          ? details.pm25
-          : typeof airQuality === 'number' && !isNaN(airQuality)
-            ? airQuality
-            : 0;
-
-        airQualityService.updateCharacteristic(
-          this.platform.Characteristic.PM2_5Density,
-          pm25Value
-        );
-      }
+  /**
+   * Update device states based on the latest details
+   */
+  protected async updateDeviceSpecificStates(details: any): Promise<void> {
+    // Update power state
+    const isOn = details.enabled;
+    this.service.updateCharacteristic(this.platform.Characteristic.Active, isOn ? 1 : 0);
+    this.service.updateCharacteristic(this.platform.Characteristic.CurrentAirPurifierState, isOn ? 2 : 0);
+
+    // Update rotation speed
+    const speed = details.speed;
+    const rotationSpeed = Math.round((speed / this.device.maxSpeed) * 100);
+    this.service.updateCharacteristic(this.platform.Characteristic.RotationSpeed, rotationSpeed);
+
+    // Update air quality if available
+    if (this.capabilities.hasAirQuality) {
+      const pm25 = details.airQuality?.pm25 ?? 0;
+      const airQuality = this.convertAirQualityToHomeKit(pm25);
+      this.service.updateCharacteristic(this.platform.Characteristic.AirQuality, airQuality);
+      this.service.updateCharacteristic(this.platform.Characteristic.PM2_5Density, pm25);
     }
 
-    if (capabilities.hasSpeed && details.speed !== undefined && details.speed !== null) {
-      const normalizedSpeed = Math.min(Math.max((details.speed / (this.device.maxSpeed || 1)) * 100, 0), 100);
-      this.updateCharacteristicValue(
-        this.platform.Characteristic.RotationSpeed,
-        normalizedSpeed
+    // Update filter life if available
+    if (details.filterLife !== undefined) {
+      const filterLife = details.filterLife;
+      this.service.updateCharacteristic(this.platform.Characteristic.FilterLifeLevel, filterLife);
+      this.service.updateCharacteristic(
+        this.platform.Characteristic.FilterChangeIndication,
+        filterLife <= 20 ? 1 : 0
       );
     }
 
-    if (capabilities.hasChildLock && details.childLock !== undefined) {
-      this.updateCharacteristicValue(
-        this.platform.Characteristic.LockPhysicalControls,
-        details.childLock ? 1 : 0
-      );
-    }
+    // Update device state based on activity
+    this.updatePollingState(isOn);
+  }
 
-    if (details.filterLife !== undefined && details.filterLife !== null) {
-      this.updateCharacteristicValue(
-        this.platform.Characteristic.FilterChangeIndication,
-        details.filterLife <= 20 ? 1 : 0
-      );
-      
-      this.updateCharacteristicValue(
-        this.platform.Characteristic.FilterLifeLevel,
-        details.filterLife
-      );
+  /**
+   * Handle set active state
+   */
+  private async handleSetActive(value: CharacteristicValue): Promise<void> {
+    try {
+      const newState = value as number;
+      if (newState === 1) {
+        await this.device.turnOn();
+      } else {
+        await this.device.turnOff();
+      }
+    } catch (err) {
+      await this.handleDeviceError('set active state', err);
+      throw err;
     }
+  }
 
-    // Update air purifier state
-    const isActive = details.deviceStatus === 'on';
-    this.updateCharacteristicValue(
-      this.platform.Characteristic.Active,
-      isActive ? 1 : 0
-    );
+  /**
+   * Handle set target state
+   */
+  private async handleSetTargetState(value: CharacteristicValue): Promise<void> {
+    try {
+      const newState = value as number;
+      if (this.device.setMode) {
+        await this.device.setMode(newState === 1 ? 'auto' : 'manual');
+      }
+    } catch (err) {
+      await this.handleDeviceError('set target state', err);
+      throw err;
+    }
+  }
 
-    this.updateCharacteristicValue(
-      this.platform.Characteristic.CurrentAirPurifierState,
-      isActive ? 2 : 0 // 0 = INACTIVE, 2 = PURIFYING_AIR
-    );
+  /**
+   * Handle set rotation speed
+   */
+  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');
   }
 
-  protected getDeviceCapabilities(): DeviceCapabilities {
-    return {
-      hasBrightness: false,
-      hasColorTemp: false,
-      hasColor: false,
-      hasSpeed: true,
-      hasHumidity: false,
-      hasAirQuality: true,
-      hasWaterLevel: false,
-      hasChildLock: true,
-      hasSwingMode: false,
-    };
+  /**
+   * Handle set child lock
+   */
+  private async handleSetChildLock(value: CharacteristicValue): Promise<void> {
+    try {
+      const enabled = value as number === 1;
+      if (this.device.setChildLock) {
+        await this.device.setChildLock(enabled);
+      }
+    } catch (err) {
+      await this.handleDeviceError('set child lock', err);
+      throw err;
+    }
   }
 
   private async getActive(): Promise<CharacteristicValue> {
@@ -252,19 +283,15 @@ export class AirPurifierAccessory extends BaseAccessory {
     return Math.min(Math.max((this.device.speed / this.device.maxSpeed) * 100, 0), 100);
   }
 
-  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);
+  /**
+   * Convert HomeKit rotation speed (0-100) to fan speed (1-maxSpeed)
+   */
+  private convertRotationSpeedToFanSpeed(value: number): number {
+    if (value === 0) {
+      return 0; // Off
     }
+    // Convert from 0-100 to 1-maxSpeed
+    return Math.max(1, Math.round((value / 100) * this.device.maxSpeed));
   }
 
   private async getLockPhysicalControls(): Promise<CharacteristicValue> {
@@ -297,4 +324,10 @@ export class AirPurifierAccessory extends BaseAccessory {
   private async getFilterLifeLevel(): Promise<CharacteristicValue> {
     return this.device.filterLife;
   }
+
+  protected async updateRotationSpeed(speed: number): Promise<void> {
+    await this.withRetry(async () => {
+      await this.device.changeFanSpeed(speed);
+    }, 'update rotation speed');
+  }
 } 

package/src/accessories/base.accessory.ts

@@ -13,6 +13,7 @@ export abstract class BaseAccessory {
   private readonly pollingManager: PollingManager;
   private readonly retryManager: RetryManager;
   private readonly logger: PluginLogger;
+  private needsRetry = false;
 
   constructor(
     platform: TSVESyncPlatform,
@@ -83,6 +84,10 @@ export abstract class BaseAccessory {
       return result;
     } catch (error) {
       this.logger.operationEnd(context, error as Error);
+      await this.handleDeviceError(
+        `Failed to ${operationName}`,
+        error instanceof Error ? error : new Error(String(error))
+      );
       throw error;
     }
   }
@@ -95,7 +100,7 @@ export abstract class BaseAccessory {
   /**
    * Update device-specific states
    */
-  protected abstract updateDeviceSpecificStates(details: any): void;
+  protected abstract updateDeviceSpecificStates(details: any): Promise<void>;
 
   /**
    * Get device capabilities
@@ -168,36 +173,21 @@ export abstract class BaseAccessory {
    * Sync the device state with VeSync
    */
   protected async syncDeviceState(): Promise<void> {
-    const context = this.getLogContext('sync device state');
-    
     try {
-      await this.withRetry(async () => {
-        await this.device.getDetails();
-        const details = {
-          deviceStatus: this.device.deviceStatus,
-          // Add any other properties needed from the device
-        };
-        
-        // Update polling state based on device status
-        const isActive = details.deviceStatus === 'on';
-        this.updatePollingState(isActive);
-        
-        this.logger.pollingEvent({
-          ...context,
-          interval: this.pollingManager.getCurrentInterval(),
-          active: isActive,
-        });
-        
-        // Update device-specific states
-        this.updateDeviceSpecificStates(details);
-      }, 'sync device state');
+      if (this.needsRetry) {
+        this.platform.log.debug(`[${this.accessory.displayName}] Retrying previous failed operation`);
+      }
+      
+      const details = await this.device.getDetails();
+      this.needsRetry = false; // Clear retry flag on success
+      
+      // Update the device state
+      await this.updateDeviceSpecificStates(details);
     } catch (error) {
-      this.logger.error(
+      await this.handleDeviceError(
         'Failed to sync device state',
-        context,
-        error as Error
+        error instanceof Error ? error : new Error(String(error))
       );
-      throw error; // Let polling manager handle the error
     }
   }
 
@@ -318,15 +308,52 @@ export abstract class BaseAccessory {
   }
 
   /**
-   * Handle device errors consistently
+   * Handle device errors with appropriate recovery actions
    */
-  protected handleDeviceError(operation: string, error: unknown): void {
+  protected async handleDeviceError(operation: string, error: unknown): Promise<void> {
     const errorObj = error instanceof Error ? error : new Error(String(error));
-    this.logger.error(
-      `Failed to ${operation}`,
-      this.getLogContext(operation),
-      errorObj
-    );
-    throw errorObj;
+    const errorDetails = errorObj as any;
+    const errorCode = errorDetails?.error?.code || errorDetails?.code;
+    const errorMsg = errorDetails?.error?.msg || errorDetails?.msg;
+    
+    // Log the error with context
+    this.platform.log.error(`[${this.accessory.displayName}] ${operation}: ${JSON.stringify(errorDetails)}`);
+
+    // Handle specific error codes
+    switch (errorCode) {
+      case 4041008: // Device not found
+        this.platform.log.warn(`[${this.accessory.displayName}] Device not found, will attempt to rediscover`);
+        await this.attemptReconnection();
+        break;
+      case -11102086: // Internal error
+        this.platform.log.warn(`[${this.accessory.displayName}] VeSync API internal error, will retry later`);
+        // Mark device for retry on next update cycle
+        this.markForRetry();
+        break;
+      default:
+        if (errorMsg?.includes('not found')) {
+          await this.attemptReconnection();
+        }
+    }
+  }
+
+  /**
+   * Attempt to reconnect to the device by triggering device discovery
+   */
+  private async attemptReconnection(): Promise<void> {
+    try {
+      // Attempt to refresh the device list
+      await this.platform.discoverDevices();
+      this.platform.log.info(`[${this.accessory.displayName}] Successfully refreshed device list`);
+    } catch (error) {
+      this.platform.log.error(`[${this.accessory.displayName}] Failed to reconnect: ${error}`);
+    }
+  }
+
+  /**
+   * Mark the device for retry on next update cycle
+   */
+  private markForRetry(): void {
+    this.needsRetry = true;
   }
 } 

package/src/accessories/fan.accessory.ts

@@ -9,14 +9,16 @@ const COUNTER_CLOCKWISE = 1;
 
 export class FanAccessory extends BaseAccessory {
   protected readonly device: VeSyncFan;
+  private readonly capabilities: DeviceCapabilities;
 
   constructor(
     platform: TSVESyncPlatform,
     accessory: PlatformAccessory,
-    device: VeSyncFan,
+    device: VeSyncFan
   ) {
     super(platform, accessory, device);
     this.device = device;
+    this.capabilities = this.getDeviceCapabilities();
   }
 
   protected setupService(): void {
@@ -38,7 +40,7 @@ export class FanAccessory extends BaseAccessory {
       this.setupCharacteristic(
         this.platform.Characteristic.RotationSpeed,
         this.getRotationSpeed.bind(this),
-        this.setRotationSpeed.bind(this)
+        this.handleSetRotationSpeed.bind(this)
       );
     }
 
@@ -74,48 +76,50 @@ export class FanAccessory 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 fanDetails = details as {
+      deviceStatus: string;
+      speed: number;
+      childLock: boolean;
+      swingMode: boolean;
+    };
+
+    // Update active state
+    const isActive = fanDetails.deviceStatus === 'on';
+    this.updateCharacteristicValue(
+      this.platform.Characteristic.Active,
+      isActive ? 1 : 0
+    );
 
-    // 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
+        fanDetails.speed
       );
     }
 
-    // Update rotation direction if available
-    if ('rotationDirection' in details) {
+    // Update child lock if supported
+    if (this.capabilities.hasChildLock) {
       this.updateCharacteristicValue(
-        this.platform.Characteristic.RotationDirection,
-        details.rotationDirection === 'clockwise' ? CLOCKWISE : COUNTER_CLOCKWISE
+        this.platform.Characteristic.LockPhysicalControls,
+        fanDetails.childLock ? 1 : 0
       );
     }
 
-    // Update swing mode if available
-    if (capabilities.hasSwingMode && details.swingMode !== undefined) {
+    // Update swing mode if supported
+    if (this.capabilities.hasSwingMode) {
       this.updateCharacteristicValue(
         this.platform.Characteristic.SwingMode,
-        details.swingMode ? 1 : 0
-      );
-    }
-
-    // Update child lock if available
-    if (capabilities.hasChildLock && details.childLock !== undefined) {
-      this.updateCharacteristicValue(
-        this.platform.Characteristic.LockPhysicalControls,
-        details.childLock ? 1 : 0
+        fanDetails.swingMode ? 1 : 0
       );
     }
 
-    // Update active state
-    const isActive = details.deviceStatus === 'on';
-    this.updateCharacteristicValue(
-      this.platform.Characteristic.Active,
-      isActive ? 1 : 0
-    );
+    // Update polling state based on active status
+    this.updatePollingState(isActive);
   }
 
   protected getDeviceCapabilities(): DeviceCapabilities {
@@ -151,23 +155,15 @@ export class FanAccessory 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 getRotationDirection(): Promise<CharacteristicValue> {