@switchbot/homebridge-switchbot 2.0.0-beta.3 → 2.0.0-beta.30

package/dist/platform.js

@@ -28,8 +28,10 @@ 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");
+const rxjs_1 = require("rxjs");
 /**
  * HomebridgePlatform
  * This class is the main constructor for your plugin, this is where you should
@@ -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,37 +155,37 @@ 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');
                 }
             }
         }
+        // Rediscover Devices
+        if (!this.config.options.reDiscoverDevices) {
+            this.config.options.reDiscoverDevices = false;
+            this.debugWarnLog(`Rediscover Devices disabled, discoverDevices: ${this.config.options.reDiscoverDevices}`);
+        }
+        if (!this.config.options.reDiscoverDevicesInterval && this.config.options.reDiscoverDevices) {
+            this.config.options.reDiscoverDevicesInterval = 1;
+            this.debugWarnLog(`Default Rediscover Devices Interval, discoverDevicesInterval: ${this.config.options.reDiscoverDevicesInterval} Day`);
+        }
     }
     /**
      * The openToken was old config.
@@ -233,20 +214,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 +261,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 +402,21 @@ 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}`);
+        }
+        if (this.config.options?.reDiscoverDevices) {
+            this.debugWarnLog(`Rediscover Devices Interval, discoverDevicesInterval: ${this.config.options.reDiscoverDevicesInterval} Day`);
+            if (this.config.options.reDiscoverDevicesInterval > 1) {
+                (0, rxjs_1.interval)(this.config.options.reDiscoverDevicesInterval * 86400000)
+                    .pipe((0, rxjs_1.take)(1))
+                    .subscribe(async () => {
+                    await this.discoverDevices();
+                });
+            }
+            else {
+                this.debugErrorLog(`discoverDevicesInterval must be > 1, discoverDevicesInterval: ${this.config.options.reDiscoverDevicesInterval} Day`);
+            }
         }
     }
     createDevice(device) {
@@ -471,7 +452,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':
@@ -493,7 +474,6 @@ class SwitchBotPlatform {
                 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 +481,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 +542,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 +554,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,7 +573,7 @@ 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}`);
             // create a new accessory
@@ -626,17 +585,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 +605,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 +625,10 @@ 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));
+            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 +638,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 +659,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,7 +678,7 @@ 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}`);
             // create a new accessory
@@ -731,17 +690,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 +710,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,7 +729,7 @@ 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}`);
             // create a new accessory
@@ -782,17 +741,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 +761,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,7 +780,7 @@ 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}`);
             // create a new accessory
@@ -833,17 +792,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 +812,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,7 +831,7 @@ 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}`);
             // create a new accessory
@@ -884,17 +843,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 +863,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,7 +882,7 @@ 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.group && !device.curtain?.disable_group) {
@@ -932,10 +891,10 @@ class SwitchBotPlatform {
             }
             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 +906,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 +926,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,7 +945,7 @@ 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}`);
             // create a new accessory
@@ -1010,17 +957,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 +977,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,7 +996,7 @@ 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}`);
             // create a new accessory
@@ -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,7 +1047,7 @@ 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}`);
             // create a new accessory
@@ -1112,17 +1059,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 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) {
@@ -1132,15 +1079,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`
@@ -1151,7 +1098,7 @@ 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}`);
             // create a new accessory
@@ -1163,17 +1110,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 +1129,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`
@@ -1208,7 +1155,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 +1165,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 +1180,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`
@@ -1263,17 +1210,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 +1231,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`
@@ -1314,17 +1261,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 +1282,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`
@@ -1365,17 +1312,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 +1333,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`
@@ -1416,17 +1363,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 +1384,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`
@@ -1467,17 +1414,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 +1435,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`
@@ -1518,17 +1465,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 +1486,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`
@@ -1569,17 +1516,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 +1537,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`
@@ -1620,91 +1567,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 registerCurtains(device) {
+        this.warnLog(`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 {
+            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 connectionTypeNewAccessory(device, accessory) {
-        if (device.ble) {
-            accessory.context.connectionType = 'BLE';
+    async connectionType(device) {
+        let connectionType;
+        if (!device.connectionType && this.config.credentials?.token && this.config.credentials.secret) {
+            connectionType = 'OpenAPI';
         }
         else {
-            accessory.context.connectionType = 'OpenAPI';
+            connectionType = device.connectionType;
         }
+        return connectionType;
     }
-    async connectionTypeExistingAccessory(device, existingAccessory) {
-        if (device.ble) {
-            existingAccessory.context.connectionType = 'BLE';
+    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) {
+        this.debugLog(`${accessory.displayName} External Accessory Mode: ${device.external}`);
+        if (device.external) {
+            this.warnLog(`${accessory.displayName} External Accessory Mode`);
+            this.externalAccessory(accessory);
+        }
+        else {
+            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 +1737,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 +1766,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') {