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

package/src/irdevice/camera.ts

@@ -28,6 +28,8 @@ export class Camera extends irdeviceBase {
     device: irdevice & irDevicesConfig,
   ) {
     super(platform, accessory, device);
+    // Set category
+    accessory.category = this.hap.Categories.CAMERA;
 
     // Initialize Switch Service
     accessory.context.Switch = accessory.context.Switch ?? {};
@@ -48,7 +50,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 +71,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 +86,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,14 +101,14 @@ 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();
         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 {
@@ -118,20 +120,15 @@ 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> {
-    // On
-    if (this.Switch.On === undefined) {
-      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);
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic On: ${this.Switch.On}`);
-    }
+    await this.debugLog('updateHomeKitCharacteristics');
+    // Active
+    await this.updateCharacteristic(this.Switch.Service, this.hap.Characteristic.On,
+      this.Switch.On, 'On');
   }
 
   async apiError(e: any): Promise<void> {

package/src/irdevice/fan.ts

@@ -31,6 +31,8 @@ export class IRFan extends irdeviceBase {
     device: irdevice & irDevicesConfig,
   ) {
     super(platform, accessory, device);
+    // Set category
+    accessory.category = this.hap.Categories.FAN;
 
     // Initialize Switch Service
     accessory.context.Fan = accessory.context.Fan ?? {};
@@ -68,9 +70,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 +87,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 +110,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 +124,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 +144,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 +159,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,14 +201,14 @@ 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();
         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 {
@@ -218,33 +220,21 @@ 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> {
-    if (this.Fan.Active === undefined) {
-      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);
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic Active: ${this.Fan.Active}`);
-    }
-    if (this.Fan.SwingMode === undefined) {
-      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);
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic SwingMode: ${this.Fan.SwingMode}`);
-    }
-    if (this.Fan.RotationSpeed === undefined) {
-      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);
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic RotationSpeed: ${this.Fan.RotationSpeed}`);
-    }
+    await this.debugLog('updateHomeKitCharacteristics');
+    // Active
+    await this.updateCharacteristic(this.Fan.Service, this.hap.Characteristic.Active,
+      this.Fan.Active, 'Active');
+    // SwingMode
+    await this.updateCharacteristic(this.Fan.Service, this.hap.Characteristic.SwingMode,
+      this.Fan.SwingMode, 'SwingMode');
+    // RotationSpeed
+    await this.updateCharacteristic(this.Fan.Service, this.hap.Characteristic.RotationSpeed,
+      this.Fan.RotationSpeed, 'RotationSpeed');
   }
 
   async apiError(e: any): Promise<void> {

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 } from 'homebridge';
+import type { API, HAP, Logging, PlatformAccessory, Service, CharacteristicValue } from 'homebridge';
 import type { SwitchBotPlatformConfig, irDevicesConfig } from '../settings.js';
 import type { irdevice } from '../types/irdevicelist.js';
 
@@ -43,8 +43,8 @@ export abstract class irdeviceBase {
       .getService(this.hap.Service.AccessoryInformation)!
       .setCharacteristic(this.hap.Characteristic.Manufacturer, 'SwitchBot')
       .setCharacteristic(this.hap.Characteristic.AppMatchingIdentifier, 'id1087374760')
-      .setCharacteristic(this.hap.Characteristic.Name, accessory.context.name ?? accessory.displayName)
-      .setCharacteristic(this.hap.Characteristic.ConfiguredName, accessory.context.name ?? accessory.displayName)
+      .setCharacteristic(this.hap.Characteristic.Name, device.configDeviceName ?? device.deviceName ?? accessory.displayName)
+      .setCharacteristic(this.hap.Characteristic.ConfiguredName, device.configDeviceName ?? device.deviceName ?? accessory.displayName)
       .setCharacteristic(this.hap.Characteristic.Model, accessory.context.model ?? 'Unknown')
       .setCharacteristic(this.hap.Characteristic.ProductData, accessory.context.deviceId)
       .setCharacteristic(this.hap.Characteristic.SerialNumber, accessory.context.deviceId);
@@ -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';
-      this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} Using Debug Mode Logging: ${this.deviceLogging}`);
+      await this.debugWarnLog(`Using Debug Mode Logging: ${this.deviceLogging}`);
     } else if (device.logging) {
       this.deviceLogging = this.accessory.context.logging = device.logging;
-      this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} Using Device Config Logging: ${this.deviceLogging}`);
+      await this.debugWarnLog(`Using Device Config Logging: ${this.deviceLogging}`);
     } else if (this.config.logging) {
       this.deviceLogging = this.accessory.context.logging = this.config.logging;
-      this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} Using Platform Config Logging: ${this.deviceLogging}`);
+      await this.debugWarnLog(`Using Platform Config Logging: ${this.deviceLogging}`);
     } else {
       this.deviceLogging = this.accessory.context.logging = 'standard';
-      this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} Logging Not Set, Using: ${this.deviceLogging}`);
+      await this.debugWarnLog(`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(`${this.device.remoteType}: ${this.accessory.displayName} Config: ${JSON.stringify(config)}`);
+      this.debugSuccessLog(`Config: ${JSON.stringify(config)}`);
     }
   }
 
@@ -146,33 +146,10 @@ export abstract class irdeviceBase {
     accessory.context.model = device.remoteType;
     accessory.context.deviceId = device.deviceId;
     accessory.context.remoteType = device.remoteType;
-    if (device.firmware) {
-      accessory.context.firmware = device.firmware;
-    } else if (device.firmware === undefined || accessory.context.firmware === undefined) {
-      device.firmware = this.platform.version;
-      accessory.context.firmware = device.firmware;
-    } else {
-      accessory.context.firmware = 'Unknown';
-    }
 
-    // Firmware Version
-    let deviceFirmwareVersion: string;
-    if (device.firmware) {
-      deviceFirmwareVersion = device.firmware;
-      this.debugSuccessLog(`${device.remoteType}: ${accessory.displayName} 1 FirmwareRevision: ${device.firmware}`);
-    } else if (accessory.context.deviceVersion) {
-      deviceFirmwareVersion = accessory.context.deviceVersion;
-      this.debugSuccessLog(`${device.remoteType}: ${accessory.displayName} 2 FirmwareRevision: ${accessory.context.deviceVersion}`);
-    } else {
-      deviceFirmwareVersion = this.platform.version ?? '0.0.0';
-      if (this.platform.version) {
-        this.debugSuccessLog(`${device.remoteType}: ${accessory.displayName} 3 FirmwareRevision: ${this.platform.version}`);
-      } else {
-        this.debugSuccessLog(`${device.remoteType}: ${accessory.displayName} 4 FirmwareRevision: ${deviceFirmwareVersion}`);
-      }
-    }
+    const deviceFirmwareVersion = device.firmware ?? accessory.context.version ?? this.platform.version ?? '0.0.0';
     const version = deviceFirmwareVersion.toString();
-    this.debugLog(`${this.device.remoteType}: ${accessory.displayName} Firmware Version: ${version?.replace(/^V|-.*$/g, '')}`);
+    await this.debugLog(`version: ${version?.replace(/^V|-.*$/g, '')}`);
     let deviceVersion: string;
     if (version?.includes('.') === false) {
       const replace = version?.replace(/^V|-.*$/g, '');
@@ -189,8 +166,8 @@ export abstract class irdeviceBase {
       .setCharacteristic(this.hap.Characteristic.FirmwareRevision, deviceVersion)
       .getCharacteristic(this.hap.Characteristic.FirmwareRevision)
       .updateValue(deviceVersion);
-    accessory.context.deviceVersion = deviceVersion;
-    this.debugSuccessLog(`${device.remoteType}: ${accessory.displayName} deviceVersion: ${accessory.context.deviceVersion}`);
+    accessory.context.version = deviceVersion;
+    this.debugSuccessLog(`version: ${accessory.context.version}`);
   }
 
   async pushChangeRequest(bodyChange: string): Promise<{ body: any; statusCode: any; }> {
@@ -201,21 +178,48 @@ export abstract class irdeviceBase {
     });
   }
 
+  async successfulStatusCodes(statusCode: any, deviceStatus: any) {
+    return await this.successfulStatusCodes(statusCode, deviceStatus);
+  }
+
+  /**
+  * 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) {
-    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}`);
+    await this.debugWarnLog(`statusCode: ${statusCode}`);
+    await this.debugWarnLog(`deviceStatus: ${JSON.stringify(deviceStatus)}`);
+    await this.debugWarnLog(`deviceStatus statusCode: ${deviceStatus.statusCode}`);
   }
 
   async successfulPushChange(statusCode: any, deviceStatus: any, bodyChange: any) {
-    this.debugSuccessLog(`${this.device.remoteType}: ${this.accessory.displayName} statusCode: ${statusCode} & deviceStatus `
+    this.debugSuccessLog(`statusCode: ${statusCode} & deviceStatus `
       + `StatusCode: ${deviceStatus.statusCode}`);
-    this.successLog(`${this.device.remoteType}: ${this.accessory.displayName} request to SwitchBot API,`
+    this.successLog('request to SwitchBot API,'
       + ` body: ${JSON.stringify(JSON.parse(bodyChange))} sent successfully`);
   }
 
   async pushChangeError(e: Error) {
-    this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} failed pushChanges with ${this.device.connectionType}`
+    this.errorLog(`failed pushChanges with ${this.device.connectionType}`
       + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
   }
 
@@ -278,69 +282,66 @@ export abstract class irdeviceBase {
   async statusCode(statusCode: number): Promise<void> {
     switch (statusCode) {
       case 151:
-        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Command not supported by this deviceType, statusCode: ${statusCode}`);
+        this.errorLog(`Command not supported by this deviceType, statusCode: ${statusCode}`);
         break;
       case 152:
-        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Device not found, statusCode: ${statusCode}`);
+        this.errorLog(`Device not found, statusCode: ${statusCode}`);
         break;
       case 160:
-        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Command is not supported, statusCode: ${statusCode}`);
+        this.errorLog(`Command is not supported, statusCode: ${statusCode}`);
         break;
       case 161:
-        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Device is offline, statusCode: ${statusCode}`);
+        this.errorLog(`Device is offline, statusCode: ${statusCode}`);
         break;
       case 171:
-        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Hub Device is offline, statusCode: ${statusCode}. `
-          + `Hub: ${this.device.hubDeviceId}`);
+        this.errorLog(`Hub Device is offline, statusCode: ${statusCode}. Hub: ${this.device.hubDeviceId}`);
         break;
       case 190:
-        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}`);
+        this.errorLog('Device internal error due to device states not synchronized with server, Or command format is invalid,'
+          + ` statusCode: ${statusCode}`);
         break;
       case 100:
-        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Command successfully sent, statusCode: ${statusCode}`);
+        await this.debugLog(`Command successfully sent, statusCode: ${statusCode}`);
         break;
       case 200:
-        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Request successful, statusCode: ${statusCode}`);
+        await this.debugLog(`Request successful, statusCode: ${statusCode}`);
         break;
       case 400:
-        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}`);
+        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}`);
         break;
       case 401:
-        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Unauthorized,	Authorization for the API is required, `
-          + `but the request has not been authenticated, statusCode: ${statusCode}`);
+        this.errorLog(`Unauthorized, Authorization for the API is required, but the request has not been authenticated, statusCode: ${statusCode}`);
         break;
       case 403:
-        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}`);
+        this.errorLog('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(`${this.device.remoteType}: ${this.accessory.displayName} Not Found,	Specifies the requested path does not exist, `
-          + `statusCode: ${statusCode}`);
+        this.errorLog(`Not Found,	Specifies the requested path does not exist, statusCode: ${statusCode}`);
         break;
       case 406:
-        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}`);
+        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}`);
         break;
       case 415:
-        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}`);
+        this.errorLog('Unsupported Media Type,	The client has defined a contentType header that is not supported by the server,'
+          + ` statusCode: ${statusCode}`);
         break;
       case 422:
-        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}`);
+        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}`);
         break;
       case 429:
-        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}`);
+        this.errorLog('Too Many Requests,	The client has exceeded the number of requests allowed for a given time window,'
+          + ` statusCode: ${statusCode}`);
         break;
       case 500:
-        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}`);
+        this.errorLog('Internal Server Error,	An unexpected error on the SmartThings servers has occurred. These errors should be rare,'
+          + ` statusCode: ${statusCode}`);
         break;
       default:
-        this.infoLog(`${this.device.remoteType}: ${this.accessory.displayName} Unknown statusCode: `
+        this.infoLog('Unknown statusCode: '
           + `${statusCode}, Submit Bugs Here: ' + 'https://tinyurl.com/SwitchBotBug`);
     }
   }
@@ -348,65 +349,65 @@ export abstract class irdeviceBase {
   /**
    * Logging for Device
    */
-  infoLog(...log: any[]): void {
-    if (this.enablingDeviceLogging()) {
-      this.log.info(String(...log));
+  async infoLog(...log: any[]): Promise<void> {
+    if (await this.enablingDeviceLogging()) {
+      this.log.info(`${this.device.remoteType}: ${this.accessory.displayName}`, String(...log));
     }
   }
 
-  successLog(...log: any[]): void {
-    if (this.enablingDeviceLogging()) {
-      this.platform.log.success(String(...log));
+  async successLog(...log: any[]): Promise<void> {
+    if (await this.enablingDeviceLogging()) {
+      this.log.success(`${this.device.remoteType}: ${this.accessory.displayName}`, String(...log));
     }
   }
 
-  debugSuccessLog(...log: any[]): void {
-    if (this.enablingDeviceLogging()) {
+  async debugSuccessLog(...log: any[]): Promise<void> {
+    if (await this.enablingDeviceLogging()) {
       if (this.deviceLogging?.includes('debug')) {
-        this.log.success('[DEBUG]', String(...log));
+        this.log.success(`[DEBUG] ${this.device.remoteType}: ${this.accessory.displayName}`, String(...log));
       }
     }
   }
 
-  warnLog(...log: any[]): void {
-    if (this.enablingDeviceLogging()) {
-      this.log.warn(String(...log));
+  async warnLog(...log: any[]): Promise<void> {
+    if (await this.enablingDeviceLogging()) {
+      this.log.warn(`${this.device.remoteType}: ${this.accessory.displayName}`, String(...log));
     }
   }
 
-  debugWarnLog(...log: any[]): void {
-    if (this.enablingDeviceLogging()) {
+  async debugWarnLog(...log: any[]): Promise<void> {
+    if (await this.enablingDeviceLogging()) {
       if (this.deviceLogging?.includes('debug')) {
-        this.log.warn('[DEBUG]', String(...log));
+        this.log.warn(`[DEBUG] ${this.device.remoteType}: ${this.accessory.displayName}`, String(...log));
       }
     }
   }
 
-  errorLog(...log: any[]): void {
-    if (this.enablingDeviceLogging()) {
-      this.log.error(String(...log));
+  async errorLog(...log: any[]): Promise<void> {
+    if (await this.enablingDeviceLogging()) {
+      this.log.error(`${this.device.remoteType}: ${this.accessory.displayName}`, String(...log));
     }
   }
 
-  debugErrorLog(...log: any[]): void {
-    if (this.enablingDeviceLogging()) {
+  async debugErrorLog(...log: any[]): Promise<void> {
+    if (await this.enablingDeviceLogging()) {
       if (this.deviceLogging?.includes('debug')) {
-        this.log.error('[DEBUG]', String(...log));
+        this.log.error(`[DEBUG] ${this.device.remoteType}: ${this.accessory.displayName}`, String(...log));
       }
     }
   }
 
-  debugLog(...log: any[]): void {
-    if (this.enablingDeviceLogging()) {
+  async debugLog(...log: any[]): Promise<void> {
+    if (await this.enablingDeviceLogging()) {
       if (this.deviceLogging === 'debug') {
-        this.log.info('[DEBUG]', String(...log));
+        this.log.info(`[DEBUG] ${this.device.remoteType}: ${this.accessory.displayName}`, String(...log));
       } else {
-        this.log.debug(String(...log));
+        this.log.debug(`${this.device.remoteType}: ${this.accessory.displayName}`, String(...log));
       }
     }
   }
 
-  enablingDeviceLogging(): boolean {
+  async enablingDeviceLogging(): Promise<boolean> {
     return this.deviceLogging.includes('debug') || this.deviceLogging === 'standard';
   }
 }