@switchbot/homebridge-switchbot 2.0.0-beta.4 → 2.0.0-beta.40

package/dist/platform.js

@@ -13,6 +13,7 @@ const contact_1 = require("./device/contact");
 const curtain_1 = require("./device/curtain");
 const meterplus_1 = require("./device/meterplus");
 const colorbulb_1 = require("./device/colorbulb");
+const ceilinglight_1 = require("./device/ceilinglight");
 const striplight_1 = require("./device/striplight");
 const humidifier_1 = require("./device/humidifier");
 const tv_1 = require("./irdevice/tv");
@@ -28,6 +29,7 @@ const https_1 = __importDefault(require("https"));
 const crypto_1 = __importDefault(require("crypto"));
 const buffer_1 = require("buffer");
 const fakegato_history_1 = __importDefault(require("fakegato-history"));
+const super_stringify_1 = __importDefault(require("super-stringify"));
 const fs_1 = require("fs");
 const settings_1 = require("./settings");
 /**
@@ -61,10 +63,8 @@ class SwitchBotPlatform {
             this.debugLog('Config OK');
         }
         catch (e) {
-            this.errorLog(JSON.stringify(e.message));
-            if (this.platformLogging?.includes('debug')) {
-                this.errorLog(JSON.stringify(e));
-            }
+            this.errorLog(`Verify Config, Error Message: ${e.message}`);
+            this.debugErrorLog(`Verify Config, Error: ${e}`);
             return;
         }
         // import fakegato-history module
@@ -80,39 +80,20 @@ class SwitchBotPlatform {
                 if (this.config.credentials?.openToken && !this.config.credentials.token) {
                     await this.updateToken();
                 }
+                else if (this.config.credentials?.token && !this.config.credentials?.secret) {
+                    // eslint-disable-next-line no-useless-escape
+                    this.errorLog('\"secret\" config is not populated, you must populate then please restart Homebridge.');
+                }
                 else {
                     this.discoverDevices();
                 }
             }
             catch (e) {
-                this.errorLog('Failed to Discover Devices.', JSON.stringify(e.message));
-                if (this.platformLogging?.includes('debug')) {
-                    this.errorLog(JSON.stringify(e));
-                }
+                this.errorLog(`Failed to Discover, Error Message: ${e.message}`);
+                this.debugErrorLog(`Failed to Discover, Error: ${e}`);
             }
         });
     }
-    logs() {
-        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;
-            if (this.platformLogging.includes('debug')) {
-                this.log.warn(`Using Config Logging: ${this.platformLogging}`);
-            }
-        }
-        else if (this.debugMode) {
-            this.platformLogging = 'debugMode';
-            if (this.platformLogging?.includes('debug')) {
-                this.log.warn(`Using ${this.platformLogging} Logging`);
-            }
-        }
-        else {
-            this.platformLogging = 'standard';
-            if (this.platformLogging?.includes('debug')) {
-                this.log.warn(`Using ${this.platformLogging} Logging`);
-            }
-        }
-    }
     /**
      * This function is invoked when homebridge restores cached accessories from disk at startup.
      * It should be used to setup event handlers for characteristics and update respective values.
@@ -131,14 +112,14 @@ class SwitchBotPlatform {
         if (this.config.options.logging) {
             platformConfig['logging'] = this.config.options.logging;
         }
-        if (this.config.options.logging) {
+        if (this.config.options.logging && this.config.options.refreshRate) {
             platformConfig['refreshRate'] = this.config.options.refreshRate;
         }
-        if (this.config.options.logging) {
+        if (this.config.options.logging && this.config.options.pushRate) {
             platformConfig['pushRate'] = this.config.options.pushRate;
         }
         if (Object.entries(platformConfig).length !== 0) {
-            this.infoLog(`Platform Config: ${JSON.stringify(platformConfig)}`);
+            this.infoLog(`Platform Config: ${(0, super_stringify_1.default)(platformConfig)}`);
         }
         if (this.config.options) {
             // Device Config
@@ -148,7 +129,7 @@ class SwitchBotPlatform {
                         if (!deviceConfig.deviceId) {
                             throw new Error('The devices config section is missing the *Device ID* in the config. Please check your config.');
                         }
-                        if (!deviceConfig.configDeviceType && deviceConfig.ble) {
+                        if (!deviceConfig.configDeviceType && deviceConfig.connectionType) {
                             throw new Error('The devices config section is missing the *Device Type* in the config. Please check your config.');
                         }
                     }
@@ -174,34 +155,25 @@ class SwitchBotPlatform {
         if (!this.config.options.refreshRate) {
             // default 120 seconds (2 minutes)
             this.config.options.refreshRate = 120;
-            if (this.platformLogging?.includes('debug')) {
-                this.debugLog('Using Default Refresh Rate (2 minutes).');
-            }
-            if (!this.config.options.pushRate) {
-                // default 100 milliseconds
-                this.config.options.pushRate = 0.1;
-                if (this.platformLogging?.includes('debug')) {
-                    this.warnLog('Using Default Push Rate.');
-                }
-            }
-            if (!this.config.credentials) {
-                if (this.platformLogging?.includes('debug')) {
-                    this.debugLog('Missing Credentials');
-                }
-            }
+            this.debugWarnLog('Using Default Refresh Rate (2 minutes).');
+        }
+        if (!this.config.options.pushRate) {
+            // default 100 milliseconds
+            this.config.options.pushRate = 0.1;
+            this.debugWarnLog('Using Default Push Rate.');
+        }
+        if (!this.config.credentials && !this.config.options) {
+            this.debugWarnLog('Missing Credentials');
+        }
+        else if (this.config.credentials && !this.config.credentials.notice) {
             if (!this.config.credentials?.token) {
-                if (this.platformLogging?.includes('debug')) {
-                    this.errorLog('Missing token');
-                    this.warnLog('Cloud Enabled SwitchBot Devices & IR Devices will not work');
-                }
+                this.debugErrorLog('Missing token');
+                this.debugWarnLog('Cloud Enabled SwitchBot Devices & IR Devices will not work');
             }
             if (this.config.credentials?.token) {
                 if (!this.config.credentials?.secret) {
-                    if (this.platformLogging?.includes('debug')) {
-                        this.errorLog('Missing secret');
-                        this.warnLog('Cloud Enabled SwitchBot Devices & IR Devices will not work');
-                    }
-                    throw Error('Missing secret');
+                    this.debugErrorLog('Missing secret');
+                    this.debugWarnLog('Cloud Enabled SwitchBot Devices & IR Devices will not work');
                 }
             }
         }
@@ -233,20 +205,26 @@ class SwitchBotPlatform {
                 throw new Error('pluginConfig.credentials is not an object');
             }
             // Move openToken to token
-            this.warnLog('This plugin has been updated to use OpenAPI v1.1, config is set with openToken.');
-            this.warnLog('`openToken` config has been moved to the `token` config, Please restart Homebridge.');
+            if (!this.config.credentials.secret) {
+                // eslint-disable-next-line no-useless-escape, max-len
+                this.warnLog('This plugin has been updated to use OpenAPI v1.1, config is set with openToken, \"openToken\" cconfig has been moved to the \"token\" config');
+                // eslint-disable-next-line no-useless-escape
+                this.errorLog('\"secret\" config is not populated, you must populate then please restart Homebridge.');
+            }
+            else {
+                // eslint-disable-next-line no-useless-escape, max-len
+                this.warnLog('This plugin has been updated to use OpenAPI v1.1, config is set with openToken, \"openToken\" config has been moved to the \"token\" config, please restart Homebridge.');
+            }
             // set the refresh token
             pluginConfig.credentials.token = this.config.credentials?.openToken;
             pluginConfig.credentials.openToken = 'Delete';
-            if (this.platformLogging?.includes('debug')) {
-                this.warnLog(`Token: ${pluginConfig.credentials.token}`);
-            }
+            this.debugWarnLog(`Token: ${pluginConfig.credentials.token}`);
             // save the config, ensuring we maintain pretty json
             (0, fs_1.writeFileSync)(this.api.user.configPath(), JSON.stringify(currentConfig, null, 4));
             this.verifyConfig();
         }
         catch (e) {
-            this.errorLog(e);
+            this.errorLog(`Update Token: ${e}`);
         }
     }
     /**
@@ -274,104 +252,132 @@ class SwitchBotPlatform {
                         'Content-Type': 'application/json',
                     },
                 };
-                const req = https_1.default.request(options, (res) => {
+                const req = https_1.default.request(options, async (res) => {
                     this.debugLog(`statusCode: ${res.statusCode}`);
-                    this.debugLog(`headers: ${JSON.stringify(res.headers)}`);
+                    await this.statusCode({ res });
+                    this.debugLog(`headers: ${(0, super_stringify_1.default)(res.headers)}`);
                     let rawData = '';
                     res.on('data', (d) => {
                         rawData += d;
+                        this.deviceStatus = d;
                         this.debugLog(`d: ${d}`);
                     });
                     res.on('end', () => {
                         try {
                             const devicesAPI = JSON.parse(rawData);
-                            this.debugLog(`devicesAPI: ${JSON.stringify(devicesAPI.body)}`);
+                            this.debugLog(`devicesAPI: ${(0, super_stringify_1.default)(devicesAPI.body)}`);
                             // SwitchBot Devices
-                            if (devicesAPI.body.deviceList.length !== 0) {
-                                this.infoLog(`Total SwitchBot Devices Found: ${devicesAPI.body.deviceList.length}`);
-                            }
-                            else {
-                                this.debugLog(`Total SwitchBot Devices Found: ${devicesAPI.body.deviceList.length}`);
-                            }
-                            const deviceLists = devicesAPI.body.deviceList;
-                            if (!this.config.options?.devices) {
-                                this.debugLog(`SwitchBot Device Config Not Set: ${JSON.stringify(this.config.options?.devices)}`);
-                                const devices = deviceLists.map((v) => v);
-                                for (const device of devices) {
-                                    if (device.deviceType) {
-                                        if (device.configDeviceName) {
-                                            device.deviceName = device.configDeviceName;
+                            /*if (devicesAPI.body.deviceList.length !== 0) {
+                              this.infoLog(`Total SwitchBot Devices Found: ${devicesAPI.body.deviceList.length}`);
+                            } else {
+                              this.debugLog(`Total SwitchBot Devices Found: ${devicesAPI.body.deviceList.length}`);
+                            }*/
+                            const deviceBodyList = devicesAPI.body.deviceList;
+                            let deviceLists;
+                            if (deviceBodyList) {
+                                if (deviceBodyList.length > 1) {
+                                    deviceLists = deviceBodyList;
+                                    this.infoLog(`Total SwitchBot Devices Found: ${deviceLists.length}`);
+                                }
+                                else {
+                                    deviceLists = [deviceBodyList];
+                                    this.infoLog(`Total SwitchBot Devices Found: ${deviceLists.length}`);
+                                }
+                                if (!this.config.options?.devices) {
+                                    this.debugLog(`SwitchBot Device Config Not Set: ${(0, super_stringify_1.default)(this.config.options?.devices)}`);
+                                    const devices = deviceLists.map((v) => v);
+                                    for (const device of devices) {
+                                        if (device.deviceType) {
+                                            if (device.configDeviceName) {
+                                                device.deviceName = device.configDeviceName;
+                                            }
+                                            this.createDevice(device);
                                         }
-                                        this.createDevice(device);
                                     }
                                 }
-                            }
-                            else if (this.config.credentials?.token && this.config.options.devices) {
-                                this.debugLog(`SwitchBot Device Config Set: ${JSON.stringify(this.config.options?.devices)}`);
-                                const deviceConfigs = this.config.options?.devices;
-                                const mergeBydeviceId = (a1, a2) => a1.map((itm) => ({
-                                    ...a2.find((item) => item.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') === itm.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') && item),
-                                    ...itm,
-                                }));
-                                const devices = mergeBydeviceId(deviceLists, deviceConfigs);
-                                this.debugLog(`SwitchBot Devices: ${JSON.stringify(devices)}`);
-                                for (const device of devices) {
-                                    if (device.deviceType) {
-                                        if (device.configDeviceName) {
-                                            device.deviceName = device.configDeviceName;
+                                else if (this.config.credentials?.token && this.config.options.devices) {
+                                    this.debugLog(`SwitchBot Device Config Set: ${(0, super_stringify_1.default)(this.config.options?.devices)}`);
+                                    const deviceConfigs = this.config.options?.devices;
+                                    const mergeBydeviceId = (a1, a2) => a1.map((itm) => ({
+                                        ...a2.find((item) => item.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') === itm.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') && item),
+                                        ...itm,
+                                    }));
+                                    const devices = mergeBydeviceId(deviceLists, deviceConfigs);
+                                    this.debugLog(`SwitchBot Devices: ${(0, super_stringify_1.default)(devices)}`);
+                                    for (const device of devices) {
+                                        if (device.deviceType) {
+                                            if (device.configDeviceName) {
+                                                device.deviceName = device.configDeviceName;
+                                            }
+                                            this.createDevice(device);
                                         }
-                                        this.createDevice(device);
                                     }
                                 }
+                                else {
+                                    this.errorLog('SwitchBot Token Supplied, Issue with Auth.');
+                                }
                             }
                             else {
-                                this.errorLog('SwitchBot Token Supplied, Issue with Auth.');
+                                this.errorLog(`SwitchBot Device Request Issue: ${this.deviceStatus}`);
                             }
                             // IR Devices
-                            if (devicesAPI.body.infraredRemoteList.length !== 0) {
-                                this.infoLog(`Total IR Devices Found: ${devicesAPI.body.infraredRemoteList.length}`);
-                            }
-                            else {
-                                this.debugLog(`Total IR Devices Found: ${devicesAPI.body.infraredRemoteList.length}`);
-                            }
-                            const irDeviceLists = devicesAPI.body.infraredRemoteList;
-                            if (!this.config.options?.irdevices) {
-                                this.debugLog(`IR Device Config Not Set: ${JSON.stringify(this.config.options?.irdevices)}`);
-                                const devices = irDeviceLists.map((v) => v);
-                                for (const device of devices) {
-                                    if (device.remoteType) {
-                                        this.createIRDevice(device);
+                            /*if (devicesAPI.body.infraredRemoteList.length !== 0) {
+                              this.infoLog(`Total IR Devices Found: ${devicesAPI.body.infraredRemoteList.length}`);
+                            } else {
+                              this.debugLog(`Total IR Devices Found: ${devicesAPI.body.infraredRemoteList.length}`);
+                            }*/
+                            const irDeviceBodyList = devicesAPI.body.infraredRemoteList;
+                            let irDeviceLists;
+                            if (irDeviceBodyList) {
+                                if (irDeviceBodyList.length > 1) {
+                                    irDeviceLists = irDeviceBodyList;
+                                    this.infoLog(`Total IR Devices Found: ${irDeviceLists.length}`);
+                                }
+                                else {
+                                    irDeviceLists = [irDeviceBodyList];
+                                    this.infoLog(`Total IR Devices Found: ${irDeviceLists.length}`);
+                                }
+                                if (!this.config.options?.irdevices) {
+                                    this.debugLog(`IR Device Config Not Set: ${(0, super_stringify_1.default)(this.config.options?.irdevices)}`);
+                                    const devices = irDeviceLists.map((v) => v);
+                                    for (const device of devices) {
+                                        if (device.remoteType) {
+                                            this.createIRDevice(device);
+                                        }
                                     }
                                 }
-                            }
-                            else {
-                                this.debugLog(`IR Device Config Set: ${JSON.stringify(this.config.options?.irdevices)}`);
-                                const irDeviceConfig = this.config.options?.irdevices;
-                                const mergeIRBydeviceId = (a1, a2) => a1.map((itm) => ({
-                                    ...a2.find((item) => item.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') === itm.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') && item),
-                                    ...itm,
-                                }));
-                                const devices = mergeIRBydeviceId(irDeviceLists, irDeviceConfig);
-                                this.debugLog(`IR Devices: ${JSON.stringify(devices)}`);
-                                for (const device of devices) {
-                                    if (device.remoteType) {
-                                        this.createIRDevice(device);
+                                else {
+                                    this.debugLog(`IR Device Config Set: ${(0, super_stringify_1.default)(this.config.options?.irdevices)}`);
+                                    const irDeviceConfig = this.config.options?.irdevices;
+                                    const mergeIRBydeviceId = (a1, a2) => a1.map((itm) => ({
+                                        ...a2.find((item) => item.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') === itm.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') && item),
+                                        ...itm,
+                                    }));
+                                    const devices = mergeIRBydeviceId(irDeviceLists, irDeviceConfig);
+                                    this.debugLog(`IR Devices: ${(0, super_stringify_1.default)(devices)}`);
+                                    for (const device of devices) {
+                                        if (device.remoteType) {
+                                            this.createIRDevice(device);
+                                        }
                                     }
                                 }
                             }
+                            else {
+                                this.errorLog(`SwitchBot IR Device Request Issue: ${this.deviceStatus}`);
+                            }
                         }
                         catch (e) {
-                            this.errorLog(e.message);
+                            this.errorLog(`API Request: ${e}`);
                         }
                     });
                 });
-                req.on('error', (error) => {
-                    this.errorLog(error);
+                req.on('error', (e) => {
+                    this.errorLog(`req: ${e}`);
                 });
                 req.end();
             }
             else if (!this.config.credentials?.token && this.config.options?.devices) {
-                this.debugLog(`SwitchBot Device Manual Config Set: ${JSON.stringify(this.config.options?.devices)}`);
+                this.debugLog(`SwitchBot Device Manual Config Set: ${(0, super_stringify_1.default)(this.config.options?.devices)}`);
                 const deviceConfigs = this.config.options?.devices;
                 const devices = deviceConfigs.map((v) => v);
                 for (const device of devices) {
@@ -387,55 +393,8 @@ class SwitchBotPlatform {
             }
         }
         catch (e) {
-            this.deviceError(e);
-        }
-    }
-    deviceError(e) {
-        if (e.message.includes('400')) {
-            this.errorLog('Failed to Discover Devices: Bad Request');
-            this.debugLog('The client has issued an invalid request. This is commonly used to specify validation errors in a request payload.');
-        }
-        else if (e.message.includes('401')) {
-            this.errorLog('Failed to Discover Devices: Unauthorized Request');
-            this.debugLog('Authorization for the API is required, but the request has not been authenticated.');
-        }
-        else if (e.message.includes('403')) {
-            this.errorLog('Failed to Discover Devices: Forbidden Request');
-            this.debugLog('The request has been authenticated but does not have appropriate permissions, or a requested resource is not found.');
-        }
-        else if (e.message.includes('404')) {
-            this.errorLog('Failed to Discover Devices: Requst Not Found');
-            this.debugLog('Specifies the requested path does not exist.');
-        }
-        else if (e.message.includes('406')) {
-            this.errorLog('Failed to Discover Devices: Request Not Acceptable');
-            this.debugLog('The client has requested a MIME type via the Accept header for a value not supported by the server.');
-        }
-        else if (e.message.includes('415')) {
-            this.errorLog('Failed to Discover Devices: Unsupported Requst Header');
-            this.debugLog('The client has defined a contentType header that is not supported by the server.');
-        }
-        else if (e.message.includes('422')) {
-            this.errorLog('Failed to Discover Devices: Unprocessable Entity');
-            this.debugLog('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.');
-        }
-        else if (e.message.includes('429')) {
-            this.errorLog('Failed to Discover Devices: Too Many Requests');
-            this.debugLog('The client has exceeded the number of requests allowed for a given time window.');
-        }
-        else if (e.message.includes('500')) {
-            this.errorLog('Failed to Discover Devices: Internal Server Error');
-            this.debugLog('An unexpected error on the SmartThings servers has occurred. These errors should be rare.');
-        }
-        else {
-            this.errorLog('Failed to Discover Devices');
-        }
-        if (this.platformLogging === 'debug') {
-            this.errorLog(`Failed to Discover Devices, Error Message: ${JSON.stringify(e.message)}`);
-        }
-        if (this.platformLogging === 'debugMode') {
-            this.errorLog(`Failed to Discover Devices, Error: ${JSON.stringify(e)}`);
+            this.debugErrorLog(`Failed to Discover Devices, Error Message: ${(0, super_stringify_1.default)(e.message)}`);
+            this.debugErrorLog(`Failed to Discover Devices, Error: ${e}`);
         }
     }
     createDevice(device) {
@@ -471,7 +430,7 @@ class SwitchBotPlatform {
                 this.createContact(device);
                 break;
             case 'Curtain':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.deviceType} ${device.deviceName}: ${device.deviceId}`);
                 this.createCurtain(device);
                 break;
             case 'Plug':
@@ -488,12 +447,15 @@ class SwitchBotPlatform {
                 this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createColorBulb(device);
                 break;
+            case 'Ceiling Light':
+                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.createCeilingLight(device);
+                break;
             case 'Strip Light':
                 this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createStripLight(device);
                 break;
             case 'Indoor Cam':
-                this.deviceInfo(device);
                 this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.warnLog(`Device: ${device.deviceName} with Device Type: ${device.deviceType}, is currently not supported.`);
                 break;
@@ -501,7 +463,6 @@ class SwitchBotPlatform {
                 this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId} is Not Supported.`);
                 break;
             default:
-                this.deviceInfo(device);
                 this.warnLog(`Device: ${device.deviceName} with Device Type: ${device.deviceType}, is currently not supported.`);
                 this.warnLog('Submit Feature Requests Here: https://git.io/JL14Z');
         }
@@ -563,30 +524,11 @@ class SwitchBotPlatform {
                 this.createOthers(device);
                 break;
             default:
-                this.deviceInfo(device);
+                this.debugLog(`Unsupported Device: ${(0, super_stringify_1.default)(device)}`);
                 this.warnLog(`Device: ${device.deviceName} with Device Type: ${device.remoteType}, is currently not supported.`);
                 this.warnLog('Submit Feature Requests Here: https://git.io/JL14Z');
         }
     }
-    registerDevice(device) {
-        if (!device.hide_device && device.enableCloudService && device.ble) {
-            this.registeringDevice = true;
-            this.debugLog(`Device: ${device.deviceName} Both OpenAPI and BLE Connections Enabled`);
-        }
-        else if (!device.hide_device && device.deviceId && device.configDeviceType && device.configDeviceName && !device.enableCloudService) {
-            this.registeringDevice = true;
-            this.debugLog(`Device: ${device.deviceName} BLE Connection Enabled`);
-        }
-        else if (!device.hide_device && device.enableCloudService && !device.ble) {
-            this.registeringDevice = true;
-            this.debugLog(`Device: ${device.deviceName} OpenAPI Connection Enabled`);
-        }
-        else {
-            this.registeringDevice = false;
-            this.debugLog(`Device: ${device.deviceName} OpenAPI and BLE Are Not Enabled`);
-        }
-        return this.registeringDevice;
-    }
     async createHumidifier(device) {
         const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.deviceType}`);
         // see if an accessory with the same uuid has already been registered and restored from
@@ -594,16 +536,15 @@ class SwitchBotPlatform {
         const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
-            if (this.registerDevice(device)) {
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+            if (await this.registerDevice(device)) {
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
-                //existingAccessory.context.firmwareRevision = firmware;
                 existingAccessory.context.model = device.deviceType;
                 existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.deviceName;
+                existingAccessory.displayName = device.configDeviceName || device.deviceName;
                 existingAccessory.context.firmwareRevision = device.firmware;
                 existingAccessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-                await this.connectionTypeExistingAccessory(device, existingAccessory);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.connectionType = await this.connectionType(device);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
@@ -614,9 +555,11 @@ class SwitchBotPlatform {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
-        else if (this.registerDevice(device)) {
+        else if (await this.registerDevice(device)) {
             // the accessory does not yet exist, so we need to create it
-            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            if (!device.external) {
+                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
@@ -626,17 +569,17 @@ class SwitchBotPlatform {
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = device.firmware;
             accessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-            await this.connectionTypeNewAccessory(device, accessory);
+            accessory.context.connectionType = await this.connectionType(device);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new humidifier_1.Humidifier(this, accessory, device);
             this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
-            // link the accessory to your platform
-            this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
+            // publish device externally or link the accessory to your platform
+            this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createBot(device) {
@@ -646,16 +589,16 @@ class SwitchBotPlatform {
         const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
-            if (this.registerDevice(device)) {
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
-                this.debugLog(JSON.stringify(device.bot?.mode));
+            if (await this.registerDevice(device)) {
+                this.debugLog((0, super_stringify_1.default)(device.bot?.mode));
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
                 existingAccessory.context.model = device.deviceType;
                 existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.deviceName;
+                existingAccessory.displayName = device.configDeviceName || device.deviceName;
                 existingAccessory.context.firmwareRevision = device.firmware;
                 existingAccessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-                await this.connectionTypeExistingAccessory(device, existingAccessory);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.connectionType = await this.connectionType(device);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
@@ -666,10 +609,12 @@ class SwitchBotPlatform {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
-        else if (this.registerDevice(device)) {
+        else if (await this.registerDevice(device)) {
             // the accessory does not yet exist, so we need to create it
-            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
-            this.debugLog(JSON.stringify(device.bot?.mode));
+            if (!device.external) {
+                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            }
+            this.debugLog((0, super_stringify_1.default)(device.bot?.mode));
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
@@ -679,18 +624,18 @@ class SwitchBotPlatform {
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = device.firmware;
             accessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-            await this.connectionTypeNewAccessory(device, accessory);
+            accessory.context.connectionType = await this.connectionType(device);
             // accessory.context.firmwareRevision = findaccessories.accessoryAttribute.softwareRevision;
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new bot_1.Bot(this, accessory, device);
             this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
-            // link the accessory to your platform
-            this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
+            // publish device externally or link the accessory to your platform
+            this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createMeter(device) {
@@ -700,15 +645,15 @@ class SwitchBotPlatform {
         const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
-            if (this.registerDevice(device)) {
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+            if (await this.registerDevice(device)) {
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
                 existingAccessory.context.model = device.deviceType;
                 existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.deviceName;
+                existingAccessory.displayName = device.configDeviceName || device.deviceName;
                 existingAccessory.context.firmwareRevision = device.firmware;
                 existingAccessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-                await this.connectionTypeExistingAccessory(device, existingAccessory);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.connectionType = await this.connectionType(device);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
@@ -719,9 +664,11 @@ class SwitchBotPlatform {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
-        else if (this.registerDevice(device)) {
+        else if (await this.registerDevice(device)) {
             // the accessory does not yet exist, so we need to create it
-            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            if (!device.external) {
+                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
@@ -731,17 +678,17 @@ class SwitchBotPlatform {
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = device.firmware;
             accessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-            await this.connectionTypeNewAccessory(device, accessory);
+            accessory.context.connectionType = await this.connectionType(device);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new meter_1.Meter(this, accessory, device);
             this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
-            // link the accessory to your platform
-            this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
+            // publish device externally or link the accessory to your platform
+            this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createMeterPlus(device) {
@@ -751,15 +698,15 @@ class SwitchBotPlatform {
         const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
-            if (this.registerDevice(device)) {
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+            if (await this.registerDevice(device)) {
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
                 existingAccessory.context.model = device.deviceType;
                 existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.deviceName;
+                existingAccessory.displayName = device.configDeviceName || device.deviceName;
                 existingAccessory.context.firmwareRevision = device.firmware;
                 existingAccessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-                await this.connectionTypeExistingAccessory(device, existingAccessory);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.connectionType = await this.connectionType(device);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
@@ -770,9 +717,11 @@ class SwitchBotPlatform {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
-        else if (this.registerDevice(device)) {
+        else if (await this.registerDevice(device)) {
             // the accessory does not yet exist, so we need to create it
-            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            if (!device.external) {
+                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
@@ -782,17 +731,17 @@ class SwitchBotPlatform {
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = device.firmware;
             accessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-            await this.connectionTypeNewAccessory(device, accessory);
+            accessory.context.connectionType = await this.connectionType(device);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new meterplus_1.MeterPlus(this, accessory, device);
             this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
-            // link the accessory to your platform
-            this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
+            // publish device externally or link the accessory to your platform
+            this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createMotion(device) {
@@ -802,15 +751,15 @@ class SwitchBotPlatform {
         const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
-            if (this.registerDevice(device)) {
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+            if (await this.registerDevice(device)) {
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
                 existingAccessory.context.model = device.deviceType;
                 existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.deviceName;
+                existingAccessory.displayName = device.configDeviceName || device.deviceName;
                 existingAccessory.context.firmwareRevision = device.firmware;
                 existingAccessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-                await this.connectionTypeExistingAccessory(device, existingAccessory);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.connectionType = await this.connectionType(device);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
@@ -821,9 +770,11 @@ class SwitchBotPlatform {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
-        else if (this.registerDevice(device)) {
+        else if (await this.registerDevice(device)) {
             // the accessory does not yet exist, so we need to create it
-            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            if (!device.external) {
+                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
@@ -833,17 +784,17 @@ class SwitchBotPlatform {
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = device.firmware;
             accessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-            await this.connectionTypeNewAccessory(device, accessory);
+            accessory.context.connectionType = await this.connectionType(device);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new motion_1.Motion(this, accessory, device);
             this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
-            // link the accessory to your platform
-            this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
+            // publish device externally or link the accessory to your platform
+            this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createContact(device) {
@@ -853,15 +804,15 @@ class SwitchBotPlatform {
         const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
-            if (this.registerDevice(device)) {
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+            if (await this.registerDevice(device)) {
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
                 existingAccessory.context.model = device.deviceType;
                 existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.deviceName;
+                existingAccessory.displayName = device.configDeviceName || device.deviceName;
                 existingAccessory.context.firmwareRevision = device.firmware;
                 existingAccessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-                await this.connectionTypeExistingAccessory(device, existingAccessory);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.connectionType = await this.connectionType(device);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
@@ -872,9 +823,11 @@ class SwitchBotPlatform {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
-        else if (this.registerDevice(device)) {
+        else if (await this.registerDevice(device)) {
             // the accessory does not yet exist, so we need to create it
-            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            if (!device.external) {
+                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
@@ -884,17 +837,17 @@ class SwitchBotPlatform {
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = device.firmware;
             accessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-            await this.connectionTypeNewAccessory(device, accessory);
+            accessory.context.connectionType = await this.connectionType(device);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new contact_1.Contact(this, accessory, device);
             this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
-            // link the accessory to your platform
-            this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
+            // publish device externally or link the accessory to your platform
+            this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createCurtain(device) {
@@ -904,15 +857,15 @@ class SwitchBotPlatform {
         const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
-            if (this.isCurtainGrouped(device)) {
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+            if (await this.registerDevice(device)) {
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
                 existingAccessory.context.model = device.deviceType;
                 existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.deviceName;
+                existingAccessory.displayName = device.configDeviceName || device.deviceName;
                 existingAccessory.context.firmwareRevision = device.firmware;
                 existingAccessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-                await this.connectionTypeExistingAccessory(device, existingAccessory);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.connectionType = await this.connectionType(device);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
@@ -923,19 +876,21 @@ class SwitchBotPlatform {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
-        else if (this.isCurtainGrouped(device)) {
+        else if (await this.registerDevice(device)) {
             // the accessory does not yet exist, so we need to create it
-            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            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.debugLog(`Main Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
+                    this.warnLog(`Main Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
                 }
                 else {
-                    this.debugLog(`Secondary Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
+                    this.errorLog(`Secondary Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
                 }
             }
             // create a new accessory
@@ -947,29 +902,17 @@ class SwitchBotPlatform {
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = device.firmware;
             accessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-            await this.connectionTypeNewAccessory(device, accessory);
+            accessory.context.connectionType = await this.connectionType(device);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new curtain_1.Curtain(this, accessory, device);
             this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
-            // link the accessory to your platform
-            this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
+            // publish device externally or link the accessory to your platform
+            this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
-        }
-    }
-    isCurtainGrouped(device) {
-        this.debugLog(`deviceId: ${device.deviceId}, curtainDevicesIds: ${device.curtainDevicesIds},` +
-            ` master: ${device.master}, group: ${device.group}, disable_group: ${device.curtain?.disable_group}`);
-        if (device.group && !device.curtain?.disable_group) {
-            this.debugLog(`[Curtain Config] disable_group: ${device.curtain?.disable_group}`);
-            return device.master && this.registerDevice(device);
-        }
-        else {
-            this.debugLog(`[Curtain Config] disable_group: ${device.curtain?.disable_group}, UnGrouping ${device.master}`);
-            return this.registerDevice(device);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createPlug(device) {
@@ -979,15 +922,15 @@ class SwitchBotPlatform {
         const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
-            if (this.registerDevice(device)) {
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+            if (await this.registerDevice(device)) {
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
                 existingAccessory.context.model = device.deviceType;
                 existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.deviceName;
+                existingAccessory.displayName = device.configDeviceName || device.deviceName;
                 existingAccessory.context.firmwareRevision = device.firmware;
                 existingAccessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-                await this.connectionTypeExistingAccessory(device, existingAccessory);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.connectionType = await this.connectionType(device);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
@@ -998,9 +941,11 @@ class SwitchBotPlatform {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
-        else if (this.registerDevice(device)) {
+        else if (await this.registerDevice(device)) {
             // the accessory does not yet exist, so we need to create it
-            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            if (!device.external) {
+                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
@@ -1010,17 +955,17 @@ class SwitchBotPlatform {
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = device.firmware;
             accessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-            await this.connectionTypeNewAccessory(device, accessory);
+            accessory.context.connectionType = await this.connectionType(device);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new plug_1.Plug(this, accessory, device);
             this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
-            // link the accessory to your platform
-            this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
+            // publish device externally or link the accessory to your platform
+            this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createLock(device) {
@@ -1030,15 +975,15 @@ class SwitchBotPlatform {
         const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
-            if (this.registerDevice(device)) {
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+            if (await this.registerDevice(device)) {
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
                 existingAccessory.context.model = device.deviceType;
                 existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.deviceName;
+                existingAccessory.displayName = device.configDeviceName || device.deviceName;
                 existingAccessory.context.firmwareRevision = device.firmware;
                 existingAccessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-                await this.connectionTypeExistingAccessory(device, existingAccessory);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.connectionType = await this.connectionType(device);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
@@ -1049,9 +994,11 @@ class SwitchBotPlatform {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
-        else if (this.registerDevice(device)) {
+        else if (await this.registerDevice(device)) {
             // the accessory does not yet exist, so we need to create it
-            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            if (!device.external) {
+                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
@@ -1061,17 +1008,17 @@ class SwitchBotPlatform {
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = device.firmware;
             accessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-            await this.connectionTypeNewAccessory(device, accessory);
+            accessory.context.connectionType = await this.connectionType(device);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new lock_1.Lock(this, accessory, device);
             this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
-            // link the accessory to your platform
-            this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
+            // publish device externally or link the accessory to your platform
+            this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createColorBulb(device) {
@@ -1081,15 +1028,15 @@ class SwitchBotPlatform {
         const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
-            if (this.registerDevice(device)) {
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+            if (await this.registerDevice(device)) {
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
                 existingAccessory.context.model = device.deviceType;
                 existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.deviceName;
+                existingAccessory.displayName = device.configDeviceName || device.deviceName;
                 existingAccessory.context.firmwareRevision = device.firmware;
                 existingAccessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-                await this.connectionTypeExistingAccessory(device, existingAccessory);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.connectionType = await this.connectionType(device);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
@@ -1100,9 +1047,11 @@ class SwitchBotPlatform {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
-        else if (this.registerDevice(device)) {
+        else if (await this.registerDevice(device)) {
             // the accessory does not yet exist, so we need to create it
-            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            if (!device.external) {
+                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
@@ -1112,35 +1061,88 @@ class SwitchBotPlatform {
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = device.firmware;
             accessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-            await this.connectionTypeNewAccessory(device, accessory);
+            accessory.context.connectionType = await this.connectionType(device);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new colorbulb_1.ColorBulb(this, accessory, device);
             this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
-            // link the accessory to your platform
-            this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
+            // publish device externally or link the accessory to your platform
+            this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
-    async createStripLight(device) {
+    async createCeilingLight(device) {
         const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.deviceType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
         const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
-            if (this.registerDevice(device)) {
+            if (await this.registerDevice(device)) {
+                // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
+                existingAccessory.context.model = device.deviceType;
+                existingAccessory.context.deviceID = device.deviceId;
+                existingAccessory.displayName = device.configDeviceName || device.deviceName;
+                existingAccessory.context.firmwareRevision = device.firmware;
+                existingAccessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
                 this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.connectionType = await this.connectionType(device);
+                this.api.updatePlatformAccessories([existingAccessory]);
+                // create the accessory handler for the restored accessory
+                // this is imported from `platformAccessory.ts`
+                new ceilinglight_1.CeilingLight(this, existingAccessory, device);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+            }
+            else {
+                this.unregisterPlatformAccessories(existingAccessory);
+            }
+        }
+        else if (await this.registerDevice(device)) {
+            // the accessory does not yet exist, so we need to create it
+            if (!device.external) {
+                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            }
+            // create a new accessory
+            const accessory = new this.api.platformAccessory(device.deviceName, uuid);
+            // store a copy of the device object in the `accessory.context`
+            // the `context` property can be used to store any data about the accessory you may need
+            accessory.context.device = device;
+            accessory.context.model = device.deviceType;
+            accessory.context.deviceID = device.deviceId;
+            accessory.context.firmwareRevision = device.firmware;
+            accessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
+            accessory.context.connectionType = await this.connectionType(device);
+            // create the accessory handler for the newly create accessory
+            // this is imported from `platformAccessory.ts`
+            new ceilinglight_1.CeilingLight(this, accessory, device);
+            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            // publish device externally or link the accessory to your platform
+            this.externalOrPlatform(device, accessory);
+            this.accessories.push(accessory);
+        }
+        else {
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+        }
+    }
+    async createStripLight(device) {
+        const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.deviceType}`);
+        // see if an accessory with the same uuid has already been registered and restored from
+        // the cached devices we stored in the `configureAccessory` method above
+        const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
+        if (existingAccessory) {
+            // the accessory already exists
+            if (await this.registerDevice(device)) {
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
                 existingAccessory.context.model = device.deviceType;
                 existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.deviceName;
+                existingAccessory.displayName = device.configDeviceName || device.deviceName;
                 existingAccessory.context.firmwareRevision = device.firmware;
                 existingAccessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-                await this.connectionTypeExistingAccessory(device, existingAccessory);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.connectionType = await this.connectionType(device);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
@@ -1151,9 +1153,11 @@ class SwitchBotPlatform {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
-        else if (this.registerDevice(device)) {
+        else if (await this.registerDevice(device)) {
             // the accessory does not yet exist, so we need to create it
-            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            if (!device.external) {
+                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
@@ -1163,17 +1167,17 @@ class SwitchBotPlatform {
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = device.firmware;
             accessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-            await this.connectionTypeNewAccessory(device, accessory);
+            accessory.context.connectionType = await this.connectionType(device);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new striplight_1.StripLight(this, accessory, device);
             this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
-            // link the accessory to your platform
-            this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
+            // publish device externally or link the accessory to your platform
+            this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createTV(device) {
@@ -1182,14 +1186,14 @@ class SwitchBotPlatform {
         // the cached devices we stored in the `configureAccessory` method above
         const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
         if (!device.hide_device && existingAccessory) {
-            this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
             // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
             existingAccessory.context.model = device.remoteType;
             existingAccessory.context.deviceID = device.deviceId;
-            existingAccessory.displayName = device.deviceName;
+            existingAccessory.displayName = device.configDeviceName || device.deviceName;
             existingAccessory.context.firmwareRevision = device.firmware;
             existingAccessory.context.deviceType = `IR: ${device.remoteType}`;
-            await this.connectionTypeExistingIRAccessory(existingAccessory);
+            this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+            existingAccessory.context.connectionType = await this.connectionType(device);
             this.api.updatePlatformAccessories([existingAccessory]);
             // create the accessory handler for the restored accessory
             // this is imported from `platformAccessory.ts`
@@ -1198,7 +1202,9 @@ class SwitchBotPlatform {
         }
         else if (!device.hide_device && device.hubDeviceId) {
             // the accessory does not yet exist, so we need to create it
-            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            if (!device.external) {
+                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
@@ -1208,7 +1214,7 @@ class SwitchBotPlatform {
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = device.firmware;
             accessory.context.deviceType = `IR: ${device.remoteType}`;
-            await this.connectionTypeNewIRAccessory(accessory);
+            accessory.context.connectionType = await this.connectionType(device);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new tv_1.TV(this, accessory, device);
@@ -1218,11 +1224,11 @@ class SwitchBotPlatform {
              * Only one TV can exist per bridge, to bypass this limitation, you should
              * publish your TV as an external accessory.
              */
-            this.api.publishExternalAccessories(settings_1.PLUGIN_NAME, [accessory]);
+            this.externalAccessory(accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
         }
     }
     async createFan(device) {
@@ -1233,14 +1239,14 @@ class SwitchBotPlatform {
         if (existingAccessory) {
             // the accessory already exists
             if (!device.hide_device && device.hubDeviceId) {
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
                 existingAccessory.context.model = device.remoteType;
                 existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.deviceName;
+                existingAccessory.displayName = device.configDeviceName || device.deviceName;
                 existingAccessory.context.firmwareRevision = device.firmware;
                 existingAccessory.context.deviceType = `IR: ${device.remoteType}`;
-                await this.connectionTypeExistingIRAccessory(existingAccessory);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.connectionType = await this.connectionType(device);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
@@ -1253,7 +1259,9 @@ class SwitchBotPlatform {
         }
         else if (!device.hide_device && device.hubDeviceId) {
             // the accessory does not yet exist, so we need to create it
-            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            if (!device.external) {
+                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
@@ -1263,17 +1271,17 @@ class SwitchBotPlatform {
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = device.firmware;
             accessory.context.deviceType = `IR: ${device.remoteType}`;
-            await this.connectionTypeNewIRAccessory(accessory);
+            accessory.context.connectionType = await this.connectionType(device);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new fan_1.Fan(this, accessory, device);
             this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
-            // link the accessory to your platform
-            this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
+            // publish device externally or link the accessory to your platform
+            this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
         }
     }
     async createLight(device) {
@@ -1284,14 +1292,14 @@ class SwitchBotPlatform {
         if (existingAccessory) {
             // the accessory already exists
             if (!device.hide_device && device.hubDeviceId) {
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
                 existingAccessory.context.model = device.remoteType;
                 existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.deviceName;
+                existingAccessory.displayName = device.configDeviceName || device.deviceName;
                 existingAccessory.context.firmwareRevision = device.firmware;
                 existingAccessory.context.deviceType = `IR: ${device.remoteType}`;
-                await this.connectionTypeExistingIRAccessory(existingAccessory);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.connectionType = await this.connectionType(device);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
@@ -1304,7 +1312,9 @@ class SwitchBotPlatform {
         }
         else if (!device.hide_device && device.hubDeviceId) {
             // the accessory does not yet exist, so we need to create it
-            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            if (!device.external) {
+                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
@@ -1314,17 +1324,17 @@ class SwitchBotPlatform {
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = device.firmware;
             accessory.context.deviceType = `IR: ${device.remoteType}`;
-            await this.connectionTypeNewIRAccessory(accessory);
+            accessory.context.connectionType = await this.connectionType(device);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new light_1.Light(this, accessory, device);
             this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
-            // link the accessory to your platform
-            this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
+            // publish device externally or link the accessory to your platform
+            this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
         }
     }
     async createAirConditioner(device) {
@@ -1335,14 +1345,14 @@ class SwitchBotPlatform {
         if (existingAccessory) {
             // the accessory already exists
             if (!device.hide_device && device.hubDeviceId) {
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
                 existingAccessory.context.model = device.remoteType;
                 existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.deviceName;
+                existingAccessory.displayName = device.configDeviceName || device.deviceName;
                 existingAccessory.context.firmwareRevision = device.firmware;
                 existingAccessory.context.deviceType = `IR: ${device.remoteType}`;
-                await this.connectionTypeExistingIRAccessory(existingAccessory);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.connectionType = await this.connectionType(device);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
@@ -1355,7 +1365,9 @@ class SwitchBotPlatform {
         }
         else if (!device.hide_device && device.hubDeviceId) {
             // the accessory does not yet exist, so we need to create it
-            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            if (!device.external) {
+                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
@@ -1365,17 +1377,17 @@ class SwitchBotPlatform {
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = device.firmware;
             accessory.context.deviceType = `IR: ${device.remoteType}`;
-            await this.connectionTypeNewIRAccessory(accessory);
+            accessory.context.connectionType = await this.connectionType(device);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new airconditioner_1.AirConditioner(this, accessory, device);
             this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
-            // link the accessory to your platform
-            this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
+            // publish device externally or link the accessory to your platform
+            this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
         }
     }
     async createAirPurifier(device) {
@@ -1386,14 +1398,14 @@ class SwitchBotPlatform {
         if (existingAccessory) {
             // the accessory already exists
             if (!device.hide_device && device.hubDeviceId) {
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
                 existingAccessory.context.model = device.remoteType;
                 existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.deviceName;
+                existingAccessory.displayName = device.configDeviceName || device.deviceName;
                 existingAccessory.context.firmwareRevision = device.firmware;
                 existingAccessory.context.deviceType = `IR: ${device.remoteType}`;
-                await this.connectionTypeExistingIRAccessory(existingAccessory);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.connectionType = await this.connectionType(device);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
@@ -1406,7 +1418,9 @@ class SwitchBotPlatform {
         }
         else if (!device.hide_device && device.hubDeviceId) {
             // the accessory does not yet exist, so we need to create it
-            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            if (!device.external) {
+                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
@@ -1416,17 +1430,17 @@ class SwitchBotPlatform {
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = device.firmware;
             accessory.context.deviceType = `IR: ${device.remoteType}`;
-            await this.connectionTypeNewIRAccessory(accessory);
+            accessory.context.connectionType = await this.connectionType(device);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new airpurifier_1.AirPurifier(this, accessory, device);
             this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
-            // link the accessory to your platform
-            this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
+            // publish device externally or link the accessory to your platform
+            this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
         }
     }
     async createWaterHeater(device) {
@@ -1437,14 +1451,14 @@ class SwitchBotPlatform {
         if (existingAccessory) {
             // the accessory already exists
             if (!device.hide_device && device.hubDeviceId) {
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
                 existingAccessory.context.model = device.remoteType;
                 existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.deviceName;
+                existingAccessory.displayName = device.configDeviceName || device.deviceName;
                 existingAccessory.context.firmwareRevision = device.firmware;
                 existingAccessory.context.deviceType = `IR: ${device.remoteType}`;
-                await this.connectionTypeExistingIRAccessory(existingAccessory);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.connectionType = await this.connectionType(device);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
@@ -1457,7 +1471,9 @@ class SwitchBotPlatform {
         }
         else if (!device.hide_device && device.hubDeviceId) {
             // the accessory does not yet exist, so we need to create it
-            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            if (!device.external) {
+                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
@@ -1467,17 +1483,17 @@ class SwitchBotPlatform {
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = device.firmware;
             accessory.context.deviceType = `IR: ${device.remoteType}`;
-            await this.connectionTypeNewIRAccessory(accessory);
+            accessory.context.connectionType = await this.connectionType(device);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new waterheater_1.WaterHeater(this, accessory, device);
             this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
-            // link the accessory to your platform
-            this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
+            // publish device externally or link the accessory to your platform
+            this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
         }
     }
     async createVacuumCleaner(device) {
@@ -1488,14 +1504,14 @@ class SwitchBotPlatform {
         if (existingAccessory) {
             // the accessory already exists
             if (!device.hide_device && device.hubDeviceId) {
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
                 existingAccessory.context.model = device.remoteType;
                 existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.deviceName;
+                existingAccessory.displayName = device.configDeviceName || device.deviceName;
                 existingAccessory.context.firmwareRevision = device.firmware;
                 existingAccessory.context.deviceType = `IR: ${device.remoteType}`;
-                await this.connectionTypeExistingIRAccessory(existingAccessory);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.connectionType = await this.connectionType(device);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
@@ -1508,7 +1524,9 @@ class SwitchBotPlatform {
         }
         else if (!device.hide_device && device.hubDeviceId) {
             // the accessory does not yet exist, so we need to create it
-            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            if (!device.external) {
+                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
@@ -1518,17 +1536,17 @@ class SwitchBotPlatform {
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = device.firmware;
             accessory.context.deviceType = `IR: ${device.remoteType}`;
-            await this.connectionTypeNewIRAccessory(accessory);
+            accessory.context.connectionType = await this.connectionType(device);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new vacuumcleaner_1.VacuumCleaner(this, accessory, device);
             this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
-            // link the accessory to your platform
-            this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
+            // publish device externally or link the accessory to your platform
+            this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
         }
     }
     async createCamera(device) {
@@ -1539,14 +1557,14 @@ class SwitchBotPlatform {
         if (existingAccessory) {
             // the accessory already exists
             if (!device.hide_device && device.hubDeviceId) {
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
                 existingAccessory.context.model = device.remoteType;
                 existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.deviceName;
+                existingAccessory.displayName = device.configDeviceName || device.deviceName;
                 existingAccessory.context.firmwareRevision = device.firmware;
                 existingAccessory.context.deviceType = `IR: ${device.remoteType}`;
-                await this.connectionTypeExistingIRAccessory(existingAccessory);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.connectionType = await this.connectionType(device);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
@@ -1559,7 +1577,9 @@ class SwitchBotPlatform {
         }
         else if (!device.hide_device && device.hubDeviceId) {
             // the accessory does not yet exist, so we need to create it
-            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            if (!device.external) {
+                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
@@ -1569,17 +1589,17 @@ class SwitchBotPlatform {
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = device.firmware;
             accessory.context.deviceType = `IR: ${device.remoteType}`;
-            await this.connectionTypeNewIRAccessory(accessory);
+            accessory.context.connectionType = await this.connectionType(device);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new camera_1.Camera(this, accessory, device);
             this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
-            // link the accessory to your platform
-            this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
+            // publish device externally or link the accessory to your platform
+            this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
         }
     }
     async createOthers(device) {
@@ -1590,14 +1610,14 @@ class SwitchBotPlatform {
         if (existingAccessory) {
             // the accessory already exists
             if (!device.hide_device && device.hubDeviceId) {
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
                 existingAccessory.context.model = device.remoteType;
                 existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.deviceName;
+                existingAccessory.displayName = device.configDeviceName || device.deviceName;
                 existingAccessory.context.firmwareRevision = device.firmware;
                 existingAccessory.context.deviceType = `IR: ${device.remoteType}`;
-                await this.connectionTypeExistingIRAccessory(existingAccessory);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.connectionType = await this.connectionType(device);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
@@ -1610,7 +1630,9 @@ class SwitchBotPlatform {
         }
         else if (!device.hide_device && device.hubDeviceId) {
             // the accessory does not yet exist, so we need to create it
-            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            if (!device.external) {
+                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
@@ -1620,91 +1642,160 @@ class SwitchBotPlatform {
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = device.firmware;
             accessory.context.deviceType = `IR: ${device.remoteType}`;
-            await this.connectionTypeNewIRAccessory(accessory);
+            accessory.context.connectionType = await this.connectionType(device);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new other_1.Others(this, accessory, device);
             this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
-            // link the accessory to your platform
-            this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
+            // publish device externally or link the accessory to your platform
+            this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
         }
     }
-    async connectionTypeNewAccessory(device, accessory) {
-        if (device.ble) {
-            accessory.context.connectionType = 'BLE';
+    async registerCurtains(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}`);
+        let registerCurtain;
+        if (device.group && !device.curtain?.disable_group) {
+            registerCurtain = true;
+            this.debugLog(`deviceName: ${device.deviceName} [Curtain Config] disable_group: ${device.curtain?.disable_group}`);
+            this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}`);
+        }
+        else if (device.connectionType?.includes('BLE') || device.connectionType === 'Disabled') {
+            registerCurtain = true;
+            this.debugLog(`deviceName: ${device.deviceName} [Curtain Config] connectionType: ${device.connectionType}`);
+            this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}`);
         }
         else {
-            accessory.context.connectionType = 'OpenAPI';
+            registerCurtain = false;
+            this.errorLog(`deviceName: ${device.deviceName} [Curtain Config] disable_group: ${device.curtain?.disable_group}, UnGrouping ${device.master}`);
+            this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}`);
         }
+        return registerCurtain;
     }
-    async connectionTypeExistingAccessory(device, existingAccessory) {
-        if (device.ble) {
-            existingAccessory.context.connectionType = 'BLE';
+    async connectionType(device) {
+        let connectionType;
+        if (!device.connectionType && this.config.credentials?.token && this.config.credentials.secret) {
+            connectionType = 'OpenAPI';
+        }
+        else {
+            connectionType = device.connectionType;
+        }
+        return connectionType;
+    }
+    async registerDevice(device) {
+        device.connectionType = await this.connectionType(device);
+        let registerDevice;
+        if (!device.hide_device && device.enableCloudService && device.connectionType === 'BLE/OpenAPI') {
+            if (device.deviceType === 'Curtain') {
+                registerDevice = await this.registerCurtains(device);
+                this.debugWarnLog(`Device: ${device.deviceName} Curtain registerDevice: ${registerDevice}`);
+            }
+            else {
+                registerDevice = true;
+                this.debugWarnLog(`Device: ${device.deviceName} registerDevice: ${registerDevice}`);
+            }
+            this.debugWarnLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will display in HomeKit`);
+        }
+        else if (!device.hide_device && device.deviceId && device.configDeviceType && device.configDeviceName
+            && device.connectionType === 'BLE') {
+            if (device.deviceType === 'Curtain') {
+                registerDevice = await this.registerCurtains(device);
+                this.debugWarnLog(`Device: ${device.deviceName} Curtain registerDevice: ${registerDevice}`);
+            }
+            else {
+                registerDevice = true;
+                this.debugWarnLog(`Device: ${device.deviceName} registerDevice: ${registerDevice}`);
+            }
+            this.debugWarnLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will display in HomeKit`);
+        }
+        else if (!device.hide_device && device.enableCloudService && device.connectionType === 'OpenAPI') {
+            if (device.deviceType === 'Curtain') {
+                registerDevice = await this.registerCurtains(device);
+                this.debugWarnLog(`Device: ${device.deviceName} Curtain registerDevice: ${registerDevice}`);
+            }
+            else {
+                registerDevice = true;
+                this.debugWarnLog(`Device: ${device.deviceName} registerDevice: ${registerDevice}`);
+            }
+            this.debugWarnLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will display in HomeKit`);
+        }
+        else if (!device.hide_device && device.connectionType === 'Disabled') {
+            if (device.deviceType === 'Curtain') {
+                registerDevice = await this.registerCurtains(device);
+                this.debugWarnLog(`Device: ${device.deviceName} Curtain registerDevice: ${registerDevice}`);
+            }
+            else {
+                registerDevice = true;
+                this.debugWarnLog(`Device: ${device.deviceName} registerDevice: ${registerDevice}`);
+            }
+            this.debugWarnLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will continue to display in HomeKit`);
+        }
+        else if (!device.connectionType && !device.hide_device) {
+            registerDevice = false;
+            this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will not display in HomeKit`);
+        }
+        else if (device.hide_device) {
+            registerDevice = false;
+            this.debugErrorLog(`Device: ${device.deviceName} hide_device: ${device.hide_device}, will not display in HomeKit`);
         }
         else {
-            existingAccessory.context.connectionType = 'OpenAPI';
+            registerDevice = false;
+            this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, hide_device: `
+                + `${device.hide_device},  will not display in HomeKit`);
         }
+        return registerDevice;
     }
-    async connectionTypeNewIRAccessory(accessory) {
-        accessory.context.connectionType = 'IR wirth OpenAPI';
+    async externalOrPlatform(device, accessory) {
+        if (device.external) {
+            this.debugWarnLog(`${accessory.displayName} External Accessory Mode`);
+            this.externalAccessory(accessory);
+        }
+        else {
+            this.debugLog(`${accessory.displayName} External Accessory Mode: ${device.external}`);
+            this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
+        }
     }
-    async connectionTypeExistingIRAccessory(existingAccessory) {
-        existingAccessory.context.connectionType = 'IR with OpenAPI';
+    async externalAccessory(accessory) {
+        this.api.publishExternalAccessories(settings_1.PLUGIN_NAME, [accessory]);
     }
     unregisterPlatformAccessories(existingAccessory) {
         // remove platform accessories when no longer present
         this.api.unregisterPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [existingAccessory]);
         this.warnLog(`Removing existing accessory from cache: ${existingAccessory.displayName}`);
     }
-    deviceListInfo(devices) {
-        if (this.platformLogging?.includes('debug')) {
-            this.warnLog(`deviceListInfoStatus: ${JSON.stringify(devices)}`);
-        }
-    }
-    async deviceInfo(device) {
-        if (this.platformLogging?.includes('debug')) {
-            this.warnLog(JSON.stringify(device));
-            const t = Date.now();
-            const nonce = 'requestID';
-            const data = this.config.credentials?.token + t + nonce;
-            const signTerm = crypto_1.default.createHmac('sha256', this.config.credentials?.secret).update(buffer_1.Buffer.from(data, 'utf-8')).digest();
-            const sign = signTerm.toString('base64');
-            this.debugLog(sign);
-            const options = {
-                hostname: settings_1.HostDomain,
-                port: 443,
-                path: `${settings_1.DevicePath}/${device.deviceId}/status`,
-                method: 'GET',
-                headers: {
-                    Authorization: this.config.credentials?.token,
-                    sign: sign,
-                    nonce: nonce,
-                    t: t,
-                    'Content-Type': 'application/json',
-                },
-            };
-            const req = https_1.default.request(options, (res) => {
-                this.debugLog(`statusCode: ${res.statusCode}`);
-                res.on('data', (d) => {
-                    process.stdout.write(d);
-                });
-            });
-            req.on('error', (error) => {
-                this.errorLog(error);
-            });
-            req.end();
-            this.deviceStatus = req;
-            if (this.deviceStatus.message === 'success') {
-                this.warnLog(`${device.deviceName} deviceInfoStatus: ${JSON.stringify(this.deviceStatus)}`);
-            }
-            else {
-                this.warnLog(`${device.deviceName} deviceInfoStatus: ${JSON.stringify(this.deviceStatus.message)}`);
-                this.warnLog('Unable to retreive deviceInfoStatus.');
-            }
+    async statusCode({ res }) {
+        switch (res.statusCode) {
+            case 151:
+                this.errorLog('Command not supported by this device type.');
+                break;
+            case 152:
+                this.errorLog('Device not found.');
+                break;
+            case 160:
+                this.errorLog('Command is not supported.');
+                break;
+            case 161:
+                this.errorLog('Device is offline.');
+                break;
+            case 171:
+                this.errorLog('is offline');
+                break;
+            case 190:
+                this.errorLog('Requests reached the daily limit');
+                break;
+            case 100:
+                if (this.debugMode) {
+                    this.debugLog('Command successfully sent.');
+                }
+                break;
+            default:
+                if (this.debugMode) {
+                    this.debugLog('Unknown statusCode.');
+                }
         }
     }
     // BLE Connection
@@ -1721,6 +1812,21 @@ class SwitchBotPlatform {
         }
         return switchbot;
     }
+    logs() {
+        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}`);
+        }
+        else if (this.debugMode) {
+            this.platformLogging = 'debugMode';
+            this.debugWarnLog(`Using ${this.platformLogging} Logging`);
+        }
+        else {
+            this.platformLogging = 'standard';
+            this.debugWarnLog(`Using ${this.platformLogging} Logging`);
+        }
+    }
     /**
      * If device level logging is turned on, log to log.warn
      * Otherwise send debug logs to log.debug
@@ -1735,11 +1841,25 @@ class SwitchBotPlatform {
             this.log.warn(String(...log));
         }
     }
+    debugWarnLog(...log) {
+        if (this.enablingPlatfromLogging()) {
+            if (this.platformLogging?.includes('debug')) {
+                this.log.warn('[DEBUG]', String(...log));
+            }
+        }
+    }
     errorLog(...log) {
         if (this.enablingPlatfromLogging()) {
             this.log.error(String(...log));
         }
     }
+    debugErrorLog(...log) {
+        if (this.enablingPlatfromLogging()) {
+            if (this.platformLogging?.includes('debug')) {
+                this.log.error('[DEBUG]', String(...log));
+            }
+        }
+    }
     debugLog(...log) {
         if (this.enablingPlatfromLogging()) {
             if (this.platformLogging === 'debugMode') {