@switchbot/homebridge-switchbot 3.5.1-beta.12 → 3.5.1-beta.3

package/src/irdevice/airpurifier.ts

@@ -23,7 +23,6 @@ export class AirPurifier extends irdeviceBase {
     RotationSpeed: CharacteristicValue;
     CurrentAirPurifierState: CharacteristicValue;
     TargetAirPurifierState: CharacteristicValue;
-    CurrentHeaterCoolerState: CharacteristicValue;
   };
 
   private TemperatureSensor: {
@@ -37,6 +36,7 @@ export class AirPurifier extends irdeviceBase {
   CurrentAPTemp!: CharacteristicValue;
   CurrentAPMode!: CharacteristicValue;
   CurrentAPFanSpeed!: CharacteristicValue;
+  CurrentHeaterCoolerState!: CharacteristicValue;
 
   // Others
   Busy: any;
@@ -64,7 +64,6 @@ 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;
 
@@ -107,7 +106,7 @@ export class AirPurifier extends irdeviceBase {
   }
 
   async ActiveSet(value: CharacteristicValue): Promise<void> {
-    await this.debugLog(`Set Active: ${value}`);
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Set Active: ${value}`);
 
     this.AirPurifier.Active = value;
     if (this.AirPurifier.Active === this.hap.Characteristic.Active.ACTIVE) {
@@ -154,7 +153,7 @@ export class AirPurifier extends irdeviceBase {
    * AirPurifier:        "command"       "highSpeed"      "default"	        =        fan speed to high
    */
   async pushAirPurifierOnChanges(): Promise<void> {
-    await this.debugLog(`pushAirPurifierOnChanges Active: ${this.AirPurifier.Active},`
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} 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();
@@ -169,7 +168,7 @@ export class AirPurifier extends irdeviceBase {
   }
 
   async pushAirPurifierOffChanges(): Promise<void> {
-    await this.debugLog(`pushAirPurifierOffChanges Active: ${this.AirPurifier.Active},`
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} 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();
@@ -184,11 +183,11 @@ export class AirPurifier extends irdeviceBase {
   }
 
   async pushAirPurifierStatusChanges(): Promise<void> {
-    await this.debugLog(`pushAirPurifierStatusChanges Active: ${this.AirPurifier.Active},`
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirPurifierStatusChanges Active: ${this.AirPurifier.Active},`
       + ` disablePushOff: ${this.disablePushOff},  disablePushOn: ${this.disablePushOn}`);
     if (!this.Busy) {
       this.Busy = true;
-      this.AirPurifier.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.IDLE;
+      this.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.IDLE;
     }
     clearTimeout(this.Timeout);
 
@@ -197,7 +196,7 @@ export class AirPurifier extends irdeviceBase {
   }
 
   async pushAirPurifierDetailsChanges(): Promise<void> {
-    await this.debugLog(`pushAirPurifierDetailsChanges Active: ${this.AirPurifier.Active},`
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirPurifierDetailsChanges Active: ${this.AirPurifier.Active},`
       + ` disablePushOff: ${this.disablePushOff},  disablePushOn: ${this.disablePushOn}`);
     this.CurrentAPTemp = this.TemperatureSensor!.CurrentTemperature ?? 24;
     this.CurrentAPMode = this.CurrentMode ?? 1;
@@ -211,20 +210,20 @@ export class AirPurifier extends irdeviceBase {
     });
     if (this.AirPurifier.Active === 1) {
       if ((Number(this.TemperatureSensor!.CurrentTemperature) || 24) < (this.LastTemperature || 30)) {
-        this.AirPurifier.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.COOLING;
+        this.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.COOLING;
       } else {
-        this.AirPurifier.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.HEATING;
+        this.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.HEATING;
       }
     } else {
-      this.AirPurifier.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.INACTIVE;
+      this.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.INACTIVE;
     }
     await this.pushChanges(bodyChange);
   }
 
   async pushChanges(bodyChange: any): Promise<void> {
-    await this.debugLog('pushChanges');
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushChanges`);
     if (this.device.connectionType === 'OpenAPI') {
-      this.infoLog(`Sending request to SwitchBot API, body: ${bodyChange},`);
+      this.infoLog(`${this.device.remoteType}: ${this.accessory.displayName} Sending request to SwitchBot API, body: ${bodyChange},`);
       try {
         const { body, statusCode } = await this.pushChangeRequest(bodyChange);
         const deviceStatus: any = await body.json();
@@ -241,24 +240,47 @@ export class AirPurifier extends irdeviceBase {
         await this.pushChangeError(e);
       }
     } else {
-      this.warnLog(`Connection Type: ${this.device.connectionType}, commands will not be sent to OpenAPI`);
+      this.warnLog(`${this.device.remoteType}: ${this.accessory.displayName}`
+        + ` Connection Type: ${this.device.connectionType}, commands will not be sent to OpenAPI`);
     }
   }
 
   async updateHomeKitCharacteristics(): Promise<void> {
-    await this.debugLog('updateHomeKitCharacteristics');
     // Active
-    await this.updateCharacteristic(this.AirPurifier.Service, this.hap.Characteristic.Active,
-      this.AirPurifier.Active, '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}`);
+    }
     // CurrentAirPurifierState
-    await this.updateCharacteristic(this.AirPurifier.Service, this.hap.Characteristic.CurrentAirPurifierState,
-      this.AirPurifier.CurrentAirPurifierState, '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}`);
+    }
     // CurrentHeaterCoolerState
-    await this.updateCharacteristic(this.AirPurifier.Service, this.hap.Characteristic.CurrentHeaterCoolerState,
-      this.AirPurifier.CurrentHeaterCoolerState, '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}`);
+    }
     // CurrentTemperature
-    await this.updateCharacteristic(this.TemperatureSensor.Service, this.hap.Characteristic.CurrentTemperature,
-      this.TemperatureSensor.CurrentTemperature, 'CurrentTemperature');
+    if (this.TemperatureSensor.CurrentTemperature === undefined) {
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} CurrentTemperature: ${this.TemperatureSensor.CurrentTemperature}`);
+    } else {
+      this.accessory.context.CurrentTemperature = this.TemperatureSensor.CurrentTemperature;
+      this.TemperatureSensor.Service.updateCharacteristic(this.hap.Characteristic.CurrentTemperature, this.TemperatureSensor.CurrentTemperature);
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic`
+        + ` CurrentTemperature: ${this.TemperatureSensor.CurrentTemperature}`);
+    }
   }
 
   async apiError(e: any): Promise<void> {

package/src/irdevice/camera.ts

@@ -48,7 +48,7 @@ export class Camera extends irdeviceBase {
   }
 
   async OnSet(value: CharacteristicValue): Promise<void> {
-    await this.debugLog(`On: ${value}`);
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} 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> {
-    await this.debugLog(`pushOnChanges On: ${this.Switch.On},`
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushOnChanges On: ${this.Switch.On},`
       + ` disablePushOn: ${this.disablePushOn}`);
     if (this.Switch.On && !this.disablePushOn) {
       const commandType: string = await this.commandType();
@@ -84,7 +84,7 @@ export class Camera extends irdeviceBase {
   }
 
   async pushOffChanges(): Promise<void> {
-    await this.debugLog(`pushOffChanges On: ${this.Switch.On},`
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} 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> {
-    await this.debugLog('pushChanges');
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushChanges`);
     if (this.device.connectionType === 'OpenAPI') {
-      this.infoLog(`Sending request to SwitchBot API, body: ${bodyChange},`);
+      this.infoLog(`${this.device.remoteType}: ${this.accessory.displayName} 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 {
-      await this.warnLog(`Connection Type: ${this.device.connectionType}, commands will not be sent to OpenAPI`);
+      this.warnLog(`${this.device.remoteType}: ${this.accessory.displayName}`
+        + ` 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) {
-      await this.debugLog(`On: ${this.Switch.On}`);
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} On: ${this.Switch.On}`);
     } else {
       this.accessory.context.On = this.Switch.On;
       this.Switch.Service.updateCharacteristic(this.hap.Characteristic.On, this.Switch.On);
-      await this.debugLog(`updateCharacteristic On: ${this.Switch.On}`);
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} 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('Rotation Speed Characteristic was removed.');
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Rotation Speed Characteristic was removed.`);
     } else {
-      this.debugLog('RotationSpeed Characteristic was not removed/added, '
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} 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('Swing Mode Characteristic was removed.');
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Swing Mode Characteristic was removed.`);
     } else {
-      this.debugLog('Swing Mode Characteristic was not removed/added, '
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Swing Mode Characteristic was not removed/added, `
         + `Clear Cache on ${this.accessory.displayName} To Remove Chracteristic`);
     }
   }
 
   async SwingModeSet(value: CharacteristicValue): Promise<void> {
-    await this.debugLog(`SwingMode: ${value}`);
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} 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> {
-    await this.debugLog(`RotationSpeed: ${value}`);
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} 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> {
-    await this.debugLog(`Active: ${value}`);
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} 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> {
-    await this.debugLog(`pushFanOnChanges Active: ${this.Fan.Active},`
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushFanOnChanges Active: ${this.Fan.Active},`
       + ` disablePushOn: ${this.disablePushOn}`);
     if (this.Fan.Active === this.hap.Characteristic.Active.ACTIVE && !this.disablePushOn) {
       const commandType: string = await this.commandType();
@@ -157,7 +157,7 @@ export class IRFan extends irdeviceBase {
   }
 
   async pushFanOffChanges(): Promise<void> {
-    await this.debugLog(`pushLightOffChanges Active: ${this.Fan.Active},`
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} 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> {
-    await this.debugLog('pushChanges');
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushChanges`);
     if (this.device.connectionType === 'OpenAPI') {
-      this.infoLog(`Sending request to SwitchBot API, body: ${bodyChange},`);
+      this.infoLog(`${this.device.remoteType}: ${this.accessory.displayName} 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 {
-      await this.warnLog(`Connection Type: ${this.device.connectionType}, commands will not be sent to OpenAPI`);
+      this.warnLog(`${this.device.remoteType}: ${this.accessory.displayName}`
+        + ` 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) {
-      await this.debugLog(`Active: ${this.Fan.Active}`);
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Active: ${this.Fan.Active}`);
     } else {
       this.accessory.context.Active = this.Fan.Active;
       this.Fan.Service.updateCharacteristic(this.hap.Characteristic.Active, this.Fan.Active);
-      await this.debugLog(`updateCharacteristic Active: ${this.Fan.Active}`);
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic Active: ${this.Fan.Active}`);
     }
     if (this.Fan.SwingMode === undefined) {
-      await this.debugLog(`SwingMode: ${this.Fan.SwingMode}`);
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} SwingMode: ${this.Fan.SwingMode}`);
     } else {
       this.accessory.context.SwingMode = this.Fan.SwingMode;
       this.Fan.Service.updateCharacteristic(this.hap.Characteristic.SwingMode, this.Fan.SwingMode);
-      await this.debugLog(`updateCharacteristic SwingMode: ${this.Fan.SwingMode}`);
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic SwingMode: ${this.Fan.SwingMode}`);
     }
     if (this.Fan.RotationSpeed === undefined) {
-      await this.debugLog(`RotationSpeed: ${this.Fan.RotationSpeed}`);
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} RotationSpeed: ${this.Fan.RotationSpeed}`);
     } else {
       this.accessory.context.RotationSpeed = this.Fan.RotationSpeed;
       this.Fan.Service.updateCharacteristic(this.hap.Characteristic.RotationSpeed, this.Fan.RotationSpeed);
-      await this.debugLog(`updateCharacteristic RotationSpeed: ${this.Fan.RotationSpeed}`);
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic RotationSpeed: ${this.Fan.RotationSpeed}`);
     }
   }
 

package/src/irdevice/irdevice.ts

@@ -6,7 +6,7 @@ import { request } from 'undici';
 import { Devices } from '../settings.js';
 
 import type { SwitchBotPlatform } from '../platform.js';
-import type { API, HAP, Logging, PlatformAccessory, Service, CharacteristicValue } from 'homebridge';
+import type { API, HAP, Logging, PlatformAccessory } from 'homebridge';
 import type { SwitchBotPlatformConfig, irDevicesConfig } from '../settings.js';
 import type { irdevice } from '../types/irdevicelist.js';
 
@@ -53,16 +53,16 @@ export abstract class irdeviceBase {
   async getDeviceLogSettings(device: irdevice & irDevicesConfig): Promise<void> {
     if (this.platform.debugMode) {
       this.deviceLogging = this.accessory.context.logging = 'debugMode';
-      await this.debugWarnLog(`Using Debug Mode Logging: ${this.deviceLogging}`);
+      this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} Using Debug Mode Logging: ${this.deviceLogging}`);
     } else if (device.logging) {
       this.deviceLogging = this.accessory.context.logging = device.logging;
-      await this.debugWarnLog(`Using Device Config Logging: ${this.deviceLogging}`);
+      this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} Using Device Config Logging: ${this.deviceLogging}`);
     } else if (this.config.logging) {
       this.deviceLogging = this.accessory.context.logging = this.config.logging;
-      await this.debugWarnLog(`Using Platform Config Logging: ${this.deviceLogging}`);
+      this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} Using Platform Config Logging: ${this.deviceLogging}`);
     } else {
       this.deviceLogging = this.accessory.context.logging = 'standard';
-      await this.debugWarnLog(`Logging Not Set, Using: ${this.deviceLogging}`);
+      this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} Logging Not Set, Using: ${this.deviceLogging}`);
     }
   }
 
@@ -137,7 +137,7 @@ export abstract class irdeviceBase {
     const config = Object.assign({}, deviceConfig, irairConfig, irpurConfig, ircamConfig, irfanConfig, irlightConfig, otherConfig,
       irtvConfig, irvcConfig, irwhConfig);
     if (Object.entries(config).length !== 0) {
-      this.debugSuccessLog(`Config: ${JSON.stringify(config)}`);
+      this.debugSuccessLog(`${this.device.remoteType}: ${this.accessory.displayName} Config: ${JSON.stringify(config)}`);
     }
   }
 
@@ -172,7 +172,7 @@ export abstract class irdeviceBase {
       }
     }
     const version = deviceFirmwareVersion.toString();
-    await this.debugLog(`${this.device.remoteType}: ${accessory.displayName} Firmware Version: ${version?.replace(/^V|-.*$/g, '')}`);
+    this.debugLog(`${this.device.remoteType}: ${accessory.displayName} Firmware Version: ${version?.replace(/^V|-.*$/g, '')}`);
     let deviceVersion: string;
     if (version?.includes('.') === false) {
       const replace = version?.replace(/^V|-.*$/g, '');
@@ -201,48 +201,21 @@ export abstract class irdeviceBase {
     });
   }
 
-  async successfulStatusCodes(statusCode: any, deviceStatus: any) {
-    return (statusCode === 200 || statusCode === 100) && (deviceStatus.statusCode === 200 || deviceStatus.statusCode === 100);
-  }
-
-  /**
-  * Update the characteristic value and log the change.
-  *
-  * @param Service: Service
-  * @param Characteristic: Characteristic
-  * @param CharacteristicValue: CharacteristicValue | undefined
-  * @param CharacteristicName: string
-  * @return: void
-  *
-  */
-  async updateCharacteristic(Service: Service, Characteristic: any,
-    CharacteristicValue: CharacteristicValue | undefined, CharacteristicName: string): Promise<void> {
-    if (CharacteristicValue === undefined) {
-      await this.debugLog(`${CharacteristicName}: ${CharacteristicValue}`);
-    } else {
-      Service.updateCharacteristic(Characteristic, CharacteristicValue);
-      await this.debugLog(`updateCharacteristic ${CharacteristicName}: ${CharacteristicValue}`);
-      await this.debugWarnLog(`context before: ${this.accessory.context[CharacteristicName]}`);
-      this.accessory.context[CharacteristicName] = CharacteristicValue;
-      await this.debugWarnLog(`context after: ${this.accessory.context[CharacteristicName]}`);
-    }
-  }
-
   async pushStatusCodes(statusCode: any, deviceStatus: any) {
-    await this.debugWarnLog(`statusCode: ${statusCode}`);
-    await this.debugWarnLog(`deviceStatus: ${JSON.stringify(deviceStatus)}`);
-    await this.debugWarnLog(`deviceStatus statusCode: ${deviceStatus.statusCode}`);
+    this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} statusCode: ${statusCode}`);
+    this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} deviceStatus: ${JSON.stringify(deviceStatus)}`);
+    this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} deviceStatus statusCode: ${deviceStatus.statusCode}`);
   }
 
   async successfulPushChange(statusCode: any, deviceStatus: any, bodyChange: any) {
-    this.debugSuccessLog(`statusCode: ${statusCode} & deviceStatus `
+    this.debugSuccessLog(`${this.device.remoteType}: ${this.accessory.displayName} statusCode: ${statusCode} & deviceStatus `
       + `StatusCode: ${deviceStatus.statusCode}`);
-    this.successLog('request to SwitchBot API,'
+    this.successLog(`${this.device.remoteType}: ${this.accessory.displayName} request to SwitchBot API,`
       + ` body: ${JSON.stringify(JSON.parse(bodyChange))} sent successfully`);
   }
 
   async pushChangeError(e: Error) {
-    this.errorLog(`failed pushChanges with ${this.device.connectionType}`
+    this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} failed pushChanges with ${this.device.connectionType}`
       + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
   }
 
@@ -305,66 +278,69 @@ export abstract class irdeviceBase {
   async statusCode(statusCode: number): Promise<void> {
     switch (statusCode) {
       case 151:
-        this.errorLog(`Command not supported by this deviceType, statusCode: ${statusCode}`);
+        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Command not supported by this deviceType, statusCode: ${statusCode}`);
         break;
       case 152:
-        this.errorLog(`Device not found, statusCode: ${statusCode}`);
+        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Device not found, statusCode: ${statusCode}`);
         break;
       case 160:
-        this.errorLog(`Command is not supported, statusCode: ${statusCode}`);
+        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Command is not supported, statusCode: ${statusCode}`);
         break;
       case 161:
-        this.errorLog(`Device is offline, statusCode: ${statusCode}`);
+        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Device is offline, statusCode: ${statusCode}`);
         break;
       case 171:
-        this.errorLog(`Hub Device is offline, statusCode: ${statusCode}. Hub: ${this.device.hubDeviceId}`);
+        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Hub Device is offline, statusCode: ${statusCode}. `
+          + `Hub: ${this.device.hubDeviceId}`);
         break;
       case 190:
-        this.errorLog('Device internal error due to device states not synchronized with server, Or command format is invalid,'
-          + ` statusCode: ${statusCode}`);
+        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Device internal error due to device states not synchronized with`
+          + ` server, Or command format is invalid, statusCode: ${statusCode}`);
         break;
       case 100:
-        await this.debugLog(`Command successfully sent, statusCode: ${statusCode}`);
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Command successfully sent, statusCode: ${statusCode}`);
         break;
       case 200:
-        await this.debugLog(`Request successful, statusCode: ${statusCode}`);
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Request successful, statusCode: ${statusCode}`);
         break;
       case 400:
-        this.errorLog('Bad Request, The client has issued an invalid request. This is commonly used to specify validation errors in a request'
-          + ` payload, statusCode: ${statusCode}`);
+        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Bad Request, The client has issued an invalid request. `
+          + `This is commonly used to specify validation errors in a request payload, statusCode: ${statusCode}`);
         break;
       case 401:
-        this.errorLog(`Unauthorized, Authorization for the API is required, but the request has not been authenticated, statusCode: ${statusCode}`);
+        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Unauthorized,	Authorization for the API is required, `
+          + `but the request has not been authenticated, statusCode: ${statusCode}`);
         break;
       case 403:
-        this.errorLog('Forbidden,	The request has been authenticated but does not have appropriate permissions, or a requested resource is not'
-          + ` found, statusCode: ${statusCode}`);
+        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Forbidden,	The request has been authenticated but does not `
+          + `have appropriate permissions, or a requested resource is not found, statusCode: ${statusCode}`);
         break;
       case 404:
-        this.errorLog(`Not Found,	Specifies the requested path does not exist, statusCode: ${statusCode}`);
+        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Not Found,	Specifies the requested path does not exist, `
+          + `statusCode: ${statusCode}`);
         break;
       case 406:
-        this.errorLog('Not Acceptable, The client has requested a MIME type via the Accept header for a value not supported by the server,'
-          + ` statusCode: ${statusCode}`);
+        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Not Acceptable,	The client has requested a MIME type via `
+          + `the Accept header for a value not supported by the server, statusCode: ${statusCode}`);
         break;
       case 415:
-        this.errorLog('Unsupported Media Type,	The client has defined a contentType header that is not supported by the server,'
-          + ` statusCode: ${statusCode}`);
+        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Unsupported Media Type,	The client has defined a contentType `
+          + `header that is not supported by the server, statusCode: ${statusCode}`);
         break;
       case 422:
-        this.errorLog('Unprocessable Entity,	The client has made a valid request, but the server cannot process it. This is often used for APIs'
-          + ` for which certain limits have been exceeded, statusCode: ${statusCode}`);
+        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Unprocessable Entity,	The client has made a valid request, `
+          + `but the server cannot process it. This is often used for APIs for which certain limits have been exceeded, statusCode: ${statusCode}`);
         break;
       case 429:
-        this.errorLog('Too Many Requests,	The client has exceeded the number of requests allowed for a given time window,'
-          + ` statusCode: ${statusCode}`);
+        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Too Many Requests,	The client has exceeded the number of `
+          + `requests allowed for a given time window, statusCode: ${statusCode}`);
         break;
       case 500:
-        this.errorLog('Internal Server Error,	An unexpected error on the SmartThings servers has occurred. These errors should be rare,'
-          + ` statusCode: ${statusCode}`);
+        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Internal Server Error,	An unexpected error on the SmartThings `
+          + `servers has occurred. These errors should be rare, statusCode: ${statusCode}`);
         break;
       default:
-        this.infoLog('Unknown statusCode: '
+        this.infoLog(`${this.device.remoteType}: ${this.accessory.displayName} Unknown statusCode: `
           + `${statusCode}, Submit Bugs Here: ' + 'https://tinyurl.com/SwitchBotBug`);
     }
   }
@@ -372,65 +348,65 @@ export abstract class irdeviceBase {
   /**
    * Logging for Device
    */
-  async infoLog(...log: any[]): Promise<void> {
-    if (await this.enablingDeviceLogging()) {
-      this.log.info(`${this.device.remoteType}: ${this.accessory.displayName}`, String(...log));
+  infoLog(...log: any[]): void {
+    if (this.enablingDeviceLogging()) {
+      this.log.info(String(...log));
     }
   }
 
-  async successLog(...log: any[]): Promise<void> {
-    if (await this.enablingDeviceLogging()) {
-      this.log.success(`${this.device.remoteType}: ${this.accessory.displayName}`, String(...log));
+  successLog(...log: any[]): void {
+    if (this.enablingDeviceLogging()) {
+      this.platform.log.success(String(...log));
     }
   }
 
-  async debugSuccessLog(...log: any[]): Promise<void> {
-    if (await this.enablingDeviceLogging()) {
+  debugSuccessLog(...log: any[]): void {
+    if (this.enablingDeviceLogging()) {
       if (this.deviceLogging?.includes('debug')) {
-        this.log.success(`[DEBUG] ${this.device.remoteType}: ${this.accessory.displayName}`, String(...log));
+        this.log.success('[DEBUG]', String(...log));
       }
     }
   }
 
-  async warnLog(...log: any[]): Promise<void> {
-    if (await this.enablingDeviceLogging()) {
-      this.log.warn(`${this.device.remoteType}: ${this.accessory.displayName}`, String(...log));
+  warnLog(...log: any[]): void {
+    if (this.enablingDeviceLogging()) {
+      this.log.warn(String(...log));
     }
   }
 
-  async debugWarnLog(...log: any[]): Promise<void> {
-    if (await this.enablingDeviceLogging()) {
+  debugWarnLog(...log: any[]): void {
+    if (this.enablingDeviceLogging()) {
       if (this.deviceLogging?.includes('debug')) {
-        this.log.warn(`[DEBUG] ${this.device.remoteType}: ${this.accessory.displayName}`, String(...log));
+        this.log.warn('[DEBUG]', String(...log));
       }
     }
   }
 
-  async errorLog(...log: any[]): Promise<void> {
-    if (await this.enablingDeviceLogging()) {
-      this.log.error(`${this.device.remoteType}: ${this.accessory.displayName}`, String(...log));
+  errorLog(...log: any[]): void {
+    if (this.enablingDeviceLogging()) {
+      this.log.error(String(...log));
     }
   }
 
-  async debugErrorLog(...log: any[]): Promise<void> {
-    if (await this.enablingDeviceLogging()) {
+  debugErrorLog(...log: any[]): void {
+    if (this.enablingDeviceLogging()) {
       if (this.deviceLogging?.includes('debug')) {
-        this.log.error(`[DEBUG] ${this.device.remoteType}: ${this.accessory.displayName}`, String(...log));
+        this.log.error('[DEBUG]', String(...log));
       }
     }
   }
 
-  async debugLog(...log: any[]): Promise<void> {
-    if (await this.enablingDeviceLogging()) {
+  debugLog(...log: any[]): void {
+    if (this.enablingDeviceLogging()) {
       if (this.deviceLogging === 'debug') {
-        this.log.info(`[DEBUG] ${this.device.remoteType}: ${this.accessory.displayName}`, String(...log));
+        this.log.info('[DEBUG]', String(...log));
       } else {
-        this.log.debug(`${this.device.remoteType}: ${this.accessory.displayName}`, String(...log));
+        this.log.debug(String(...log));
       }
     }
   }
 
-  async enablingDeviceLogging(): Promise<boolean> {
+  enablingDeviceLogging(): boolean {
     return this.deviceLogging.includes('debug') || this.deviceLogging === 'standard';
   }
 }