@switchbot/homebridge-switchbot 3.5.1-beta.10 → 3.5.1-beta.11

package/src/irdevice/airconditioner.ts

@@ -181,7 +181,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 +196,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 +211,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 +224,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 +241,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,9 +344,9 @@ 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();
@@ -363,35 +363,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} `
+      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} `
+      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 +400,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 +411,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 +435,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 +448,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 +457,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;
   }
@@ -538,84 +534,82 @@ export class AirConditioner extends irdeviceBase {
         this.HumiditySensor!.CurrentRelativeHumidity = 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}`);
+      await this.debugLog(`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.debugLog(`updateCharacteristic Active: ${this.HeaterCooler.Active}`);
     }
     // RotationSpeed
     if (this.HeaterCooler.RotationSpeed === undefined) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} RotationSpeed: ${this.HeaterCooler.RotationSpeed}`);
+      await this.debugLog(`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`
+      await this.debugLog('updateCharacteristic'
         + ` RotationSpeed: ${this.HeaterCooler.RotationSpeed}`);
     }
     // CurrentTemperature
     if (this.HeaterCooler.CurrentTemperature === undefined) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} CurrentTemperature: ${this.HeaterCooler.CurrentTemperature}`);
+      await this.debugLog(`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`
+      await this.debugLog('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}`);
+        await this.debugLog(`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`
+        await this.debugLog('updateCharacteristic'
           + ` CurrentRelativeHumidity: ${this.HumiditySensor!.CurrentRelativeHumidity}`);
       }
     }
     // TargetHeaterCoolerState
     if (this.HeaterCooler.TargetHeaterCoolerState === undefined) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} TargetHeaterCoolerState: ${this.HeaterCooler.TargetHeaterCoolerState}`);
+      await this.debugLog(`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`
+      await this.debugLog('updateCharacteristic'
         + ` TargetHeaterCoolerState: ${this.HeaterCooler.TargetHeaterCoolerState}`);
     }
     // CurrentHeaterCoolerState
     if (this.HeaterCooler.CurrentHeaterCoolerState === undefined) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}`
-        + ` CurrentHeaterCoolerState: ${this.HeaterCooler.CurrentHeaterCoolerState}`);
+      await this.debugLog(`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}`);
+      await this.debugLog(`updateCharacteristic CurrentHeaterCoolerState: ${this.HeaterCooler.CurrentHeaterCoolerState}`);
     }
     // ThresholdTemperature
     if (this.HeaterCooler.ThresholdTemperature === undefined) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} ThresholdTemperature: ${this.HeaterCooler.ThresholdTemperature}`);
+      await this.debugLog(`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`
+      await this.debugLog('updateCharacteristic'
         + ` ThresholdTemperature: ${this.HeaterCooler.ThresholdTemperature}`);
     }
   }

package/src/irdevice/airpurifier.ts

@@ -106,7 +106,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 +153,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 +168,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,7 +183,7 @@ 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;
@@ -196,7 +196,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;
@@ -221,9 +221,9 @@ export class AirPurifier 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.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();
@@ -240,45 +240,45 @@ 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}`);
+      await this.debugLog(`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.debugLog(`updateCharacteristic Active: ${this.AirPurifier.Active}`);
     }
     // CurrentAirPurifierState
     if (this.AirPurifier.CurrentAirPurifierState === undefined) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} CurrentAirPurifierState: ${this.AirPurifier.CurrentAirPurifierState}`);
+      await this.debugLog(`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`
+      await this.debugLog('updateCharacteristic'
         + ` CurrentAirPurifierState: ${this.AirPurifier.CurrentAirPurifierState}`);
     }
     // CurrentHeaterCoolerState
     if (this.CurrentHeaterCoolerState === undefined) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`);
+      await this.debugLog(`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`
+      await this.debugLog('updateCharacteristic'
         + ` CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`);
     }
     // CurrentTemperature
     if (this.TemperatureSensor.CurrentTemperature === undefined) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} CurrentTemperature: ${this.TemperatureSensor.CurrentTemperature}`);
+      await this.debugLog(`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`
+      await this.debugLog('updateCharacteristic'
         + ` CurrentTemperature: ${this.TemperatureSensor.CurrentTemperature}`);
     }
   }

package/src/irdevice/camera.ts

@@ -48,7 +48,7 @@ export class Camera extends irdeviceBase {
   }
 
   async OnSet(value: CharacteristicValue): Promise<void> {
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} On: ${value}`);
+    await this.debugLog(`On: ${value}`);
 
     this.Switch.On = value;
     if (this.Switch.On) {
@@ -69,7 +69,7 @@ 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.Switch.On},`
+    await this.debugLog(`pushOnChanges On: ${this.Switch.On},`
       + ` disablePushOn: ${this.disablePushOn}`);
     if (this.Switch.On && !this.disablePushOn) {
       const commandType: string = await this.commandType();
@@ -84,7 +84,7 @@ export class Camera extends irdeviceBase {
   }
 
   async pushOffChanges(): Promise<void> {
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushOffChanges On: ${this.Switch.On},`
+    await this.debugLog(`pushOffChanges On: ${this.Switch.On},`
       + ` disablePushOff: ${this.disablePushOff}`);
     if (!this.Switch.On && !this.disablePushOff) {
       const commandType: string = await this.commandType();
@@ -99,9 +99,9 @@ export class Camera 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.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();
@@ -118,19 +118,19 @@ export class Camera 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`);
+      await this.warnLog(`Connection Type: ${this.device.connectionType}, commands will not be sent to OpenAPI`);
     }
   }
 
   async updateHomeKitCharacteristics(): Promise<void> {
+    await this.debugLog('updateHomeKitCharacteristics');
     // On
     if (this.Switch.On === undefined) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} On: ${this.Switch.On}`);
+      await this.debugLog(`On: ${this.Switch.On}`);
     } else {
       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}`);
+      await this.debugLog(`updateCharacteristic On: ${this.Switch.On}`);
     }
   }
 

package/src/irdevice/fan.ts

@@ -68,9 +68,9 @@ export class IRFan extends irdeviceBase {
     } 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.`);
+      this.debugLog('Rotation Speed Characteristic was removed.');
     } else {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} RotationSpeed Characteristic was not removed/added, `
+      this.debugLog('RotationSpeed Characteristic was not removed/added, '
         + `Clear Cache on ${this.accessory.displayName} to remove Chracteristic`);
     }
 
@@ -85,15 +85,15 @@ export class IRFan extends irdeviceBase {
     } 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.`);
+      this.debugLog('Swing Mode Characteristic was removed.');
     } else {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Swing Mode Characteristic was not removed/added, `
+      this.debugLog('Swing Mode Characteristic was not removed/added, '
         + `Clear Cache on ${this.accessory.displayName} To Remove Chracteristic`);
     }
   }
 
   async SwingModeSet(value: CharacteristicValue): Promise<void> {
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} SwingMode: ${value}`);
+    await this.debugLog(`SwingMode: ${value}`);
     if (value > this.Fan.SwingMode) {
       this.Fan.SwingMode = 1;
       await this.pushFanOnChanges();
@@ -108,7 +108,7 @@ export class IRFan extends irdeviceBase {
   }
 
   async RotationSpeedSet(value: CharacteristicValue): Promise<void> {
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} RotationSpeed: ${value}`);
+    await this.debugLog(`RotationSpeed: ${value}`);
     if (value > this.Fan.RotationSpeed) {
       this.Fan.RotationSpeed = 1;
       this.pushFanSpeedUpChanges();
@@ -122,7 +122,7 @@ export class IRFan extends irdeviceBase {
   }
 
   async ActiveSet(value: CharacteristicValue): Promise<void> {
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Active: ${value}`);
+    await this.debugLog(`Active: ${value}`);
 
     this.Fan.Active = value;
     if (this.Fan.Active === this.hap.Characteristic.Active.ACTIVE) {
@@ -142,7 +142,7 @@ export class IRFan 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.Fan.Active},`
+    await this.debugLog(`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();
@@ -157,7 +157,7 @@ export class IRFan extends irdeviceBase {
   }
 
   async pushFanOffChanges(): Promise<void> {
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushLightOffChanges Active: ${this.Fan.Active},`
+    await this.debugLog(`pushLightOffChanges Active: ${this.Fan.Active},`
       + ` disablePushOff: ${this.disablePushOff}`);
     if (this.Fan.Active === this.hap.Characteristic.Active.INACTIVE && !this.disablePushOff) {
       const commandType: string = await this.commandType();
@@ -199,9 +199,9 @@ export class IRFan 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.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();
@@ -218,32 +218,32 @@ export class IRFan 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`);
+      await this.warnLog(`Connection Type: ${this.device.connectionType}, commands will not be sent to OpenAPI`);
     }
   }
 
   async updateHomeKitCharacteristics(): Promise<void> {
+    await this.debugLog('updateHomeKitCharacteristics');
     if (this.Fan.Active === undefined) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Active: ${this.Fan.Active}`);
+      await this.debugLog(`Active: ${this.Fan.Active}`);
     } else {
       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}`);
+      await this.debugLog(`updateCharacteristic Active: ${this.Fan.Active}`);
     }
     if (this.Fan.SwingMode === undefined) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} SwingMode: ${this.Fan.SwingMode}`);
+      await this.debugLog(`SwingMode: ${this.Fan.SwingMode}`);
     } else {
       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}`);
+      await this.debugLog(`updateCharacteristic SwingMode: ${this.Fan.SwingMode}`);
     }
     if (this.Fan.RotationSpeed === undefined) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} RotationSpeed: ${this.Fan.RotationSpeed}`);
+      await this.debugLog(`RotationSpeed: ${this.Fan.RotationSpeed}`);
     } else {
       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}`);
+      await this.debugLog(`updateCharacteristic RotationSpeed: ${this.Fan.RotationSpeed}`);
     }
   }