homebridge-tsvesync 1.0.0 → 1.0.2

package/src/platformAccessory.ts

@@ -1,6 +1,23 @@
 import { Service, PlatformAccessory, CharacteristicValue } from 'homebridge';
 import { TSVESyncPlatform } from './platform';
-import { TSVESync, Device } from 'tsvesync';
+import { VeSyncBaseDevice } from 'tsvesync/dist/src/lib/vesyncBaseDevice';
+
+interface VeSyncDeviceWithPower extends VeSyncBaseDevice {
+  deviceStatus: string;
+  turnOn(): Promise<boolean>;
+  turnOff(): Promise<boolean>;
+}
+
+interface VeSyncDeviceWithBrightness extends VeSyncDeviceWithPower {
+  brightness: number;
+  setBrightness(value: number): Promise<boolean>;
+}
+
+interface VeSyncDeviceWithSpeed extends VeSyncDeviceWithPower {
+  speed: number;
+  maxSpeed: number;
+  setSpeed(value: number): Promise<boolean>;
+}
 
 export class TSVESyncAccessory {
   private service!: Service;
@@ -8,51 +25,81 @@ export class TSVESyncAccessory {
   constructor(
     private readonly platform: TSVESyncPlatform,
     private readonly accessory: PlatformAccessory,
-    private readonly client: TSVESync,
+    private readonly device: VeSyncBaseDevice,
   ) {
-    // Get the device from context
-    const device = accessory.context.device as Device;
-
     // set accessory information
     this.accessory.getService(this.platform.Service.AccessoryInformation)!
-      .setCharacteristic(this.platform.Characteristic.Manufacturer, 'TSVESync')
-      .setCharacteristic(this.platform.Characteristic.Model, device.model || 'Unknown')
-      .setCharacteristic(this.platform.Characteristic.SerialNumber, device.id);
+      .setCharacteristic(this.platform.Characteristic.Manufacturer, 'VeSync')
+      .setCharacteristic(this.platform.Characteristic.Model, device.deviceType)
+      .setCharacteristic(this.platform.Characteristic.SerialNumber, device.cid);
 
     // Set up the appropriate service based on device type
-    this.setupService(device);
+    this.setupService();
+  }
+
+  private setupService() {
+    const deviceType = this.device.deviceType;
+    
+    if (deviceType.includes('BULB')) {
+      this.setupBulb();
+    } else if (deviceType.includes('FAN') || deviceType.includes('AIR')) {
+      this.setupFan();
+    } else {
+      this.setupSwitch();
+    }
   }
 
-  private setupService(device: Device) {
-    // Determine the appropriate service type based on device capabilities
-    if (device.supportsBrightness) {
-      // Set up as a lightbulb if it supports brightness
-      this.service = this.accessory.getService(this.platform.Service.Lightbulb) 
-        || this.accessory.addService(this.platform.Service.Lightbulb);
+  private setupBulb() {
+    this.service = this.accessory.getService(this.platform.Service.Lightbulb) 
+      || this.accessory.addService(this.platform.Service.Lightbulb);
 
-      // Add brightness characteristic
+    // Add brightness characteristic if device supports it
+    const bulb = this.device as VeSyncDeviceWithBrightness;
+    if ('setBrightness' in bulb) {
       this.service.getCharacteristic(this.platform.Characteristic.Brightness)
         .onSet(this.setBrightness.bind(this))
         .onGet(this.getBrightness.bind(this));
-    } else {
-      // Set up as a switch for basic on/off functionality
-      this.service = this.accessory.getService(this.platform.Service.Switch) 
-        || this.accessory.addService(this.platform.Service.Switch);
     }
 
-    // Add on/off characteristic (common to both switch and lightbulb)
     this.service.getCharacteristic(this.platform.Characteristic.On)
       .onSet(this.setOn.bind(this))
       .onGet(this.getOn.bind(this));
   }
 
-  /**
-   * Handle "SET" requests from HomeKit for power state
-   */
+  private setupFan() {
+    this.service = this.accessory.getService(this.platform.Service.Fan)
+      || this.accessory.addService(this.platform.Service.Fan);
+
+    this.service.getCharacteristic(this.platform.Characteristic.On)
+      .onSet(this.setOn.bind(this))
+      .onGet(this.getOn.bind(this));
+
+    const fan = this.device as VeSyncDeviceWithSpeed;
+    if ('setSpeed' in fan) {
+      this.service.getCharacteristic(this.platform.Characteristic.RotationSpeed)
+        .onSet(this.setFanSpeed.bind(this))
+        .onGet(this.getFanSpeed.bind(this));
+    }
+  }
+
+  private setupSwitch() {
+    this.service = this.accessory.getService(this.platform.Service.Switch)
+      || this.accessory.addService(this.platform.Service.Switch);
+
+    this.service.getCharacteristic(this.platform.Characteristic.On)
+      .onSet(this.setOn.bind(this))
+      .onGet(this.getOn.bind(this));
+  }
+
   async setOn(value: CharacteristicValue) {
     try {
-      const device = this.accessory.context.device as Device;
-      await this.client.setPowerState(device.id, value as boolean);
+      const device = this.device as VeSyncDeviceWithPower;
+      const newState = value as boolean;
+      if (newState) {
+        await device.turnOn();
+      } else {
+        await device.turnOff();
+      }
       this.platform.log.debug('Set power state ->', value);
     } catch (error) {
       this.platform.log.error('Failed to set power state:', error);
@@ -60,52 +107,58 @@ export class TSVESyncAccessory {
     }
   }
 
-  /**
-   * Handle "GET" requests from HomeKit for power state
-   */
   async getOn(): Promise<CharacteristicValue> {
     try {
-      const device = this.accessory.context.device as Device;
-      const state = await this.client.getPowerState(device.id);
-      this.platform.log.debug('Get power state ->', state);
-      return state;
+      const device = this.device as VeSyncDeviceWithPower;
+      return device.deviceStatus === 'on';
     } catch (error) {
       this.platform.log.error('Failed to get power state:', error);
       throw error;
     }
   }
 
-  /**
-   * Handle "SET" requests from HomeKit for brightness
-   */
   async setBrightness(value: CharacteristicValue) {
     try {
-      const device = this.accessory.context.device as Device;
-      if (device.supportsBrightness) {
-        await this.client.setBrightness(device.id, value as number);
-        this.platform.log.debug('Set brightness ->', value);
-      }
+      const device = this.device as VeSyncDeviceWithBrightness;
+      await device.setBrightness(value as number);
+      this.platform.log.debug('Set brightness ->', value);
     } catch (error) {
       this.platform.log.error('Failed to set brightness:', error);
       throw error;
     }
   }
 
-  /**
-   * Handle "GET" requests from HomeKit for brightness
-   */
   async getBrightness(): Promise<CharacteristicValue> {
     try {
-      const device = this.accessory.context.device as Device;
-      if (device.supportsBrightness) {
-        const brightness = await this.client.getBrightness(device.id);
-        this.platform.log.debug('Get brightness ->', brightness);
-        return brightness;
-      }
-      return 100;
+      const device = this.device as VeSyncDeviceWithBrightness;
+      return device.brightness || 100;
     } catch (error) {
       this.platform.log.error('Failed to get brightness:', error);
       throw error;
     }
   }
+
+  async setFanSpeed(value: CharacteristicValue) {
+    try {
+      const device = this.device as VeSyncDeviceWithSpeed;
+      // Convert HomeKit 0-100 to device speed levels
+      const speed = Math.ceil((value as number) / (100 / device.maxSpeed));
+      await device.setSpeed(speed);
+      this.platform.log.debug('Set fan speed ->', speed);
+    } catch (error) {
+      this.platform.log.error('Failed to set fan speed:', error);
+      throw error;
+    }
+  }
+
+  async getFanSpeed(): Promise<CharacteristicValue> {
+    try {
+      const device = this.device as VeSyncDeviceWithSpeed;
+      // Convert device speed levels to HomeKit 0-100
+      return (device.speed || 0) * (100 / device.maxSpeed);
+    } catch (error) {
+      this.platform.log.error('Failed to get fan speed:', error);
+      throw error;
+    }
+  }
 }