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

package/dist/platform.js

@@ -32,13 +32,13 @@ import { AirConditioner } from './irdevice/airconditioner.js';
 import { Buffer } from 'buffer';
 import { request } from 'undici';
 import asyncmqtt from 'async-mqtt';
-import { sleep } from './utils.js';
 import { createServer } from 'http';
 import { queueScheduler } from 'rxjs';
 import fakegato from 'fakegato-history';
 import crypto, { randomUUID } from 'crypto';
 import { readFileSync, writeFileSync } from 'fs';
 import { EveHomeKitTypes } from 'homebridge-lib/EveHomeKitTypes';
+import { isBlindTiltDevice, isCurtainDevice, sleep } from './utils.js';
 import { PLATFORM_NAME, PLUGIN_NAME, Devices, setupWebhook, updateWebhook, deleteWebhook, queryWebhook } from './settings.js';
 /**
  * HomebridgePlatform
@@ -128,29 +128,29 @@ export class SwitchBotPlatform {
             try {
                 const { connectAsync } = asyncmqtt;
                 this.mqttClient = await connectAsync(this.config.options?.mqttURL, this.config.options.mqttOptions || {});
-                this.debugLog('MQTT connection has been established successfully.');
-                this.mqttClient.on('error', (e) => {
-                    this.errorLog(`Failed to publish MQTT messages. ${e}`);
+                await this.debugLog('MQTT connection has been established successfully.');
+                this.mqttClient.on('error', async (e) => {
+                    await this.errorLog(`Failed to publish MQTT messages. ${e}`);
                 });
                 if (!this.config.options?.webhookURL) {
                     // receive webhook events via MQTT
-                    this.infoLog(`Webhook is configured to be received through ${this.config.options.mqttURL}/homebridge-switchbot/webhook.`);
+                    await this.infoLog(`Webhook is configured to be received through ${this.config.options.mqttURL}/homebridge-switchbot/webhook.`);
                     this.mqttClient.subscribe('homebridge-switchbot/webhook/+');
                     this.mqttClient.on('message', async (topic, message) => {
                         try {
-                            this.debugLog(`Received Webhook via MQTT: ${topic}=${message}`);
+                            await this.debugLog(`Received Webhook via MQTT: ${topic}=${message}`);
                             const context = JSON.parse(message.toString());
-                            await this.webhookEventHandler[context.deviceMac]?.(context);
+                            this.webhookEventHandler[context.deviceMac]?.(context);
                         }
                         catch (e) {
-                            this.errorLog(`Failed to handle webhook event. Error:${e}`);
+                            await this.errorLog(`Failed to handle webhook event. Error:${e}`);
                         }
                     });
                 }
             }
             catch (e) {
                 this.mqttClient = null;
-                this.errorLog(`Failed to establish MQTT connection. ${e}`);
+                await this.errorLog(`Failed to establish MQTT connection. ${e}`);
             }
         }
     }
@@ -177,7 +177,7 @@ export class SwitchBotPlatform {
                                         const options = this.config.options?.mqttPubOptions || {};
                                         this.mqttClient?.publish(`homebridge-switchbot/webhook/${mac}`, `${JSON.stringify(body.context)}`, options);
                                     }
-                                    await this.webhookEventHandler[body.context.deviceMac]?.(body.context);
+                                    this.webhookEventHandler[body.context.deviceMac]?.(body.context);
                                 }
                                 catch (e) {
                                     this.errorLog(`Failed to handle webhook event. Error:${e}`);
@@ -275,9 +275,7 @@ export class SwitchBotPlatform {
                         }),
                     });
                     const response = await body.json();
-                    this.debugLog(`deleteWebhook: url:${url}`);
-                    this.debugLog(`deleteWebhook: body:${JSON.stringify(response)}`);
-                    this.debugLog(`deleteWebhook: statusCode:${statusCode}`);
+                    this.debugLog(`deleteWebhook: url:${url}, body:${JSON.stringify(response)}, statusCode:${statusCode}`);
                     if (statusCode !== 200 || response?.statusCode !== 100) {
                         this.errorLog(`Failed to delete webhook. HTTP:${statusCode} API:${response?.statusCode} message:${response?.message}`);
                     }
@@ -1330,16 +1328,18 @@ export class SwitchBotPlatform {
             if (!device.external) {
                 this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
             }
-            if (device.group && !device.curtain?.disable_group) {
-                this.debugLog('Your Curtains are grouped, ' +
-                    `, Secondary curtain automatically hidden. Main Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
-            }
-            else {
-                if (device.master) {
-                    this.warnLog(`Main Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
+            if (isBlindTiltDevice(device)) {
+                if (device.group && !device.curtain?.disable_group) {
+                    this.debugLog('Your Curtains are grouped, ' +
+                        `, Secondary curtain automatically hidden. Main Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
                 }
                 else {
-                    this.errorLog(`Secondary Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
+                    if (device.master) {
+                        this.warnLog(`Main Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
+                    }
+                    else {
+                        this.errorLog(`Secondary Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
+                    }
                 }
             }
             // create a new accessory
@@ -1399,16 +1399,18 @@ export class SwitchBotPlatform {
             if (!device.external) {
                 this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
             }
-            if (device.group && !device.curtain?.disable_group) {
-                this.debugLog('Your Curtains are grouped, ' +
-                    `, Secondary curtain automatically hidden. Main Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
-            }
-            else {
-                if (device.master) {
-                    this.warnLog(`Main Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
+            if (isCurtainDevice(device)) {
+                if (device.group && !device.curtain?.disable_group) {
+                    this.debugLog('Your Curtains are grouped, ' +
+                        `, Secondary curtain automatically hidden. Main Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
                 }
                 else {
-                    this.errorLog(`Secondary Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
+                    if (device.master) {
+                        this.warnLog(`Main Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
+                    }
+                    else {
+                        this.errorLog(`Secondary Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
+                    }
                 }
             }
             // create a new accessory
@@ -1844,9 +1846,6 @@ export class SwitchBotPlatform {
             existingAccessory.context.model = device.remoteType;
             existingAccessory.context.deviceID = device.deviceId;
             existingAccessory.displayName = device.configDeviceName || device.deviceName;
-            if (device.version && !device.firmware) {
-                existingAccessory.context.version = device.version;
-            }
             existingAccessory.context.deviceType = `IR: ${device.remoteType}`;
             this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
             existingAccessory.context.connectionType = device.connectionType;
@@ -2341,16 +2340,32 @@ export class SwitchBotPlatform {
         }
     }
     async registerCurtains(device) {
-        switch (device.deviceType) {
-            case 'Curtain':
-            case 'Curtain3':
-                this.debugWarnLog(`deviceName: ${device.deviceName} deviceId: ${device.deviceId}, curtainDevicesIds: ${device.curtainDevicesIds}, master: `
-                    + `${device.master}, group: ${device.group}, disable_group: ${device.curtain?.disable_group}, connectionType: ${device.connectionType}`);
-                break;
-            default:
-                this.debugWarnLog(`deviceName: ${device.deviceName} deviceId: ${device.deviceId}, blindTiltDevicesIds: ${device.blindTiltDevicesIds}, master:`
-                    + ` ${device.master}, group: ${device.group}, disable_group: ${device.curtain?.disable_group}, connectionType: ${device.connectionType}`);
+        /*function isCurtainDevice(device: device & devicesConfig): device is (curtain | curtain3) & devicesConfig {
+          return device.deviceType === 'Curtain' || device.deviceType === 'Curtain3';
+        }
+    
+        function isBlindTiltDevice(device: device & devicesConfig): device is blindTilt & devicesConfig {
+          return device.deviceType === 'Blind Tilt';
+        }*/
+        let registerWindowCovering;
+        if (isCurtainDevice(device)) {
+            this.debugWarnLog(`deviceName: ${device.deviceName} deviceId: ${device.deviceId}, curtainDevicesIds: ${device.curtainDevicesIds}, master: `
+                + `${device.master}, group: ${device.group}, disable_group: ${device.curtain?.disable_group}, connectionType: ${device.connectionType}`);
+            registerWindowCovering = await this.registerWindowCovering(device);
+        }
+        else if (isBlindTiltDevice(device)) {
+            this.debugWarnLog(`deviceName: ${device.deviceName} deviceId: ${device.deviceId}, blindTiltDevicesIds: ${device.blindTiltDevicesIds},`
+                + ` master: ${device.master}, group: ${device.group}, disable_group: ${device.curtain?.disable_group},`
+                + ` connectionType: ${device.connectionType}`);
+            registerWindowCovering = await this.registerWindowCovering(device);
+        }
+        else {
+            registerWindowCovering = false;
         }
+        return registerWindowCovering;
+    }
+    async registerWindowCovering(device) {
+        this.debugLog(device.master);
         let registerCurtain;
         if (device.master && device.group) {
             // OpenAPI: Master Curtains/Blind Tilt in Group
@@ -2524,67 +2539,67 @@ export class SwitchBotPlatform {
     async statusCode(statusCode) {
         switch (statusCode) {
             case 151:
-                this.errorLog(`Command not supported by this device type, statusCode: ${statusCode}, Submit Feature Request Here: ` +
+                await this.errorLog(`Command not supported by this device type, statusCode: ${statusCode}, Submit Feature Request Here: ` +
                     'https://tinyurl.com/SwitchBotFeatureRequest');
                 break;
             case 152:
-                this.errorLog(`Device not found, statusCode: ${statusCode}`);
+                await this.errorLog(`Device not found, statusCode: ${statusCode}`);
                 break;
             case 160:
-                this.errorLog(`Command is not supported, statusCode: ${statusCode}, Submit Bugs Here: https://tinyurl.com/SwitchBotBug`);
+                await this.errorLog(`Command is not supported, statusCode: ${statusCode}, Submit Bugs Here: https://tinyurl.com/SwitchBotBug`);
                 break;
             case 161:
-                this.errorLog(`Device is offline, statusCode: ${statusCode}`);
+                await this.errorLog(`Device is offline, statusCode: ${statusCode}`);
                 break;
             case 171:
-                this.errorLog(`is offline, statusCode: ${statusCode}`);
+                await this.errorLog(`is offline, statusCode: ${statusCode}`);
                 break;
             case 190:
-                this.errorLog(`Requests reached the daily limit, statusCode: ${statusCode}`);
+                await this.errorLog(`Requests reached the daily limit, statusCode: ${statusCode}`);
                 break;
             case 100:
-                this.debugLog(`Command successfully sent, statusCode: ${statusCode}`);
+                await this.debugLog(`Command successfully sent, statusCode: ${statusCode}`);
                 break;
             case 200:
-                this.debugLog(`Request successful, statusCode: ${statusCode}`);
+                await this.debugLog(`Request successful, statusCode: ${statusCode}`);
                 break;
             case 400:
-                this.errorLog('Bad Request, The client has issued an invalid request. This is commonly used to specify validation errors in a request '
+                await 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('Unauthorized,	Authorization for the API is required, but the request has not been authenticated, '
+                await this.errorLog('Unauthorized,	Authorization for the API is required, but the request has not been authenticated, '
                     + `statusCode: ${statusCode}`);
                 break;
             case 403:
-                this.errorLog('Forbidden,	The request has been authenticated but does not have appropriate permissions, or a requested resource is not '
+                await 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(`Not Found,	Specifies the requested path does not exist, statusCode: ${statusCode}`);
+                await this.errorLog(`Not Found,	Specifies the requested path does not exist, statusCode: ${statusCode}`);
                 break;
             case 406:
-                this.errorLog('Not Acceptable,	The client has requested a MIME type via the Accept header for a value not supported by the server, '
+                await 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('Unsupported Media Type,	The client has defined a contentType header that is not supported by the server, '
+                await 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('Unprocessable Entity,	The client has made a valid request, but the server cannot process it. This is often used for '
+                await 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('Too Many Requests,	The client has exceeded the number of requests allowed for a given time window, '
+                await 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('Internal Server Error,	An unexpected error on the SmartThings servers has occurred. These errors should be rare, '
+                await this.errorLog('Internal Server Error,	An unexpected error on the SmartThings servers has occurred. These errors should be rare, '
                     + `statusCode: ${statusCode}`);
                 break;
             default:
-                this.errorLog(`Unknown statusCode, statusCode: ${statusCode}, Submit Bugs Here: ' + 'https://tinyurl.com/SwitchBotBug`);
+                await this.errorLog(`Unknown statusCode, statusCode: ${statusCode}, Submit Bugs Here: ' + 'https://tinyurl.com/SwitchBotBug`);
         }
     }
     async retryRequest(deviceMaxRetries, deviceDelayBetweenRetries, url, options) {
@@ -2598,34 +2613,35 @@ export class SwitchBotPlatform {
                     return { body, statusCode };
                 }
                 else {
-                    this.debugLog(`Received status code: ${statusCode}`);
+                    await this.debugLog(`Received status code: ${statusCode}`);
                 }
             }
             catch (error) {
-                this.errorLog(`Error making request: ${error.message}`);
+                await this.errorLog(`Error making request: ${error.message}`);
             }
             retryCount++;
-            this.debugLog(`Retry attempt ${retryCount} of ${maxRetries}`);
+            await this.debugLog(`Retry attempt ${retryCount} of ${maxRetries}`);
             await sleep(delayBetweenRetries);
         }
         return { body: null, statusCode: -1 };
     }
     // BLE Connection
-    async connectBLE() {
+    async connectBLE(accessory, device) {
         let switchbot;
         try {
             const SwitchBot = (await import('node-switchbot')).SwitchBot;
             queueScheduler.schedule(() => (switchbot = new SwitchBot()));
+            await this.debugLog(`${device.deviceType}: ${accessory.displayName} 'node-switchbot' found: ${switchbot}`);
         }
         catch (e) {
             switchbot = false;
-            this.errorLog(`Was 'node-switchbot' found: ${switchbot}, Error: ${e}`);
+            await this.errorLog(`${device.deviceType}: ${accessory.displayName} 'node-switchbot' found: ${switchbot}, Error: ${e}`);
         }
         return switchbot;
     }
     async getVersion() {
         const json = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf-8'));
-        this.debugLog(`Plugin Version: ${json.version}`);
+        await this.debugLog(`Plugin Version: ${json.version}`);
         this.version = json.version;
     }
     async getPlatformConfigSettings() {
@@ -2662,7 +2678,7 @@ export class SwitchBotPlatform {
                 platformConfig.delayBetweenRetries = this.delayBetweenRetries / 1000;
             }
             if (Object.entries(platformConfig).length !== 0) {
-                this.debugLog(`Platform Config: ${JSON.stringify(platformConfig)}`);
+                await this.debugLog(`Platform Config: ${JSON.stringify(platformConfig)}`);
             }
             this.platformConfig = platformConfig;
         }
@@ -2671,64 +2687,64 @@ export class SwitchBotPlatform {
         this.debugMode = process.argv.includes('-D') || process.argv.includes('--debug');
         if (this.config.options?.logging === 'debug' || this.config.options?.logging === 'standard' || this.config.options?.logging === 'none') {
             this.platformLogging = this.config.options.logging;
-            this.debugWarnLog(`Using Config Logging: ${this.platformLogging}`);
+            await this.debugWarnLog(`Using Config Logging: ${this.platformLogging}`);
         }
         else if (this.debugMode) {
             this.platformLogging = 'debugMode';
-            this.debugWarnLog(`Using ${this.platformLogging} Logging`);
+            await this.debugWarnLog(`Using ${this.platformLogging} Logging`);
         }
         else {
             this.platformLogging = 'standard';
-            this.debugWarnLog(`Using ${this.platformLogging} Logging`);
+            await this.debugWarnLog(`Using ${this.platformLogging} Logging`);
         }
     }
     /**
      * If device level logging is turned on, log to log.warn
      * Otherwise send debug logs to log.debug
      */
-    infoLog(...log) {
-        if (this.enablingPlatformLogging()) {
+    async infoLog(...log) {
+        if (await this.enablingPlatformLogging()) {
             this.log.info(String(...log));
         }
     }
-    successLog(...log) {
-        if (this.enablingPlatformLogging()) {
+    async successLog(...log) {
+        if (await this.enablingPlatformLogging()) {
             this.log.success(String(...log));
         }
     }
-    debugSuccessLog(...log) {
-        if (this.enablingPlatformLogging()) {
+    async debugSuccessLog(...log) {
+        if (await this.enablingPlatformLogging()) {
             if (this.platformLogging?.includes('debug')) {
                 this.log.success('[DEBUG]', String(...log));
             }
         }
     }
-    warnLog(...log) {
-        if (this.enablingPlatformLogging()) {
+    async warnLog(...log) {
+        if (await this.enablingPlatformLogging()) {
             this.log.warn(String(...log));
         }
     }
-    debugWarnLog(...log) {
-        if (this.enablingPlatformLogging()) {
+    async debugWarnLog(...log) {
+        if (await this.enablingPlatformLogging()) {
             if (this.platformLogging?.includes('debug')) {
                 this.log.warn('[DEBUG]', String(...log));
             }
         }
     }
-    errorLog(...log) {
-        if (this.enablingPlatformLogging()) {
+    async errorLog(...log) {
+        if (await this.enablingPlatformLogging()) {
             this.log.error(String(...log));
         }
     }
-    debugErrorLog(...log) {
-        if (this.enablingPlatformLogging()) {
+    async debugErrorLog(...log) {
+        if (await this.enablingPlatformLogging()) {
             if (this.platformLogging?.includes('debug')) {
                 this.log.error('[DEBUG]', String(...log));
             }
         }
     }
-    debugLog(...log) {
-        if (this.enablingPlatformLogging()) {
+    async debugLog(...log) {
+        if (await this.enablingPlatformLogging()) {
             if (this.platformLogging === 'debugMode') {
                 this.log.debug(String(...log));
             }
@@ -2737,7 +2753,7 @@ export class SwitchBotPlatform {
             }
         }
     }
-    enablingPlatformLogging() {
+    async enablingPlatformLogging() {
         return this.platformLogging?.includes('debug') || this.platformLogging === 'standard';
     }
 }