@switchbot/homebridge-switchbot 3.5.1-beta.2 → 3.5.1-beta.4

package/dist/device/ceilinglight.js

@@ -3,9 +3,9 @@
  * ceilinglight.ts: @switchbot/homebridge-switchbot.
  */
 import { deviceBase } from './device.js';
-import { interval, Subject } from 'rxjs';
-import { hs2rgb, rgb2hs, m2hs } from '../utils.js';
-import { debounceTime, skipWhile, take, tap } from 'rxjs/operators';
+import { hs2rgb, m2hs } from '../utils.js';
+import { SwitchBotBLEModel, SwitchBotBLEModelName } from 'node-switchbot';
+import { Subject, debounceTime, interval, skipWhile, take, tap } from 'rxjs';
 /**
  * Platform Accessory
  * An instance of this class is created for each accessory your platform registers
@@ -32,7 +32,7 @@ export class CeilingLight extends deviceBase {
         // Initialize LightBulb Service
         accessory.context.LightBulb = accessory.context.LightBulb ?? {};
         this.LightBulb = {
-            Name: accessory.context.LightBul.bName ?? accessory.displayName,
+            Name: accessory.context.LightBulb.Name ?? accessory.displayName,
             Service: accessory.getService(this.hap.Service.Lightbulb) ?? accessory.addService(this.hap.Service.Lightbulb),
             On: accessory.context.On ?? false,
             Hue: accessory.context.Hue ?? 0,
@@ -46,7 +46,7 @@ export class CeilingLight extends deviceBase {
             accessory.removeService(this.LightBulb.Service);
             this.LightBulb.Service = accessory.addService(this.hap.Service.Lightbulb);
             accessory.context.adaptiveLighting = false;
-            this.debugLog(`${device.deviceType}: ${accessory.displayName} adaptiveLighting: ${accessory.context.adaptiveLighting}`);
+            this.debugLog(`adaptiveLighting: ${accessory.context.adaptiveLighting}`);
         }
         if (this.adaptiveLightingShift !== -1) {
             this.AdaptiveLightingController = new platform.api.hap.AdaptiveLightingController(this.LightBulb.Service, {
@@ -54,10 +54,10 @@ export class CeilingLight extends deviceBase {
             });
             this.accessory.configureController(this.AdaptiveLightingController);
             this.accessory.context.adaptiveLighting = true;
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} adaptiveLighting: ${this.accessory.context.adaptiveLighting},`
+            this.debugLog(`adaptiveLighting: ${this.accessory.context.adaptiveLighting},`
                 + ` adaptiveLightingShift: ${this.adaptiveLightingShift}`);
         }
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} adaptiveLightingShift: ${this.adaptiveLightingShift}`);
+        this.debugLog(`adaptiveLightingShift: ${this.adaptiveLightingShift}`);
         // Initialize LightBulb Characteristics
         this.LightBulb.Service
             .setCharacteristic(this.hap.Characteristic.Name, this.LightBulb.Name)
@@ -119,14 +119,14 @@ export class CeilingLight extends deviceBase {
         this.refreshStatus();
         // Update Homekit
         this.updateHomeKitCharacteristics();
+        //regisiter webhook event handler
+        this.registerWebhook();
         // Start an update interval
         interval(this.deviceRefreshRate * 1000)
             .pipe(skipWhile(() => this.ceilingLightUpdateInProgress))
             .subscribe(async () => {
             await this.refreshStatus();
         });
-        //regisiter webhook event handler
-        this.registerWebhook(accessory, device);
         // Watch for Bulb change events
         // We put in a debounce of 100ms so we don't make duplicate calls
         this.doCeilingLightUpdate
@@ -138,9 +138,8 @@ export class CeilingLight extends deviceBase {
                 await this.pushChanges();
             }
             catch (e) {
-                this.apiError(e);
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed pushChanges with ${this.device.connectionType} Connection,`
-                    + ` Error Message: ${JSON.stringify(e.message)}`);
+                await this.apiError(e);
+                await this.errorLog(`failed pushChanges with ${device.connectionType} Connection, Error Message: ${JSON.stringify(e.message)}`);
             }
             this.ceilingLightUpdateInProgress = false;
         });
@@ -149,63 +148,35 @@ export class CeilingLight extends deviceBase {
      * Parse the device status from the SwitchBotBLE API
      */
     async BLEparseStatus(serviceData) {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BLEparseStatus`);
-        // State
-        switch (serviceData.state) {
-            case 'on':
-                this.LightBulb.On = true;
-                break;
-            default:
-                this.LightBulb.On = false;
-        }
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} On: ${this.LightBulb.On}`);
+        await this.debugLog('BLEparseStatus');
+        // On
+        this.LightBulb.On = serviceData.state;
+        await this.debugLog(`On: ${this.LightBulb.On}`);
     }
     /**
      * Parse the device status from the SwitchBot OpenAPI
      */
     async openAPIparseStatus(deviceStatus) {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} openAPIparseStatus`);
-        switch (deviceStatus.body.power) {
-            case 'on':
-                this.LightBulb.On = true;
-                break;
-            default:
-                this.LightBulb.On = false;
-        }
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} On: ${this.LightBulb.On}`);
+        await this.debugLog('openAPIparseStatus');
+        // On
+        this.LightBulb.On = deviceStatus.power;
+        await this.debugLog(`On: ${this.LightBulb.On}`);
         // Brightness
-        this.LightBulb.Brightness = Number(deviceStatus.body.brightness);
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Brightness: ${this.LightBulb.Brightness}`);
-        // Color, Hue & Brightness
-        if (deviceStatus.body.color) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} color: ${JSON.stringify(deviceStatus.body.color)}`);
-            const [red, green, blue] = deviceStatus.body.color.split(':');
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} red: ${JSON.stringify(red)}`);
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} green: ${JSON.stringify(green)}`);
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} blue: ${JSON.stringify(blue)}`);
-            const [hue, saturation] = rgb2hs(Number(red), Number(green), Number(blue));
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName}`
-                + ` hs: ${JSON.stringify(rgb2hs(Number(red), Number(green), Number(blue)))}`);
-            // Hue
-            this.LightBulb.Hue = hue;
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Hue: ${this.LightBulb.Hue}`);
-            // Saturation
-            this.LightBulb.Saturation = saturation;
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Saturation: ${this.LightBulb.Saturation}`);
-        }
+        this.LightBulb.Brightness = deviceStatus.brightness;
+        await this.debugLog(`Brightness: ${this.LightBulb.Brightness}`);
         // ColorTemperature
-        if (!Number.isNaN(deviceStatus.body.colorTemperature)) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} OpenAPI ColorTemperature: ${deviceStatus.body.colorTemperature}`);
-            const mired = Math.round(1000000 / deviceStatus.body.colorTemperature);
+        if (!Number.isNaN(deviceStatus.colorTemperature)) {
+            await this.debugLog(`OpenAPI ColorTemperature: ${deviceStatus.colorTemperature}`);
+            const mired = Math.round(1000000 / deviceStatus.colorTemperature);
             this.LightBulb.ColorTemperature = Number(mired);
             this.LightBulb.ColorTemperature = Math.max(Math.min(this.LightBulb.ColorTemperature, 500), 140);
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} ColorTemperature: ${this.LightBulb.ColorTemperature}`);
+            await this.debugLog(`ColorTemperature: ${this.LightBulb.ColorTemperature}`);
         }
         // Firmware Version
-        const version = deviceStatus.body.version?.toString();
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Firmware Version: ${version?.replace(/^V|-.*$/g, '')}`);
-        if (deviceStatus.body.version) {
-            const deviceVersion = version?.replace(/^V|-.*$/g, '') ?? '0.0.0';
+        const version = deviceStatus.version.toString();
+        await this.debugLog(`Firmware Version: ${version.replace(/^V|-.*$/g, '')}`);
+        if (deviceStatus.version) {
+            const deviceVersion = version.replace(/^V|-.*$/g, '') ?? '0.0.0';
             this.accessory
                 .getService(this.hap.Service.AccessoryInformation)
                 .setCharacteristic(this.hap.Characteristic.HardwareRevision, deviceVersion)
@@ -213,29 +184,43 @@ export class CeilingLight extends deviceBase {
                 .getCharacteristic(this.hap.Characteristic.FirmwareRevision)
                 .updateValue(deviceVersion);
             this.accessory.context.deviceVersion = deviceVersion;
-            this.debugSuccessLog(`${this.device.deviceType}: ${this.accessory.displayName} deviceVersion: ${this.accessory.context.deviceVersion}`);
+            await this.debugSuccessLog(`deviceVersion: ${this.accessory.context.deviceVersion}`);
         }
     }
+    async parseStatusWebhook(context) {
+        await this.debugLog('parseStatusWebhook');
+        await this.debugLog(`(powerState, brightness, colorTemperature) = Webhook:(${context.powerState}, ${context.brightness},`
+            + ` ${context.colorTemperature}), current:(${this.LightBulb.On}, ${this.LightBulb.Brightness}, ${this.LightBulb.ColorTemperature})`);
+        // On
+        this.LightBulb.On = context.powerState === 'ON' ? true : false;
+        await this.debugLog(`On: ${this.LightBulb.On}`);
+        // Brightness
+        this.LightBulb.Brightness = context.brightness;
+        await this.debugLog(`Brightness: ${this.LightBulb.Brightness}`);
+        // ColorTemperature
+        this.LightBulb.ColorTemperature = context.colorTemperature;
+        await this.debugLog(`ColorTemperature: ${this.LightBulb.ColorTemperature}`);
+    }
     /**
      * Asks the SwitchBot API for the latest device information
      */
     async refreshStatus() {
         if (!this.device.enableCloudService && this.OpenAPI) {
-            this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} refreshStatus enableCloudService: ${this.device.enableCloudService}`);
-            /*} else if (this.BLE) {
-              await this.BLERefreshStatus();*/
+            await this.errorLog(`refreshStatus enableCloudService: ${this.device.enableCloudService}`);
+        }
+        else if (this.BLE) {
+            await this.BLERefreshStatus();
         }
         else if (this.OpenAPI && this.platform.config.credentials?.token) {
             await this.openAPIRefreshStatus();
         }
         else {
             await this.offlineOff();
-            this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} Connection Type:`
-                + ` ${this.device.connectionType}, refreshStatus will not happen.`);
+            await this.debugWarnLog(`Connection Type: ${this.device.connectionType}, refreshStatus will not happen.`);
         }
     }
     async BLERefreshStatus() {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BLERefreshStatus`);
+        await this.debugLog('BLERefreshStatus');
         const switchbot = await this.switchbotBLE();
         if (switchbot === undefined) {
             await this.BLERefreshConnection(switchbot);
@@ -245,84 +230,56 @@ export class CeilingLight extends deviceBase {
                 // Start to monitor advertisement packets
                 const serviceData = await this.monitorAdvertisementPackets(switchbot);
                 // Update HomeKit
-                if (serviceData.model !== '' && serviceData.modelName !== '') {
+                if ((serviceData.model === SwitchBotBLEModel.CeilingLight || SwitchBotBLEModel.CeilingLightPro)
+                    && serviceData.modelName === SwitchBotBLEModelName.CeilingLight || SwitchBotBLEModelName.CeilingLightPro) {
                     await this.BLEparseStatus(serviceData);
                     await this.updateHomeKitCharacteristics();
                 }
                 else {
-                    this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed to get serviceData, serviceData: ${serviceData}`);
+                    await this.errorLog(`failed to get serviceData, serviceData: ${serviceData}`);
                     await this.BLERefreshConnection(switchbot);
                 }
             })();
         }
     }
     async openAPIRefreshStatus() {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} openAPIRefreshStatus`);
+        await this.debugLog('openAPIRefreshStatus');
         try {
             const { body, statusCode } = await this.deviceRefreshStatus();
             const deviceStatus = await body.json();
-            await this.refreshStatusCodes(statusCode, deviceStatus);
+            await this.debugLog(`statusCode: ${statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
             ;
-            if ((statusCode === 200 || statusCode === 100) && (deviceStatus.statusCode === 200 || deviceStatus.statusCode === 100)) {
-                await this.successfulRefreshStatus(statusCode, deviceStatus);
-                await this.openAPIparseStatus(deviceStatus);
+            if (await this.successfulStatusCodes(statusCode, deviceStatus)) {
+                await this.debugSuccessLog(`statusCode: ${statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
+                await this.openAPIparseStatus(deviceStatus.body);
                 await this.updateHomeKitCharacteristics();
             }
             else {
-                await this.statusCodes(statusCode, deviceStatus);
+                await this.debugWarnLog(`statusCode: ${statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
+                await this.debugWarnLog(statusCode, deviceStatus);
             }
         }
         catch (e) {
             await this.apiError(e);
-            await this.openAPIRefreshError(e);
+            await this.errorLog(`failed openAPIRefreshStatus with ${this.device.connectionType} Connection, Error Message: ${JSON.stringify(e.message)}`);
         }
     }
-    async registerWebhook(accessory, device) {
-        if (device.webhook) {
-            this.debugLog(`${device.deviceType}: ${accessory.displayName} is listening webhook.`);
-            this.platform.webhookEventHandler[device.deviceId] = async (context) => {
+    async registerWebhook() {
+        if (this.device.webhook) {
+            await this.debugLog('is listening webhook.');
+            this.platform.webhookEventHandler[this.device.deviceId] = async (context) => {
                 try {
-                    this.debugLog(`${device.deviceType}: ${accessory.displayName} received Webhook: ${JSON.stringify(context)}`);
-                    const { powerState, brightness, colorTemperature } = context;
-                    const { On, Brightness, ColorTemperature } = this.LightBulb;
-                    this.debugLog(`${device.deviceType}: ${accessory.displayName} ` +
-                        '(powerState, brightness, colorTemperature) = ' +
-                        `Webhook:(${powerState}, ${brightness}, ${colorTemperature}), `
-                        + `current:(${On}, ${Brightness}, ${ColorTemperature})`);
-                    // On
-                    this.LightBulb.On = powerState === 'ON' ? true : false;
-                    if (accessory.context.Brightness !== this.LightBulb.On) {
-                        this.infoLog(`${device.deviceType}: ${accessory.displayName} On: ${this.LightBulb.On}`);
-                    }
-                    else {
-                        this.debugLog(`${device.deviceType}: ${accessory.displayName} On: ${this.LightBulb.On}`);
-                    }
-                    // Brightness
-                    this.LightBulb.Brightness = brightness;
-                    if (accessory.context.Brightness !== this.LightBulb.Brightness) {
-                        this.infoLog(`${device.deviceType}: ${accessory.displayName} Brightness: ${this.LightBulb.Brightness}`);
-                    }
-                    else {
-                        this.debugLog(`${device.deviceType}: ${accessory.displayName} Brightness: ${this.LightBulb.Brightness}`);
-                    }
-                    // ColorTemperature
-                    this.LightBulb.ColorTemperature = colorTemperature;
-                    if (accessory.context.ColorTemperature !== this.LightBulb.ColorTemperature) {
-                        this.infoLog(`${device.deviceType}: ${accessory.displayName} ColorTemperature: ${this.LightBulb.ColorTemperature}`);
-                    }
-                    else {
-                        this.debugLog(`${device.deviceType}: ${accessory.displayName} ColorTemperature: ${this.LightBulb.ColorTemperature}`);
-                    }
-                    this.updateHomeKitCharacteristics();
+                    await this.debugLog(`received Webhook: ${JSON.stringify(context)}`);
+                    await this.parseStatusWebhook(context);
+                    await this.updateHomeKitCharacteristics();
                 }
                 catch (e) {
-                    this.errorLog(`${device.deviceType}: ${accessory.displayName} `
-                        + `failed to handle webhook. Received: ${JSON.stringify(context)} Error: ${e}`);
+                    await this.errorLog(`failed to handle webhook. Received: ${JSON.stringify(context)} Error: ${e}`);
                 }
             };
         }
         else {
-            this.debugLog(`${device.deviceType}: ${accessory.displayName} is not listening webhook.`);
+            await this.debugLog('is not listening webhook.');
         }
     }
     /**
@@ -338,17 +295,32 @@ export class CeilingLight extends deviceBase {
      */
     async pushChanges() {
         if (!this.device.enableCloudService && this.OpenAPI) {
-            this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} pushChanges enableCloudService: ${this.device.enableCloudService}`);
+            await this.errorLog(`pushChanges enableCloudService: ${this.device.enableCloudService}`);
         }
         else if (this.BLE) {
             await this.BLEpushChanges();
         }
         else if (this.OpenAPI && this.platform.config.credentials?.token) {
             await this.openAPIpushChanges();
+            if (this.LightBulb.On) {
+                await this.debugLog(`On: ${this.LightBulb.On}`);
+                // Push Brightness Update
+                await this.debugLog(`Brightness: ${this.LightBulb.Brightness}`);
+                await this.pushBrightnessChanges();
+                // Push ColorTemperature Update
+                await this.debugLog(`ColorTemperature: ${this.LightBulb.ColorTemperature}`);
+                await this.pushColorTemperatureChanges();
+                // Push Hue & Saturation Update
+                await this.debugLog(`Hue: ${this.LightBulb.Hue}, Saturation: ${this.LightBulb.Saturation}`);
+                await this.pushHueSaturationChanges();
+            }
+            else {
+                await this.debugLog('BLE (Brightness), (ColorTemperature), (Hue), & (Saturation) changes will not happen, as the device is OFF.');
+            }
         }
         else {
             await this.offlineOff();
-            await this.pushChangeDisabled();
+            await this.debugWarnLog(`Connection Type: ${this.device.connectionType}, pushChanges will not happen.`);
         }
         // Refresh the status from the API
         interval(15000)
@@ -359,70 +331,63 @@ export class CeilingLight extends deviceBase {
         });
     }
     async BLEpushChanges() {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BLEpushChanges`);
+        await this.debugLog('BLEpushChanges');
         if (this.LightBulb.On !== this.accessory.context.On) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName}`
-                + ` BLEpushChanges On: ${this.LightBulb.On} OnCached: ${this.accessory.context.On}`);
-            const switchbot = await this.platform.connectBLE();
-            // Convert to BLE Address
+            await this.debugLog(`BLEpushChanges On: ${this.LightBulb.On} OnCached: ${this.accessory.context.On}`);
+            const switchbot = await this.platform.connectBLE(this.accessory, this.device);
             await this.convertBLEAddress();
-            switchbot
-                .discover({ model: this.device.bleModel, id: this.device.bleMac })
-                .then(async (device_list) => {
-                this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} On: ${this.LightBulb.On}`);
-                return await this.retryBLE({
-                    max: await this.maxRetryBLE(),
-                    fn: async () => {
-                        if (this.LightBulb.On) {
-                            return await device_list[0].turnOn({ id: this.device.bleMac });
-                        }
-                        else {
-                            return await device_list[0].turnOff({ id: this.device.bleMac });
-                        }
-                    },
+            if (switchbot !== false) {
+                switchbot
+                    .discover({ model: this.device.bleModel, id: this.device.bleMac })
+                    .then(async (device_list) => {
+                    this.infoLog(`On: ${this.LightBulb.On}`);
+                    return await this.retryBLE({
+                        max: await this.maxRetryBLE(),
+                        fn: async () => {
+                            if (this.LightBulb.On) {
+                                return await device_list[0].turnOn({ id: this.device.bleMac });
+                            }
+                            else {
+                                return await device_list[0].turnOff({ id: this.device.bleMac });
+                            }
+                        },
+                    });
+                })
+                    .then(async () => {
+                    await this.successLog(`On: ${this.LightBulb.On} sent over SwitchBot BLE,  sent successfully`);
+                    this.LightBulb.On = false;
+                })
+                    .catch(async (e) => {
+                    await this.apiError(e);
+                    await this.errorLog(`failed BLEpushChanges with ${this.device.connectionType} Connection, Error Message: ${JSON.stringify(e.message)}`);
+                    await this.BLEPushConnection();
                 });
-            })
-                .then(() => {
-                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Done.`);
-                this.successLog(`${this.device.deviceType}: ${this.accessory.displayName} `
-                    + `On: ${this.LightBulb.On} sent over BLE,  sent successfully`);
-                this.LightBulb.On = false;
-            })
-                .catch(async (e) => {
-                this.apiError(e);
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed BLEpushChanges with ${this.device.connectionType}`
-                    + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
+            }
+            else {
+                await this.errorLog(`wasn't able to establish BLE Connection, node-switchbot: ${switchbot}`);
                 await this.BLEPushConnection();
-            });
+            }
         }
         else {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName}`
-                + ` No BLEpushChanges: On: ${this.LightBulb.On}, `
-                + `OnCached: ${this.accessory.context.On}`);
+            await this.debugLog(`No changes (BLEpushChanges): On: ${this.LightBulb.On}, OnCached: ${this.accessory.context.On}`);
         }
     }
     async openAPIpushChanges() {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} openAPIpushChanges`);
+        await this.debugLog('openAPIpushChanges');
         if (this.LightBulb.On !== this.accessory.context.On) {
-            let command = '';
-            if (this.LightBulb.On) {
-                command = 'turnOn';
-            }
-            else {
-                command = 'turnOff';
-            }
+            const command = this.LightBulb.On ? 'turnOn' : 'turnOff';
             const bodyChange = JSON.stringify({
                 command: `${command}`,
                 parameter: 'default',
                 commandType: 'command',
             });
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Sending request to SwitchBot API, body: ${bodyChange},`);
+            await this.debugLog(`SwitchBot OpenAPI bodyChange: ${JSON.stringify(bodyChange)}`);
             try {
                 const { body, statusCode } = await this.pushChangeRequest(bodyChange);
                 const deviceStatus = await body.json();
-                await this.pushStatusCodes(statusCode, deviceStatus);
-                if ((statusCode === 200 || statusCode === 100) && (deviceStatus.statusCode === 200 || deviceStatus.statusCode === 100)) {
-                    await this.successfulPushChange(statusCode, deviceStatus, bodyChange);
+                await this.debugLog(`statusCode: ${statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
+                if (await this.successfulStatusCodes(statusCode, deviceStatus)) {
+                    await this.debugSuccessLog(`statusCode: ${statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
                     await this.updateHomeKitCharacteristics();
                 }
                 else {
@@ -431,48 +396,33 @@ export class CeilingLight extends deviceBase {
                 }
             }
             catch (e) {
-                this.apiError(e);
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed openAPIpushChanges with ${this.device.connectionType}`
-                    + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
+                await this.apiError(e);
+                await this.errorLog(`failed openAPIpushChanges with ${this.device.connectionType} Connection, Error Message: ${JSON.stringify(e.message)}`);
             }
         }
         else {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No openAPIpushChanges.`
-                + `On: ${this.LightBulb.On}, `
-                + `OnCached: ${this.accessory.context.On}`);
-        }
-        // Push Hue & Saturation Update
-        if (this.LightBulb.On) {
-            await this.pushHueSaturationChanges();
-        }
-        // Push ColorTemperature Update
-        if (this.LightBulb.On) {
-            await this.pushColorTemperatureChanges();
-        }
-        // Push Brightness Update
-        if (this.LightBulb.On) {
-            await this.pushBrightnessChanges();
+            await this.debugLog(`No changes (openAPIpushChanges), On: ${this.LightBulb.On}, OnCached: ${this.accessory.context.On}`);
         }
     }
     async pushHueSaturationChanges() {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} pushHueSaturationChanges`);
-        if (this.LightBulb.Hue !== this.accessory.context.Hue || this.LightBulb.Saturation !== this.accessory.context.Saturation) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Hue: ${JSON.stringify(this.LightBulb.Hue)}`);
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Saturation: ${JSON.stringify(this.LightBulb.Saturation)}`);
+        await this.debugLog('pushHueSaturationChanges');
+        if ((this.LightBulb.Hue !== this.accessory.context.Hue) || (this.LightBulb.Saturation !== this.accessory.context.Saturation)) {
+            await this.debugLog(`Hue: ${JSON.stringify(this.LightBulb.Hue)}`);
+            await this.debugLog(`Saturation: ${JSON.stringify(this.LightBulb.Saturation)}`);
             const [red, green, blue] = hs2rgb(Number(this.LightBulb.Hue), Number(this.LightBulb.Saturation));
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} rgb: ${JSON.stringify([red, green, blue])}`);
+            await this.debugLog(`rgb: ${JSON.stringify([red, green, blue])}`);
             const bodyChange = JSON.stringify({
                 command: 'setColor',
                 parameter: `${red}:${green}:${blue}`,
                 commandType: 'command',
             });
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Sending request to SwitchBot API, body: ${bodyChange},`);
+            await this.debugLog(`(pushHueSaturationChanges) SwitchBot OpenAPI bodyChange: ${JSON.stringify(bodyChange)}`);
             try {
                 const { body, statusCode } = await this.pushChangeRequest(bodyChange);
                 const deviceStatus = await body.json();
-                await this.pushStatusCodes(statusCode, deviceStatus);
-                if ((statusCode === 200 || statusCode === 100) && (deviceStatus.statusCode === 200 || deviceStatus.statusCode === 100)) {
-                    await this.successfulPushChange(statusCode, deviceStatus, bodyChange);
+                await this.debugLog(`(pushHueSaturationChanges) statusCode: ${statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
+                if (await this.successfulStatusCodes(statusCode, deviceStatus)) {
+                    await this.debugSuccessLog(`(pushHueSaturationChanges) statusCode: ${statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
                     await this.updateHomeKitCharacteristics();
                 }
                 else {
@@ -481,18 +431,18 @@ export class CeilingLight extends deviceBase {
                 }
             }
             catch (e) {
-                this.apiError(e);
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed pushHueSaturationChanges with ${this.device.connectionType}`
-                    + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
+                await this.apiError(e);
+                await this.errorLog(`failed pushHueSaturationChanges with ${this.device.connectionType} Connection,`
+                    + ` Error Message: ${JSON.stringify(e.message)}`);
             }
         }
         else {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No pushHueSaturationChanges. Hue: ${this.LightBulb.Hue}, HueCached: `
-                + `${this.accessory.context.Hue}, Saturation: ${this.LightBulb.Saturation}, SaturationCached: ${this.accessory.context.Saturation}`);
+            await this.debugLog(`No changes (pushHueSaturationChanges), Hue: ${this.LightBulb.Hue}, HueCached: ${this.accessory.context.Hue},`
+                + ` Saturation: ${this.LightBulb.Saturation}, SaturationCached: ${this.accessory.context.Saturation}`);
         }
     }
     async pushColorTemperatureChanges() {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} pushColorTemperatureChanges`);
+        await this.debugLog('pushColorTemperatureChanges');
         if (this.LightBulb.ColorTemperature !== this.accessory.context.ColorTemperature) {
             const kelvin = Math.round(1000000 / Number(this.LightBulb.ColorTemperature));
             this.accessory.context.kelvin = kelvin;
@@ -501,13 +451,13 @@ export class CeilingLight extends deviceBase {
                 parameter: `${kelvin}`,
                 commandType: 'command',
             });
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Sending request to SwitchBot API, body: ${bodyChange},`);
+            await this.debugLog(`(pushColorTemperatureChanges) SwitchBot OpenAPI bodyChange: ${JSON.stringify(bodyChange)}`);
             try {
                 const { body, statusCode } = await this.pushChangeRequest(bodyChange);
                 const deviceStatus = await body.json();
-                await this.pushStatusCodes(statusCode, deviceStatus);
-                if ((statusCode === 200 || statusCode === 100) && (deviceStatus.statusCode === 200 || deviceStatus.statusCode === 100)) {
-                    await this.successfulPushChange(statusCode, deviceStatus, bodyChange);
+                await this.debugLog(`(pushColorTemperatureChanges) statusCode: ${statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
+                if (await this.successfulStatusCodes(statusCode, deviceStatus)) {
+                    await this.debugSuccessLog(`(pushColorTemperatureChanges) statusCode: ${statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
                     await this.updateHomeKitCharacteristics();
                 }
                 else {
@@ -516,31 +466,31 @@ export class CeilingLight extends deviceBase {
                 }
             }
             catch (e) {
-                this.apiError(e);
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed pushColorTemperatureChanges with`
-                    + ` ${this.device.connectionType} Connection, Error Message: ${JSON.stringify(e.message)}`);
+                await this.apiError(e);
+                await this.errorLog(`failed pushColorTemperatureChanges with ${this.device.connectionType} Connection,`
+                    + ` Error Message: ${JSON.stringify(e.message)}`);
             }
         }
         else {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No pushColorTemperatureChanges.`
-                + `ColorTemperature: ${this.LightBulb.ColorTemperature}, ColorTemperatureCached: ${this.accessory.context.ColorTemperature}`);
+            await this.debugLog(`No changes (pushColorTemperatureChanges), ColorTemperature: ${this.LightBulb.ColorTemperature},`
+                + ` ColorTemperatureCached: ${this.accessory.context.ColorTemperature}`);
         }
     }
     async pushBrightnessChanges() {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} pushBrightnessChanges`);
+        await this.debugLog('pushBrightnessChanges');
         if (this.LightBulb.Brightness !== this.accessory.context.Brightness) {
             const bodyChange = JSON.stringify({
                 command: 'setBrightness',
                 parameter: `${this.LightBulb.Brightness}`,
                 commandType: 'command',
             });
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Sending request to SwitchBot API, body: ${bodyChange},`);
+            await this.debugLog(`(pushBrightnessChanges) SwitchBot OpenAPI bodyChange: ${JSON.stringify(bodyChange)}`);
             try {
                 const { body, statusCode } = await this.pushChangeRequest(bodyChange);
                 const deviceStatus = await body.json();
-                await this.pushStatusCodes(statusCode, deviceStatus);
-                if ((statusCode === 200 || statusCode === 100) && (deviceStatus.statusCode === 200 || deviceStatus.statusCode === 100)) {
-                    await this.successfulPushChange(statusCode, deviceStatus, bodyChange);
+                await this.debugLog(`(pushBrightnessChanges) statusCode: ${statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
+                if (await this.successfulStatusCodes(statusCode, deviceStatus)) {
+                    await this.debugSuccessLog(`(pushBrightnessChanges) statusCode: ${statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
                     await this.updateHomeKitCharacteristics();
                 }
                 else {
@@ -549,26 +499,25 @@ export class CeilingLight extends deviceBase {
                 }
             }
             catch (e) {
-                this.apiError(e);
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed pushBrightnessChanges with ${this.device.connectionType}`
-                    + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
+                await this.apiError(e);
+                await this.errorLog(`failed pushBrightnessChanges with ${this.device.connectionType} Connection,`
+                    + ` Error Message: ${JSON.stringify(e.message)}`);
             }
         }
         else {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No pushBrightnessChanges.`
-                + `Brightness: ${this.LightBulb.Brightness}, `
-                + `BrightnessCached: ${this.accessory.context.Brightness}`);
+            await this.debugLog(`No changes (pushBrightnessChanges), Brightness: ${this.LightBulb.Brightness},`
+                + ` BrightnessCached: ${this.accessory.context.Brightness}`);
         }
     }
     /**
      * Handle requests to set the value of the "On" characteristic
      */
     async OnSet(value) {
-        if (this.LightBulb.On === this.accessory.context.On) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No Changes, Set On: ${value}`);
+        if (this.LightBulb.On !== this.accessory.context.On) {
+            await this.infoLog(`Set On: ${value}`);
         }
         else {
-            this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Set On: ${value}`);
+            await this.debugLog(`No Changes, Set On: ${value}`);
         }
         this.LightBulb.On = value;
         this.doCeilingLightUpdate.next();
@@ -577,14 +526,16 @@ export class CeilingLight extends deviceBase {
      * Handle requests to set the value of the "Brightness" characteristic
      */
     async BrightnessSet(value) {
-        if (this.LightBulb.Brightness === this.accessory.context.Brightness) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No Changes, Set Brightness: ${value}`);
-        }
-        else if (this.LightBulb.On) {
-            this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Set Brightness: ${value}`);
+        if (this.LightBulb.On && (this.LightBulb.Brightness !== this.accessory.context.Brightness)) {
+            await this.infoLog(`Set Brightness: ${value}`);
         }
         else {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Set Brightness: ${value}`);
+            if (this.LightBulb.On) {
+                this.debugLog(`No Changes, Brightness: ${value}`);
+            }
+            else {
+                this.debugLog(`Set Brightness: ${value}, On: ${this.LightBulb.On}`);
+            }
         }
         this.LightBulb.Brightness = value;
         this.doCeilingLightUpdate.next();
@@ -593,14 +544,16 @@ export class CeilingLight extends deviceBase {
      * Handle requests to set the value of the "ColorTemperature" characteristic
      */
     async ColorTemperatureSet(value) {
-        if (this.LightBulb.ColorTemperature === this.accessory.context.ColorTemperature) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No Changes, Set ColorTemperature: ${value}`);
-        }
-        else if (this.LightBulb.On) {
-            this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Set ColorTemperature: ${value}`);
+        if (this.LightBulb.On && (this.LightBulb.ColorTemperature !== this.accessory.context.ColorTemperature)) {
+            this.infoLog(`Set ColorTemperature: ${value}`);
         }
         else {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Set ColorTemperature: ${value}`);
+            if (this.LightBulb.On) {
+                this.debugLog(`No Changes, ColorTemperature: ${value}`);
+            }
+            else {
+                this.debugLog(`Set ColorTemperature: ${value}, On: ${this.LightBulb.On}`);
+            }
         }
         const minKelvin = 2000;
         const maxKelvin = 9000;
@@ -622,14 +575,16 @@ export class CeilingLight extends deviceBase {
      * Handle requests to set the value of the "Hue" characteristic
      */
     async HueSet(value) {
-        if (this.LightBulb.Hue === this.accessory.context.Hue) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No Changes, Set Hue: ${value}`);
-        }
-        else if (this.LightBulb.On) {
-            this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Set Hue: ${value}`);
+        if (this.LightBulb.On && (this.LightBulb.Hue !== this.accessory.context.Hue)) {
+            this.infoLog(`Set Hue: ${value}`);
         }
         else {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Set Hue: ${value}`);
+            if (this.LightBulb.On) {
+                this.debugLog(`No Changes, Hue: ${value}`);
+            }
+            else {
+                this.debugLog(`Set Hue: ${value}, On: ${this.LightBulb.On}`);
+            }
         }
         this.LightBulb.Service.updateCharacteristic(this.hap.Characteristic.ColorTemperature, 140);
         this.LightBulb.Hue = value;
@@ -639,14 +594,16 @@ export class CeilingLight extends deviceBase {
      * Handle requests to set the value of the "Saturation" characteristic
      */
     async SaturationSet(value) {
-        if (this.LightBulb.Saturation === this.accessory.context.Saturation) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No Changes, Set Saturation: ${value}`);
-        }
-        else if (this.LightBulb.On) {
-            this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Set Saturation: ${value}`);
+        if (this.LightBulb.On && (this.LightBulb.Saturation !== this.accessory.context.Saturation)) {
+            this.infoLog(`Set Saturation: ${value}`);
         }
         else {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Set Saturation: ${value}`);
+            if (this.LightBulb.On) {
+                this.debugLog(`No Changes, Saturation: ${value}`);
+            }
+            else {
+                this.debugLog(`Set Saturation: ${value}, On: ${this.LightBulb.On}`);
+            }
         }
         this.LightBulb.Service.updateCharacteristic(this.hap.Characteristic.ColorTemperature, 140);
         this.LightBulb.Saturation = value;
@@ -667,24 +624,22 @@ export class CeilingLight extends deviceBase {
     async adaptiveLighting(device) {
         if (device.ceilinglight?.adaptiveLightingShift) {
             this.adaptiveLightingShift = device.ceilinglight.adaptiveLightingShift;
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} adaptiveLightingShift: ${this.adaptiveLightingShift}`);
         }
         else {
             this.adaptiveLightingShift = 0;
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} adaptiveLightingShift: ${this.adaptiveLightingShift}`);
         }
+        await this.debugLog(`adaptiveLightingShift: ${this.adaptiveLightingShift}`);
     }
     async BLEPushConnection() {
         if (this.platform.config.credentials?.token && this.device.connectionType === 'BLE/OpenAPI') {
-            this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection to Push Changes`);
+            await this.warnLog('Using OpenAPI Connection to Push Changes');
             await this.openAPIpushChanges();
         }
     }
     async BLERefreshConnection(switchbot) {
-        this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} wasn't able to establish BLE Connection, node-switchbot:`
-            + ` ${JSON.stringify(switchbot)}`);
+        await this.errorLog(`wasn't able to establish BLE Connection, node-switchbot: ${JSON.stringify(switchbot)}`);
         if (this.platform.config.credentials?.token && this.device.connectionType === 'BLE/OpenAPI') {
-            this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection to Refresh Status`);
+            await this.warnLog('Using OpenAPI Connection to Refresh Status');
             await this.openAPIRefreshStatus();
         }
     }