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

package/dist/device/fan.js

@@ -3,6 +3,7 @@
  * plug.ts: @switchbot/homebridge-switchbot.
  */
 import { deviceBase } from './device.js';
+import { SwitchBotBLEModel, SwitchBotBLEModelName } from 'node-switchbot';
 import { Subject, debounceTime, interval, skipWhile, take, tap } from 'rxjs';
 export class Fan extends deviceBase {
     platform;
@@ -107,14 +108,14 @@ export class Fan 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.fanUpdateInProgress))
             .subscribe(async () => {
             await this.refreshStatus();
         });
-        //regisiter webhook event handler
-        this.registerWebhook(accessory, device);
         // Watch for Plug change events
         // We put in a debounce of 100ms so we don't make duplicate calls
         this.doFanUpdate
@@ -126,56 +127,85 @@ export class Fan extends deviceBase {
                 await this.pushChanges();
             }
             catch (e) {
-                this.apiError(e);
-                this.errorLog(`${device.deviceType}: ${accessory.displayName} failed pushChanges with ${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.fanUpdateInProgress = false;
         });
     }
     async BLEparseStatus(serviceData) {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BLEparseStatus`);
-        // State
-        switch (serviceData.state) {
-            case 'on':
-                this.Fan.Active = true;
-                break;
-            default:
-                this.Fan.Active = false;
-        }
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} On: ${this.Fan.Active}`);
+        await this.debugLog('BLEparseStatus');
+        // Active
+        this.Fan.Active = serviceData.state === 'on' ? this.hap.Characteristic.Active.ACTIVE : this.hap.Characteristic.Active.INACTIVE;
+        await this.debugLog(`Active: ${this.Fan.Active}`);
     }
     async openAPIparseStatus(deviceStatus) {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} openAPIparseStatus`);
+        await this.debugLog('openAPIparseStatus');
         // Active
-        this.Fan.Active = deviceStatus.body.power === 'on' ? this.hap.Characteristic.Active.ACTIVE : this.hap.Characteristic.Active.INACTIVE;
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Active: ${this.Fan.Active}`);
+        this.Fan.Active = deviceStatus.power === 'on' ? this.hap.Characteristic.Active.ACTIVE : this.hap.Characteristic.Active.INACTIVE;
+        this.debugLog(`Active: ${this.Fan.Active}`);
         // SwingMode
-        this.Fan.SwingMode = deviceStatus.body.oscillation === 'on' ?
+        this.Fan.SwingMode = deviceStatus.oscillation === 'on' ?
             this.hap.Characteristic.SwingMode.SWING_ENABLED : this.hap.Characteristic.SwingMode.SWING_DISABLED;
+        await this.debugLog(`SwingMode: ${this.Fan.SwingMode}`);
         // RotationSpeed
-        this.Fan.RotationSpeed = deviceStatus.body.fanSpeed;
+        this.Fan.RotationSpeed = deviceStatus.fanSpeed;
+        await this.debugLog(`RotationSpeed: ${this.Fan.RotationSpeed}`);
         // ChargingState
-        this.Battery.ChargingState = deviceStatus.body.chargingStatus === 'charging' ?
+        this.Battery.ChargingState = deviceStatus.chargingStatus === 'charging' ?
             this.hap.Characteristic.ChargingState.CHARGING : this.hap.Characteristic.ChargingState.NOT_CHARGING;
         // BatteryLevel
-        this.Battery.BatteryLevel = Number(deviceStatus.body.battery);
-        if (this.Battery.BatteryLevel < 10) {
-            this.Battery.StatusLowBattery = this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_LOW;
-        }
-        else {
-            this.Battery.StatusLowBattery = this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL;
-        }
-        if (Number.isNaN(this.Battery.BatteryLevel)) {
-            this.Battery.BatteryLevel = 100;
-        }
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BatteryLevel: ${this.Battery.BatteryLevel},`
-            + ` StatusLowBattery: ${this.Battery.StatusLowBattery}`);
+        this.Battery.BatteryLevel = Number(deviceStatus.battery);
+        await this.debugLog(`BatteryLevel: ${this.Battery.BatteryLevel}`);
+        // StatusLowBattery
+        this.Battery.StatusLowBattery = this.Battery.BatteryLevel < 10
+            ? this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_LOW : this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL;
+        await this.debugLog(`StatusLowBattery: ${this.Battery.StatusLowBattery}`);
         // 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)
+                .setCharacteristic(this.hap.Characteristic.FirmwareRevision, deviceVersion)
+                .getCharacteristic(this.hap.Characteristic.FirmwareRevision)
+                .updateValue(deviceVersion);
+            this.accessory.context.deviceVersion = deviceVersion;
+            await this.debugSuccessLog(`deviceVersion: ${this.accessory.context.deviceVersion}`);
+        }
+    }
+    async parseStatusWebhook(context) {
+        await this.debugLog('parseStatusWebhook');
+        await this.debugLog(`(version, battery, powerState, oscillation, chargingStatus, fanSpeed) = Webhook:(${context.version}, ${context.battery},`
+            + ` ${context.powerState}, ${context.oscillation}, ${context.chargingStatus}, ${context.fanSpeed}),`
+            + ` current:(${this.accessory.context.deviceVersion}, ${this.Battery.BatteryLevel}, ${this.Fan.Active}, ${this.Fan.SwingMode},`
+            + ` ${this.Battery.ChargingState}, ${this.Fan.RotationSpeed})`);
+        // Active
+        this.Fan.Active = context.powerState === 'ON' ? this.hap.Characteristic.Active.ACTIVE : this.hap.Characteristic.Active.INACTIVE;
+        await this.debugLog(`Active: ${this.Fan.Active}`);
+        // SwingMode
+        this.Fan.SwingMode = context.oscillation === 'on' ?
+            this.hap.Characteristic.SwingMode.SWING_ENABLED : this.hap.Characteristic.SwingMode.SWING_DISABLED;
+        await this.debugLog(`SwingMode: ${this.Fan.SwingMode}`);
+        // RotationSpeed
+        this.Fan.RotationSpeed = context.fanSpeed;
+        await this.debugLog(`RotationSpeed: ${this.Fan.RotationSpeed}`);
+        // BatteryLevel
+        this.Battery.BatteryLevel = context.battery;
+        await this.debugLog(`BatteryLevel: ${this.Battery.BatteryLevel}`);
+        // StatusLowBattery
+        this.Battery.StatusLowBattery = this.Battery.BatteryLevel < 10
+            ? this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_LOW : this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL;
+        await this.debugLog(`StatusLowBattery: ${this.Battery.StatusLowBattery}`);
+        // ChargingState
+        this.Battery.ChargingState = context.chargingStatus === 'charging' ?
+            this.hap.Characteristic.ChargingState.CHARGING : this.hap.Characteristic.ChargingState.NOT_CHARGING;
+        await this.debugLog(`ChargingState: ${this.Battery.ChargingState}`);
+        // FirmwareVersion
+        if (context.version) {
+            const deviceVersion = context.version.replace(/^V|-.*$/g, '') ?? '0.0.0';
             this.accessory
                 .getService(this.hap.Service.AccessoryInformation)
                 .setCharacteristic(this.hap.Characteristic.HardwareRevision, deviceVersion)
@@ -183,7 +213,7 @@ export class Fan 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}`);
         }
     }
     /**
@@ -191,7 +221,7 @@ export class Fan extends deviceBase {
      */
     async refreshStatus() {
         if (!this.device.enableCloudService && this.OpenAPI) {
-            this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} refreshStatus enableCloudService: ${this.device.enableCloudService}`);
+            await this.errorLog(`refreshStatus enableCloudService: ${this.device.enableCloudService}`);
         }
         else if (this.BLE) {
             await this.BLERefreshStatus();
@@ -201,12 +231,11 @@ export class Fan extends deviceBase {
         }
         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);
@@ -217,82 +246,55 @@ export class Fan extends deviceBase {
                 // Start to monitor advertisement packets
                 const serviceData = await this.monitorAdvertisementPackets(switchbot);
                 // Update HomeKit
-                if (serviceData.model !== '' && serviceData.modelName !== '') {
+                if (serviceData.model === SwitchBotBLEModel.Unknown && SwitchBotBLEModelName.Unknown) {
                     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) {
-            this.apiError(e);
-            this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed openAPIRefreshStatus with ${this.device.connectionType}`
-                + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
+            await this.apiError(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 { version, battery, powerState, oscillation, chargingStatus, fanSpeed } = context;
-                    const { Active, SwingMode, RotationSpeed } = this.Fan;
-                    const { BatteryLevel, ChargingState } = this.Battery;
-                    const { FirmwareRevision } = accessory.context;
-                    this.debugLog(`${device.deviceType}: ${accessory.displayName} (version, battery, powerState, oscillation, chargingStatus, fanSpeed) = `
-                        + `Webhook:(${version}, ${battery}, ${powerState}, ${oscillation}, ${chargingStatus}, ${fanSpeed}), `
-                        + `current:(${FirmwareRevision}, ${BatteryLevel}, ${Active}, ${SwingMode}, ${ChargingState}, ${RotationSpeed})`);
-                    // Active
-                    this.Fan.Active = powerState === 'ON' ? this.hap.Characteristic.Active.ACTIVE : this.hap.Characteristic.Active.INACTIVE;
-                    // SwingMode
-                    this.Fan.SwingMode = oscillation === 'on' ?
-                        this.hap.Characteristic.SwingMode.SWING_ENABLED : this.hap.Characteristic.SwingMode.SWING_DISABLED;
-                    // RotationSpeed
-                    this.Fan.RotationSpeed = fanSpeed;
-                    // ChargingState
-                    this.Battery.ChargingState = chargingStatus === 'charging' ?
-                        this.hap.Characteristic.ChargingState.CHARGING : this.hap.Characteristic.ChargingState.NOT_CHARGING;
-                    // BatteryLevel
-                    this.Battery.BatteryLevel = battery;
-                    // Firmware Version
-                    if (version) {
-                        accessory.context.version = version;
-                        accessory
-                            .getService(this.hap.Service.AccessoryInformation)
-                            .setCharacteristic(this.hap.Characteristic.FirmwareRevision, accessory.context.version)
-                            .getCharacteristic(this.hap.Characteristic.FirmwareRevision)
-                            .updateValue(accessory.context.version);
-                    }
-                    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.');
         }
     }
     /**
@@ -306,18 +308,29 @@ export class Fan 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.Fan.Active) {
+                await this.debugLog(`Active: ${this.Fan.Active}`);
+                // Push RotationSpeed Update
+                await this.debugLog(`RotationSpeed: ${this.Fan.RotationSpeed}`);
+                await this.pushRotationSpeedChanges();
+                // Push SwingMode Update
+                await this.debugLog(`SwingMode: ${this.Fan.SwingMode}`);
+                await this.pushSwingModeChanges();
+            }
+            else {
+                await this.debugLog('BLE (RotationSpeed) & (SwingMode) changes will not happen, as the device is Off.');
+            }
         }
         else {
             await this.offlineOff();
-            this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} Connection Type:`
-                + ` ${this.device.connectionType}, pushChanges will not happen.`);
+            await this.debugWarnLog(`Connection Type: ${this.device.connectionType}, pushChanges will not happen.`);
         }
         // Refresh the status from the API
         interval(15000)
@@ -328,69 +341,62 @@ export class Fan extends deviceBase {
         });
     }
     async BLEpushChanges() {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BLEpushChanges`);
+        await this.debugLog('BLEpushChanges');
         if (this.Fan.Active !== this.accessory.context.Active) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BLEpushChanges`
-                + ` On: ${this.Fan.Active} OnCached: ${this.accessory.context.Active}`);
-            const switchbot = await this.platform.connectBLE();
-            // Convert to BLE Address
+            await this.debugLog(`BLEpushChanges On: ${this.Fan.Active} OnCached: ${this.accessory.context.Active}`);
+            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.Fan.Active}`);
-                return await this.retryBLE({
-                    max: await this.maxRetryBLE(),
-                    fn: async () => {
-                        if (this.Fan.Active) {
-                            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) => {
+                    return await this.retryBLE({
+                        max: await this.maxRetryBLE(),
+                        fn: async () => {
+                            if (this.Fan.Active) {
+                                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(`Active: ${this.Fan.Active} sent over SwitchBot BLE,  sent successfully`);
+                    await this.updateHomeKitCharacteristics();
+                })
+                    .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} `
-                    + `Active: ${this.Fan.Active} sent over BLE,  sent successfully`);
-                this.Fan.Active = 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,`
-                + ` Active: ${this.Fan.Active}, ActiveCached: ${this.accessory.context.Active}`);
+            await this.debugLog(`No change (BLEpushChanges), Active: ${this.Fan.Active}, ActiveCached: ${this.accessory.context.Active}`);
         }
     }
     async openAPIpushChanges() {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} openAPIpushChanges`);
+        await this.debugLog('openAPIpushChanges');
         if (this.Fan.Active !== this.accessory.context.Active) {
-            let command = '';
-            if (this.Fan.Active) {
-                command = 'turnOn';
-            }
-            else {
-                command = 'turnOff';
-            }
+            const command = this.Fan.Active ? '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 {
@@ -399,39 +405,29 @@ export class Fan 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.Fan.Active}, ActiveCached: ${this.accessory.context.Active}`);
-        }
-        // Push RotationSpeed Update
-        if (this.Fan.Active) {
-            await this.pushRotationSpeedChanges();
-        }
-        // Push SwingMode Update
-        if (this.Fan.Active) {
-            await this.pushSwingModeChanges();
+            await this.debugLog(`No changes (openAPIpushChanges), Active: ${this.Fan.Active}, ActiveCached: ${this.accessory.context.Active}`);
         }
     }
     async pushRotationSpeedChanges() {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} pushRotationSpeedChanges`);
+        await this.debugLog('pushRotationSpeedChanges');
         if (this.Fan.SwingMode !== this.accessory.context.SwingMode) {
             const bodyChange = JSON.stringify({
                 command: 'setWindSpeed',
                 parameter: `${this.Fan.RotationSpeed}`,
                 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 {
@@ -440,38 +436,32 @@ export class Fan extends deviceBase {
                 }
             }
             catch (e) {
-                this.apiError(e);
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed pushRotationSpeedChanges with ${this.device.connectionType}`
-                    + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
+                await this.apiError(e);
+                await this.errorLog(`failed pushRotationSpeedChanges with ${this.device.connectionType} Connection,`
+                    + ` Error Message: ${JSON.stringify(e.message)}`);
             }
         }
         else {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No Changes, pushRotationSpeedChanges: ${this.Fan.RotationSpeed}, `
-                + `pushRotationSpeedChangesCached: ${this.accessory.context.RotationSpeed}`);
+            await this.debugLog(`No changes (pushRotationSpeedChanges), RotationSpeed: ${this.Fan.RotationSpeed},`
+                + ` RotationSpeedCached: ${this.accessory.context.RotationSpeed}`);
         }
     }
     async pushSwingModeChanges() {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} pushSwingModeChanges`);
+        await this.debugLog('pushSwingModeChanges');
         if (this.Fan.SwingMode !== this.accessory.context.SwingMode) {
-            let parameter = '';
-            if (this.Fan.SwingMode === this.hap.Characteristic.SwingMode.SWING_ENABLED) {
-                parameter = 'on';
-            }
-            else {
-                parameter = 'off';
-            }
+            const parameter = this.Fan.SwingMode === this.hap.Characteristic.SwingMode.SWING_ENABLED ? 'on' : 'off';
             const bodyChange = JSON.stringify({
                 command: 'setOscillation',
                 parameter: `${parameter}`,
                 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 {
@@ -480,25 +470,24 @@ export class Fan extends deviceBase {
                 }
             }
             catch (e) {
-                this.apiError(e);
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed pushSwingModeChanges with ${this.device.connectionType}`
-                    + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
+                await this.apiError(e);
+                await this.errorLog(`failed pushSwingModeChanges with ${this.device.connectionType} Connection, Error Message: ${JSON.stringify(e.message)}`);
             }
         }
         else {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No Changes, SwingMode: ${this.Fan.SwingMode}, `
-                + `SwingModeCached: ${this.accessory.context.SwingMode}`);
+            await this.debugLog(`No changes (pushSwingModeChanges), SwingMode: ${this.Fan.SwingMode},`
+                + ` SwingModeCached: ${this.accessory.context.SwingMode}`);
         }
     }
     /**
      * Handle requests to set the value of the "On" characteristic
      */
     async ActiveSet(value) {
-        if (this.Fan.Active === this.accessory.context.Active) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No Changes, Set Active: ${value}`);
+        if (this.Fan.Active !== this.accessory.context.Active) {
+            await this.infoLog(`Set Active: ${value}`);
         }
         else {
-            this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Set Active: ${value}`);
+            await this.debugLog(`No Changes, Active: ${value}`);
         }
         this.Fan.Active = value;
         this.doFanUpdate.next();
@@ -507,11 +496,11 @@ export class Fan extends deviceBase {
      * Handle requests to set the value of the "On" characteristic
      */
     async RotationSpeedSet(value) {
-        if (this.Fan.RotationSpeed === this.accessory.context.RotationSpeed) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No Changes, Set RotationSpeed: ${value}`);
+        if (this.Fan.RotationSpeed !== this.accessory.context.RotationSpeed) {
+            await this.infoLog(`Set RotationSpeed ${value}`);
         }
         else {
-            this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Set RotationSpeed: ${value}`);
+            await this.debugLog(`No Changes, RotationSpeed: ${value}`);
         }
         this.Fan.RotationSpeed = value;
         this.doFanUpdate.next();
@@ -520,11 +509,11 @@ export class Fan extends deviceBase {
      * Handle requests to set the value of the "On" characteristic
      */
     async SwingModeSet(value) {
-        if (this.Fan.SwingMode === this.accessory.context.SwingMode) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No Changes, Set SwingMode: ${value}`);
+        if (this.Fan.SwingMode !== this.accessory.context.SwingMode) {
+            await this.infoLog(`Set SwingMode ${value}`);
         }
         else {
-            this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Set SwingMode: ${value}`);
+            await this.debugLog(`No Changes, SwingMode: ${value}`);
         }
         this.Fan.SwingMode = value;
         this.doFanUpdate.next();
@@ -533,11 +522,11 @@ export class Fan extends deviceBase {
      * 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, On: ${value}`);
         }
         this.LightBulb.On = value;
         this.doFanUpdate.next();
@@ -546,86 +535,48 @@ export class Fan 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.doFanUpdate.next();
     }
     async updateHomeKitCharacteristics() {
         // Active
-        if (this.Fan.Active === undefined) {
-            this.debugLog(`${this.device.deviceType}: ${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.deviceType}: ${this.accessory.displayName} updateCharacteristic Active: ${this.Fan.Active}`);
-        }
+        await this.updateCharacteristic(this.Fan.Service, this.hap.Characteristic.Active, this.Fan.Active, 'Active');
         // RotationSpeed
-        if (this.Fan.RotationSpeed === undefined) {
-            this.debugLog(`${this.device.deviceType}: ${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.deviceType}: ${this.accessory.displayName} updateCharacteristic RotationSpeed: ${this.Fan.RotationSpeed}`);
-        }
+        await this.updateCharacteristic(this.Fan.Service, this.hap.Characteristic.RotationSpeed, this.Fan.RotationSpeed, 'RotationSpeed');
         // SwingMode
-        if (this.Fan.SwingMode === undefined) {
-            this.debugLog(`${this.device.deviceType}: ${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.deviceType}: ${this.accessory.displayName} updateCharacteristic SwingMode: ${this.Fan.SwingMode}`);
-        }
-        // BateryLevel
-        if (this.Battery.BatteryLevel === undefined) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BatteryLevel: ${this.Battery.BatteryLevel}`);
-        }
-        else {
-            this.accessory.context.BatteryLevel = this.Battery.BatteryLevel;
-            this.Battery.Service.updateCharacteristic(this.hap.Characteristic.BatteryLevel, this.Battery.BatteryLevel);
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic BatteryLevel: ${this.Battery.BatteryLevel}`);
-        }
+        await this.updateCharacteristic(this.Fan.Service, this.hap.Characteristic.SwingMode, this.Fan.SwingMode, 'SwingMode');
+        // BatteryLevel
+        await this.updateCharacteristic(this.Battery.Service, this.hap.Characteristic.BatteryLevel, this.Battery.BatteryLevel, 'BatteryLevel');
         // ChargingState
-        if (this.Battery.ChargingState === undefined) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} ChargingState: ${this.Battery.ChargingState}`);
-        }
-        else {
-            this.accessory.context.ChargingState = this.Battery.ChargingState;
-            this.Battery.Service.updateCharacteristic(this.hap.Characteristic.ChargingState, this.Battery.ChargingState);
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic ChargingState: ${this.Battery.ChargingState}`);
-        }
+        await this.updateCharacteristic(this.Battery.Service, this.hap.Characteristic.ChargingState, this.Battery.ChargingState, 'ChargingState');
         // StatusLowBattery
-        if (this.Battery.StatusLowBattery === undefined) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} StatusLowBattery: ${this.Battery.StatusLowBattery}`);
-        }
-        else {
-            this.accessory.context.StatusLowBattery = this.Battery.StatusLowBattery;
-            this.Battery.Service.updateCharacteristic(this.hap.Characteristic.StatusLowBattery, this.Battery.StatusLowBattery);
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic`
-                + ` StatusLowBattery: ${this.Battery.StatusLowBattery}`);
-        }
+        await this.updateCharacteristic(this.Battery.Service, this.hap.Characteristic.StatusLowBattery, this.Battery.StatusLowBattery, 'StatusLowBattery');
+        // On
+        await this.updateCharacteristic(this.LightBulb.Service, this.hap.Characteristic.On, this.LightBulb.On, 'On');
+        // Brightness
+        await this.updateCharacteristic(this.LightBulb.Service, this.hap.Characteristic.Brightness, this.LightBulb.Brightness, 'Brightness');
     }
     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();
         }
     }
@@ -634,12 +585,16 @@ export class Fan extends deviceBase {
             this.Fan.Service.updateCharacteristic(this.hap.Characteristic.Active, this.hap.Characteristic.Active.INACTIVE);
             this.Fan.Service.updateCharacteristic(this.hap.Characteristic.RotationSpeed, 0);
             this.Fan.Service.updateCharacteristic(this.hap.Characteristic.SwingMode, this.hap.Characteristic.SwingMode.SWING_DISABLED);
+            this.LightBulb.Service.updateCharacteristic(this.hap.Characteristic.On, false);
+            this.LightBulb.Service.updateCharacteristic(this.hap.Characteristic.Brightness, 0);
         }
     }
     async apiError(e) {
         this.Fan.Service.updateCharacteristic(this.hap.Characteristic.Active, e);
         this.Fan.Service.updateCharacteristic(this.hap.Characteristic.RotationSpeed, e);
         this.Fan.Service.updateCharacteristic(this.hap.Characteristic.SwingMode, e);
+        this.LightBulb.Service.updateCharacteristic(this.hap.Characteristic.On, e);
+        this.LightBulb.Service.updateCharacteristic(this.hap.Characteristic.Brightness, e);
     }
 }
 //# sourceMappingURL=fan.js.map