@switchbot/homebridge-switchbot 1.11.0 → 1.12.1

package/src/irdevice/airconditioner.ts

@@ -10,7 +10,7 @@ import { CharacteristicValue, PlatformAccessory, Service } from 'homebridge';
  */
 export class AirConditioner {
   // Services
-  service!: Service;
+  coolerService!: Service;
 
   // Characteristic Values
   Active!: CharacteristicValue;
@@ -76,7 +76,7 @@ export class AirConditioner {
 
     // get the Television service if it exists, otherwise create a new Television service
     // you can create multiple services for each accessory
-    (this.service = accessory.getService(this.platform.Service.HeaterCooler) || accessory.addService(this.platform.Service.HeaterCooler)),
+    (this.coolerService = accessory.getService(this.platform.Service.HeaterCooler) || accessory.addService(this.platform.Service.HeaterCooler)),
     `${accessory.displayName} Air Conditioner`;
 
     // To avoid "Cannot add a Service with the same UUID another Service without also defining a unique 'subtype' property." error,
@@ -85,12 +85,12 @@ export class AirConditioner {
 
     // set the service name, this is what is displayed as the default name on the Home app
     // in this example we are using the name we stored in the `accessory.context` in the `discoverDevices` method.
-    this.service.setCharacteristic(this.platform.Characteristic.Name, accessory.displayName);
+    this.coolerService.setCharacteristic(this.platform.Characteristic.Name, accessory.displayName);
 
     // handle on / off events using the Active characteristic
-    this.service.getCharacteristic(this.platform.Characteristic.Active).onSet(this.ActiveSet.bind(this));
+    this.coolerService.getCharacteristic(this.platform.Characteristic.Active).onSet(this.ActiveSet.bind(this));
 
-    this.service
+    this.coolerService
       .getCharacteristic(this.platform.Characteristic.CurrentTemperature)
       .setProps({
         minValue: 0,
@@ -116,7 +116,7 @@ export class AirConditioner {
           ` hide_automode: ${this.hide_automode}, TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}`,
       );
     }
-    this.service
+    this.coolerService
       .getCharacteristic(this.platform.Characteristic.TargetHeaterCoolerState)
       .setProps({
         validValues: this.ValidValues,
@@ -126,11 +126,11 @@ export class AirConditioner {
       })
       .onSet(this.TargetHeaterCoolerStateSet.bind(this));
 
-    this.service.getCharacteristic(this.platform.Characteristic.CurrentHeaterCoolerState).onGet(async () => {
+    this.coolerService.getCharacteristic(this.platform.Characteristic.CurrentHeaterCoolerState).onGet(async () => {
       return this.CurrentHeaterCoolerStateGet();
     });
 
-    this.service
+    this.coolerService
       .getCharacteristic(this.platform.Characteristic.HeatingThresholdTemperature)
       .setProps({
         minValue: 16,
@@ -142,7 +142,7 @@ export class AirConditioner {
       })
       .onSet(this.HeatingThresholdTemperatureSet.bind(this));
 
-    this.service
+    this.coolerService
       .getCharacteristic(this.platform.Characteristic.CoolingThresholdTemperature)
       .setProps({
         minValue: 16,
@@ -154,7 +154,7 @@ export class AirConditioner {
       })
       .onSet(this.CoolingThresholdTemperatureSet.bind(this));
 
-    this.service
+    this.coolerService
       .getCharacteristic(this.platform.Characteristic.RotationSpeed)
       .setProps({
         minStep: 1,
@@ -176,7 +176,7 @@ export class AirConditioner {
    * AirConditioner:        "command"       "middleSpeed"    "default"	        =        fan speed to medium
    * AirConditioner:        "command"       "highSpeed"      "default"	        =        fan speed to high
    */
-  async pushAirConditionerOnChanges() {
+  async pushAirConditionerOnChanges(): Promise<void> {
     if (this.Active !== this.platform.Characteristic.Active.ACTIVE || this.pushOn) {
       const payload = {
         commandType: 'command',
@@ -187,7 +187,7 @@ export class AirConditioner {
     }
   }
 
-  async pushAirConditionerOffChanges() {
+  async pushAirConditionerOffChanges(): Promise<void> {
     const payload = {
       commandType: 'command',
       parameter: 'default',
@@ -196,7 +196,7 @@ export class AirConditioner {
     await this.pushChanges(payload);
   }
 
-  async pushAirConditionerStatusChanges() {
+  async pushAirConditionerStatusChanges(): Promise<void> {
     if (!this.Busy) {
       this.Busy = true;
       this.CurrentHeaterCoolerState = this.platform.Characteristic.CurrentHeaterCoolerState.IDLE;
@@ -207,7 +207,7 @@ export class AirConditioner {
     this.Timeout = setTimeout(this.pushAirConditionerDetailsChanges.bind(this), 1500);
   }
 
-  async pushAirConditionerDetailsChanges() {
+  async pushAirConditionerDetailsChanges(): Promise<void> {
     const payload = {
       commandType: 'command',
       command: 'setAll',
@@ -247,7 +247,7 @@ export class AirConditioner {
     await this.pushChanges(payload);
   }
 
-  public async pushChanges(payload: payload) {
+  async pushChanges(payload: payload): Promise<void> {
     try {
       this.infoLog(
         `Air Conditioner: ${this.accessory.displayName} Sending request to SwitchBot API. command: ${payload.command},` +
@@ -269,17 +269,14 @@ export class AirConditioner {
       this.updateHomeKitCharacteristics();
     } catch (e: any) {
       this.errorLog(`Air Conditioner: ${this.accessory.displayName} failed pushChanges`);
-      if (this.deviceLogging === 'debug') {
+      if (this.deviceLogging.includes('debug')) {
         this.errorLog(`Air Conditioner: ${this.accessory.displayName} failed pushChanges,` + ` Error Message: ${JSON.stringify(e.message)}`);
       }
-      if (this.platform.debugMode) {
-        this.errorLog(`Air Conditioner: ${this.accessory.displayName} failed pushChanges,` + ` Error: ${JSON.stringify(e)}`);
-      }
       this.apiError(e);
     }
   }
 
-  statusCode(push: AxiosResponse<{ statusCode: number }>) {
+  async statusCode(push: AxiosResponse<{ statusCode: number }>): Promise<void> {
     switch (push.data.statusCode) {
       case 151:
         this.errorLog(`Air Conditioner: ${this.accessory.displayName} Command not supported by this device type.`);
@@ -310,29 +307,29 @@ export class AirConditioner {
     }
   }
 
-  updateHomeKitCharacteristics() {
+  async updateHomeKitCharacteristics(): Promise<void> {
     if (this.Active === undefined) {
       this.debugLog(`Air Conditioner: ${this.accessory.displayName} Active: ${this.Active}`);
     } else {
-      this.service?.updateCharacteristic(this.platform.Characteristic.Active, this.Active);
+      this.coolerService?.updateCharacteristic(this.platform.Characteristic.Active, this.Active);
       this.debugLog(`Air Conditioner: ${this.accessory.displayName} updateCharacteristic Active: ${this.Active}`);
     }
     if (this.RotationSpeed === undefined) {
       this.debugLog(`Air Conditioner: ${this.accessory.displayName} RotationSpeed: ${this.RotationSpeed}`);
     } else {
-      this.service?.updateCharacteristic(this.platform.Characteristic.RotationSpeed, this.RotationSpeed);
+      this.coolerService?.updateCharacteristic(this.platform.Characteristic.RotationSpeed, this.RotationSpeed);
       this.debugLog(`Air Conditioner: ${this.accessory.displayName} updateCharacteristic RotationSpeed: ${this.RotationSpeed}`);
     }
     if (this.CurrentTemperature === undefined) {
       this.debugLog(`Air Conditioner: ${this.accessory.displayName} CurrentTemperature: ${this.CurrentTemperature}`);
     } else {
-      this.service?.updateCharacteristic(this.platform.Characteristic.CurrentTemperature, this.CurrentTemperature);
+      this.coolerService?.updateCharacteristic(this.platform.Characteristic.CurrentTemperature, this.CurrentTemperature);
       this.debugLog(`Air Conditioner: ${this.accessory.displayName} updateCharacteristic CurrentTemperature: ${this.CurrentTemperature}`);
     }
     if (this.TargetHeaterCoolerState === undefined) {
       this.debugLog(`Air Conditioner: ${this.accessory.displayName} TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}`);
     } else {
-      this.service?.updateCharacteristic(this.platform.Characteristic.TargetHeaterCoolerState, this.TargetHeaterCoolerState);
+      this.coolerService?.updateCharacteristic(this.platform.Characteristic.TargetHeaterCoolerState, this.TargetHeaterCoolerState);
       this.debugLog(
         `Air Conditioner: ${this.accessory.displayName}` + ` updateCharacteristic TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}`,
       );
@@ -340,7 +337,7 @@ export class AirConditioner {
     if (this.CurrentHeaterCoolerState === undefined) {
       this.debugLog(`Air Conditioner: ${this.accessory.displayName} CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`);
     } else {
-      this.service?.updateCharacteristic(this.platform.Characteristic.CurrentHeaterCoolerState, this.CurrentHeaterCoolerState);
+      this.coolerService?.updateCharacteristic(this.platform.Characteristic.CurrentHeaterCoolerState, this.CurrentHeaterCoolerState);
       this.debugLog(
         `Air Conditioner: ${this.accessory.displayName}` + ` updateCharacteristic CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`,
       );
@@ -348,7 +345,7 @@ export class AirConditioner {
     if (this.HeatingThresholdTemperature === undefined) {
       this.debugLog(`Air Conditioner: ${this.accessory.displayName} HeatingThresholdTemperature: ${this.HeatingThresholdTemperature}`);
     } else {
-      this.service?.updateCharacteristic(this.platform.Characteristic.HeatingThresholdTemperature, this.HeatingThresholdTemperature);
+      this.coolerService?.updateCharacteristic(this.platform.Characteristic.HeatingThresholdTemperature, this.HeatingThresholdTemperature);
       this.debugLog(
         `Air Conditioner: ${this.accessory.displayName}` + ` updateCharacteristic HeatingThresholdTemperature: ${this.HeatingThresholdTemperature}`,
       );
@@ -356,25 +353,25 @@ export class AirConditioner {
     if (this.CoolingThresholdTemperature === undefined) {
       this.debugLog(`Air Conditioner: ${this.accessory.displayName} CoolingThresholdTemperature: ${this.CoolingThresholdTemperature}`);
     } else {
-      this.service?.updateCharacteristic(this.platform.Characteristic.CoolingThresholdTemperature, this.CoolingThresholdTemperature);
+      this.coolerService?.updateCharacteristic(this.platform.Characteristic.CoolingThresholdTemperature, this.CoolingThresholdTemperature);
       this.debugLog(
         `Air Conditioner: ${this.accessory.displayName}` + ` updateCharacteristic CoolingThresholdTemperature: ${this.CoolingThresholdTemperature}`,
       );
     }
   }
 
-  public apiError(e: any) {
-    this.service.updateCharacteristic(this.platform.Characteristic.Active, e);
-    this.service.updateCharacteristic(this.platform.Characteristic.RotationSpeed, e);
-    this.service.updateCharacteristic(this.platform.Characteristic.CurrentTemperature, e);
-    this.service.updateCharacteristic(this.platform.Characteristic.TargetHeaterCoolerState, e);
-    this.service.updateCharacteristic(this.platform.Characteristic.CurrentHeaterCoolerState, e);
-    this.service.updateCharacteristic(this.platform.Characteristic.HeatingThresholdTemperature, e);
-    this.service.updateCharacteristic(this.platform.Characteristic.CoolingThresholdTemperature, e);
+  async apiError(e: any): Promise<void> {
+    this.coolerService.updateCharacteristic(this.platform.Characteristic.Active, e);
+    this.coolerService.updateCharacteristic(this.platform.Characteristic.RotationSpeed, e);
+    this.coolerService.updateCharacteristic(this.platform.Characteristic.CurrentTemperature, e);
+    this.coolerService.updateCharacteristic(this.platform.Characteristic.TargetHeaterCoolerState, e);
+    this.coolerService.updateCharacteristic(this.platform.Characteristic.CurrentHeaterCoolerState, e);
+    this.coolerService.updateCharacteristic(this.platform.Characteristic.HeatingThresholdTemperature, e);
+    this.coolerService.updateCharacteristic(this.platform.Characteristic.CoolingThresholdTemperature, e);
     //throw new this.platform.api.hap.HapStatusError(HAPStatus.SERVICE_COMMUNICATION_FAILURE);
   }
 
-  CurrentTemperatureGet() {
+  async CurrentTemperatureGet(): Promise<CharacteristicValue> {
     if (this.CurrentTemperature === undefined) {
       this.CurrentTemperature = 24;
       this.CurrentTemperatureCached = this.CurrentTemperature;
@@ -386,7 +383,7 @@ export class AirConditioner {
     return this.CurrentTemperature;
   }
 
-  RotationSpeedGet() {
+  async RotationSpeedGet(): Promise<number> {
     if (!this.CurrentFanSpeed) {
       this.RotationSpeed = 4;
     } else if (this.CurrentFanSpeed === 1) {
@@ -400,7 +397,7 @@ export class AirConditioner {
     return this.RotationSpeed;
   }
 
-  RotationSpeedSet(value: CharacteristicValue) {
+  async RotationSpeedSet(value: CharacteristicValue): Promise<void> {
     if (value === 4) {
       this.CurrentFanSpeed = 1;
     } else {
@@ -412,7 +409,7 @@ export class AirConditioner {
     this.pushAirConditionerStatusChanges();
   }
 
-  ActiveSet(value: CharacteristicValue) {
+  async ActiveSet(value: CharacteristicValue): Promise<void> {
     this.debugLog(`Air Conditioner: ${this.accessory.displayName} Set Active: ${value}`);
 
     this.Active = value;
@@ -432,7 +429,7 @@ export class AirConditioner {
     }
   }
 
-  TargetHeaterCoolerStateGet() {
+  async TargetHeaterCoolerStateGet(): Promise<CharacteristicValue> {
     if (this.ValidValues === [0, 1, 2]) {
       this.TargetHeaterCoolerState = this.platform.Characteristic.TargetHeaterCoolerState.AUTO;
       this.debugLog(
@@ -457,7 +454,7 @@ export class AirConditioner {
     return this.TargetHeaterCoolerState;
   }
 
-  TargetHeaterCoolerStateSet(value: CharacteristicValue) {
+  async TargetHeaterCoolerStateSet(value: CharacteristicValue): Promise<void> {
     if (this.hide_automode) {
       if (value === this.platform.Characteristic.TargetHeaterCoolerState.HEAT) {
         this.TargetHeaterCoolerStateHEAT();
@@ -488,28 +485,28 @@ export class AirConditioner {
     this.pushAirConditionerStatusChanges();
   }
 
-  private TargetHeaterCoolerStateAUTO() {
+  async TargetHeaterCoolerStateAUTO(): Promise<void> {
     this.TargetHeaterCoolerState = this.platform.Characteristic.TargetHeaterCoolerState.AUTO;
     this.CurrentMode = 1;
     this.debugLog(`Air Conditioner: ${this.accessory.displayName} Set (AUTO) TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}`);
     this.debugLog(`Air Conditioner: ${this.accessory.displayName} Switchbot CurrentMode: ${this.CurrentMode}`);
   }
 
-  private TargetHeaterCoolerStateCOOL() {
+  async TargetHeaterCoolerStateCOOL(): Promise<void> {
     this.TargetHeaterCoolerState = this.platform.Characteristic.TargetHeaterCoolerState.COOL;
     this.CurrentMode = 2;
     this.debugLog(`Air Conditioner: ${this.accessory.displayName} Set (COOL) TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}`);
     this.debugLog(`Air Conditioner: ${this.accessory.displayName} Switchbot CurrentMode: ${this.CurrentMode}`);
   }
 
-  private TargetHeaterCoolerStateHEAT() {
+  async TargetHeaterCoolerStateHEAT(): Promise<void> {
     this.TargetHeaterCoolerState = this.platform.Characteristic.TargetHeaterCoolerState.HEAT;
     this.CurrentMode = 5;
     this.debugLog(`Air Conditioner: ${this.accessory.displayName} Set (HEAT) TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}`);
     this.debugLog(`Air Conditioner: ${this.accessory.displayName} Switchbot CurrentMode: ${this.CurrentMode}`);
   }
 
-  CurrentHeaterCoolerStateGet() {
+  async CurrentHeaterCoolerStateGet(): Promise<CharacteristicValue> {
     if (this.Active === this.platform.Characteristic.Active.ACTIVE) {
       this.CurrentTemperatureUndefined();
       if (this.CurrentTemperature < this.CurrentTemperatureCached) {
@@ -528,7 +525,7 @@ export class AirConditioner {
     return this.CurrentHeaterCoolerState;
   }
 
-  private HeatingThresholdTemperatureGet() {
+  async HeatingThresholdTemperatureGet(): Promise<CharacteristicValue> {
     this.CurrentTemperatureUndefined;
     this.CurrentTemperature = this.CurrentTemperatureCached;
     this.HeatingThresholdTemperature = this.CurrentTemperatureCached;
@@ -538,7 +535,7 @@ export class AirConditioner {
     return this.HeatingThresholdTemperature;
   }
 
-  private HeatingThresholdTemperatureSet(value: CharacteristicValue) {
+  async HeatingThresholdTemperatureSet(value: CharacteristicValue): Promise<void> {
     this.CurrentTemperatureCached = this.CurrentTemperature;
     this.CurrentTemperature = value;
     this.HeatingThresholdTemperatureCached = this.HeatingThresholdTemperature;
@@ -550,7 +547,7 @@ export class AirConditioner {
     this.pushAirConditionerStatusChanges();
   }
 
-  private CoolingThresholdTemperatureGet() {
+  async CoolingThresholdTemperatureGet(): Promise<CharacteristicValue> {
     this.CurrentTemperatureUndefined;
     this.CurrentTemperature = this.CurrentTemperatureCached;
     this.CoolingThresholdTemperature = this.CurrentTemperatureCached;
@@ -560,7 +557,7 @@ export class AirConditioner {
     return this.CoolingThresholdTemperature;
   }
 
-  private CoolingThresholdTemperatureSet(value: CharacteristicValue) {
+  async CoolingThresholdTemperatureSet(value: CharacteristicValue): Promise<void> {
     this.CurrentTemperatureCached = this.CurrentTemperature;
     this.CurrentTemperature = value;
     this.CoolingThresholdTemperatureCached = this.CoolingThresholdTemperature;
@@ -572,7 +569,7 @@ export class AirConditioner {
     this.pushAirConditionerStatusChanges();
   }
 
-  private CurrentTemperatureUndefined() {
+  async CurrentTemperatureUndefined(): Promise<void> {
     if (this.CurrentTemperature === undefined) {
       this.CurrentTemperature = 24;
     }
@@ -581,7 +578,7 @@ export class AirConditioner {
     }
   }
 
-  config(device: irdevice & irDevicesConfig) {
+  async config(device: irdevice & irDevicesConfig): Promise<void> {
     let config = {};
     if (device.irair) {
       config = device.irair;
@@ -590,11 +587,11 @@ export class AirConditioner {
       config['logging'] = device.logging;
     }
     if (Object.entries(config).length !== 0) {
-      this.warnLog(`Air Conditioner: ${this.accessory.displayName} Config: ${JSON.stringify(config)}`);
+      this.infoLog(`Air Conditioner: ${this.accessory.displayName} Config: ${JSON.stringify(config)}`);
     }
   }
 
-  logs(device: irdevice & irDevicesConfig) {
+  async logs(device: irdevice & irDevicesConfig): Promise<void> {
     if (this.platform.debugMode) {
       this.deviceLogging = this.accessory.context.logging = 'debugMode';
       this.debugLog(`Air Conditioner: ${this.accessory.displayName} Using Debug Mode Logging: ${this.deviceLogging}`);
@@ -611,7 +608,7 @@ export class AirConditioner {
   }
 
 
-  pushOnChanges(device: irdevice & irDevicesConfig) {
+  async pushOnChanges(device: irdevice & irDevicesConfig): Promise<void> {
     if (device.irair?.pushOn) {
       this.pushOn = true;
     } else {
@@ -622,25 +619,25 @@ export class AirConditioner {
   /**
    * Logging for Device
    */
-  infoLog(...log: any[]) {
+  infoLog(...log: any[]): void {
     if (this.enablingDeviceLogging()) {
       this.platform.log.info(String(...log));
     }
   }
 
-  warnLog(...log: any[]) {
+  warnLog(...log: any[]): void {
     if (this.enablingDeviceLogging()) {
       this.platform.log.warn(String(...log));
     }
   }
 
-  errorLog(...log: any[]) {
+  errorLog(...log: any[]): void {
     if (this.enablingDeviceLogging()) {
       this.platform.log.error(String(...log));
     }
   }
 
-  debugLog(...log: any[]) {
+  debugLog(...log: any[]): void {
     if (this.enablingDeviceLogging()) {
       if (this.deviceLogging === 'debug') {
         this.platform.log.info('[DEBUG]', String(...log));
@@ -651,6 +648,6 @@ export class AirConditioner {
   }
 
   enablingDeviceLogging(): boolean {
-    return this.deviceLogging === 'debug' || this.deviceLogging === 'standard';
+    return this.deviceLogging.includes('debug') || this.deviceLogging === 'standard';
   }
 }

package/src/irdevice/airpurifier.ts

@@ -10,7 +10,7 @@ import { CharacteristicValue, PlatformAccessory, Service } from 'homebridge';
  */
 export class AirPurifier {
   // Services
-  service!: Service;
+  airPurifierService!: Service;
 
   // Characteristic Values
   Active!: CharacteristicValue;
@@ -62,7 +62,7 @@ export class AirPurifier {
 
     // get the Television service if it exists, otherwise create a new Television service
     // you can create multiple services for each accessory
-    (this.service = accessory.getService(this.platform.Service.AirPurifier) || accessory.addService(this.platform.Service.AirPurifier)),
+    (this.airPurifierService = accessory.getService(this.platform.Service.AirPurifier) || accessory.addService(this.platform.Service.AirPurifier)),
     `${accessory.displayName} Air Purifier`;
 
     // To avoid "Cannot add a Service with the same UUID another Service without also defining a unique 'subtype' property." error,
@@ -71,19 +71,19 @@ export class AirPurifier {
 
     // set the service name, this is what is displayed as the default name on the Home app
     // in this example we are using the name we stored in the `accessory.context` in the `discoverDevices` method.
-    this.service.setCharacteristic(this.platform.Characteristic.Name, accessory.displayName);
+    this.airPurifierService.setCharacteristic(this.platform.Characteristic.Name, accessory.displayName);
 
     // handle on / off events using the Active characteristic
-    this.service.getCharacteristic(this.platform.Characteristic.Active).onSet(this.ActiveSet.bind(this));
+    this.airPurifierService.getCharacteristic(this.platform.Characteristic.Active).onSet(this.ActiveSet.bind(this));
 
-    this.service.getCharacteristic(this.platform.Characteristic.CurrentAirPurifierState).onGet(() => {
+    this.airPurifierService.getCharacteristic(this.platform.Characteristic.CurrentAirPurifierState).onGet(() => {
       return this.CurrentAirPurifierStateGet();
     });
 
-    this.service.getCharacteristic(this.platform.Characteristic.TargetAirPurifierState).onSet(this.TargetAirPurifierStateSet.bind(this));
+    this.airPurifierService.getCharacteristic(this.platform.Characteristic.TargetAirPurifierState).onSet(this.TargetAirPurifierStateSet.bind(this));
   }
 
-  private ActiveSet(value: CharacteristicValue) {
+  async ActiveSet(value: CharacteristicValue): Promise<void> {
     this.debugLog(`Air Purifier: ${this.accessory.displayName} Set Active: ${value}`);
     if (value === this.platform.Characteristic.Active.INACTIVE) {
       this.pushAirPurifierOffChanges();
@@ -95,30 +95,30 @@ export class AirPurifier {
     this.accessory.context.Active = this.ActiveCached;
   }
 
-  private updateHomeKitCharacteristics() {
+  async updateHomeKitCharacteristics(): Promise<void> {
     if (this.Active === undefined) {
       this.debugLog(`Air Purifier: ${this.accessory.displayName} Active: ${this.Active}`);
     } else {
-      this.service?.updateCharacteristic(this.platform.Characteristic.Active, this.Active);
+      this.airPurifierService?.updateCharacteristic(this.platform.Characteristic.Active, this.Active);
       this.debugLog(`Air Purifier: ${this.accessory.displayName} updateCharacteristic Active: ${this.Active}`);
     }
     if (this.CurrentAirPurifierState === undefined) {
       this.debugLog(`Air Purifier: ${this.accessory.displayName} CurrentAirPurifierState: ${this.CurrentAirPurifierState}`);
     } else {
-      this.service?.updateCharacteristic(this.platform.Characteristic.CurrentAirPurifierState, this.CurrentAirPurifierState);
+      this.airPurifierService?.updateCharacteristic(this.platform.Characteristic.CurrentAirPurifierState, this.CurrentAirPurifierState);
       this.debugLog(`Air Purifier: ${this.accessory.displayName}` + ` updateCharacteristic CurrentAirPurifierState: ${this.CurrentAirPurifierState}`);
     }
     if (this.CurrentHeaterCoolerState === undefined) {
       this.debugLog(`Air Purifier: ${this.accessory.displayName} CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`);
     } else {
-      this.service?.updateCharacteristic(this.platform.Characteristic.CurrentHeaterCoolerState, this.CurrentHeaterCoolerState);
+      this.airPurifierService?.updateCharacteristic(this.platform.Characteristic.CurrentHeaterCoolerState, this.CurrentHeaterCoolerState);
       this.debugLog(
         `Air Purifier: ${this.accessory.displayName}` + ` updateCharacteristic CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`,
       );
     }
   }
 
-  private TargetAirPurifierStateSet(value: CharacteristicValue) {
+  async TargetAirPurifierStateSet(value: CharacteristicValue): Promise<void> {
     switch (value) {
       case this.platform.Characteristic.CurrentAirPurifierState.PURIFYING_AIR:
         this.CurrentMode = AirPurifier.PURIFYING_AIR;
@@ -134,7 +134,7 @@ export class AirPurifier {
     }
   }
 
-  private CurrentAirPurifierStateGet() {
+  async CurrentAirPurifierStateGet(): Promise<number> {
     if (this.Active === 1) {
       this.CurrentAirPurifierState = this.platform.Characteristic.CurrentAirPurifierState.PURIFYING_AIR;
     } else {
@@ -154,7 +154,7 @@ export class AirPurifier {
    * AirPurifier:        "command"       "middleSpeed"    "default"	        =        fan speed to medium
    * AirPurifier:        "command"       "highSpeed"      "default"	        =        fan speed to high
    */
-  async pushAirPurifierOnChanges() {
+  async pushAirPurifierOnChanges(): Promise<void> {
     if (this.Active !== 1) {
       const payload = {
         commandType: 'command',
@@ -165,7 +165,7 @@ export class AirPurifier {
     }
   }
 
-  async pushAirPurifierOffChanges() {
+  async pushAirPurifierOffChanges(): Promise<void> {
     if (this.Active !== 0) {
       const payload = {
         commandType: 'command',
@@ -176,7 +176,7 @@ export class AirPurifier {
     }
   }
 
-  async pushAirConditionerStatusChanges() {
+  async pushAirConditionerStatusChanges(): Promise<void> {
     if (!this.Busy) {
       this.Busy = true;
       this.CurrentHeaterCoolerState = this.platform.Characteristic.CurrentHeaterCoolerState.IDLE;
@@ -187,7 +187,7 @@ export class AirPurifier {
     this.Timeout = setTimeout(this.pushAirConditionerDetailsChanges.bind(this), 1500);
   }
 
-  async pushAirConditionerDetailsChanges() {
+  async pushAirConditionerDetailsChanges(): Promise<void> {
     const payload = {
       commandType: 'command',
       command: 'setAll',
@@ -212,7 +212,7 @@ export class AirPurifier {
     await this.pushChanges(payload);
   }
 
-  public async pushChanges(payload: payload) {
+  async pushChanges(payload: payload): Promise<void> {
     try {
       this.infoLog(
         `Air Purifier: ${this.accessory.displayName} Sending request to SwitchBot API. command: ${payload.command},` +
@@ -228,19 +228,16 @@ export class AirPurifier {
       this.accessory.context.CurrentTemperature = this.CurrentTemperatureCached;
     } catch (e: any) {
       this.errorLog(`Air Purifier: ${this.accessory.displayName} failed pushChanges with OpenAPI Connection`);
-      if (this.deviceLogging === 'debug') {
+      if (this.deviceLogging.includes('debug')) {
         this.errorLog(
           `Air Purifier: ${this.accessory.displayName} failed pushChanges with OpenAPI Connection,` + ` Error Message: ${JSON.stringify(e.message)}`,
         );
       }
-      if (this.platform.debugMode) {
-        this.errorLog(`Air Purifier: ${this.accessory.displayName} failed pushChanges with OpenAPI Connection,` + ` Error: ${JSON.stringify(e)}`);
-      }
       this.apiError(e);
     }
   }
 
-  private statusCode(push: AxiosResponse<{ statusCode: number }>) {
+  async statusCode(push: AxiosResponse<{ statusCode: number }>): Promise<void> {
     switch (push.data.statusCode) {
       case 151:
         this.errorLog(`Air Purifier: ${this.accessory.displayName} Command not supported by this device type.`);
@@ -271,15 +268,15 @@ export class AirPurifier {
     }
   }
 
-  public apiError(e: any) {
-    this.service.updateCharacteristic(this.platform.Characteristic.CurrentHeaterCoolerState, e);
-    this.service.updateCharacteristic(this.platform.Characteristic.CurrentAirPurifierState, e);
-    this.service.updateCharacteristic(this.platform.Characteristic.TargetAirPurifierState, e);
-    this.service.updateCharacteristic(this.platform.Characteristic.Active, e);
+  async apiError(e: any): Promise<void> {
+    this.airPurifierService.updateCharacteristic(this.platform.Characteristic.CurrentHeaterCoolerState, e);
+    this.airPurifierService.updateCharacteristic(this.platform.Characteristic.CurrentAirPurifierState, e);
+    this.airPurifierService.updateCharacteristic(this.platform.Characteristic.TargetAirPurifierState, e);
+    this.airPurifierService.updateCharacteristic(this.platform.Characteristic.Active, e);
     //throw new this.platform.api.hap.HapStatusError(HAPStatus.SERVICE_COMMUNICATION_FAILURE);
   }
 
-  config(device: irdevice & irDevicesConfig) {
+  async config(device: irdevice & irDevicesConfig): Promise<void> {
     let config = {};
     if (device.irpur) {
       config = device.irpur;
@@ -288,11 +285,11 @@ export class AirPurifier {
       config['logging'] = device.logging;
     }
     if (Object.entries(config).length !== 0) {
-      this.warnLog(`Air Purifier: ${this.accessory.displayName} Config: ${JSON.stringify(config)}`);
+      this.infoLog(`Air Purifier: ${this.accessory.displayName} Config: ${JSON.stringify(config)}`);
     }
   }
 
-  logs(device: irdevice & irDevicesConfig) {
+  async logs(device: irdevice & irDevicesConfig): Promise<void> {
     if (this.platform.debugMode) {
       this.deviceLogging = this.accessory.context.logging = 'debugMode';
       this.debugLog(`Air Purifier: ${this.accessory.displayName} Using Debug Mode Logging: ${this.deviceLogging}`);
@@ -311,25 +308,25 @@ export class AirPurifier {
   /**
    * Logging for Device
    */
-  infoLog(...log: any[]) {
+  infoLog(...log: any[]): void {
     if (this.enablingDeviceLogging()) {
       this.platform.log.info(String(...log));
     }
   }
 
-  warnLog(...log: any[]) {
+  warnLog(...log: any[]): void {
     if (this.enablingDeviceLogging()) {
       this.platform.log.warn(String(...log));
     }
   }
 
-  errorLog(...log: any[]) {
+  errorLog(...log: any[]): void {
     if (this.enablingDeviceLogging()) {
       this.platform.log.error(String(...log));
     }
   }
 
-  debugLog(...log: any[]) {
+  debugLog(...log: any[]): void {
     if (this.enablingDeviceLogging()) {
       if (this.deviceLogging === 'debug') {
         this.platform.log.info('[DEBUG]', String(...log));
@@ -340,6 +337,6 @@ export class AirPurifier {
   }
 
   enablingDeviceLogging(): boolean {
-    return this.deviceLogging === 'debug' || this.deviceLogging === 'standard';
+    return this.deviceLogging.includes('debug') || this.deviceLogging === 'standard';
   }
 }