@switchbot/homebridge-switchbot 3.5.1-beta.8 → 3.5.1

package/src/irdevice/airconditioner.ts

@@ -28,6 +28,7 @@ export class AirConditioner extends irdeviceBase {
   };
 
   meter?: PlatformAccessory;
+
   private HumiditySensor?: {
     Name: CharacteristicValue;
     Service: Service;
@@ -55,13 +56,14 @@ export class AirConditioner extends irdeviceBase {
     device: irdevice & irDevicesConfig,
   ) {
     super(platform, accessory, device);
+    // Set category
+    accessory.category = this.hap.Categories.AIR_CONDITIONER;
 
     // default placeholders
     this.getAirConditionerConfigSettings(accessory, device);
 
     this.ValidValues = this.hide_automode ? [1, 2] : [0, 1, 2];
 
-
     // Initialize HeaterCooler Service
     accessory.context.HeaterCooler = accessory.context.HeaterCooler ?? {};
     this.HeaterCooler = {
@@ -181,7 +183,7 @@ export class AirConditioner extends irdeviceBase {
    * AirConditioner:        "command"       "highSpeed"      "default"	        =        fan speed to high
    */
   async pushAirConditionerOnChanges(): Promise<void> {
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirConditionerOnChanges Active: ${this.HeaterCooler.Active},`
+    await this.debugLog(`pushAirConditionerOnChanges Active: ${this.HeaterCooler.Active},`
       + ` disablePushOn: ${this.disablePushOn}`);
     if (this.HeaterCooler.Active === this.hap.Characteristic.Active.ACTIVE && !this.disablePushOn) {
       const commandType: string = await this.commandType();
@@ -196,7 +198,7 @@ export class AirConditioner extends irdeviceBase {
   }
 
   async pushAirConditionerOffChanges(): Promise<void> {
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirConditionerOffChanges Active: ${this.HeaterCooler.Active},`
+    await this.debugLog(`pushAirConditionerOffChanges Active: ${this.HeaterCooler.Active},`
       + ` disablePushOff: ${this.disablePushOff}`);
     if (this.HeaterCooler.Active === this.hap.Characteristic.Active.INACTIVE && !this.disablePushOff) {
       const commandType: string = await this.commandType();
@@ -211,7 +213,7 @@ export class AirConditioner extends irdeviceBase {
   }
 
   async pushAirConditionerStatusChanges(): Promise<void> {
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirConditionerStatusChanges Active: ${this.HeaterCooler.Active},`
+    await this.debugLog(`pushAirConditionerStatusChanges Active: ${this.HeaterCooler.Active},`
       + ` disablePushOff: ${this.disablePushOff},  disablePushOn: ${this.disablePushOn}`);
     if (!this.Busy) {
       this.Busy = true;
@@ -224,7 +226,7 @@ export class AirConditioner extends irdeviceBase {
   }
 
   async pushAirConditionerDetailsChanges(): Promise<void> {
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirConditionerDetailsChanges Active: ${this.HeaterCooler.Active},`
+    await this.debugLog(`pushAirConditionerDetailsChanges Active: ${this.HeaterCooler.Active},`
       + ` disablePushOff: ${this.disablePushOff},  disablePushOn: ${this.disablePushOn}`);
     //await this.deviceContext();
     if (this.CurrentMode === undefined) {
@@ -241,7 +243,7 @@ export class AirConditioner extends irdeviceBase {
     if (this.CurrentMode === 1) {
       // Remove or make configurable?
       this.HeaterCooler.ThresholdTemperature = 25;
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} CurrentMode: ${this.CurrentMode},`
+      await this.debugLog(`CurrentMode: ${this.CurrentMode},`
         + ` ThresholdTemperature: ${this.HeaterCooler.ThresholdTemperature}`);
     }
     const parameter = `${this.HeaterCooler.ThresholdTemperature},${this.CurrentMode},${this.CurrentFanSpeed},${this.state}`;
@@ -344,14 +346,14 @@ export class AirConditioner extends irdeviceBase {
   }
 
   async pushChanges(bodyChange: any): Promise<void> {
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushChanges`);
+    await this.debugLog('pushChanges');
     if (this.device.connectionType === 'OpenAPI' && !this.disablePushDetail) {
-      this.infoLog(`${this.device.remoteType}: ${this.accessory.displayName} Sending request to SwitchBot API, body: ${bodyChange},`);
+      await this.infoLog(`Sending request to SwitchBot API, body: ${bodyChange},`);
       try {
         const { body, statusCode } = await this.pushChangeRequest(bodyChange);
         const deviceStatus: any = await body.json();
         await this.pushStatusCodes(statusCode, deviceStatus);
-        if ((statusCode === 200 || statusCode === 100) && (deviceStatus.statusCode === 200 || deviceStatus.statusCode === 100)) {
+        if (await this.successfulStatusCodes(statusCode, deviceStatus)) {
           await this.successfulPushChange(statusCode, deviceStatus, bodyChange);
           await this.updateHomeKitCharacteristics();
         } else {
@@ -363,35 +365,33 @@ export class AirConditioner extends irdeviceBase {
         await this.pushChangeError(e);
       }
     } else {
-      this.warnLog(`${this.device.remoteType}: ${this.accessory.displayName}`
-        + ` Connection Type: ${this.device.connectionType}, commands will not be sent to OpenAPI`);
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}`
-        + ` Connection Type: ${this.device.connectionType}, disablePushDetails: ${this.disablePushDetail}`);
-      this.updateHomeKitCharacteristics();
+      await this.warnLog(`Connection Type: ${this.device.connectionType}, commands will not be sent to OpenAPI`);
+      await this.debugLog(`Connection Type: ${this.device.connectionType}, disablePushDetails: ${this.disablePushDetail}`);
+      await this.updateHomeKitCharacteristics();
     }
   }
 
   async CurrentTemperatureGet(): Promise<CharacteristicValue> {
     if (this.meter?.context?.CurrentTemperature) {
       this.accessory.context.CurrentTemperature = this.meter.context.CurrentTemperature;
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} `
-        + `Using CurrentTemperature from ${this.meter.context.deviceType} (${this.meter.context.deviceID})`);
+      await this.debugLog(''
+        + `Using CurrentTemperature from ${this.meter.context.deviceType} (${this.meter.context.deviceId})`);
     }
 
     this.HeaterCooler.CurrentTemperature = this.accessory.context.CurrentTemperature || 24;
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Get CurrentTemperature: ${this.HeaterCooler.CurrentTemperature}`);
+    await this.debugLog(`Get CurrentTemperature: ${this.HeaterCooler.CurrentTemperature}`);
     return this.HeaterCooler.CurrentTemperature;
   }
 
   async CurrentRelativeHumidityGet(): Promise<CharacteristicValue> {
     if (this.meter?.context?.CurrentRelativeHumidity) {
       this.accessory.context.CurrentRelativeHumidity = this.meter.context.CurrentRelativeHumidity;
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} `
-        + `Using CurrentRelativeHumidity from ${this.meter.context.deviceType} (${this.meter.context.deviceID})`);
+      await this.debugLog(''
+        + `Using CurrentRelativeHumidity from ${this.meter.context.deviceType} (${this.meter.context.deviceId})`);
     }
 
     this.HumiditySensor!.CurrentRelativeHumidity = this.accessory.context.CurrentRelativeHumidity || 0;
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Get`
+    await this.debugLog('Get'
       + ` CurrentRelativeHumidity: ${this.HumiditySensor!.CurrentRelativeHumidity}`);
     return this.HumiditySensor!.CurrentRelativeHumidity as CharacteristicValue;
   }
@@ -402,7 +402,7 @@ export class AirConditioner extends irdeviceBase {
     } else {
       this.HeaterCooler.RotationSpeed = this.CurrentFanSpeed - 1;
     }
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Get RotationSpeed: ${this.HeaterCooler.RotationSpeed}`);
+    await this.debugLog(`Get RotationSpeed: ${this.HeaterCooler.RotationSpeed}`);
     return this.HeaterCooler.RotationSpeed;
   }
 
@@ -413,24 +413,23 @@ export class AirConditioner extends irdeviceBase {
       this.CurrentFanSpeed = Number(value) + 1;
     }
     this.HeaterCooler.RotationSpeed = value;
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}`
-      + `Set RotationSpeed: ${this.HeaterCooler.RotationSpeed}, CurrentFanSpeed: ${this.CurrentFanSpeed}`);
+    await this.debugLog(`Set RotationSpeed: ${this.HeaterCooler.RotationSpeed}, CurrentFanSpeed: ${this.CurrentFanSpeed}`);
     this.pushAirConditionerStatusChanges();
   }
 
   async ActiveSet(value: CharacteristicValue): Promise<void> {
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Set Active: ${value}`);
+    await this.debugLog(`Set Active: ${value}`);
 
     this.HeaterCooler.Active = value;
     if (this.HeaterCooler.Active === this.hap.Characteristic.Active.ACTIVE) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirConditionerOnChanges, Active: ${this.HeaterCooler.Active}`);
+      await this.debugLog(`pushAirConditionerOnChanges, Active: ${this.HeaterCooler.Active}`);
       if (this.disablePushOn) {
         this.pushAirConditionerStatusChanges();
       } else {
         this.pushAirConditionerOnChanges();
       }
     } else {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirConditionerOffChanges, Active: ${this.HeaterCooler.Active}`);
+      await this.debugLog(`pushAirConditionerOffChanges, Active: ${this.HeaterCooler.Active}`);
       this.pushAirConditionerOffChanges();
     }
   }
@@ -438,7 +437,7 @@ export class AirConditioner extends irdeviceBase {
   async TargetHeaterCoolerStateGet(): Promise<CharacteristicValue> {
     const targetState = this.HeaterCooler.TargetHeaterCoolerState || this.accessory.context.TargetHeaterCoolerState;
     this.HeaterCooler.TargetHeaterCoolerState = this.ValidValues.includes(targetState) ? targetState : this.ValidValues[0];
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Get (${this.getTargetHeaterCoolerStateName()}) TargetHeaterCoolerState:`
+    await this.debugLog(`Get (${this.getTargetHeaterCoolerStateName()}) TargetHeaterCoolerState:`
       + ` ${this.HeaterCooler.TargetHeaterCoolerState}, ValidValues: ${this.ValidValues},  hide_automode: ${this.hide_automode}`);
     return this.HeaterCooler.TargetHeaterCoolerState;
   }
@@ -451,7 +450,7 @@ export class AirConditioner extends irdeviceBase {
     } else if (value === this.hap.Characteristic.TargetHeaterCoolerState.COOL) {
       this.TargetHeaterCoolerStateCOOL();
     } else {
-      this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Set TargetHeaterCoolerState: `
+      this.errorLog('Set TargetHeaterCoolerState: '
         + `${this.HeaterCooler.TargetHeaterCoolerState}, hide_automode: ${this.hide_automode} `);
     }
     this.pushAirConditionerStatusChanges();
@@ -460,31 +459,30 @@ export class AirConditioner extends irdeviceBase {
   async TargetHeaterCoolerStateAUTO(): Promise<void> {
     this.HeaterCooler.TargetHeaterCoolerState = this.hap.Characteristic.TargetHeaterCoolerState.AUTO;
     this.CurrentMode = 1;
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Set (AUTO)`
+    await this.debugLog('Set (AUTO)'
       + ` TargetHeaterCoolerState: ${this.HeaterCooler.TargetHeaterCoolerState}`);
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Switchbot CurrentMode: ${this.CurrentMode}`);
+    await this.debugLog(`Switchbot CurrentMode: ${this.CurrentMode}`);
   }
 
   async TargetHeaterCoolerStateCOOL(): Promise<void> {
     this.HeaterCooler.TargetHeaterCoolerState = this.hap.Characteristic.TargetHeaterCoolerState.COOL;
     this.CurrentMode = 2;
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Set (COOL)`
+    await this.debugLog('Set (COOL)'
       + ` TargetHeaterCoolerState: ${this.HeaterCooler.TargetHeaterCoolerState}`);
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Switchbot CurrentMode: ${this.CurrentMode}`);
+    await this.debugLog(`Switchbot CurrentMode: ${this.CurrentMode}`);
   }
 
   async TargetHeaterCoolerStateHEAT(): Promise<void> {
     this.HeaterCooler.TargetHeaterCoolerState = this.hap.Characteristic.TargetHeaterCoolerState.HEAT;
     this.CurrentMode = 5;
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Set (HEAT)`
+    await this.debugLog('Set (HEAT)'
       + ` TargetHeaterCoolerState: ${this.HeaterCooler.TargetHeaterCoolerState}`);
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Switchbot CurrentMode: ${this.CurrentMode}`);
+    await this.debugLog(`Switchbot CurrentMode: ${this.CurrentMode}`);
   }
 
   async CurrentHeaterCoolerStateGet(): Promise<CharacteristicValue> {
     await this.UpdateCurrentHeaterCoolerState();
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}`
-      + ` Get (${this.getTargetHeaterCoolerStateName()}) CurrentHeaterCoolerState: ${this.HeaterCooler.CurrentHeaterCoolerState}`);
+    await this.debugLog(`Get (${this.getTargetHeaterCoolerStateName()}) CurrentHeaterCoolerState: ${this.HeaterCooler.CurrentHeaterCoolerState}`);
 
     return this.HeaterCooler.CurrentHeaterCoolerState;
   }
@@ -504,123 +502,68 @@ export class AirConditioner extends irdeviceBase {
   }
 
   async ThresholdTemperatureGet(): Promise<CharacteristicValue> {
+    this.HeaterCooler.Active = this.HeaterCooler.Active === undefined ? this.hap.Characteristic.Active.INACTIVE
+      : this.HeaterCooler.Active ?? this.accessory.context.Active;
 
-    if (this.HeaterCooler.Active === undefined) {
-      this.HeaterCooler.Active = this.hap.Characteristic.Active.INACTIVE;
-    } else {
-      this.HeaterCooler.Active = this.HeaterCooler.Active ? this.HeaterCooler.Active : this.accessory.context.Active;
-    }
+    this.HeaterCooler.CurrentTemperature = (this.HeaterCooler.CurrentTemperature === undefined
+      && this.accessory.context.CurrentTemperature === undefined) ? 24 : this.HeaterCooler.CurrentTemperature
+      ?? this.accessory.context.CurrentTemperature;
 
-    if (this.HeaterCooler.CurrentTemperature === undefined && this.accessory.context.CurrentTemperature === undefined) {
-      this.HeaterCooler.CurrentTemperature = 24;
-    } else {
-      this.HeaterCooler.CurrentTemperature = this.HeaterCooler.CurrentTemperature || this.accessory.context.CurrentTemperature;
-    }
+    this.HeaterCooler.ThresholdTemperature = this.HeaterCooler.ThresholdTemperature === undefined ? 24 : this.HeaterCooler.ThresholdTemperature
+    ?? this.accessory.context.ThresholdTemperature;
 
-    if (this.HeaterCooler.ThresholdTemperature === undefined && this.accessory.context.ThresholdTemperature === undefined) {
-      this.HeaterCooler.ThresholdTemperature = 24;
-    } else {
-      this.HeaterCooler.ThresholdTemperature = this.HeaterCooler.ThresholdTemperature || this.accessory.context.ThresholdTemperature;
-    }
-
-    if (this.HeaterCooler.RotationSpeed === undefined && this.accessory.context.RotationSpeed === undefined) {
-      this.HeaterCooler.RotationSpeed = 4;
-    } else {
-      this.HeaterCooler.RotationSpeed = this.HeaterCooler.RotationSpeed || this.accessory.context.RotationSpeed;
-    }
+    this.HeaterCooler.RotationSpeed = (this.HeaterCooler.RotationSpeed === undefined && this.accessory.context.RotationSpeed === undefined) ? 4
+      : this.HeaterCooler.RotationSpeed ?? this.accessory.context.RotationSpeed;
 
     await this.getAirConditionerConfigSettings(this.accessory, this.device);
 
-    if (this.meter) {
-      if (this.HumiditySensor!.CurrentRelativeHumidity === undefined && this.accessory.context.CurrentRelativeHumidity === undefined) {
-        this.HumiditySensor!.CurrentRelativeHumidity = 0;
-      } else {
-        this.HumiditySensor!.CurrentRelativeHumidity = this.HumiditySensor!.CurrentRelativeHumidity || this.accessory.context.CurrentRelativeHumidity;
-      }
+    if (this.meter && this.HumiditySensor?.Service) {
+      this.HumiditySensor.CurrentRelativeHumidity = (this.HumiditySensor.CurrentRelativeHumidity === undefined
+        && this.accessory.context.CurrentRelativeHumidity === undefined) ? 0 : this.HumiditySensor.CurrentRelativeHumidity
+        ?? this.accessory.context.CurrentRelativeHumidity;
     }
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Get ThresholdTemperature: ${this.HeaterCooler.ThresholdTemperature}`);
+    await this.debugLog(`Get ThresholdTemperature: ${this.HeaterCooler.ThresholdTemperature}`);
     return this.HeaterCooler.ThresholdTemperature;
   }
 
   async ThresholdTemperatureSet(value: CharacteristicValue): Promise<void> {
     this.HeaterCooler.ThresholdTemperature = value;
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Set ThresholdTemperature: ${this.HeaterCooler.ThresholdTemperature},`
+    await this.debugLog(`Set ThresholdTemperature: ${this.HeaterCooler.ThresholdTemperature},`
       + ` ThresholdTemperatureCached: ${this.accessory.context.ThresholdTemperature}`);
     this.pushAirConditionerStatusChanges();
   }
 
   async updateHomeKitCharacteristics(): Promise<void> {
+    await this.debugLog('updateHomeKitCharacteristics');
     // Active
-    if (this.HeaterCooler.Active === undefined) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Active: ${this.HeaterCooler.Active}`);
-    } else {
-      this.accessory.context.Active = this.HeaterCooler.Active;
-      this.HeaterCooler.Service.updateCharacteristic(this.hap.Characteristic.Active, this.HeaterCooler.Active);
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic Active: ${this.HeaterCooler.Active}`);
-    }
+    await this.updateCharacteristic(this.HeaterCooler.Service, this.hap.Characteristic.Active,
+      this.HeaterCooler.Active, 'Active');
     // RotationSpeed
-    if (this.HeaterCooler.RotationSpeed === undefined) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} RotationSpeed: ${this.HeaterCooler.RotationSpeed}`);
-    } else {
-      this.accessory.context.RotationSpeed = this.HeaterCooler.RotationSpeed;
-      this.HeaterCooler.Service.updateCharacteristic(this.hap.Characteristic.RotationSpeed, this.HeaterCooler.RotationSpeed);
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic`
-        + ` RotationSpeed: ${this.HeaterCooler.RotationSpeed}`);
-    }
+    await this.updateCharacteristic(this.HeaterCooler.Service, this.hap.Characteristic.RotationSpeed,
+      this.HeaterCooler.RotationSpeed, 'RotationSpeed');
     // CurrentTemperature
-    if (this.HeaterCooler.CurrentTemperature === undefined) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} CurrentTemperature: ${this.HeaterCooler.CurrentTemperature}`);
-    } else {
-      this.accessory.context.CurrentTemperature = this.HeaterCooler.CurrentTemperature;
-      this.HeaterCooler.Service.updateCharacteristic(this.hap.Characteristic.CurrentTemperature, this.HeaterCooler.CurrentTemperature);
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic`
-        + ` CurrentTemperature: ${this.HeaterCooler.CurrentTemperature}`);
-    }
-    // CurrentRelativeHumidity
-    if (this.meter) {
-      if (this.HumiditySensor!.CurrentRelativeHumidity === undefined) {
-        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}`
-          + ` CurrentRelativeHumidity: ${this.HumiditySensor!.CurrentRelativeHumidity}`);
-      } else {
-        this.accessory.context.CurrentRelativeHumidity = this.HumiditySensor!.CurrentRelativeHumidity;
-        this.HeaterCooler.Service.updateCharacteristic(this.hap.Characteristic.CurrentRelativeHumidity,
-          this.HumiditySensor!.CurrentRelativeHumidity);
-        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic`
-          + ` CurrentRelativeHumidity: ${this.HumiditySensor!.CurrentRelativeHumidity}`);
-      }
-    }
+    await this.updateCharacteristic(this.HeaterCooler.Service, this.hap.Characteristic.CurrentTemperature,
+      this.HeaterCooler.CurrentTemperature, 'CurrentTemperature');
     // TargetHeaterCoolerState
-    if (this.HeaterCooler.TargetHeaterCoolerState === undefined) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} TargetHeaterCoolerState: ${this.HeaterCooler.TargetHeaterCoolerState}`);
-    } else {
-      this.accessory.context.TargetHeaterCoolerState = this.HeaterCooler.TargetHeaterCoolerState;
-      this.HeaterCooler.Service.updateCharacteristic(this.hap.Characteristic.TargetHeaterCoolerState, this.HeaterCooler.TargetHeaterCoolerState);
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic`
-        + ` TargetHeaterCoolerState: ${this.HeaterCooler.TargetHeaterCoolerState}`);
-    }
+    await this.updateCharacteristic(this.HeaterCooler.Service, this.hap.Characteristic.TargetHeaterCoolerState,
+      this.HeaterCooler.TargetHeaterCoolerState, 'TargetHeaterCoolerState');
     // CurrentHeaterCoolerState
-    if (this.HeaterCooler.CurrentHeaterCoolerState === undefined) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}`
-        + ` CurrentHeaterCoolerState: ${this.HeaterCooler.CurrentHeaterCoolerState}`);
-    } else {
-      this.accessory.context.CurrentHeaterCoolerState = this.HeaterCooler.CurrentHeaterCoolerState;
-      this.HeaterCooler.Service.updateCharacteristic(this.hap.Characteristic.CurrentHeaterCoolerState, this.HeaterCooler.CurrentHeaterCoolerState);
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}`
-        + ` updateCharacteristic CurrentHeaterCoolerState: ${this.HeaterCooler.CurrentHeaterCoolerState}`);
-    }
-    // ThresholdTemperature
-    if (this.HeaterCooler.ThresholdTemperature === undefined) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} ThresholdTemperature: ${this.HeaterCooler.ThresholdTemperature}`);
-    } else {
-      this.accessory.context.ThresholdTemperature = this.HeaterCooler.ThresholdTemperature;
-      this.HeaterCooler.Service.updateCharacteristic(this.hap.Characteristic.HeatingThresholdTemperature, this.HeaterCooler.ThresholdTemperature);
-      this.HeaterCooler.Service.updateCharacteristic(this.hap.Characteristic.CoolingThresholdTemperature, this.HeaterCooler.ThresholdTemperature);
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic`
-        + ` ThresholdTemperature: ${this.HeaterCooler.ThresholdTemperature}`);
+    await this.updateCharacteristic(this.HeaterCooler.Service, this.hap.Characteristic.CurrentHeaterCoolerState,
+      this.HeaterCooler.CurrentHeaterCoolerState, 'CurrentHeaterCoolerState');
+    // HeatingThresholdTemperature
+    await this.updateCharacteristic(this.HeaterCooler.Service, this.hap.Characteristic.HeatingThresholdTemperature,
+      this.HeaterCooler.ThresholdTemperature, 'ThresholdTemperature');
+    // CoolingThresholdTemperature
+    await this.updateCharacteristic(this.HeaterCooler.Service, this.hap.Characteristic.CoolingThresholdTemperature,
+      this.HeaterCooler.ThresholdTemperature, 'ThresholdTemperature');
+    if (this.meter && this.HumiditySensor?.Service) {
+      // CurrentRelativeHumidity
+      await this.updateCharacteristic(this.HumiditySensor.Service, this.hap.Characteristic.CurrentRelativeHumidity,
+        this.HumiditySensor.CurrentRelativeHumidity, 'CurrentRelativeHumidity');
     }
   }
 
-  async apiError({ e }: { e: any }): Promise<void> {
+  async apiError(e: any): Promise<void> {
     this.HeaterCooler.Service.updateCharacteristic(this.hap.Characteristic.Active, e);
     this.HeaterCooler.Service.updateCharacteristic(this.hap.Characteristic.RotationSpeed, e);
     this.HeaterCooler.Service.updateCharacteristic(this.hap.Characteristic.CurrentTemperature, e);
@@ -632,42 +575,10 @@ export class AirConditioner extends irdeviceBase {
   }
 
   async getAirConditionerConfigSettings(accessory: PlatformAccessory, device: irdevice & irDevicesConfig): Promise<void> {
-    if (this.device.irair?.hide_automode) {
-      this.hide_automode = device.irair?.hide_automode;
-      accessory.context.hide_automode = this.hide_automode;
-    } else {
-      this.hide_automode = device.irair?.hide_automode;
-      accessory.context.hide_automode = this.hide_automode;
-    }
-
-    if (this.device.irair?.set_max_heat) {
-      this.set_max_heat = device.irair?.set_max_heat;
-      accessory.context.set_max_heat = this.set_max_heat;
-    } else {
-      this.set_max_heat = 35;
-      accessory.context.set_max_heat = this.set_max_heat;
-    }
-    if (this.device.irair?.set_min_heat) {
-      this.set_min_heat = device.irair?.set_min_heat;
-      accessory.context.set_min_heat = this.set_min_heat;
-    } else {
-      this.set_min_heat = 0;
-      accessory.context.set_min_heat = this.set_min_heat;
-    }
-
-    if (this.device.irair?.set_max_cool) {
-      this.set_max_cool = device.irair?.set_max_cool;
-      accessory.context.set_max_cool = this.set_max_cool;
-    } else {
-      this.set_max_cool = 35;
-      accessory.context.set_max_cool = this.set_max_cool;
-    }
-    if (this.device.irair?.set_min_cool) {
-      this.set_min_cool = device.irair?.set_min_cool;
-      accessory.context.set_min_cool = this.set_min_cool;
-    } else {
-      this.set_min_cool = 0;
-      accessory.context.set_min_cool = this.set_min_cool;
-    }
+    accessory.context.hide_automode = this.hide_automode = device.irair?.hide_automode;
+    accessory.context.set_max_heat = this.set_max_heat = device.irair?.set_max_heat ?? 35;
+    accessory.context.set_min_heat = this.set_min_heat = device.irair?.set_min_heat ?? 0;
+    accessory.context.set_max_cool = this.set_max_cool = device.irair?.set_max_cool ?? 35;
+    accessory.context.set_min_cool = this.set_min_cool = device.irair?.set_min_cool ?? 0;
   }
 }

package/src/irdevice/airpurifier.ts

@@ -23,6 +23,7 @@ export class AirPurifier extends irdeviceBase {
     RotationSpeed: CharacteristicValue;
     CurrentAirPurifierState: CharacteristicValue;
     TargetAirPurifierState: CharacteristicValue;
+    CurrentHeaterCoolerState: CharacteristicValue;
   };
 
   private TemperatureSensor: {
@@ -36,7 +37,6 @@ export class AirPurifier extends irdeviceBase {
   CurrentAPTemp!: CharacteristicValue;
   CurrentAPMode!: CharacteristicValue;
   CurrentAPFanSpeed!: CharacteristicValue;
-  CurrentHeaterCoolerState!: CharacteristicValue;
 
   // Others
   Busy: any;
@@ -54,6 +54,8 @@ export class AirPurifier extends irdeviceBase {
     device: irdevice & irDevicesConfig,
   ) {
     super(platform, accessory, device);
+    // Set category
+    accessory.category = this.hap.Categories.AIR_PURIFIER;
 
     // Initialize AirPurifier Service
     accessory.context.AirPurifier = accessory.context.AirPurifier ?? {};
@@ -64,6 +66,7 @@ export class AirPurifier extends irdeviceBase {
       RotationSpeed: accessory.context.RotationSpeed ?? 0,
       CurrentAirPurifierState: accessory.context.CurrentAirPurifierState ?? this.hap.Characteristic.CurrentAirPurifierState.INACTIVE,
       TargetAirPurifierState: accessory.context.TargetAirPurifierState ?? this.hap.Characteristic.TargetAirPurifierState.AUTO,
+      CurrentHeaterCoolerState: accessory.context.CurrentHeaterCoolerState ?? this.hap.Characteristic.CurrentHeaterCoolerState.INACTIVE,
     };
     accessory.context.AirPurifier = this.AirPurifier as object;
 
@@ -106,7 +109,7 @@ export class AirPurifier extends irdeviceBase {
   }
 
   async ActiveSet(value: CharacteristicValue): Promise<void> {
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Set Active: ${value}`);
+    await this.debugLog(`Set Active: ${value}`);
 
     this.AirPurifier.Active = value;
     if (this.AirPurifier.Active === this.hap.Characteristic.Active.ACTIVE) {
@@ -153,7 +156,7 @@ export class AirPurifier extends irdeviceBase {
    * AirPurifier:        "command"       "highSpeed"      "default"	        =        fan speed to high
    */
   async pushAirPurifierOnChanges(): Promise<void> {
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirPurifierOnChanges Active: ${this.AirPurifier.Active},`
+    await this.debugLog(`pushAirPurifierOnChanges Active: ${this.AirPurifier.Active},`
       + ` disablePushOn: ${this.disablePushOn}`);
     if (this.AirPurifier.Active === this.hap.Characteristic.Active.ACTIVE && !this.disablePushOn) {
       const commandType: string = await this.commandType();
@@ -168,7 +171,7 @@ export class AirPurifier extends irdeviceBase {
   }
 
   async pushAirPurifierOffChanges(): Promise<void> {
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirPurifierOffChanges Active: ${this.AirPurifier.Active},`
+    await this.debugLog(`pushAirPurifierOffChanges Active: ${this.AirPurifier.Active},`
       + ` disablePushOff: ${this.disablePushOff}`);
     if (this.AirPurifier.Active === this.hap.Characteristic.Active.INACTIVE && !this.disablePushOn) {
       const commandType: string = await this.commandType();
@@ -183,11 +186,11 @@ export class AirPurifier extends irdeviceBase {
   }
 
   async pushAirPurifierStatusChanges(): Promise<void> {
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirPurifierStatusChanges Active: ${this.AirPurifier.Active},`
+    await this.debugLog(`pushAirPurifierStatusChanges Active: ${this.AirPurifier.Active},`
       + ` disablePushOff: ${this.disablePushOff},  disablePushOn: ${this.disablePushOn}`);
     if (!this.Busy) {
       this.Busy = true;
-      this.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.IDLE;
+      this.AirPurifier.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.IDLE;
     }
     clearTimeout(this.Timeout);
 
@@ -196,7 +199,7 @@ export class AirPurifier extends irdeviceBase {
   }
 
   async pushAirPurifierDetailsChanges(): Promise<void> {
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirPurifierDetailsChanges Active: ${this.AirPurifier.Active},`
+    await this.debugLog(`pushAirPurifierDetailsChanges Active: ${this.AirPurifier.Active},`
       + ` disablePushOff: ${this.disablePushOff},  disablePushOn: ${this.disablePushOn}`);
     this.CurrentAPTemp = this.TemperatureSensor!.CurrentTemperature ?? 24;
     this.CurrentAPMode = this.CurrentMode ?? 1;
@@ -210,25 +213,25 @@ export class AirPurifier extends irdeviceBase {
     });
     if (this.AirPurifier.Active === 1) {
       if ((Number(this.TemperatureSensor!.CurrentTemperature) || 24) < (this.LastTemperature || 30)) {
-        this.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.COOLING;
+        this.AirPurifier.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.COOLING;
       } else {
-        this.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.HEATING;
+        this.AirPurifier.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.HEATING;
       }
     } else {
-      this.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.INACTIVE;
+      this.AirPurifier.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.INACTIVE;
     }
     await this.pushChanges(bodyChange);
   }
 
   async pushChanges(bodyChange: any): Promise<void> {
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushChanges`);
+    await this.debugLog('pushChanges');
     if (this.device.connectionType === 'OpenAPI') {
-      this.infoLog(`${this.device.remoteType}: ${this.accessory.displayName} Sending request to SwitchBot API, body: ${bodyChange},`);
+      this.infoLog(`Sending request to SwitchBot API, body: ${bodyChange},`);
       try {
         const { body, statusCode } = await this.pushChangeRequest(bodyChange);
         const deviceStatus: any = await body.json();
         await this.pushStatusCodes(statusCode, deviceStatus);
-        if ((statusCode === 200 || statusCode === 100) && (deviceStatus.statusCode === 200 || deviceStatus.statusCode === 100)) {
+        if (await this.successfulStatusCodes(statusCode, deviceStatus)) {
           await this.successfulPushChange(statusCode, deviceStatus, bodyChange);
           await this.updateHomeKitCharacteristics();
         } else {
@@ -240,54 +243,31 @@ export class AirPurifier extends irdeviceBase {
         await this.pushChangeError(e);
       }
     } else {
-      this.warnLog(`${this.device.remoteType}: ${this.accessory.displayName}`
-        + ` Connection Type: ${this.device.connectionType}, commands will not be sent to OpenAPI`);
+      this.warnLog(`Connection Type: ${this.device.connectionType}, commands will not be sent to OpenAPI`);
     }
   }
 
   async updateHomeKitCharacteristics(): Promise<void> {
+    await this.debugLog('updateHomeKitCharacteristics');
     // Active
-    if (this.AirPurifier.Active === undefined) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Active: ${this.AirPurifier.Active}`);
-    } else {
-      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}`);
-    }
+    await this.updateCharacteristic(this.AirPurifier.Service, this.hap.Characteristic.Active,
+      this.AirPurifier.Active, 'Active');
     // CurrentAirPurifierState
-    if (this.AirPurifier.CurrentAirPurifierState === undefined) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} CurrentAirPurifierState: ${this.AirPurifier.CurrentAirPurifierState}`);
-    } else {
-      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}`);
-    }
+    await this.updateCharacteristic(this.AirPurifier.Service, this.hap.Characteristic.CurrentAirPurifierState,
+      this.AirPurifier.CurrentAirPurifierState, '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.AirPurifier.Service.updateCharacteristic(this.hap.Characteristic.CurrentHeaterCoolerState, this.CurrentHeaterCoolerState);
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic`
-        + ` CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`);
-    }
+    await this.updateCharacteristic(this.AirPurifier.Service, this.hap.Characteristic.CurrentHeaterCoolerState,
+      this.AirPurifier.CurrentHeaterCoolerState, '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}`);
-    }
+    await this.updateCharacteristic(this.TemperatureSensor.Service, this.hap.Characteristic.CurrentTemperature,
+      this.TemperatureSensor.CurrentTemperature, 'CurrentTemperature');
   }
 
   async apiError(e: any): Promise<void> {
-    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.AirPurifier.Service.updateCharacteristic(this.hap.Characteristic.TargetAirPurifierState, e);
+    this.AirPurifier.Service.updateCharacteristic(this.hap.Characteristic.CurrentAirPurifierState, e);
+    this.AirPurifier.Service.updateCharacteristic(this.hap.Characteristic.CurrentHeaterCoolerState, e);
     this.TemperatureSensor.Service.updateCharacteristic(this.hap.Characteristic.CurrentTemperature, e);
   }
 }