@switchbot/homebridge-switchbot 0.1.2-beta.7 → 0.2.0-alpha.1

package/dist/platform.js

@@ -12,6 +12,7 @@ const meters_1 = require("./devices/meters");
 const motion_1 = require("./devices/motion");
 const contact_1 = require("./devices/contact");
 const curtains_1 = require("./devices/curtains");
+const indoorcam_1 = require("./devices/indoorcam");
 const humidifiers_1 = require("./devices/humidifiers");
 const tvs_1 = require("./irdevices/tvs");
 const fans_1 = require("./irdevices/fans");
@@ -90,13 +91,9 @@ class SwitchBotPlatform {
      */
     configureAccessory(accessory) {
         this.log.info('Loading accessory from cache:', accessory.displayName);
-        //accessory.context.timeout = this.apiError(accessory);
         // add the restored accessory to the accessories cache so we can track if it has already been registered
         this.accessories.push(accessory);
     }
-    apiError(accessory) {
-        this.log.debug('API Error:', accessory.displayName);
-    }
     /**
      * Verify the config passed to the plugin is valid
      */
@@ -105,58 +102,26 @@ class SwitchBotPlatform {
          * Hidden Device Discovery Option
          * This will disable adding any device and will just output info.
          */
-        this.config.devicediscovery;
         this.config.options = this.config.options || {};
-        //Enable BLE for Device
-        this.config.options.ble;
-        // Hide Devices by DeviceID
-        this.config.options.hide_device = this.config.options.hide_device || [];
-        // Meter Config Options
-        this.config.options.bot = this.config.options.bot || {};
-        this.config.options.bot.device_press;
-        this.config.options.bot.device_switch;
-        // Meter Config Options
-        this.config.options.meter = this.config.options.meter || {};
-        this.config.options.meter.hide_temperature;
-        this.config.options.meter.hide_humidity;
-        // Humidifier Config Options
-        this.config.options.humidifier = this.config.options.humidifier || {};
-        this.config.options.humidifier.set_minStep;
-        this.config.options.humidifier.hide_temperature;
-        // Curtain Config Options
-        this.config.options.curtain = this.config.options.curtain || {};
-        this.config.options.curtain.disable_group;
-        if (!this.config.options.curtain.refreshRate) {
-            this.config.options.curtain.refreshRate = 5;
-            if (this.config.options.debug) {
-                this.log.warn('Using Default Curtain Refresh Rate.');
+        this.config.options.debug;
+        // Device Config
+        if (this.config.options.devices) {
+            for (const deviceConfig of this.config.options.devices) {
+                if (!deviceConfig.type) {
+                    this.log.error('The devices config section is missing the "Type" in the config, Check Your Conifg.');
+                }
+                if (!deviceConfig.deviceId) {
+                    this.log.error('The devices config section is missing the "Device ID" in the config, Check Your Conifg.');
+                }
             }
         }
-        this.config.options.curtain.set_minStep;
-        this.config.options.curtain.set_min;
-        this.config.options.curtain.set_max;
-        // Fan Config Options
-        this.config.options.fan = this.config.options.fan || {};
-        this.config.options.fan.swing_mode;
-        this.config.options.fan.rotation_speed;
-        this.config.options.fan.set_minStep;
-        this.config.options.fan.set_min;
-        this.config.options.fan.set_max;
-        // AirConditioner Config Options
-        this.config.options.irair = this.config.options.irair || {};
-        this.config.options.irair.hide_automode;
-        // Others Config Options
-        this.config.options.other = this.config.options.other || {};
-        this.config.options.other.deviceType;
-        this.config.options.other.commandOn;
-        this.config.options.other.commandOff;
-        if (this.config.options.refreshRate < 120) {
-            throw new Error('Refresh Rate must be above 120 (2 minutes).');
+        if (this.config.options.refreshRate < 30) {
+            throw new Error('Refresh Rate must be above 30 (30 seconds).');
         }
         if (!this.config.options.refreshRate) {
-            // default 600 seconds (15 minutes)
-            this.config.options.refreshRate = 1000;
-            this.log.warn('Using Default Refresh Rate.');
+            // default 120 seconds (2 minutes)
+            this.config.options.refreshRate = 120;
+            this.log.warn('Using Default Refresh Rate (2 minutes).');
         }
         if (!this.config.options.pushRate) {
             // default 100 milliseconds
@@ -175,168 +140,40 @@ class SwitchBotPlatform {
    */
     async discoverDevices() {
         try {
-            const devices = (await this.axios.get(settings_1.DeviceURL)).data;
-            if (this.config.devicediscovery) {
-                this.deviceListInfo(devices);
-            }
-            else {
-                this.log.debug(JSON.stringify(devices));
-            }
-            this.log.info('Total SwitchBot Devices Found:', devices.body.deviceList.length);
-            this.log.info('Total IR Devices Found:', devices.body.infraredRemoteList.length);
-            for (const device of devices.body.deviceList) {
-                if (this.config.devicediscovery) {
-                    this.deviceInfo(device);
-                }
-                else {
-                    this.debug(JSON.stringify(device));
-                }
-                // For Future Devices
-                switch (device.deviceType) {
-                    case 'Humidifier':
-                        if (this.config.devicediscovery) {
-                            this.log.info('Discovered %s %s', device.deviceName, device.deviceType);
-                        }
-                        this.createHumidifier(device);
-                        break;
-                    case 'Hub Mini':
-                        if (this.config.devicediscovery) {
-                            this.log.info('Discovered a %s', device.deviceType);
-                        }
-                        break;
-                    case 'Hub Plus':
-                        if (this.config.devicediscovery) {
-                            this.log.info('Discovered a %s', device.deviceType);
-                        }
-                        break;
-                    case 'Bot':
-                        if (this.config.devicediscovery) {
-                            this.log.info('Discovered %s %s', device.deviceName, device.deviceType);
-                        }
-                        this.createBot(device);
-                        break;
-                    case 'Meter':
-                        if (this.config.devicediscovery) {
-                            this.log.info('Discovered %s %s', device.deviceName, device.deviceType);
-                        }
-                        this.createMeter(device);
-                        break;
-                    case 'Motion Sensor':
-                        if (this.config.devicediscovery) {
-                            this.log.info('Discovered %s %s', device.deviceName, device.deviceType);
-                        }
-                        this.createMotion(device);
-                        break;
-                    case 'Contact Sensor':
-                        if (this.config.devicediscovery) {
-                            this.log.info('Discovered %s %s', device.deviceName, device.deviceType);
-                        }
-                        this.createContact(device);
-                        break;
-                    case 'Curtain':
-                        if (this.config.devicediscovery) {
-                            this.log.info('Discovered %s %s', device.deviceName, device.deviceType);
-                        }
-                        this.createCurtain(device);
-                        break;
-                    case 'Plug':
-                        if (this.config.devicediscovery) {
-                            this.log.info('Discovered %s %s', device.deviceName, device.deviceType);
-                        }
-                        this.createPlug(device);
-                        break;
-                    case 'Remote':
-                        if (this.config.devicediscovery) {
-                            this.debug(`Discovered ${device.deviceName}, ${device.deviceType} is Not Supported.`);
-                        }
-                        break;
-                    default:
-                        this.log.info('Device: %s with Device Type: %s, is currently not supported.', device.deviceName, device.deviceType, 'Submit Feature Requests Here: https://git.io/JL14Z');
+            const devicesAPI = (await this.axios.get(settings_1.DeviceURL)).data;
+            this.deviceListInfo(devicesAPI);
+            this.debug(JSON.stringify(devicesAPI));
+            this.log.info('Total SwitchBot Devices Found:', devicesAPI.body.deviceList.length);
+            this.log.info('Total IR Devices Found:', devicesAPI.body.infraredRemoteList.length);
+            const deviceLists = devicesAPI.body.deviceList;
+            if (!this.config.options?.devices) {
+                this.debug(`Config Not Set: ${JSON.stringify(this.config.options?.devices)}`);
+                const devices = deviceLists.map((v) => v);
+                for (const device of devices) {
+                    if (device.deviceType) {
+                        this.createDevice(device);
+                    }
+                    else {
+                        this.createIRDevice(device);
+                    }
                 }
             }
-            for (const device of devices.body.infraredRemoteList) {
-                if (this.config.devicediscovery) {
-                    this.deviceInfo(device);
-                }
-                else {
-                    this.debug(JSON.stringify(device));
-                }
-                // For Future Devices
-                switch (device.remoteType) {
-                    case 'TV':
-                    case 'DIY TV':
-                    case 'Projector':
-                    case 'DIY Projector':
-                    case 'Set Top Box':
-                    case 'DIY Set Top Box':
-                    case 'IPTV':
-                    case 'DIY IPTV':
-                    case 'DVD':
-                    case 'DIY DVD':
-                    case 'Speaker':
-                    case 'DIY Speaker':
-                        if (this.config.devicediscovery) {
-                            this.log.info('Discovered %s %s', device.deviceName, device.remoteType);
-                        }
-                        this.createTV(device);
-                        break;
-                    case 'Fan':
-                    case 'DIY Fan':
-                        if (this.config.devicediscovery) {
-                            this.log.info('Discovered %s %s', device.deviceName, device.remoteType);
-                        }
-                        this.createFan(device);
-                        break;
-                    case 'Air Conditioner':
-                    case 'DIY Air Conditioner':
-                        if (this.config.devicediscovery) {
-                            this.log.info('Discovered %s %s', device.deviceName, device.remoteType);
-                        }
-                        this.createAirConditioner(device);
-                        break;
-                    case 'Light':
-                    case 'DIY Light':
-                        if (this.config.devicediscovery) {
-                            this.log.info('Discovered %s %s', device.deviceName, device.remoteType);
-                        }
-                        this.createLight(device);
-                        break;
-                    case 'Air Purifier':
-                    case 'DIY Air Purifier':
-                        if (this.config.devicediscovery) {
-                            this.log.info('Discovered %s %s', device.deviceName, device.remoteType);
-                        }
-                        this.createAirPurifier(device);
-                        break;
-                    case 'Water Heater':
-                    case 'DIY Water Heater':
-                        if (this.config.devicediscovery) {
-                            this.log.info('Discovered %s %s', device.deviceName, device.remoteType);
-                        }
-                        this.createWaterHeater(device);
-                        break;
-                    case 'Vacuum Cleaner':
-                    case 'DIY Vacuum Cleaner':
-                        if (this.config.devicediscovery) {
-                            this.log.info('Discovered %s %s', device.deviceName, device.remoteType);
-                        }
-                        this.createVacuumCleaner(device);
-                        break;
-                    case 'Camera':
-                    case 'DIY Camera':
-                        if (this.config.devicediscovery) {
-                            this.log.info('Discovered %s %s', device.deviceName, device.remoteType);
-                        }
-                        this.createCamera(device);
-                        break;
-                    case 'Others':
-                        if (this.config.devicediscovery) {
-                            this.log.info('Discovered %s %s', device.deviceName, device.remoteType);
-                        }
-                        this.createOthers(device);
-                        break;
-                    default:
-                        this.log.info('Device: %s with Device Type: %s, is currently not supported.', device.deviceName, device.remoteType, 'Submit Feature Requests Here: https://git.io/JL14Z');
+            else {
+                this.debug(`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) && item),
+                    ...itm,
+                }));
+                const devices = mergeBydeviceId(deviceLists, deviceConfigs);
+                this.debug(JSON.stringify(devices));
+                for (const device of devices) {
+                    if (device.deviceType) {
+                        this.createDevice(device);
+                    }
+                    else {
+                        this.createIRDevice(device);
+                    }
                 }
             }
         }
@@ -345,189 +182,301 @@ class SwitchBotPlatform {
             this.debug(JSON.stringify(e));
         }
     }
+    createDevice(device) {
+        switch (device.deviceType) {
+            case 'Humidifier':
+                this.debug(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.createHumidifier(device);
+                break;
+            case 'Hub Mini':
+                this.debug(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                break;
+            case 'Hub Plus':
+                this.debug(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                break;
+            case 'Bot':
+                this.debug(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.createBot(device);
+                break;
+            case 'Meter':
+                this.debug(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.createMeter(device);
+                break;
+            case 'Motion Sensor':
+                this.debug(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.createMotion(device);
+                break;
+            case 'Contact Sensor':
+                this.debug(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.createContact(device);
+                break;
+            case 'Curtain':
+                this.debug(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.createCurtain(device);
+                break;
+            case 'Plug':
+                this.debug(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.createPlug(device);
+                break;
+            case 'IndoorCam':
+                this.debug(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.createIndoorCam(device);
+                break;
+            case 'Remote':
+                this.debug(`Discovered ${device.deviceType}: ${device.deviceId} is Not Supported.`);
+                break;
+            default:
+                this.log.info(`Device: ${device.deviceName} with Device Type: ${device.deviceType}, is currently not supported.`);
+                this.log.info('Submit Feature Requests Here: https://git.io/JL14Z');
+        }
+    }
+    createIRDevice(device) {
+        switch (device.remoteType) {
+            case 'TV':
+            case 'DIY TV':
+            case 'Projector':
+            case 'DIY Projector':
+            case 'Set Top Box':
+            case 'DIY Set Top Box':
+            case 'IPTV':
+            case 'DIY IPTV':
+            case 'DVD':
+            case 'DIY DVD':
+            case 'Speaker':
+            case 'DIY Speaker':
+                this.debug(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                this.createTV(device);
+                break;
+            case 'Fan':
+            case 'DIY Fan':
+                this.debug(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                this.createFan(device);
+                break;
+            case 'Air Conditioner':
+            case 'DIY Air Conditioner':
+                this.debug(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                this.createAirConditioner(device);
+                break;
+            case 'Light':
+            case 'DIY Light':
+                this.debug(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                this.createLight(device);
+                break;
+            case 'Air Purifier':
+            case 'DIY Air Purifier':
+                this.debug(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                this.createAirPurifier(device);
+                break;
+            case 'Water Heater':
+            case 'DIY Water Heater':
+                this.debug(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                this.createWaterHeater(device);
+                break;
+            case 'Vacuum Cleaner':
+            case 'DIY Vacuum Cleaner':
+                this.debug(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                this.createVacuumCleaner(device);
+                break;
+            case 'Camera':
+            case 'DIY Camera':
+                this.debug(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                this.createCamera(device);
+                break;
+            case 'Others':
+                this.debug(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                this.createOthers(device);
+                break;
+            default:
+                this.log.info(`Device: ${device.deviceName} with Device Type: ${device.remoteType}, is currently not supported.`);
+                this.log.info('Submit Feature Requests Here: https://git.io/JL14Z');
+        }
+    }
     async createHumidifier(device) {
-        const uuid = this.api.hap.uuid.generate(`${device.deviceName}-${device.deviceId}-${device.deviceType}`);
+        const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.deviceType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
         const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
-            if (!this.config.options?.hide_device.includes(device.deviceId) && device.enableCloudService) {
-                this.log.info('Restoring existing accessory from cache: %s DeviceID: %s', existingAccessory.displayName, device.deviceId);
+            if (!device.hide_device && device.enableCloudService) {
+                this.log.info(`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.firmwareRevision = firmware;
                 existingAccessory.context.model = device.deviceType;
                 existingAccessory.context.deviceID = device.deviceId;
+                existingAccessory.displayName = device.deviceName;
                 existingAccessory.context.firmwareRevision = this.version;
                 await this.connectionTypeExistingAccessory(device, existingAccessory);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new humidifiers_1.Humidifier(this, existingAccessory, device);
-                this.debug(`${device.deviceType} UDID: ${device.deviceName}-${device.deviceId}-${device.deviceType}`);
+                this.debug(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
-        else if (!this.config.options?.hide_device.includes(device.deviceId) && device.enableCloudService) {
+        else if (!device.hide_device && device.enableCloudService) {
             // the accessory does not yet exist, so we need to create it
-            this.log.info('Adding new accessory: %s %s DeviceID: %s', device.deviceName, device.deviceType, device.deviceId);
+            this.log.info(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
             // create a new accessory
-            const accessory = new this.api.platformAccessory(`${device.deviceName} ${device.deviceType}`, uuid);
+            const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
             accessory.context.model = device.deviceType;
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = this.version;
-            await this.connectionTypeNewAccessory(device, accessory);
+            await this.connectionTypeExistingAccessory(device, accessory);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new humidifiers_1.Humidifier(this, accessory, device);
-            this.debug(`${device.deviceType} UDID: ${device.deviceName}-${device.deviceId}-${device.deviceType}`);
+            this.debug(`${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]);
             this.accessories.push(accessory);
         }
         else {
-            if (this.config.devicediscovery) {
-                this.log.error('Unable to Register new device: %s %s - %s', device.deviceName, device.deviceType, device.deviceId);
-            }
+            this.device(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
         }
     }
     async createBot(device) {
-        const uuid = this.api.hap.uuid.generate(`${device.deviceName}-${device.deviceId}-${device.deviceType}`);
+        const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.deviceType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
         const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
-            if (!this.config.options?.hide_device.includes(device.deviceId) && device.enableCloudService) {
-                this.log.info('Restoring existing accessory from cache: %s DeviceID: %s', existingAccessory.displayName, device.deviceId);
+            if (!device.hide_device && device.enableCloudService) {
+                this.log.info(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                this.log.error(JSON.stringify(device.bot?.mode));
+                if (!device.bot?.mode) {
+                    this.log.error('You must set your Bot to Press or Switch 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.context.firmwareRevision = this.version;
                 await this.connectionTypeExistingAccessory(device, existingAccessory);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new bots_1.Bot(this, existingAccessory, device);
-                this.debug(`${device.deviceType} UDID: ${device.deviceName}-${device.deviceId}-${device.deviceType}`);
+                this.debug(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
-        else if (!this.config.options?.hide_device.includes(device.deviceId) && device.enableCloudService) {
+        else if (!device.hide_device && device.enableCloudService) {
             // the accessory does not yet exist, so we need to create it
-            this.log.info('Adding new accessory: %s %s DeviceID: %s', device.deviceName, device.deviceType, device.deviceId);
-            if (!this.config.options?.bot?.device_press && !this.config.options?.bot?.device_switch) {
+            this.log.info(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            this.log.error(JSON.stringify(device.bot?.mode));
+            if (!device.bot?.mode) {
                 this.log.error('You must set your Bot to Press or Switch Mode');
             }
             // create a new accessory
-            const accessory = new this.api.platformAccessory(`${device.deviceName} ${device.deviceType}`, uuid);
+            const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
             accessory.context.model = device.deviceType;
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = this.version;
-            await this.connectionTypeNewAccessory(device, accessory);
+            await this.connectionTypeExistingAccessory(device, accessory);
             // accessory.context.firmwareRevision = findaccessories.accessoryAttribute.softwareRevision;
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new bots_1.Bot(this, accessory, device);
-            this.debug(`${device.deviceType} UDID: ${device.deviceName}-${device.deviceId}-${device.deviceType}`);
+            this.debug(`${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]);
             this.accessories.push(accessory);
         }
         else {
-            if (this.config.devicediscovery) {
-                this.log.error('Unable to Register new device: %s %s - %s', device.deviceName, device.deviceType, device.deviceId);
-            }
+            this.device(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
         }
     }
     async createMeter(device) {
-        const uuid = this.api.hap.uuid.generate(`${device.deviceName}-${device.deviceId}-${device.deviceType}`);
+        const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.deviceType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
         const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
-            if (!this.config.options?.hide_device.includes(device.deviceId) && device.enableCloudService) {
-                this.log.info('Restoring existing accessory from cache: %s DeviceID: %s', existingAccessory.displayName, device.deviceId);
+            if (!device.hide_device && device.enableCloudService) {
+                this.log.info(`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.deviceType;
                 existingAccessory.context.deviceID = device.deviceId;
+                existingAccessory.displayName = device.deviceName;
                 existingAccessory.context.firmwareRevision = this.version;
                 await this.connectionTypeExistingAccessory(device, existingAccessory);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new meters_1.Meter(this, existingAccessory, device);
-                this.debug(`${device.deviceType} UDID: ${device.deviceName}-${device.deviceId}-${device.deviceType}`);
+                this.debug(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
-        else if (!this.config.options?.hide_device.includes(device.deviceId) && device.enableCloudService) {
+        else if (!device.hide_device && device.enableCloudService) {
             // the accessory does not yet exist, so we need to create it
-            this.log.info('Adding new accessory: %s %s DeviceID: %s', device.deviceName, device.deviceType, device.deviceId);
+            this.log.info(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
             // create a new accessory
-            const accessory = new this.api.platformAccessory(`${device.deviceName} ${device.deviceType}`, uuid);
+            const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
             accessory.context.model = device.deviceType;
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = this.version;
-            await this.connectionTypeNewAccessory(device, accessory);
+            await this.connectionTypeExistingAccessory(device, accessory);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new meters_1.Meter(this, accessory, device);
-            this.debug(`${device.deviceType} UDID: ${device.deviceName}-${device.deviceId}-${device.deviceType}`);
+            this.debug(`${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]);
             this.accessories.push(accessory);
         }
         else {
-            if (this.config.devicediscovery) {
-                this.log.error('Unable to Register new device: %s %s - %s', device.deviceName, device.deviceType, device.deviceId);
-            }
+            this.device(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
         }
     }
     async createMotion(device) {
-        const uuid = this.api.hap.uuid.generate(`${device.deviceName}-${device.deviceId}-${device.deviceType}`);
+        const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.deviceType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
         const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
-            if (!this.config.options?.hide_device.includes(device.deviceId) && device.enableCloudService) {
-                this.log.info('Restoring existing accessory from cache: %s DeviceID: %s', existingAccessory.displayName, device.deviceId);
+            if (!device.hide_device && device.enableCloudService) {
+                this.log.info(`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.deviceType;
                 existingAccessory.context.deviceID = device.deviceId;
+                existingAccessory.displayName = device.deviceName;
                 existingAccessory.context.firmwareRevision = this.version;
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new motion_1.Motion(this, existingAccessory, device);
-                this.debug(`${device.deviceType} UDID: ${device.deviceName}-${device.deviceId}-${device.deviceType}`);
+                this.debug(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
-        else if (!this.config.options?.hide_device.includes(device.deviceId) && device.enableCloudService) {
+        else if (!device.hide_device && device.enableCloudService) {
             // the accessory does not yet exist, so we need to create it
-            this.log.info('Adding new accessory: %s %s DeviceID: %s', device.deviceName, device.deviceType, device.deviceId);
+            this.log.info(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
             // create a new accessory
-            const accessory = new this.api.platformAccessory(`${device.deviceName} ${device.deviceType}`, uuid);
+            const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
@@ -537,45 +486,44 @@ class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new motion_1.Motion(this, accessory, device);
-            this.debug(`${device.deviceType} UDID: ${device.deviceName}-${device.deviceId}-${device.deviceType}`);
+            this.debug(`${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]);
             this.accessories.push(accessory);
         }
         else {
-            if (this.config.devicediscovery) {
-                this.log.error('Unable to Register new device: %s %s - %s', device.deviceName, device.deviceType, device.deviceId);
-            }
+            this.device(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
         }
     }
     async createContact(device) {
-        const uuid = this.api.hap.uuid.generate(`${device.deviceName}-${device.deviceId}-${device.deviceType}`);
+        const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.deviceType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
         const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
-            if (!this.config.options?.hide_device.includes(device.deviceId) && device.enableCloudService) {
-                this.log.info('Restoring existing accessory from cache: %s DeviceID: %s', existingAccessory.displayName, device.deviceId);
+            if (!device.hide_device && device.enableCloudService) {
+                this.log.info(`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.deviceType;
                 existingAccessory.context.deviceID = device.deviceId;
+                existingAccessory.displayName = device.deviceName;
                 existingAccessory.context.firmwareRevision = this.version;
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new contact_1.Contact(this, existingAccessory, device);
-                this.debug(`${device.deviceType} UDID: ${device.deviceName}-${device.deviceId}-${device.deviceType}`);
+                this.debug(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
-        else if (!this.config.options?.hide_device.includes(device.deviceId) && device.enableCloudService) {
+        else if (!device.hide_device && device.enableCloudService) {
             // the accessory does not yet exist, so we need to create it
-            this.log.info('Adding new accessory: %s %s DeviceID: %s', device.deviceName, device.deviceType, device.deviceId);
+            this.log.info(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
             // create a new accessory
-            const accessory = new this.api.platformAccessory(`${device.deviceName} ${device.deviceType}`, uuid);
+            const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
@@ -585,36 +533,35 @@ class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new contact_1.Contact(this, accessory, device);
-            this.debug(`${device.deviceType} UDID: ${device.deviceName}-${device.deviceId}-${device.deviceType}`);
+            this.debug(`${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]);
             this.accessories.push(accessory);
         }
         else {
-            if (this.config.devicediscovery) {
-                this.log.error('Unable to Register new device: %s %s - %s', device.deviceName, device.deviceType, device.deviceId);
-            }
+            this.device(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
         }
     }
     async createCurtain(device) {
-        const uuid = this.api.hap.uuid.generate(`${device.deviceName}-${device.deviceId}-${device.deviceType}`);
+        const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.deviceType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
         const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
             if (this.isCurtainGrouped(device)) {
-                this.log.info('Restoring existing accessory from cache: %s DeviceID: %s', existingAccessory.displayName, device.deviceId);
+                this.log.info(`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.deviceType;
                 existingAccessory.context.deviceID = device.deviceId;
+                existingAccessory.displayName = device.deviceName;
                 existingAccessory.context.firmwareRevision = this.version;
                 await this.connectionTypeExistingAccessory(device, existingAccessory);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new curtains_1.Curtain(this, existingAccessory, device);
-                this.debug(`${device.deviceType} UDID: ${device.deviceName}-${device.deviceId}-${device.deviceType}`);
+                this.debug(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -622,133 +569,181 @@ class SwitchBotPlatform {
         }
         else if (this.isCurtainGrouped(device)) {
             // the accessory does not yet exist, so we need to create it
-            this.log.info('Adding new accessory: %s %s DeviceID: %s', device.deviceName, device.deviceType, device.deviceId);
-            if (device.group && !this.config.options?.curtain?.disable_group) {
-                this.log.warn('Your Curtains are grouped, Secondary curtain automatically hidden. Main Curtain: %s, DeviceID: %s', device.deviceName, device.deviceId);
+            this.log.info(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            if (device.group && !device.curtain?.disable_group) {
+                this.device(`Your Curtains are grouped
+        , Secondary curtain automatically hidden. Main Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
             }
             else {
                 if (device.master) {
-                    this.log.warn('Main Curtain: %s, DeviceID: %s', device.deviceName, device.deviceId);
+                    this.device(`Main Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
                 }
                 else {
-                    this.log.warn('Secondary Curtain: %s, DeviceID: %s', device.deviceName, device.deviceId);
+                    this.device(`Secondary Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
                 }
             }
             // create a new accessory
-            const accessory = new this.api.platformAccessory(`${device.deviceName} ${device.deviceType}`, uuid);
+            const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
             accessory.context.model = device.deviceType;
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = this.version;
-            await this.connectionTypeNewAccessory(device, accessory);
+            await this.connectionTypeExistingAccessory(device, accessory);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new curtains_1.Curtain(this, accessory, device);
-            this.debug(`${device.deviceType} UDID: ${device.deviceName}-${device.deviceId}-${device.deviceType}`);
+            this.debug(`${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]);
             this.accessories.push(accessory);
         }
         else {
-            if (this.config.devicediscovery) {
-                this.log.error('Unable to Register new device: %s %s - %s', device.deviceName, device.deviceType, device.deviceId);
-            }
+            this.device(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
         }
     }
     isCurtainGrouped(device) {
-        if (device.group && !this.config.options?.curtain?.disable_group) {
-            return device.master && !this.config.options?.hide_device.includes(device.deviceId) && device.enableCloudService;
+        if (device.group && !device.curtain?.disable_group) {
+            return device.master && !device.hide_device && device.enableCloudService;
         }
         else {
-            return !this.config.options?.hide_device.includes(device.deviceId) && device.enableCloudService;
+            return !device.hide_device && device.enableCloudService;
         }
     }
     async createPlug(device) {
-        const uuid = this.api.hap.uuid.generate(`${device.deviceName}-${device.deviceId}-${device.deviceType}`);
+        const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.deviceType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
         const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
-            if (!this.config.options?.hide_device.includes(device.deviceId) && device.enableCloudService) {
-                this.log.info('Restoring existing accessory from cache: %s DeviceID: %s', existingAccessory.displayName, device.deviceId);
+            if (!device.hide_device && device.enableCloudService) {
+                this.log.info(`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.deviceType;
                 existingAccessory.context.deviceID = device.deviceId;
+                existingAccessory.displayName = device.deviceName;
                 existingAccessory.context.firmwareRevision = this.version;
                 await this.connectionTypeExistingAccessory(device, existingAccessory);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new plugs_1.Plug(this, existingAccessory, device);
-                this.debug(`${device.deviceType} UDID: ${device.deviceName}-${device.deviceId}-${device.deviceType}`);
+                this.debug(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
-        else if (!this.config.options?.hide_device.includes(device.deviceId) && device.enableCloudService) {
+        else if (!device.hide_device && device.enableCloudService) {
             // the accessory does not yet exist, so we need to create it
-            this.log.info('Adding new accessory: %s %s DeviceID: %s', device.deviceName, device.deviceType, device.deviceId);
+            this.log.info(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
             // create a new accessory
-            const accessory = new this.api.platformAccessory(`${device.deviceName} ${device.deviceType}`, uuid);
+            const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
             accessory.context.model = device.deviceType;
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = this.version;
-            await this.connectionTypeNewAccessory(device, accessory);
+            await this.connectionTypeExistingAccessory(device, accessory);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new plugs_1.Plug(this, accessory, device);
-            this.debug(`${device.deviceType} UDID: ${device.deviceName}-${device.deviceId}-${device.deviceType}`);
+            this.debug(`${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]);
             this.accessories.push(accessory);
         }
         else {
-            if (this.config.devicediscovery) {
-                this.log.error('Unable to Register new device: %s %s - %s', device.deviceName, device.deviceType, device.deviceId);
+            this.device(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
+        }
+    }
+    async createIndoorCam(device) {
+        const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.deviceType}`);
+        // see if an accessory with the same uuid has already been registered and restored from
+        // the cached devices we stored in the `configureAccessory` method above
+        const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
+        if (existingAccessory) {
+            // the accessory already exists
+            if (!device.hide_device && device.enableCloudService) {
+                this.log.info(`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.deviceType;
+                existingAccessory.context.deviceID = device.deviceId;
+                existingAccessory.displayName = device.deviceName;
+                existingAccessory.context.firmwareRevision = this.version;
+                await this.connectionTypeExistingAccessory(device, existingAccessory);
+                this.api.updatePlatformAccessories([existingAccessory]);
+                // create the accessory handler for the restored accessory
+                // this is imported from `platformAccessory.ts`
+                new indoorcam_1.IndoorCam(this, existingAccessory, device);
+                this.debug(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+            }
+            else {
+                this.unregisterPlatformAccessories(existingAccessory);
             }
         }
+        else if (!device.hide_device && device.enableCloudService) {
+            // the accessory does not yet exist, so we need to create it
+            this.log.info(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            // create a new accessory
+            const accessory = new this.api.platformAccessory(device.deviceName, uuid);
+            // store a copy of the device object in the `accessory.context`
+            // the `context` property can be used to store any data about the accessory you may need
+            accessory.context.device = device;
+            accessory.context.model = device.deviceType;
+            accessory.context.deviceID = device.deviceId;
+            accessory.context.firmwareRevision = this.version;
+            await this.connectionTypeExistingAccessory(device, accessory);
+            // create the accessory handler for the newly create accessory
+            // this is imported from `platformAccessory.ts`
+            new indoorcam_1.IndoorCam(this, accessory, device);
+            this.debug(`${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]);
+            this.accessories.push(accessory);
+        }
+        else {
+            this.device(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
+        }
     }
     async createTV(device) {
-        const uuid = this.api.hap.uuid.generate(`${device.deviceName}-${device.deviceId}-${device.remoteType}-${device.hubDeviceId}`);
+        const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.remoteType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
         const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
-        if (existingAccessory && !this.config.options?.hide_device.includes(device.deviceId)) {
-            this.log.info('Restoring existing accessory from cache: %s DeviceID: %s', existingAccessory.displayName, device.deviceId);
+        if (existingAccessory) {
+            this.log.info(`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.context.firmwareRevision = this.version;
             await this.connectionTypeExistingAccessory(device, existingAccessory);
             this.api.updatePlatformAccessories([existingAccessory]);
             // create the accessory handler for the restored accessory
             // this is imported from `platformAccessory.ts`
             new tvs_1.TV(this, existingAccessory, device);
-            this.debug(`${device.remoteType} UDID: ${device.deviceName}-${device.deviceId}-${device.remoteType}-${device.hubDeviceId}`);
+            this.debug(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
         }
-        else if (!this.config.options?.hide_device.includes(device.deviceId)) {
+        else if (device.hubDeviceId) {
             // the accessory does not yet exist, so we need to create it
-            this.log.info('Adding new accessory: %s %s DeviceID: %s', device.deviceName, device.remoteType, device.deviceId);
+            this.log.info(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
             // create a new accessory
-            const accessory = new this.api.platformAccessory(`${device.deviceName} ${device.remoteType}`, uuid);
+            const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
             accessory.context.model = device.remoteType;
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = this.version;
-            await this.connectionTypeNewAccessory(device, accessory);
+            await this.connectionTypeExistingAccessory(device, accessory);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new tvs_1.TV(this, accessory, device);
-            this.debug(`${device.remoteType} UDID: ${device.deviceName}-${device.deviceId}-${device.remoteType}-${device.hubDeviceId}`);
+            this.debug(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             /**
            * Publish as external accessory
            * Only one TV can exist per bridge, to bypass this limitation, you should
@@ -758,413 +753,403 @@ class SwitchBotPlatform {
             this.accessories.push(accessory);
         }
         else {
-            if (this.config.devicediscovery) {
-                this.log.error('Unable to Register new device: %s %s - %s', device.deviceName, device.remoteType, device.deviceId);
-            }
+            this.device(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
         }
     }
     async createFan(device) {
-        const uuid = this.api.hap.uuid.generate(`${device.deviceName}-${device.deviceId}-${device.remoteType}`);
+        const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.remoteType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
         const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
-            if (!this.config.options?.hide_device.includes(device.deviceId)) {
-                this.log.info('Restoring existing accessory from cache: %s DeviceID: %s', existingAccessory.displayName, device.deviceId);
+            if (device.hubDeviceId) {
+                this.log.info(`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.context.firmwareRevision = this.version;
                 await this.connectionTypeExistingAccessory(device, existingAccessory);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new fans_1.Fan(this, existingAccessory, device);
-                this.debug(`${device.remoteType} UDID: ${device.deviceName}-${device.deviceId}-${device.remoteType}`);
+                this.debug(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
-        else if (!this.config.options?.hide_device.includes(device.deviceId)) {
+        else if (device.hubDeviceId) {
             // the accessory does not yet exist, so we need to create it
-            this.log.info('Adding new accessory: %s %s DeviceID: %s', device.deviceName, device.remoteType, device.deviceId);
+            this.log.info(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
             // create a new accessory
-            const accessory = new this.api.platformAccessory(`${device.deviceName} ${device.remoteType}`, uuid);
+            const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
             accessory.context.model = device.remoteType;
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = this.version;
-            await this.connectionTypeNewAccessory(device, accessory);
+            await this.connectionTypeExistingAccessory(device, accessory);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new fans_1.Fan(this, accessory, device);
-            this.debug(`${device.remoteType} UDID: ${device.deviceName}-${device.deviceId}-${device.remoteType}`);
+            this.debug(`${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]);
             this.accessories.push(accessory);
         }
         else {
-            if (this.config.devicediscovery) {
-                this.log.error('Unable to Register new device: %s %s - %s', device.deviceName, device.remoteType, device.deviceId);
-            }
+            this.device(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
         }
     }
     async createLight(device) {
-        const uuid = this.api.hap.uuid.generate(`${device.deviceName}-${device.deviceId}-${device.remoteType}`);
+        const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.remoteType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
         const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
-            if (!this.config.options?.hide_device.includes(device.deviceId)) {
-                this.log.info('Restoring existing accessory from cache: %s DeviceID: %s', existingAccessory.displayName, device.deviceId);
+            if (device.hubDeviceId) {
+                this.log.info(`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.context.firmwareRevision = this.version;
                 await this.connectionTypeExistingAccessory(device, existingAccessory);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new lights_1.Light(this, existingAccessory, device);
-                this.debug(`${device.remoteType} UDID: ${device.deviceName}-${device.deviceId}-${device.remoteType}`);
+                this.debug(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
-        else if (!this.config.options?.hide_device.includes(device.deviceId)) {
+        else if (device.hubDeviceId) {
             // the accessory does not yet exist, so we need to create it
-            this.log.info('Adding new accessory: %s %s DeviceID: %s', device.deviceName, device.remoteType, device.deviceId);
+            this.log.info(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
             // create a new accessory
-            const accessory = new this.api.platformAccessory(`${device.deviceName} ${device.remoteType}`, uuid);
+            const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
             accessory.context.model = device.remoteType;
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = this.version;
-            await this.connectionTypeNewAccessory(device, accessory);
+            await this.connectionTypeExistingAccessory(device, accessory);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new lights_1.Light(this, accessory, device);
-            this.debug(`${device.remoteType} UDID: ${device.deviceName}-${device.deviceId}-${device.remoteType}`);
+            this.debug(`${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]);
             this.accessories.push(accessory);
         }
         else {
-            if (this.config.devicediscovery) {
-                this.log.error('Unable to Register new device: %s %s - %s', device.deviceName, device.remoteType, device.deviceId);
-            }
+            this.device(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
         }
     }
     async createAirConditioner(device) {
-        const uuid = this.api.hap.uuid.generate(`${device.deviceName}-${device.deviceId}-${device.remoteType}`);
+        const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.remoteType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
         const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
-            if (!this.config.options?.hide_device.includes(device.deviceId)) {
-                this.log.info('Restoring existing accessory from cache: %s DeviceID: %s', existingAccessory.displayName, device.deviceId);
+            if (device.hubDeviceId) {
+                this.log.info(`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.context.firmwareRevision = this.version;
                 await this.connectionTypeExistingAccessory(device, existingAccessory);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new airconditioners_1.AirConditioner(this, existingAccessory, device);
-                this.debug(`Fan UDID: ${device.deviceName}-${device.deviceId}-${device.remoteType}`);
+                this.debug(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
-        else if (!this.config.options?.hide_device.includes(device.deviceId)) {
+        else if (device.hubDeviceId) {
             // the accessory does not yet exist, so we need to create it
-            this.log.info('Adding new accessory: %s %s DeviceID: %s', device.deviceName, device.remoteType, device.deviceId);
+            this.log.info(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
             // create a new accessory
-            const accessory = new this.api.platformAccessory(`${device.deviceName} ${device.remoteType}`, uuid);
+            const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
             accessory.context.model = device.remoteType;
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = this.version;
-            await this.connectionTypeNewAccessory(device, accessory);
+            await this.connectionTypeExistingAccessory(device, accessory);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new airconditioners_1.AirConditioner(this, accessory, device);
-            this.debug(`Fan UDID: ${device.deviceName}-${device.deviceId}-${device.remoteType}`);
+            this.debug(`${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]);
             this.accessories.push(accessory);
         }
         else {
-            if (this.config.devicediscovery) {
-                this.log.error('Unable to Register new device: %s %s - %s', device.deviceName, device.remoteType, device.deviceId);
-            }
+            this.device(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
         }
     }
     async createAirPurifier(device) {
-        const uuid = this.api.hap.uuid.generate(`${device.deviceName}-${device.deviceId}-${device.remoteType}`);
+        const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.remoteType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
         const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
-            if (!this.config.options?.hide_device.includes(device.deviceId)) {
-                this.log.info('Restoring existing accessory from cache: %s DeviceID: %s', existingAccessory.displayName, device.deviceId);
+            if (device.hubDeviceId) {
+                this.log.info(`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.context.firmwareRevision = this.version;
                 await this.connectionTypeExistingAccessory(device, existingAccessory);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new airpurifiers_1.AirPurifier(this, existingAccessory, device);
-                this.debug(`${device.remoteType} UDID: ${device.deviceName}-${device.deviceId}-${device.remoteType}`);
+                this.debug(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
-        else if (!this.config.options?.hide_device.includes(device.deviceId)) {
+        else if (device.hubDeviceId) {
             // the accessory does not yet exist, so we need to create it
-            this.log.info('Adding new accessory: %s %s DeviceID: %s', device.deviceName, device.remoteType, device.deviceId);
+            this.log.info(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
             // create a new accessory
-            const accessory = new this.api.platformAccessory(`${device.deviceName} ${device.remoteType}`, uuid);
+            const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
             accessory.context.model = device.remoteType;
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = this.version;
-            await this.connectionTypeNewAccessory(device, accessory);
+            await this.connectionTypeExistingAccessory(device, accessory);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new airpurifiers_1.AirPurifier(this, accessory, device);
-            this.debug(`${device.remoteType} UDID: ${device.deviceName}-${device.deviceId}-${device.remoteType}`);
+            this.debug(`${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]);
             this.accessories.push(accessory);
         }
         else {
-            if (this.config.devicediscovery) {
-                this.log.error('Unable to Register new device: %s %s - %s', device.deviceName, device.remoteType, device.deviceId);
-            }
+            this.device(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
         }
     }
     async createWaterHeater(device) {
-        const uuid = this.api.hap.uuid.generate(`${device.deviceName}-${device.deviceId}-${device.remoteType}`);
+        const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.remoteType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
         const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
-            if (!this.config.options?.hide_device.includes(device.deviceId)) {
-                this.log.info('Restoring existing accessory from cache: %s DeviceID: %s', existingAccessory.displayName, device.deviceId);
+            if (device.hubDeviceId) {
+                this.log.info(`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.context.firmwareRevision = this.version;
                 await this.connectionTypeExistingAccessory(device, existingAccessory);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new waterheaters_1.WaterHeater(this, existingAccessory, device);
-                this.debug(`${device.remoteType} UDID: ${device.deviceName}-${device.deviceId}-${device.remoteType}`);
+                this.debug(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
-        else if (!this.config.options?.hide_device.includes(device.deviceId)) {
+        else if (device.hubDeviceId) {
             // the accessory does not yet exist, so we need to create it
-            this.log.info('Adding new accessory: %s %s DeviceID: %s', device.deviceName, device.remoteType, device.deviceId);
+            this.log.info(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
             // create a new accessory
-            const accessory = new this.api.platformAccessory(`${device.deviceName} ${device.remoteType}`, uuid);
+            const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
             accessory.context.model = device.remoteType;
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = this.version;
-            await this.connectionTypeNewAccessory(device, accessory);
+            await this.connectionTypeExistingAccessory(device, accessory);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new waterheaters_1.WaterHeater(this, accessory, device);
-            this.debug(`${device.remoteType} UDID: ${device.deviceName}-${device.deviceId}-${device.remoteType}`);
+            this.debug(`${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]);
             this.accessories.push(accessory);
         }
         else {
-            if (this.config.devicediscovery) {
-                this.log.error('Unable to Register new device: %s %s - %s', device.deviceName, device.remoteType, device.deviceId);
-            }
+            this.device(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
         }
     }
     async createVacuumCleaner(device) {
-        const uuid = this.api.hap.uuid.generate(`${device.deviceName}-${device.deviceId}-${device.remoteType}`);
+        const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.remoteType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
         const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
-            if (!this.config.options?.hide_device.includes(device.deviceId)) {
-                this.log.info('Restoring existing accessory from cache: %s DeviceID: %s', existingAccessory.displayName, device.deviceId);
+            if (device.hubDeviceId) {
+                this.log.info(`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.context.firmwareRevision = this.version;
                 await this.connectionTypeExistingAccessory(device, existingAccessory);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new vacuumcleaners_1.VacuumCleaner(this, existingAccessory, device);
-                this.debug(`${device.remoteType} UDID: ${device.deviceName}-${device.deviceId}-${device.remoteType}`);
+                this.debug(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
-        else if (!this.config.options?.hide_device.includes(device.deviceId)) {
+        else if (device.hubDeviceId) {
             // the accessory does not yet exist, so we need to create it
-            this.log.info('Adding new accessory: %s %s DeviceID: %s', device.deviceName, device.remoteType, device.deviceId);
+            this.log.info(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
             // create a new accessory
-            const accessory = new this.api.platformAccessory(`${device.deviceName} ${device.remoteType}`, uuid);
+            const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
             accessory.context.model = device.remoteType;
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = this.version;
-            await this.connectionTypeNewAccessory(device, accessory);
+            await this.connectionTypeExistingAccessory(device, accessory);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new vacuumcleaners_1.VacuumCleaner(this, accessory, device);
-            this.debug(`${device.remoteType} UDID: ${device.deviceName}-${device.deviceId}-${device.remoteType}`);
+            this.debug(`${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]);
             this.accessories.push(accessory);
         }
         else {
-            if (this.config.devicediscovery) {
-                this.log.error('Unable to Register new device: %s %s - %s', device.deviceName, device.remoteType, device.deviceId);
-            }
+            this.device(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
         }
     }
     async createCamera(device) {
-        const uuid = this.api.hap.uuid.generate(`${device.deviceName}-${device.deviceId}-${device.remoteType}`);
+        const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.remoteType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
         const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
-            if (!this.config.options?.hide_device.includes(device.deviceId)) {
-                this.log.info('Restoring existing accessory from cache: %s DeviceID: %s', existingAccessory.displayName, device.deviceId);
+            if (device.hubDeviceId) {
+                this.log.info(`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.context.firmwareRevision = this.version;
                 await this.connectionTypeExistingAccessory(device, existingAccessory);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new cameras_1.Camera(this, existingAccessory, device);
-                this.debug(`${device.remoteType} UDID: ${device.deviceName}-${device.deviceId}-${device.remoteType}`);
+                this.debug(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
-        else if (!this.config.options?.hide_device.includes(device.deviceId)) {
+        else if (device.hubDeviceId) {
             // the accessory does not yet exist, so we need to create it
-            this.log.info('Adding new accessory: %s %s DeviceID: %s', device.deviceName, device.remoteType, device.deviceId);
+            this.log.info(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
             // create a new accessory
-            const accessory = new this.api.platformAccessory(`${device.deviceName} ${device.remoteType}`, uuid);
+            const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
             accessory.context.model = device.remoteType;
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = this.version;
-            await this.connectionTypeNewAccessory(device, accessory);
+            await this.connectionTypeExistingAccessory(device, accessory);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new cameras_1.Camera(this, accessory, device);
-            this.debug(`${device.remoteType} UDID: ${device.deviceName}-${device.deviceId}-${device.remoteType}`);
+            this.debug(`${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]);
             this.accessories.push(accessory);
         }
         else {
-            if (this.config.devicediscovery) {
-                this.log.error('Unable to Register new device: %s %s - %s', device.deviceName, device.remoteType, device.deviceId);
-            }
+            this.device(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
         }
     }
     async createOthers(device) {
-        const uuid = this.api.hap.uuid.generate(`${device.deviceName}-${device.deviceId}-${device.remoteType}`);
+        const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.remoteType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
         const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
-            if (!this.config.options?.hide_device.includes(device.deviceId)) {
-                this.log.info('Restoring existing accessory from cache: %s DeviceID: %s', existingAccessory.displayName, device.deviceId);
+            if (device.hubDeviceId) {
+                this.log.info(`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.context.firmwareRevision = this.version;
                 await this.connectionTypeExistingAccessory(device, existingAccessory);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new others_1.Others(this, existingAccessory, device);
-                this.debug(`${device.remoteType} UDID: ${device.deviceName}-${device.deviceId}-${device.remoteType}`);
+                this.debug(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
-        else if (!this.config.options?.hide_device.includes(device.deviceId)) {
+        else if (device.hubDeviceId) {
             // the accessory does not yet exist, so we need to create it
-            this.log.info('Adding new accessory: %s %s DeviceID: %s', device.deviceName, device.remoteType, device.deviceId);
+            this.log.info(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
             // create a new accessory
-            const accessory = new this.api.platformAccessory(`${device.deviceName} ${device.remoteType}`, uuid);
+            const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
             accessory.context.model = device.remoteType;
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = this.version;
-            await this.connectionTypeNewAccessory(device, accessory);
+            await this.connectionTypeExistingAccessory(device, accessory);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new others_1.Others(this, accessory, device);
-            this.debug(`${device.remoteType} UDID: ${device.deviceName}-${device.deviceId}-${device.remoteType}`);
+            this.debug(`${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]);
             this.accessories.push(accessory);
         }
         else {
-            if (this.config.devicediscovery) {
-                this.log.error('Unable to Register new device: %s %s - %s', device.deviceName, device.remoteType, device.deviceId);
-            }
+            this.device(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
         }
     }
     async connectionTypeNewAccessory(device, accessory) {
-        if (this.config.options?.ble?.includes(device.deviceId)) {
+        if (device.ble) {
             accessory.context.connectionType = 'BLE';
         }
         else {
@@ -1172,7 +1157,7 @@ class SwitchBotPlatform {
         }
     }
     async connectionTypeExistingAccessory(device, existingAccessory) {
-        if (this.config.options?.ble?.includes(device.deviceId)) {
+        if (device.ble) {
             existingAccessory.context.connectionType = 'BLE';
         }
         else {
@@ -1185,31 +1170,48 @@ class SwitchBotPlatform {
         this.log.info('Removing existing accessory from cache:', existingAccessory.displayName);
     }
     deviceListInfo(devices) {
-        this.log.warn(JSON.stringify(devices));
+        if (this.config.options?.debug === 'device') {
+            this.device(`deviceListInfoStatus: ${JSON.stringify(devices)}`);
+        }
     }
     async deviceInfo(device) {
-        this.log.warn(JSON.stringify(device));
-        const deviceStatus = (await this.axios.get(`${settings_1.DeviceURL}/${device.deviceId}/status`)).data;
-        if (deviceStatus.message === 'success') {
-            this.log.warn('deviceStatus -', device.deviceName, JSON.stringify(deviceStatus));
-        }
-        else {
-            this.log.warn('deviceStatus -', device.deviceName, JSON.stringify(deviceStatus.message));
-            this.log.error('Unable to retreive device status.');
+        if (this.config.options?.debug === 'device') {
+            this.device(JSON.stringify(device));
+            this.deviceStatus = (await this.axios.get(`${settings_1.DeviceURL}/${device.deviceId}/status`)).data;
+            if (this.deviceStatus.message === 'success') {
+                this.device(`${device.deviceName} deviceInfoStatus: ${JSON.stringify(this.deviceStatus)}`);
+            }
+            else {
+                this.device(`${device.deviceName} deviceInfoStatus: ${JSON.stringify(this.deviceStatus.message)}`);
+                this.device('Unable to retreive deviceInfoStatus.');
+            }
         }
     }
     /**
      * If debug level logging is turned on, log to log.info
      * Otherwise send debug logs to log.debug
+     * this.debugMode = process.argv.includes('-D') || process.argv.includes('--debug');
      */
     debug(...log) {
-        if (this.config.options?.debug) {
+        if (this.config.options.debug === 'debug') {
             this.log.info('[DEBUG]', String(...log));
         }
         else {
             this.log.debug(String(...log));
         }
     }
+    /**
+     * If device level logging is turned on, log to log.warn
+     * Otherwise send debug logs to log.debug
+     */
+    device(...log) {
+        if (this.config.options.debug === 'device') {
+            this.log.warn('[DEVICE]', String(...log));
+        }
+        else {
+            this.log.debug(String(...log));
+        }
+    }
 }
 exports.SwitchBotPlatform = SwitchBotPlatform;
 //# sourceMappingURL=platform.js.map