@switchbot/homebridge-switchbot 3.5.0-beta.26 → 3.5.0-beta.27

package/src/irdevice/airpurifier.ts

@@ -15,17 +15,24 @@ import { CharacteristicValue, PlatformAccessory, Service } from 'homebridge';
  */
 export class AirPurifier extends irdeviceBase {
   // Services
-  airPurifierService!: Service;
+  private AirPurifier: {
+    Service: Service;
+    Active: CharacteristicValue;
+    RotationSpeed: CharacteristicValue;
+    CurrentAirPurifierState: CharacteristicValue;
+    TargetAirPurifierState: CharacteristicValue;
+  };
+
+  private TemperatureSensor: {
+    Service: Service;
+    CurrentTemperature: CharacteristicValue;
+  };
 
   // Characteristic Values
-  Active!: CharacteristicValue;
   APActive!: CharacteristicValue;
   CurrentAPTemp!: CharacteristicValue;
   CurrentAPMode!: CharacteristicValue;
-  RotationSpeed!: CharacteristicValue;
   CurrentAPFanSpeed!: CharacteristicValue;
-  CurrentTemperature!: CharacteristicValue;
-  CurrentAirPurifierState!: CharacteristicValue;
   CurrentHeaterCoolerState!: CharacteristicValue;
 
   // Others
@@ -45,40 +52,43 @@ export class AirPurifier extends irdeviceBase {
   ) {
     super(platform, accessory, device);
 
-    // default placeholders
-    if (this.Active === undefined) {
-      this.Active = this.hap.Characteristic.Active.INACTIVE;
-    } else {
-      this.Active = this.accessory.context.Active;
-    }
-    if (this.CurrentTemperature === undefined) {
-      this.CurrentTemperature = 24;
-    } else {
-      this.CurrentTemperature = this.accessory.context.CurrentTemperature;
-    }
+    // Initialize AirPurifier property
+    this.AirPurifier = {
+      Service: accessory.getService(this.hap.Service.Switch)!,
+      Active: accessory.context.Active || this.hap.Characteristic.Active.INACTIVE,
+      RotationSpeed: accessory.context.RotationSpeed || 0,
+      CurrentAirPurifierState: accessory.context.CurrentAirPurifierState || this.hap.Characteristic.CurrentAirPurifierState.INACTIVE,
+      TargetAirPurifierState: accessory.context.TargetAirPurifierState || this.hap.Characteristic.TargetAirPurifierState.AUTO,
+    };
+
+    // Initialize TemperatureSensor property
+    this.TemperatureSensor = {
+      Service: accessory.getService(this.hap.Service.TemperatureSensor)!,
+      CurrentTemperature: accessory.context.CurrentTemperature || 24,
+    };
 
     // get the Television service if it exists, otherwise create a new Television service
     // you can create multiple services for each accessory
-    const airPurifierService = `${accessory.displayName} Air Purifier`;
-    (this.airPurifierService = accessory.getService(this.hap.Service.AirPurifier)
-      || accessory.addService(this.hap.Service.AirPurifier)), airPurifierService;
+    const AirPurifierService = `${accessory.displayName} Air Purifier`;
+    (this.AirPurifier.Service = accessory.getService(this.hap.Service.AirPurifier)
+      || accessory.addService(this.hap.Service.AirPurifier)), AirPurifierService;
 
-    this.airPurifierService.setCharacteristic(this.hap.Characteristic.Name, accessory.displayName);
+    this.AirPurifier.Service.setCharacteristic(this.hap.Characteristic.Name, accessory.displayName);
     // handle on / off events using the Active characteristic
-    this.airPurifierService.getCharacteristic(this.hap.Characteristic.Active).onSet(this.ActiveSet.bind(this));
+    this.AirPurifier.Service.getCharacteristic(this.hap.Characteristic.Active).onSet(this.ActiveSet.bind(this));
 
-    this.airPurifierService.getCharacteristic(this.hap.Characteristic.CurrentAirPurifierState).onGet(() => {
+    this.AirPurifier.Service.getCharacteristic(this.hap.Characteristic.CurrentAirPurifierState).onGet(() => {
       return this.CurrentAirPurifierStateGet();
     });
 
-    this.airPurifierService.getCharacteristic(this.hap.Characteristic.TargetAirPurifierState).onSet(this.TargetAirPurifierStateSet.bind(this));
+    this.AirPurifier.Service.getCharacteristic(this.hap.Characteristic.TargetAirPurifierState).onSet(this.TargetAirPurifierStateSet.bind(this));
   }
 
   async ActiveSet(value: CharacteristicValue): Promise<void> {
     this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Set Active: ${value}`);
 
-    this.Active = value;
-    if (this.Active === this.hap.Characteristic.Active.ACTIVE) {
+    this.AirPurifier.Active = value;
+    if (this.AirPurifier.Active === this.hap.Characteristic.Active.ACTIVE) {
       this.pushAirPurifierOnChanges();
     } else {
       this.pushAirPurifierOffChanges();
@@ -102,12 +112,12 @@ export class AirPurifier extends irdeviceBase {
   }
 
   async CurrentAirPurifierStateGet(): Promise<number> {
-    if (this.Active === 1) {
-      this.CurrentAirPurifierState = this.hap.Characteristic.CurrentAirPurifierState.PURIFYING_AIR;
+    if (this.AirPurifier.Active === 1) {
+      this.AirPurifier.CurrentAirPurifierState = this.hap.Characteristic.CurrentAirPurifierState.PURIFYING_AIR;
     } else {
-      this.CurrentAirPurifierState = this.hap.Characteristic.CurrentAirPurifierState.INACTIVE;
+      this.AirPurifier.CurrentAirPurifierState = this.hap.Characteristic.CurrentAirPurifierState.INACTIVE;
     }
-    return this.CurrentAirPurifierState;
+    return this.AirPurifier.CurrentAirPurifierState;
   }
 
   /**
@@ -123,10 +133,10 @@ export class AirPurifier extends irdeviceBase {
    */
   async pushAirPurifierOnChanges(): Promise<void> {
     this.debugLog(
-      `${this.device.remoteType}: ${this.accessory.displayName} pushAirPurifierOnChanges Active: ${this.Active},` +
+      `${this.device.remoteType}: ${this.accessory.displayName} pushAirPurifierOnChanges Active: ${this.AirPurifier.Active},` +
       ` disablePushOn: ${this.disablePushOn}`,
     );
-    if (this.Active === this.hap.Characteristic.Active.ACTIVE && !this.disablePushOn) {
+    if (this.AirPurifier.Active === this.hap.Characteristic.Active.ACTIVE && !this.disablePushOn) {
       const commandType: string = await this.commandType();
       const command: string = await this.commandOn();
       const bodyChange = JSON.stringify({
@@ -140,10 +150,10 @@ export class AirPurifier extends irdeviceBase {
 
   async pushAirPurifierOffChanges(): Promise<void> {
     this.debugLog(
-      `${this.device.remoteType}: ${this.accessory.displayName} pushAirPurifierOffChanges Active: ${this.Active},` +
+      `${this.device.remoteType}: ${this.accessory.displayName} pushAirPurifierOffChanges Active: ${this.AirPurifier.Active},` +
       ` disablePushOff: ${this.disablePushOff}`,
     );
-    if (this.Active === this.hap.Characteristic.Active.INACTIVE && !this.disablePushOn) {
+    if (this.AirPurifier.Active === this.hap.Characteristic.Active.INACTIVE && !this.disablePushOn) {
       const commandType: string = await this.commandType();
       const command: string = await this.commandOff();
       const bodyChange = JSON.stringify({
@@ -157,7 +167,7 @@ export class AirPurifier extends irdeviceBase {
 
   async pushAirPurifierStatusChanges(): Promise<void> {
     this.debugLog(
-      `${this.device.remoteType}: ${this.accessory.displayName} pushAirPurifierStatusChanges Active: ${this.Active},` +
+      `${this.device.remoteType}: ${this.accessory.displayName} pushAirPurifierStatusChanges Active: ${this.AirPurifier.Active},` +
       ` disablePushOff: ${this.disablePushOff},  disablePushOn: ${this.disablePushOn}`,
     );
     if (!this.Busy) {
@@ -172,21 +182,21 @@ export class AirPurifier extends irdeviceBase {
 
   async pushAirPurifierDetailsChanges(): Promise<void> {
     this.debugLog(
-      `${this.device.remoteType}: ${this.accessory.displayName} pushAirPurifierDetailsChanges Active: ${this.Active},` +
+      `${this.device.remoteType}: ${this.accessory.displayName} pushAirPurifierDetailsChanges Active: ${this.AirPurifier.Active},` +
       ` disablePushOff: ${this.disablePushOff},  disablePushOn: ${this.disablePushOn}`,
     );
-    this.CurrentAPTemp = this.CurrentTemperature || 24;
+    this.CurrentAPTemp = this.TemperatureSensor!.CurrentTemperature || 24;
     this.CurrentAPMode = this.CurrentMode || 1;
     this.CurrentAPFanSpeed = this.CurrentFanSpeed || 1;
-    this.APActive = this.Active === 1 ? 'on' : 'off';
+    this.APActive = this.AirPurifier.Active === 1 ? 'on' : 'off';
     const parameter = `${this.CurrentAPTemp},${this.CurrentAPMode},${this.CurrentAPFanSpeed},${this.APActive}`;
     const bodyChange = JSON.stringify({
       command: 'setAll',
       parameter: `${parameter}`,
       commandType: 'command',
     });
-    if (this.Active === 1) {
-      if ((Number(this.CurrentTemperature) || 24) < (this.LastTemperature || 30)) {
+    if (this.AirPurifier.Active === 1) {
+      if ((Number(this.TemperatureSensor!.CurrentTemperature) || 24) < (this.LastTemperature || 30)) {
         this.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.COOLING;
       } else {
         this.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.HEATING;
@@ -237,40 +247,49 @@ export class AirPurifier extends irdeviceBase {
 
   async updateHomeKitCharacteristics(): Promise<void> {
     // Active
-    if (this.Active === undefined) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Active: ${this.Active}`);
+    if (this.AirPurifier.Active === undefined) {
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Active: ${this.AirPurifier.Active}`);
     } else {
-      this.accessory.context.Active = this.Active;
-      this.airPurifierService?.updateCharacteristic(this.hap.Characteristic.Active, this.Active);
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic Active: ${this.Active}`);
+      this.accessory.context.Active = this.AirPurifier.Active;
+      this.AirPurifier.Service.updateCharacteristic(this.hap.Characteristic.Active, this.AirPurifier.Active);
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic Active: ${this.AirPurifier.Active}`);
     }
     // CurrentAirPurifierState
-    if (this.CurrentAirPurifierState === undefined) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} CurrentAirPurifierState: ${this.CurrentAirPurifierState}`);
+    if (this.AirPurifier.CurrentAirPurifierState === undefined) {
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} CurrentAirPurifierState: ${this.AirPurifier.CurrentAirPurifierState}`);
     } else {
-      this.accessory.context.CurrentAirPurifierState = this.CurrentAirPurifierState;
-      this.airPurifierService?.updateCharacteristic(this.hap.Characteristic.CurrentAirPurifierState, this.CurrentAirPurifierState);
-      this.debugLog(
-        `${this.device.remoteType}: ${this.accessory.displayName}` + ` updateCharacteristic CurrentAirPurifierState: ${this.CurrentAirPurifierState}`,
-      );
+      this.accessory.context.CurrentAirPurifierState = this.AirPurifier.CurrentAirPurifierState;
+      this.AirPurifier.Service.updateCharacteristic(this.hap.Characteristic.CurrentAirPurifierState, this.AirPurifier.CurrentAirPurifierState);
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic`
+      + ` CurrentAirPurifierState: ${this.AirPurifier.CurrentAirPurifierState}`);
     }
     // CurrentHeaterCoolerState
     if (this.CurrentHeaterCoolerState === undefined) {
       this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`);
     } else {
       this.accessory.context.CurrentHeaterCoolerState = this.CurrentHeaterCoolerState;
-      this.airPurifierService?.updateCharacteristic(this.hap.Characteristic.CurrentHeaterCoolerState, this.CurrentHeaterCoolerState);
+      this.AirPurifier.Service.updateCharacteristic(this.hap.Characteristic.CurrentHeaterCoolerState, this.CurrentHeaterCoolerState);
       this.debugLog(
         `${this.device.remoteType}: ${this.accessory.displayName}` +
         ` updateCharacteristic CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`,
       );
     }
+    // CurrentTemperature
+    if (this.TemperatureSensor.CurrentTemperature === undefined) {
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} CurrentTemperature: ${this.TemperatureSensor.CurrentTemperature}`);
+    } else {
+      this.accessory.context.CurrentTemperature = this.TemperatureSensor.CurrentTemperature;
+      this.TemperatureSensor.Service.updateCharacteristic(this.hap.Characteristic.CurrentTemperature, this.TemperatureSensor.CurrentTemperature);
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic`
+      + ` CurrentTemperature: ${this.TemperatureSensor.CurrentTemperature}`);
+    }
   }
 
   async apiError(e: any): Promise<void> {
-    this.airPurifierService.updateCharacteristic(this.hap.Characteristic.CurrentHeaterCoolerState, e);
-    this.airPurifierService.updateCharacteristic(this.hap.Characteristic.CurrentAirPurifierState, e);
-    this.airPurifierService.updateCharacteristic(this.hap.Characteristic.TargetAirPurifierState, e);
-    this.airPurifierService.updateCharacteristic(this.hap.Characteristic.Active, e);
+    this.AirPurifier.Service.updateCharacteristic(this.hap.Characteristic.CurrentHeaterCoolerState, e);
+    this.AirPurifier.Service.updateCharacteristic(this.hap.Characteristic.CurrentAirPurifierState, e);
+    this.AirPurifier.Service.updateCharacteristic(this.hap.Characteristic.TargetAirPurifierState, e);
+    this.AirPurifier.Service.updateCharacteristic(this.hap.Characteristic.Active, e);
+    this.TemperatureSensor.Service.updateCharacteristic(this.hap.Characteristic.CurrentTemperature, e);
   }
 }

package/src/irdevice/camera.ts

@@ -15,10 +15,10 @@ import { CharacteristicValue, PlatformAccessory, Service } from 'homebridge';
  */
 export class Camera extends irdeviceBase {
   // Services
-  switchService!: Service;
-
-  // Characteristic Values
-  On!: CharacteristicValue;
+  private Switch: {
+    Service: Service;
+    On: CharacteristicValue;
+  };
 
   constructor(
     readonly platform: SwitchBotPlatform,
@@ -27,30 +27,29 @@ export class Camera extends irdeviceBase {
   ) {
     super(platform, accessory, device);
 
-    // default placeholders
-    if (this.On === undefined) {
-      this.On = false;
-    } else {
-      this.On = accessory.context.On;
-    }
+    // Initialize Switch property
+    this.Switch = {
+      Service: accessory.getService(this.hap.Service.Switch)!,
+      On: accessory.context.On || false,
+    };
 
     // get the Television service if it exists, otherwise create a new Television service
     // you can create multiple services for each accessory
-    const switchService = `${accessory.displayName} Camera`;
-    (this.switchService = accessory.getService(this.hap.Service.Switch)
-      || accessory.addService(this.hap.Service.Switch)), switchService;
+    const SwitchService = `${accessory.displayName} Camera`;
+    (this.Switch.Service = accessory.getService(this.hap.Service.Switch)
+      || accessory.addService(this.hap.Service.Switch)), SwitchService;
 
-    this.switchService.setCharacteristic(this.hap.Characteristic.Name, accessory.displayName);
+    this.Switch.Service.setCharacteristic(this.hap.Characteristic.Name, SwitchService);
 
     // handle on / off events using the On characteristic
-    this.switchService.getCharacteristic(this.hap.Characteristic.On).onSet(this.OnSet.bind(this));
+    this.Switch.Service.getCharacteristic(this.hap.Characteristic.On).onSet(this.OnSet.bind(this));
   }
 
   async OnSet(value: CharacteristicValue): Promise<void> {
     this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} On: ${value}`);
 
-    this.On = value;
-    if (this.On) {
+    this.Switch.On = value;
+    if (this.Switch.On) {
       this.pushOnChanges();
     } else {
       this.pushOffChanges();
@@ -68,8 +67,9 @@ export class Camera extends irdeviceBase {
    * Camera -        "command"       "channelSub"      "default"	        =        previous channel
    */
   async pushOnChanges(): Promise<void> {
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushOnChanges On: ${this.On},` + ` disablePushOn: ${this.disablePushOn}`);
-    if (this.On && !this.disablePushOn) {
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushOnChanges On: ${this.Switch.On},`
+    + ` disablePushOn: ${this.disablePushOn}`);
+    if (this.Switch.On && !this.disablePushOn) {
       const commandType: string = await this.commandType();
       const command: string = await this.commandOn();
       const bodyChange = JSON.stringify({
@@ -83,9 +83,9 @@ export class Camera extends irdeviceBase {
 
   async pushOffChanges(): Promise<void> {
     this.debugLog(
-      `${this.device.remoteType}: ${this.accessory.displayName} pushOffChanges On: ${this.On},` + ` disablePushOff: ${this.disablePushOff}`,
+      `${this.device.remoteType}: ${this.accessory.displayName} pushOffChanges On: ${this.Switch.On},` + ` disablePushOff: ${this.disablePushOff}`,
     );
-    if (!this.On && !this.disablePushOff) {
+    if (!this.Switch.On && !this.disablePushOff) {
       const commandType: string = await this.commandType();
       const command: string = await this.commandOff();
       const bodyChange = JSON.stringify({
@@ -137,16 +137,16 @@ export class Camera extends irdeviceBase {
 
   async updateHomeKitCharacteristics(): Promise<void> {
     // On
-    if (this.On === undefined) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} On: ${this.On}`);
+    if (this.Switch.On === undefined) {
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} On: ${this.Switch.On}`);
     } else {
-      this.accessory.context.On = this.On;
-      this.switchService?.updateCharacteristic(this.hap.Characteristic.On, this.On);
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic On: ${this.On}`);
+      this.accessory.context.On = this.Switch.On;
+      this.Switch.Service?.updateCharacteristic(this.hap.Characteristic.On, this.Switch.On);
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic On: ${this.Switch.On}`);
     }
   }
 
   async apiError(e: any): Promise<void> {
-    this.switchService.updateCharacteristic(this.hap.Characteristic.On, e);
+    this.Switch.Service.updateCharacteristic(this.hap.Characteristic.On, e);
   }
 }

package/src/irdevice/fan.ts

@@ -15,14 +15,13 @@ import { CharacteristicValue, PlatformAccessory, Service } from 'homebridge';
  */
 export class Fan extends irdeviceBase {
   // Services
-  fanService!: Service;
-
-  // Characteristic Values
-  Active!: CharacteristicValue;
-  SwingMode!: CharacteristicValue;
-  RotationSpeed!: CharacteristicValue;
-  ActiveIdentifier!: CharacteristicValue;
-  RotationDirection!: CharacteristicValue;
+  private Fan: {
+    Service: Service;
+    Active: CharacteristicValue;
+    SwingMode: CharacteristicValue;
+    RotationSpeed: CharacteristicValue;
+    RotationDirection: CharacteristicValue;
+  };
 
   // Config
   minStep?: number;
@@ -36,23 +35,25 @@ export class Fan extends irdeviceBase {
   ) {
     super(platform, accessory, device);
 
-    // default placeholders
-    if (this.Active === undefined) {
-      this.Active = this.hap.Characteristic.Active.INACTIVE;
-    } else {
-      this.Active = this.accessory.context.Active;
-    }
+    // Initialize Switch property
+    this.Fan = {
+      Service: accessory.getService(this.hap.Service.Lightbulb)!,
+      Active: accessory.context.Active || this.hap.Characteristic.Active.INACTIVE,
+      SwingMode: accessory.context.SwingMode || this.hap.Characteristic.SwingMode.SWING_DISABLED,
+      RotationSpeed: accessory.context.RotationSpeed || 0,
+      RotationDirection: accessory.context.On || this.hap.Characteristic.RotationDirection.CLOCKWISE,
+    };
 
     // get the Television service if it exists, otherwise create a new Television service
     // you can create multiple services for each accessory
-    const fanService = `${accessory.displayName} Fan`;
-    (this.fanService = accessory.getService(this.hap.Service.Fanv2)
-      || accessory.addService(this.hap.Service.Fanv2)), fanService;
+    const FanService = `${accessory.displayName} Fan`;
+    (this.Fan.Service = accessory.getService(this.hap.Service.Fanv2)
+      || accessory.addService(this.hap.Service.Fanv2)), FanService;
 
-    this.fanService.setCharacteristic(this.hap.Characteristic.Name, accessory.displayName);
+    this.Fan.Service.setCharacteristic(this.hap.Characteristic.Name, accessory.displayName);
 
     // handle on / off events using the Active characteristic
-    this.fanService.getCharacteristic(this.hap.Characteristic.Active).onSet(this.ActiveSet.bind(this));
+    this.Fan.Service.getCharacteristic(this.hap.Characteristic.Active).onSet(this.ActiveSet.bind(this));
 
     if (device.irfan?.rotation_speed) {
       if (device.irfan?.set_minStep) {
@@ -71,7 +72,7 @@ export class Fan extends irdeviceBase {
         this.maxValue = 100;
       }
       // handle Rotation Speed events using the RotationSpeed characteristic
-      this.fanService
+      this.Fan.Service
         .getCharacteristic(this.hap.Characteristic.RotationSpeed)
         .setProps({
           minStep: this.minStep,
@@ -79,9 +80,9 @@ export class Fan extends irdeviceBase {
           maxValue: this.maxValue,
         })
         .onSet(this.RotationSpeedSet.bind(this));
-    } else if (this.fanService.testCharacteristic(this.hap.Characteristic.RotationSpeed) && !device.irfan?.swing_mode) {
-      const characteristic = this.fanService.getCharacteristic(this.hap.Characteristic.RotationSpeed);
-      this.fanService.removeCharacteristic(characteristic);
+    } else if (this.Fan.Service.testCharacteristic(this.hap.Characteristic.RotationSpeed) && !device.irfan?.swing_mode) {
+      const characteristic = this.Fan.Service.getCharacteristic(this.hap.Characteristic.RotationSpeed);
+      this.Fan.Service.removeCharacteristic(characteristic);
       this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Rotation Speed Characteristic was removed.`);
     } else {
       // eslint-disable-next-line max-len
@@ -93,10 +94,10 @@ export class Fan extends irdeviceBase {
 
     if (device.irfan?.swing_mode) {
       // handle Osolcation events using the SwingMode characteristic
-      this.fanService.getCharacteristic(this.hap.Characteristic.SwingMode).onSet(this.SwingModeSet.bind(this));
-    } else if (this.fanService.testCharacteristic(this.hap.Characteristic.SwingMode) && !device.irfan?.swing_mode) {
-      const characteristic = this.fanService.getCharacteristic(this.hap.Characteristic.SwingMode);
-      this.fanService.removeCharacteristic(characteristic);
+      this.Fan.Service.getCharacteristic(this.hap.Characteristic.SwingMode).onSet(this.SwingModeSet.bind(this));
+    } else if (this.Fan.Service.testCharacteristic(this.hap.Characteristic.SwingMode) && !device.irfan?.swing_mode) {
+      const characteristic = this.Fan.Service.getCharacteristic(this.hap.Characteristic.SwingMode);
+      this.Fan.Service.removeCharacteristic(characteristic);
       this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Swing Mode Characteristic was removed.`);
     } else {
       // eslint-disable-next-line max-len
@@ -109,38 +110,38 @@ export class Fan extends irdeviceBase {
 
   async SwingModeSet(value: CharacteristicValue): Promise<void> {
     this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} SwingMode: ${value}`);
-    if (value > this.SwingMode) {
-      this.SwingMode = 1;
+    if (value > this.Fan.SwingMode) {
+      this.Fan.SwingMode = 1;
       await this.pushFanOnChanges();
       await this.pushFanSwingChanges();
     } else {
-      this.SwingMode = 0;
+      this.Fan.SwingMode = 0;
       await this.pushFanOnChanges();
       await this.pushFanSwingChanges();
     }
-    this.SwingMode = value;
-    this.accessory.context.SwingMode = this.SwingMode;
+    this.Fan.SwingMode = value;
+    this.accessory.context.SwingMode = this.Fan.SwingMode;
   }
 
   async RotationSpeedSet(value: CharacteristicValue): Promise<void> {
     this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} RotationSpeed: ${value}`);
-    if (value > this.RotationSpeed) {
-      this.RotationSpeed = 1;
+    if (value > this.Fan.RotationSpeed) {
+      this.Fan.RotationSpeed = 1;
       this.pushFanSpeedUpChanges();
       this.pushFanOnChanges();
     } else {
-      this.RotationSpeed = 0;
+      this.Fan.RotationSpeed = 0;
       this.pushFanSpeedDownChanges();
     }
-    this.RotationSpeed = value;
-    this.accessory.context.RotationSpeed = this.RotationSpeed;
+    this.Fan.RotationSpeed = value;
+    this.accessory.context.RotationSpeed = this.Fan.RotationSpeed;
   }
 
   async ActiveSet(value: CharacteristicValue): Promise<void> {
     this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Active: ${value}`);
 
-    this.Active = value;
-    if (this.Active === this.hap.Characteristic.Active.ACTIVE) {
+    this.Fan.Active = value;
+    if (this.Fan.Active === this.hap.Characteristic.Active.ACTIVE) {
       this.pushFanOnChanges();
     } else {
       this.pushFanOffChanges();
@@ -157,10 +158,9 @@ export class Fan extends irdeviceBase {
    * Fan -        "command"       "highSpeed"      "default"	        =        fan speed to high
    */
   async pushFanOnChanges(): Promise<void> {
-    this.debugLog(
-      `${this.device.remoteType}: ${this.accessory.displayName} pushFanOnChanges Active: ${this.Active},` + ` disablePushOn: ${this.disablePushOn}`,
-    );
-    if (this.Active === this.hap.Characteristic.Active.ACTIVE && !this.disablePushOn) {
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushFanOnChanges Active: ${this.Fan.Active},`
+      + ` disablePushOn: ${this.disablePushOn}`);
+    if (this.Fan.Active === this.hap.Characteristic.Active.ACTIVE && !this.disablePushOn) {
       const commandType: string = await this.commandType();
       const command: string = await this.commandOn();
       const bodyChange = JSON.stringify({
@@ -174,10 +174,10 @@ export class Fan extends irdeviceBase {
 
   async pushFanOffChanges(): Promise<void> {
     this.debugLog(
-      `${this.device.remoteType}: ${this.accessory.displayName} pushLightOffChanges Active: ${this.Active},` +
+      `${this.device.remoteType}: ${this.accessory.displayName} pushLightOffChanges Active: ${this.Fan.Active},` +
       ` disablePushOff: ${this.disablePushOff}`,
     );
-    if (this.Active === this.hap.Characteristic.Active.INACTIVE && !this.disablePushOff) {
+    if (this.Fan.Active === this.hap.Characteristic.Active.INACTIVE && !this.disablePushOff) {
       const commandType: string = await this.commandType();
       const command: string = await this.commandOff();
       const bodyChange = JSON.stringify({
@@ -255,32 +255,32 @@ export class Fan extends irdeviceBase {
   }
 
   async updateHomeKitCharacteristics(): Promise<void> {
-    if (this.Active === undefined) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Active: ${this.Active}`);
+    if (this.Fan.Active === undefined) {
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Active: ${this.Fan.Active}`);
     } else {
-      this.accessory.context.Active = this.Active;
-      this.fanService?.updateCharacteristic(this.hap.Characteristic.Active, this.Active);
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic Active: ${this.Active}`);
+      this.accessory.context.Active = this.Fan.Active;
+      this.Fan.Service?.updateCharacteristic(this.hap.Characteristic.Active, this.Fan.Active);
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic Active: ${this.Fan.Active}`);
     }
-    if (this.SwingMode === undefined) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} SwingMode: ${this.SwingMode}`);
+    if (this.Fan.SwingMode === undefined) {
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} SwingMode: ${this.Fan.SwingMode}`);
     } else {
-      this.accessory.context.SwingMode = this.SwingMode;
-      this.fanService?.updateCharacteristic(this.hap.Characteristic.SwingMode, this.SwingMode);
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic SwingMode: ${this.SwingMode}`);
+      this.accessory.context.SwingMode = this.Fan.SwingMode;
+      this.Fan.Service?.updateCharacteristic(this.hap.Characteristic.SwingMode, this.Fan.SwingMode);
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic SwingMode: ${this.Fan.SwingMode}`);
     }
-    if (this.RotationSpeed === undefined) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} RotationSpeed: ${this.RotationSpeed}`);
+    if (this.Fan.RotationSpeed === undefined) {
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} RotationSpeed: ${this.Fan.RotationSpeed}`);
     } else {
-      this.accessory.context.RotationSpeed = this.RotationSpeed;
-      this.fanService?.updateCharacteristic(this.hap.Characteristic.RotationSpeed, this.RotationSpeed);
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic RotationSpeed: ${this.RotationSpeed}`);
+      this.accessory.context.RotationSpeed = this.Fan.RotationSpeed;
+      this.Fan.Service?.updateCharacteristic(this.hap.Characteristic.RotationSpeed, this.Fan.RotationSpeed);
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic RotationSpeed: ${this.Fan.RotationSpeed}`);
     }
   }
 
   async apiError(e: any): Promise<void> {
-    this.fanService.updateCharacteristic(this.hap.Characteristic.Active, e);
-    this.fanService.updateCharacteristic(this.hap.Characteristic.RotationSpeed, e);
-    this.fanService.updateCharacteristic(this.hap.Characteristic.SwingMode, e);
+    this.Fan.Service.updateCharacteristic(this.hap.Characteristic.Active, e);
+    this.Fan.Service.updateCharacteristic(this.hap.Characteristic.RotationSpeed, e);
+    this.Fan.Service.updateCharacteristic(this.hap.Characteristic.SwingMode, e);
   }
 }

package/src/irdevice/irdevice.ts

@@ -322,7 +322,7 @@ export abstract class irdeviceBase {
 
   async getDeviceContext(accessory: PlatformAccessory, device: irdevice & irDevicesConfig): Promise<void> {
     accessory.context.name = device.deviceName;
-    accessory.context.model = device.model;
+    accessory.context.model = device.remoteType;
     accessory.context.deviceId = device.deviceId;
     accessory.context.remoteType = device.remoteType;
     if (device.firmware === undefined) {

package/src/irdevice/light.ts

@@ -15,7 +15,11 @@ import { CharacteristicValue, PlatformAccessory, Service } from 'homebridge';
  */
 export class Light extends irdeviceBase {
   // Services
-  lightBulbService?: Service;
+  private LightBulb!: {
+    Service: Service;
+    On: CharacteristicValue;
+  };
+
   ProgrammableSwitchServiceOn?: Service;
   ProgrammableSwitchServiceOff?: Service;
 
@@ -33,25 +37,23 @@ export class Light extends irdeviceBase {
   ) {
     super(platform, accessory, device);
 
-    // default placeholders
-    if (this.On === undefined) {
-      this.On = false;
-    } else {
-      this.On = accessory.context.On;
-    }
-
     if (!device.irlight?.stateless) {
+      // Initialize LightBulb property
+      this.LightBulb = {
+        Service: accessory.getService(this.hap.Service.Lightbulb)!,
+        On: accessory.context.On || false,
+      };
       // get the Light service if it exists, otherwise create a new Light service
       // you can create multiple services for each accessory
-      const lightBulbService = `${accessory.displayName} ${device.remoteType}`;
-      (this.lightBulbService = accessory.getService(this.hap.Service.Lightbulb)
-        || accessory.addService(this.hap.Service.Lightbulb)), lightBulbService;
+      const LightBulbService = `${accessory.displayName} ${device.remoteType}`;
+      (this.LightBulb.Service = accessory.getService(this.hap.Service.Lightbulb)
+        || accessory.addService(this.hap.Service.Lightbulb)), LightBulbService;
 
 
-      this.lightBulbService.setCharacteristic(this.hap.Characteristic.Name, accessory.displayName);
+      this.LightBulb.Service.setCharacteristic(this.hap.Characteristic.Name, accessory.displayName);
 
       // handle on / off events using the On characteristic
-      this.lightBulbService.getCharacteristic(this.hap.Characteristic.On).onSet(this.OnSet.bind(this));
+      this.LightBulb.Service.getCharacteristic(this.hap.Characteristic.On).onSet(this.OnSet.bind(this));
     } else {
 
       // create a new Stateful Programmable Switch On service
@@ -252,7 +254,7 @@ export class Light extends irdeviceBase {
         this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} On: ${this.On}`);
       } else {
         this.accessory.context.On = this.On;
-        this.lightBulbService?.updateCharacteristic(this.hap.Characteristic.On, this.On);
+        this.LightBulb.Service?.updateCharacteristic(this.hap.Characteristic.On, this.On);
         this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic On: ${this.On}`);
       }
     } else {
@@ -283,7 +285,7 @@ export class Light extends irdeviceBase {
 
   async apiError(e: any): Promise<void> {
     if (this.device.irlight?.stateless) {
-      this.lightBulbService?.updateCharacteristic(this.hap.Characteristic.On, e);
+      this.LightBulb.Service?.updateCharacteristic(this.hap.Characteristic.On, e);
     } else {
       this.ProgrammableSwitchServiceOn?.updateCharacteristic(this.hap.Characteristic.ProgrammableSwitchEvent, e);
       this.ProgrammableSwitchServiceOn?.updateCharacteristic(this.hap.Characteristic.ProgrammableSwitchOutputState, e);