@switchbot/homebridge-switchbot 1.4.1-beta.1 → 1.4.1-beta.2

package/dist/platform.js

@@ -11,7 +11,6 @@ const motion_1 = require("./devices/motion");
 const contact_1 = require("./devices/contact");
 const curtains_1 = require("./devices/curtains");
 const colorbulb_1 = require("./devices/colorbulb");
-const indoorcam_1 = require("./devices/indoorcam");
 const humidifiers_1 = require("./devices/humidifiers");
 const tvs_1 = require("./irdevices/tvs");
 const fans_1 = require("./irdevices/fans");
@@ -41,14 +40,13 @@ class SwitchBotPlatform {
         this.axios = axios_1.default.create({
             responseType: 'json',
         });
-        // debugMode!: boolean;
         this.version = require('../package.json').version; // eslint-disable-line @typescript-eslint/no-var-requires
-        this.log.debug('Finished initializing platform:', this.config.name);
+        this.logs();
+        this.debugLog('Finished initializing platform:', this.config.name);
         // only load if configured
         if (!this.config) {
             return;
         }
-        this.debugMode = process.argv.includes('-D') || process.argv.includes('--debug');
         // HOOBS notice
         if (__dirname.includes('hoobs')) {
             this.log.warn('This plugin has not been tested under HOOBS, it is highly recommended that ' +
@@ -57,14 +55,15 @@ class SwitchBotPlatform {
         // verify the config
         try {
             this.verifyConfig();
-            this.log.debug('Config OK');
+            this.debugLog('Config OK');
         }
         catch (e) {
-            this.log.error(JSON.stringify(e.message));
-            this.log.debug(JSON.stringify(e));
+            this.errorLog(JSON.stringify(e.message));
+            if (this.platformLogging === 'debugMode') {
+                this.errorLog(JSON.stringify(e));
+            }
             return;
         }
-        this.debugMode = process.argv.includes('-D') || process.argv.includes('--debug');
         // setup axios interceptor to add headers / api key to each request
         this.axios.interceptors.request.use((request) => {
             request.headers.Authorization = this.config.credentials?.openToken;
@@ -76,23 +75,44 @@ class SwitchBotPlatform {
         // in order to ensure they weren't added to homebridge already. This event can also be used
         // to start discovery of new accessories.
         this.api.on('didFinishLaunching', async () => {
-            log.debug('Executed didFinishLaunching callback');
+            this.debugLog('Executed didFinishLaunching callback');
             // run the method to discover / register your devices as accessories
             try {
                 this.discoverDevices();
             }
             catch (e) {
-                this.log.error('Failed to Discover Devices.', JSON.stringify(e.message));
-                this.log.debug(JSON.stringify(e));
+                this.errorLog('Failed to Discover Devices.', JSON.stringify(e.message));
+                if (this.platformLogging === 'debugMode') {
+                    this.errorLog(JSON.stringify(e));
+                }
             }
         });
     }
+    logs() {
+        this.debugMode = process.argv.includes('-D') || process.argv.includes('--debug');
+        if (this.config.options?.logging === 'debug' || this.config.options?.logging === 'standard' || this.config.options?.logging === 'none') {
+            this.platformLogging = this.config.options.logging;
+            if (this.debugMode) {
+                this.log.warn(`Using Config Logging: ${this.platformLogging}`);
+            }
+        }
+        else if (this.debugMode) {
+            if (this.debugMode) {
+                this.log.warn('Using debugMode Logging');
+            }
+            this.platformLogging = 'debugMode';
+        }
+        else {
+            this.log.warn('Using Standard Logging');
+            this.platformLogging = 'standard';
+        }
+    }
     /**
      * This function is invoked when homebridge restores cached accessories from disk at startup.
      * It should be used to setup event handlers for characteristics and update respective values.
      */
     configureAccessory(accessory) {
-        this.log.info('Loading accessory from cache:', accessory.displayName);
+        this.infoLog(`Loading accessory from cache: ${accessory.displayName}`);
         // add the restored accessory to the accessories cache so we can track if it has already been registered
         this.accessories.push(accessory);
     }
@@ -105,7 +125,6 @@ class SwitchBotPlatform {
          * This will disable adding any device and will just output info.
          */
         this.config.options = this.config.options || {};
-        this.config.options.debug;
         if (this.config.options) {
             // Device Config
             if (this.config.options.devices) {
@@ -119,7 +138,7 @@ class SwitchBotPlatform {
                         }
                         if (deviceConfig.bot) {
                             if (!deviceConfig.bot?.mode) {
-                                this.log.error('You must set your Bot to Press or Switch Mode');
+                                this.errorLog('You must set your Bot to Press or Switch Mode');
                             }
                         }
                     }
@@ -130,10 +149,10 @@ class SwitchBotPlatform {
                 for (const irDeviceConfig of this.config.options.irdevices) {
                     if (!irDeviceConfig.hide_device) {
                         if (!irDeviceConfig.deviceId) {
-                            this.log.error('The devices config section is missing the *Device ID* in the config, Check Your Conifg.');
+                            this.errorLog('The devices config section is missing the *Device ID* in the config, Check Your Conifg.');
                         }
                         if (!irDeviceConfig.deviceId && !irDeviceConfig.configRemoteType) {
-                            this.log.error('The devices config section is missing the *Device Type* in the config, Check Your Conifg.');
+                            this.errorLog('The devices config section is missing the *Device Type* in the config, Check Your Conifg.');
                         }
                     }
                 }
@@ -145,19 +164,23 @@ class SwitchBotPlatform {
         if (!this.config.options.refreshRate) {
             // 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
-            this.config.options.pushRate = 0.1;
-            this.log.warn('Using Default Push Rate.');
-        }
-        if (!this.config.credentials) {
-            this.debug('Missing Credentials');
-        }
-        if (!this.config.credentials?.openToken) {
-            this.log.error('Missing openToken');
-            this.log.warn('Cloud Enabled SwitchBot Devices & IR Devices will not work');
+            if (this.debugMode) {
+                this.warnLog('Using Default Refresh Rate (2 minutes).');
+            }
+            if (!this.config.options.pushRate) {
+                // default 100 milliseconds
+                this.config.options.pushRate = 0.1;
+                if (this.debugMode) {
+                    this.warnLog('Using Default Push Rate.');
+                }
+            }
+            if (!this.config.credentials) {
+                this.debugLog('Missing Credentials');
+            }
+            if (!this.config.credentials?.openToken) {
+                this.errorLog('Missing openToken');
+                this.warnLog('Cloud Enabled SwitchBot Devices & IR Devices will not work');
+            }
         }
     }
     /**
@@ -168,12 +191,12 @@ class SwitchBotPlatform {
             if (this.config.credentials?.openToken) {
                 const devicesAPI = (await this.axios.get(settings_1.DeviceURL)).data;
                 this.deviceListInfo(devicesAPI);
-                this.debug(JSON.stringify(devicesAPI));
+                this.debugLog(JSON.stringify(devicesAPI));
                 // SwitchBot Devices
-                this.log.info('Total SwitchBot Devices Found:', devicesAPI.body.deviceList.length);
+                this.infoLog(`Total SwitchBot Devices Found: ${devicesAPI.body.deviceList.length}`);
                 const deviceLists = devicesAPI.body.deviceList;
                 if (!this.config.options?.devices) {
-                    this.debug(`SwitchBot Device Config Not Set: ${JSON.stringify(this.config.options?.devices)}`);
+                    this.debugLog(`SwitchBot Device Config Not Set: ${JSON.stringify(this.config.options?.devices)}`);
                     const devices = deviceLists.map((v) => v);
                     for (const device of devices) {
                         if (device.deviceType) {
@@ -185,14 +208,14 @@ class SwitchBotPlatform {
                     }
                 }
                 else if (this.config.credentials?.openToken && this.config.options.devices) {
-                    this.debug(`SwitchBot Device Config Set: ${JSON.stringify(this.config.options?.devices)}`);
+                    this.debugLog(`SwitchBot Device Config Set: ${JSON.stringify(this.config.options?.devices)}`);
                     const deviceConfigs = this.config.options?.devices;
                     const mergeBydeviceId = (a1, a2) => a1.map((itm) => ({
                         ...a2.find((item) => (item.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') === itm.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '')) && item),
                         ...itm,
                     }));
                     const devices = mergeBydeviceId(deviceLists, deviceConfigs);
-                    this.debug(`SwitchBot Devices: ${JSON.stringify(devices)}`);
+                    this.debugLog(`SwitchBot Devices: ${JSON.stringify(devices)}`);
                     for (const device of devices) {
                         if (device.deviceType) {
                             if (device.configDeviceName) {
@@ -203,13 +226,13 @@ class SwitchBotPlatform {
                     }
                 }
                 else {
-                    this.log.error('Neither SwitchBot OpenToken or Device Config are not set.');
+                    this.errorLog('Neither SwitchBot OpenToken or Device Config are not set.');
                 }
                 // IR Devices
-                this.log.info('Total IR Devices Found:', devicesAPI.body.infraredRemoteList.length);
+                this.infoLog(`Total IR Devices Found: ${devicesAPI.body.infraredRemoteList.length}`);
                 const irDeviceLists = devicesAPI.body.infraredRemoteList;
                 if (!this.config.options?.irdevices) {
-                    this.debug(`IR Device Config Not Set: ${JSON.stringify(this.config.options?.irdevices)}`);
+                    this.debugLog(`IR Device Config Not Set: ${JSON.stringify(this.config.options?.irdevices)}`);
                     const devices = irDeviceLists.map((v) => v);
                     for (const device of devices) {
                         if (device.remoteType) {
@@ -218,14 +241,14 @@ class SwitchBotPlatform {
                     }
                 }
                 else {
-                    this.debug(`IR Device Config Set: ${JSON.stringify(this.config.options?.irdevices)}`);
+                    this.debugLog(`IR Device Config Set: ${JSON.stringify(this.config.options?.irdevices)}`);
                     const irDeviceConfig = this.config.options?.irdevices;
                     const mergeIRBydeviceId = (a1, a2) => a1.map((itm) => ({
                         ...a2.find((item) => (item.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') === itm.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '')) && item),
                         ...itm,
                     }));
                     const devices = mergeIRBydeviceId(irDeviceLists, irDeviceConfig);
-                    this.debug(`IR Devices: ${JSON.stringify(devices)}`);
+                    this.debugLog(`IR Devices: ${JSON.stringify(devices)}`);
                     for (const device of devices) {
                         if (device.remoteType) {
                             this.createIRDevice(device);
@@ -234,7 +257,7 @@ class SwitchBotPlatform {
                 }
             }
             else if (!this.config.credentials?.openToken && this.config.options?.devices) {
-                this.debug(`SwitchBot Device Manual Config Set: ${JSON.stringify(this.config.options?.devices)}`);
+                this.debugLog(`SwitchBot Device Manual Config Set: ${JSON.stringify(this.config.options?.devices)}`);
                 const deviceConfigs = this.config.options?.devices;
                 const devices = deviceConfigs.map((v) => v);
                 for (const device of devices) {
@@ -246,7 +269,7 @@ class SwitchBotPlatform {
                 }
             }
             else {
-                this.log.error('Neither SwitchBot OpenToken or Device Config are not set.');
+                this.errorLog('Neither SwitchBot OpenToken or Device Config are not set.');
             }
         }
         catch (e) {
@@ -255,102 +278,104 @@ class SwitchBotPlatform {
     }
     deviceError(e) {
         if (e.message.includes('400')) {
-            this.log.error('Failed to Discover Devices: Bad Request');
-            this.debug('The client has issued an invalid request. This is commonly used to specify validation errors in a request payload.');
+            this.errorLog('Failed to Discover Devices: Bad Request');
+            this.debugLog('The client has issued an invalid request. This is commonly used to specify validation errors in a request payload.');
         }
         else if (e.message.includes('401')) {
-            this.log.error('Failed to Discover Devices: Unauthorized Request');
-            this.debug('Authorization for the API is required, but the request has not been authenticated.');
+            this.errorLog('Failed to Discover Devices: Unauthorized Request');
+            this.debugLog('Authorization for the API is required, but the request has not been authenticated.');
         }
         else if (e.message.includes('403')) {
-            this.log.error('Failed to Discover Devices: Forbidden Request');
-            this.debug('The request has been authenticated but does not have appropriate permissions, or a requested resource is not found.');
+            this.errorLog('Failed to Discover Devices: Forbidden Request');
+            this.debugLog('The request has been authenticated but does not have appropriate permissions, or a requested resource is not found.');
         }
         else if (e.message.includes('404')) {
-            this.log.error('Failed to Discover Devices: Requst Not Found');
-            this.debug('Specifies the requested path does not exist.');
+            this.errorLog('Failed to Discover Devices: Requst Not Found');
+            this.debugLog('Specifies the requested path does not exist.');
         }
         else if (e.message.includes('406')) {
-            this.log.error('Failed to Discover Devices: Request Not Acceptable');
-            this.debug('The client has requested a MIME type via the Accept header for a value not supported by the server.');
+            this.errorLog('Failed to Discover Devices: Request Not Acceptable');
+            this.debugLog('The client has requested a MIME type via the Accept header for a value not supported by the server.');
         }
         else if (e.message.includes('415')) {
-            this.log.error('Failed to Discover Devices: Unsupported Requst Header');
-            this.debug('The client has defined a contentType header that is not supported by the server.');
+            this.errorLog('Failed to Discover Devices: Unsupported Requst Header');
+            this.debugLog('The client has defined a contentType header that is not supported by the server.');
         }
         else if (e.message.includes('422')) {
-            this.log.error('Failed to Discover Devices: Unprocessable Entity');
-            this.debug('The client has made a valid request, but the server cannot process it.'
+            this.errorLog('Failed to Discover Devices: Unprocessable Entity');
+            this.debugLog('The client has made a valid request, but the server cannot process it.'
                 + ' This is often used for APIs for which certain limits have been exceeded.');
         }
         else if (e.message.includes('429')) {
-            this.log.error('Failed to Discover Devices: Too Many Requests');
-            this.debug('The client has exceeded the number of requests allowed for a given time window.');
+            this.errorLog('Failed to Discover Devices: Too Many Requests');
+            this.debugLog('The client has exceeded the number of requests allowed for a given time window.');
         }
         else if (e.message.includes('500')) {
-            this.log.error('Failed to Discover Devices: Internal Server Error');
-            this.debug('An unexpected error on the SmartThings servers has occurred. These errors should be rare.');
+            this.errorLog('Failed to Discover Devices: Internal Server Error');
+            this.debugLog('An unexpected error on the SmartThings servers has occurred. These errors should be rare.');
         }
         else {
-            this.log.error('Failed to Discover Devices');
+            this.errorLog('Failed to Discover Devices');
         }
-        if (this.config.options?.debug === 'device') {
-            this.log.error(`Failed to Discover Devices, Error Message: ${JSON.stringify(e.message)}`);
+        if (this.platformLogging === 'debug') {
+            this.errorLog(`Failed to Discover Devices, Error Message: ${JSON.stringify(e.message)}`);
         }
-        if (this.config.options?.debug === 'debug' || this.debugMode) {
-            this.log.error(`Failed to Discover Devices, Error: ${JSON.stringify(e)}`);
+        if (this.platformLogging === 'debugMode') {
+            this.errorLog(`Failed to Discover Devices, Error: ${JSON.stringify(e)}`);
         }
     }
     createDevice(device) {
         switch (device.deviceType) {
             case 'Humidifier':
-                this.debug(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createHumidifier(device);
                 break;
             case 'Hub Mini':
-                this.debug(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 break;
             case 'Hub Plus':
-                this.debug(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 break;
             case 'Bot':
-                this.debug(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createBot(device);
                 break;
             case 'Meter':
-                this.debug(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createMeter(device);
                 break;
             case 'Motion Sensor':
-                this.debug(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createMotion(device);
                 break;
             case 'Contact Sensor':
-                this.debug(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createContact(device);
                 break;
             case 'Curtain':
-                this.debug(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createCurtain(device);
                 break;
             case 'Plug':
-                this.debug(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createPlug(device);
                 break;
             case 'Color Bulb':
-                this.debug(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createColorBulb(device);
                 break;
             case 'Indoor Cam':
-                this.debug(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                this.createIndoorCam(device);
+                this.deviceInfo(device);
+                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.warnLog(`Device: ${device.deviceName} with Device Type: ${device.deviceType}, is currently not supported.`);
                 break;
             case 'Remote':
-                this.debug(`Discovered ${device.deviceType}: ${device.deviceId} is Not Supported.`);
+                this.debugLog(`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');
+                this.deviceInfo(device);
+                this.warnLog(`Device: ${device.deviceName} with Device Type: ${device.deviceType}, is currently not supported.`);
+                this.warnLog('Submit Feature Requests Here: https://git.io/JL14Z');
         }
     }
     createIRDevice(device) {
@@ -367,69 +392,70 @@ class SwitchBotPlatform {
             case 'DIY DVD':
             case 'Speaker':
             case 'DIY Speaker':
-                this.debug(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
                 this.createTV(device);
                 break;
             case 'Fan':
             case 'DIY Fan':
-                this.debug(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
                 this.createFan(device);
                 break;
             case 'Air Conditioner':
             case 'DIY Air Conditioner':
-                this.debug(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
                 this.createAirConditioner(device);
                 break;
             case 'Light':
             case 'DIY Light':
-                this.debug(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
                 this.createLight(device);
                 break;
             case 'Air Purifier':
             case 'DIY Air Purifier':
-                this.debug(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
                 this.createAirPurifier(device);
                 break;
             case 'Water Heater':
             case 'DIY Water Heater':
-                this.debug(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
                 this.createWaterHeater(device);
                 break;
             case 'Vacuum Cleaner':
             case 'DIY Vacuum Cleaner':
-                this.debug(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
                 this.createVacuumCleaner(device);
                 break;
             case 'Camera':
             case 'DIY Camera':
-                this.debug(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
                 this.createCamera(device);
                 break;
             case 'Others':
-                this.debug(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                this.debugLog(`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');
+                this.deviceInfo(device);
+                this.warnLog(`Device: ${device.deviceName} with Device Type: ${device.remoteType}, is currently not supported.`);
+                this.warnLog('Submit Feature Requests Here: https://git.io/JL14Z');
         }
     }
     registerDevice(device) {
         if (!device.hide_device && device.enableCloudService && device.ble) {
             this.registeringDevice = true;
-            this.device(`Device: ${device.deviceName} Both OpenAPI and BLE Connections Enabled`);
+            this.debugLog(`Device: ${device.deviceName} Both OpenAPI and BLE Connections Enabled`);
         }
         else if (!device.hide_device && device.deviceId && device.configDeviceType && device.configDeviceName && !device.enableCloudService) {
             this.registeringDevice = true;
-            this.device(`Device: ${device.deviceName} BLE Connection Enabled`);
+            this.debugLog(`Device: ${device.deviceName} BLE Connection Enabled`);
         }
         else if (!device.hide_device && device.enableCloudService && !device.ble) {
             this.registeringDevice = true;
-            this.device(`Device: ${device.deviceName} OpenAPI Connection Enabled`);
+            this.debugLog(`Device: ${device.deviceName} OpenAPI Connection Enabled`);
         }
         else {
             this.registeringDevice = false;
-            this.device(`Device: ${device.deviceName} Neither OpenAPI and BLE Enabled`);
+            this.debugLog(`Device: ${device.deviceName} Neither OpenAPI and BLE Enabled`);
         }
         return this.registeringDevice;
     }
@@ -441,7 +467,7 @@ class SwitchBotPlatform {
         if (existingAccessory) {
             // the accessory already exists
             if (this.registerDevice(device)) {
-                this.log.info(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
                 //existingAccessory.context.firmwareRevision = firmware;
                 existingAccessory.context.model = device.deviceType;
@@ -454,7 +480,7 @@ class SwitchBotPlatform {
                 // 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} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -462,7 +488,7 @@ class SwitchBotPlatform {
         }
         else if (this.registerDevice(device)) {
             // 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}`);
+            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
@@ -476,13 +502,13 @@ class SwitchBotPlatform {
             // 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} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // link the accessory to your platform
             this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
             this.accessories.push(accessory);
         }
         else {
-            this.device(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
+            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
         }
     }
     async createBot(device) {
@@ -493,8 +519,8 @@ class SwitchBotPlatform {
         if (existingAccessory) {
             // the accessory already exists
             if (this.registerDevice(device)) {
-                this.log.info(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
-                this.debug(JSON.stringify(device.bot?.mode));
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                this.debugLog(JSON.stringify(device.bot?.mode));
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
                 existingAccessory.context.model = device.deviceType;
                 existingAccessory.context.deviceID = device.deviceId;
@@ -506,7 +532,7 @@ class SwitchBotPlatform {
                 // 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} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -514,8 +540,8 @@ class SwitchBotPlatform {
         }
         else if (this.registerDevice(device)) {
             // 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}`);
-            this.debug(JSON.stringify(device.bot?.mode));
+            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            this.debugLog(JSON.stringify(device.bot?.mode));
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
@@ -530,13 +556,13 @@ class SwitchBotPlatform {
             // 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} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // link the accessory to your platform
             this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
             this.accessories.push(accessory);
         }
         else {
-            this.device(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
+            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
         }
     }
     async createMeter(device) {
@@ -547,7 +573,7 @@ class SwitchBotPlatform {
         if (existingAccessory) {
             // the accessory already exists
             if (this.registerDevice(device)) {
-                this.log.info(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
                 existingAccessory.context.model = device.deviceType;
                 existingAccessory.context.deviceID = device.deviceId;
@@ -559,7 +585,7 @@ class SwitchBotPlatform {
                 // 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} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -567,7 +593,7 @@ class SwitchBotPlatform {
         }
         else if (this.registerDevice(device)) {
             // 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}`);
+            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
@@ -581,13 +607,13 @@ class SwitchBotPlatform {
             // 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} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // link the accessory to your platform
             this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
             this.accessories.push(accessory);
         }
         else {
-            this.device(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
+            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
         }
     }
     async createMotion(device) {
@@ -598,7 +624,7 @@ class SwitchBotPlatform {
         if (existingAccessory) {
             // the accessory already exists
             if (this.registerDevice(device)) {
-                this.log.info(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
                 existingAccessory.context.model = device.deviceType;
                 existingAccessory.context.deviceID = device.deviceId;
@@ -610,7 +636,7 @@ class SwitchBotPlatform {
                 // 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} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -618,7 +644,7 @@ class SwitchBotPlatform {
         }
         else if (this.registerDevice(device)) {
             // 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}`);
+            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
@@ -632,13 +658,13 @@ 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} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // link the accessory to your platform
             this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
             this.accessories.push(accessory);
         }
         else {
-            this.device(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
+            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
         }
     }
     async createContact(device) {
@@ -649,7 +675,7 @@ class SwitchBotPlatform {
         if (existingAccessory) {
             // the accessory already exists
             if (this.registerDevice(device)) {
-                this.log.info(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
                 existingAccessory.context.model = device.deviceType;
                 existingAccessory.context.deviceID = device.deviceId;
@@ -661,7 +687,7 @@ class SwitchBotPlatform {
                 // 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} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -669,7 +695,7 @@ class SwitchBotPlatform {
         }
         else if (this.registerDevice(device)) {
             // 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}`);
+            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
@@ -683,13 +709,13 @@ 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} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // link the accessory to your platform
             this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
             this.accessories.push(accessory);
         }
         else {
-            this.device(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
+            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
         }
     }
     async createCurtain(device) {
@@ -700,7 +726,7 @@ class SwitchBotPlatform {
         if (existingAccessory) {
             // the accessory already exists
             if (this.isCurtainGrouped(device)) {
-                this.log.info(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
                 existingAccessory.context.model = device.deviceType;
                 existingAccessory.context.deviceID = device.deviceId;
@@ -712,7 +738,7 @@ class SwitchBotPlatform {
                 // 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} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -720,17 +746,17 @@ 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: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
             if (device.group && !device.curtain?.disable_group) {
-                this.device(`Your Curtains are grouped
+                this.debugLog(`Your Curtains are grouped
         , Secondary curtain automatically hidden. Main Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
             }
             else {
                 if (device.master) {
-                    this.device(`Main Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
+                    this.debugLog(`Main Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
                 }
                 else {
-                    this.device(`Secondary Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
+                    this.debugLog(`Secondary Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
                 }
             }
             // create a new accessory
@@ -746,24 +772,24 @@ class SwitchBotPlatform {
             // 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} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // link the accessory to your platform
             this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
             this.accessories.push(accessory);
         }
         else {
-            this.device(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
+            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
         }
     }
     isCurtainGrouped(device) {
-        this.debug(`deviceId: ${device.deviceId}, curtainDevicesIds: ${device.curtainDevicesIds},`
+        this.debugLog(`deviceId: ${device.deviceId}, curtainDevicesIds: ${device.curtainDevicesIds},`
             + ` master: ${device.master}, group: ${device.group}, disable_group: ${device.curtain?.disable_group}`);
         if (device.group && !device.curtain?.disable_group) {
-            this.debug(`[Curtain Config] disable_group: ${device.curtain?.disable_group}`);
+            this.debugLog(`[Curtain Config] disable_group: ${device.curtain?.disable_group}`);
             return device.master && this.registerDevice(device);
         }
         else {
-            this.debug(`[Curtain Config] disable_group: ${device.curtain?.disable_group}, UnGrouping ${device.master}`);
+            this.debugLog(`[Curtain Config] disable_group: ${device.curtain?.disable_group}, UnGrouping ${device.master}`);
             return this.registerDevice(device);
         }
     }
@@ -775,7 +801,7 @@ class SwitchBotPlatform {
         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}`);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
                 existingAccessory.context.model = device.deviceType;
                 existingAccessory.context.deviceID = device.deviceId;
@@ -787,7 +813,7 @@ class SwitchBotPlatform {
                 // 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} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -795,7 +821,7 @@ class SwitchBotPlatform {
         }
         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}`);
+            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
@@ -809,13 +835,13 @@ class SwitchBotPlatform {
             // 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} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // link the accessory to your platform
             this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
             this.accessories.push(accessory);
         }
         else {
-            this.device(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
+            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
         }
     }
     async createColorBulb(device) {
@@ -826,7 +852,7 @@ class SwitchBotPlatform {
         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}`);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
                 existingAccessory.context.model = device.deviceType;
                 existingAccessory.context.deviceID = device.deviceId;
@@ -838,7 +864,7 @@ class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new colorbulb_1.ColorBulb(this, existingAccessory, device);
-                this.debug(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -846,7 +872,7 @@ class SwitchBotPlatform {
         }
         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}`);
+            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
@@ -860,64 +886,13 @@ class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new colorbulb_1.ColorBulb(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 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;
-                existingAccessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-                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;
-            accessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-            await this.connectionTypeNewAccessory(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})`);
+            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // link the accessory to your platform
             this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
             this.accessories.push(accessory);
         }
         else {
-            this.device(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
+            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
         }
     }
     async createTV(device) {
@@ -926,23 +901,23 @@ class SwitchBotPlatform {
         // the cached devices we stored in the `configureAccessory` method above
         const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
         if (!device.hide_device && existingAccessory) {
-            this.log.info(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+            this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
             // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
             existingAccessory.context.model = device.remoteType;
             existingAccessory.context.deviceID = device.deviceId;
             existingAccessory.displayName = device.deviceName;
             existingAccessory.context.firmwareRevision = this.version;
             existingAccessory.context.deviceType = `IR: ${device.remoteType}`;
-            await this.connectionTypeExistingIRAccessory(device, existingAccessory);
+            await this.connectionTypeExistingIRAccessory(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} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
         }
         else if (!device.hide_device && device.hubDeviceId) {
             // the accessory does not yet exist, so we need to create it
-            this.log.info(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
@@ -952,11 +927,11 @@ class SwitchBotPlatform {
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = this.version;
             accessory.context.deviceType = `IR: ${device.remoteType}`;
-            await this.connectionTypeNewIRAccessory(device, accessory);
+            await this.connectionTypeNewIRAccessory(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} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            this.debugLog(`${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
@@ -966,7 +941,7 @@ class SwitchBotPlatform {
             this.accessories.push(accessory);
         }
         else {
-            this.device(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
+            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
         }
     }
     async createFan(device) {
@@ -977,19 +952,19 @@ class SwitchBotPlatform {
         if (existingAccessory) {
             // the accessory already exists
             if (!device.hide_device && device.hubDeviceId) {
-                this.log.info(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
                 existingAccessory.context.model = device.remoteType;
                 existingAccessory.context.deviceID = device.deviceId;
                 existingAccessory.displayName = device.deviceName;
                 existingAccessory.context.firmwareRevision = this.version;
                 existingAccessory.context.deviceType = `IR: ${device.remoteType}`;
-                await this.connectionTypeExistingIRAccessory(device, existingAccessory);
+                await this.connectionTypeExistingIRAccessory(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} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -997,7 +972,7 @@ class SwitchBotPlatform {
         }
         else if (!device.hide_device && device.hubDeviceId) {
             // the accessory does not yet exist, so we need to create it
-            this.log.info(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
@@ -1007,17 +982,17 @@ class SwitchBotPlatform {
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = this.version;
             accessory.context.deviceType = `IR: ${device.remoteType}`;
-            await this.connectionTypeNewIRAccessory(device, accessory);
+            await this.connectionTypeNewIRAccessory(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} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // link the accessory to your platform
             this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
             this.accessories.push(accessory);
         }
         else {
-            this.device(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
+            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
         }
     }
     async createLight(device) {
@@ -1028,19 +1003,19 @@ class SwitchBotPlatform {
         if (existingAccessory) {
             // the accessory already exists
             if (!device.hide_device && device.hubDeviceId) {
-                this.log.info(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
                 existingAccessory.context.model = device.remoteType;
                 existingAccessory.context.deviceID = device.deviceId;
                 existingAccessory.displayName = device.deviceName;
                 existingAccessory.context.firmwareRevision = this.version;
                 existingAccessory.context.deviceType = `IR: ${device.remoteType}`;
-                await this.connectionTypeExistingIRAccessory(device, existingAccessory);
+                await this.connectionTypeExistingIRAccessory(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} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1048,7 +1023,7 @@ class SwitchBotPlatform {
         }
         else if (!device.hide_device && device.hubDeviceId) {
             // the accessory does not yet exist, so we need to create it
-            this.log.info(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
@@ -1058,17 +1033,17 @@ class SwitchBotPlatform {
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = this.version;
             accessory.context.deviceType = `IR: ${device.remoteType}`;
-            await this.connectionTypeNewIRAccessory(device, accessory);
+            await this.connectionTypeNewIRAccessory(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} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // link the accessory to your platform
             this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
             this.accessories.push(accessory);
         }
         else {
-            this.device(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
+            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
         }
     }
     async createAirConditioner(device) {
@@ -1079,19 +1054,19 @@ class SwitchBotPlatform {
         if (existingAccessory) {
             // the accessory already exists
             if (!device.hide_device && device.hubDeviceId) {
-                this.log.info(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
                 existingAccessory.context.model = device.remoteType;
                 existingAccessory.context.deviceID = device.deviceId;
                 existingAccessory.displayName = device.deviceName;
                 existingAccessory.context.firmwareRevision = this.version;
                 existingAccessory.context.deviceType = `IR: ${device.remoteType}`;
-                await this.connectionTypeExistingIRAccessory(device, existingAccessory);
+                await this.connectionTypeExistingIRAccessory(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(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1099,7 +1074,7 @@ class SwitchBotPlatform {
         }
         else if (!device.hide_device && device.hubDeviceId) {
             // the accessory does not yet exist, so we need to create it
-            this.log.info(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
@@ -1109,17 +1084,17 @@ class SwitchBotPlatform {
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = this.version;
             accessory.context.deviceType = `IR: ${device.remoteType}`;
-            await this.connectionTypeNewIRAccessory(device, accessory);
+            await this.connectionTypeNewIRAccessory(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(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // link the accessory to your platform
             this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
             this.accessories.push(accessory);
         }
         else {
-            this.device(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
+            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
         }
     }
     async createAirPurifier(device) {
@@ -1130,19 +1105,19 @@ class SwitchBotPlatform {
         if (existingAccessory) {
             // the accessory already exists
             if (!device.hide_device && device.hubDeviceId) {
-                this.log.info(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
                 existingAccessory.context.model = device.remoteType;
                 existingAccessory.context.deviceID = device.deviceId;
                 existingAccessory.displayName = device.deviceName;
                 existingAccessory.context.firmwareRevision = this.version;
                 existingAccessory.context.deviceType = `IR: ${device.remoteType}`;
-                await this.connectionTypeExistingIRAccessory(device, existingAccessory);
+                await this.connectionTypeExistingIRAccessory(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} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1150,7 +1125,7 @@ class SwitchBotPlatform {
         }
         else if (!device.hide_device && device.hubDeviceId) {
             // the accessory does not yet exist, so we need to create it
-            this.log.info(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
@@ -1160,17 +1135,17 @@ class SwitchBotPlatform {
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = this.version;
             accessory.context.deviceType = `IR: ${device.remoteType}`;
-            await this.connectionTypeNewIRAccessory(device, accessory);
+            await this.connectionTypeNewIRAccessory(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} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // link the accessory to your platform
             this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
             this.accessories.push(accessory);
         }
         else {
-            this.device(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
+            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
         }
     }
     async createWaterHeater(device) {
@@ -1181,19 +1156,19 @@ class SwitchBotPlatform {
         if (existingAccessory) {
             // the accessory already exists
             if (!device.hide_device && device.hubDeviceId) {
-                this.log.info(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
                 existingAccessory.context.model = device.remoteType;
                 existingAccessory.context.deviceID = device.deviceId;
                 existingAccessory.displayName = device.deviceName;
                 existingAccessory.context.firmwareRevision = this.version;
                 existingAccessory.context.deviceType = `IR: ${device.remoteType}`;
-                await this.connectionTypeExistingIRAccessory(device, existingAccessory);
+                await this.connectionTypeExistingIRAccessory(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} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1201,7 +1176,7 @@ class SwitchBotPlatform {
         }
         else if (!device.hide_device && device.hubDeviceId) {
             // the accessory does not yet exist, so we need to create it
-            this.log.info(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
@@ -1211,17 +1186,17 @@ class SwitchBotPlatform {
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = this.version;
             accessory.context.deviceType = `IR: ${device.remoteType}`;
-            await this.connectionTypeNewIRAccessory(device, accessory);
+            await this.connectionTypeNewIRAccessory(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} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // link the accessory to your platform
             this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
             this.accessories.push(accessory);
         }
         else {
-            this.device(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
+            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
         }
     }
     async createVacuumCleaner(device) {
@@ -1232,19 +1207,19 @@ class SwitchBotPlatform {
         if (existingAccessory) {
             // the accessory already exists
             if (!device.hide_device && device.hubDeviceId) {
-                this.log.info(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
                 existingAccessory.context.model = device.remoteType;
                 existingAccessory.context.deviceID = device.deviceId;
                 existingAccessory.displayName = device.deviceName;
                 existingAccessory.context.firmwareRevision = this.version;
                 existingAccessory.context.deviceType = `IR: ${device.remoteType}`;
-                await this.connectionTypeExistingIRAccessory(device, existingAccessory);
+                await this.connectionTypeExistingIRAccessory(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} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1252,7 +1227,7 @@ class SwitchBotPlatform {
         }
         else if (!device.hide_device && device.hubDeviceId) {
             // the accessory does not yet exist, so we need to create it
-            this.log.info(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
@@ -1262,17 +1237,17 @@ class SwitchBotPlatform {
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = this.version;
             accessory.context.deviceType = `IR: ${device.remoteType}`;
-            await this.connectionTypeNewIRAccessory(device, accessory);
+            await this.connectionTypeNewIRAccessory(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} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // link the accessory to your platform
             this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
             this.accessories.push(accessory);
         }
         else {
-            this.device(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
+            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
         }
     }
     async createCamera(device) {
@@ -1283,19 +1258,19 @@ class SwitchBotPlatform {
         if (existingAccessory) {
             // the accessory already exists
             if (!device.hide_device && device.hubDeviceId) {
-                this.log.info(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
                 existingAccessory.context.model = device.remoteType;
                 existingAccessory.context.deviceID = device.deviceId;
                 existingAccessory.displayName = device.deviceName;
                 existingAccessory.context.firmwareRevision = this.version;
                 existingAccessory.context.deviceType = `IR: ${device.remoteType}`;
-                await this.connectionTypeExistingIRAccessory(device, existingAccessory);
+                await this.connectionTypeExistingIRAccessory(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} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1303,7 +1278,7 @@ class SwitchBotPlatform {
         }
         else if (!device.hide_device && device.hubDeviceId) {
             // the accessory does not yet exist, so we need to create it
-            this.log.info(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
@@ -1313,17 +1288,17 @@ class SwitchBotPlatform {
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = this.version;
             accessory.context.deviceType = `IR: ${device.remoteType}`;
-            await this.connectionTypeNewIRAccessory(device, accessory);
+            await this.connectionTypeNewIRAccessory(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} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // link the accessory to your platform
             this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
             this.accessories.push(accessory);
         }
         else {
-            this.device(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
+            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
         }
     }
     async createOthers(device) {
@@ -1334,19 +1309,19 @@ class SwitchBotPlatform {
         if (existingAccessory) {
             // the accessory already exists
             if (!device.hide_device && device.hubDeviceId) {
-                this.log.info(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
                 existingAccessory.context.model = device.remoteType;
                 existingAccessory.context.deviceID = device.deviceId;
                 existingAccessory.displayName = device.deviceName;
                 existingAccessory.context.firmwareRevision = this.version;
                 existingAccessory.context.deviceType = `IR: ${device.remoteType}`;
-                await this.connectionTypeExistingIRAccessory(device, existingAccessory);
+                await this.connectionTypeExistingIRAccessory(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} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1354,7 +1329,7 @@ class SwitchBotPlatform {
         }
         else if (!device.hide_device && device.hubDeviceId) {
             // the accessory does not yet exist, so we need to create it
-            this.log.info(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
@@ -1364,17 +1339,17 @@ class SwitchBotPlatform {
             accessory.context.deviceID = device.deviceId;
             accessory.context.firmwareRevision = this.version;
             accessory.context.deviceType = `IR: ${device.remoteType}`;
-            await this.connectionTypeNewIRAccessory(device, accessory);
+            await this.connectionTypeNewIRAccessory(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} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // link the accessory to your platform
             this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
             this.accessories.push(accessory);
         }
         else {
-            this.device(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
+            this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
         }
     }
     async connectionTypeNewAccessory(device, accessory) {
@@ -1393,63 +1368,67 @@ class SwitchBotPlatform {
             existingAccessory.context.connectionType = 'OpenAPI';
         }
     }
-    async connectionTypeNewIRAccessory(device, accessory) {
+    async connectionTypeNewIRAccessory(accessory) {
         accessory.context.connectionType = 'IR wirth OpenAPI';
     }
-    async connectionTypeExistingIRAccessory(device, existingAccessory) {
+    async connectionTypeExistingIRAccessory(existingAccessory) {
         existingAccessory.context.connectionType = 'IR with OpenAPI';
     }
     unregisterPlatformAccessories(existingAccessory) {
         // remove platform accessories when no longer present
         this.api.unregisterPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [existingAccessory]);
-        this.log.info('Removing existing accessory from cache:', existingAccessory.displayName);
+        this.infoLog('Removing existing accessory from cache:', existingAccessory.displayName);
     }
     deviceListInfo(devices) {
-        if (this.config.options?.debug === 'device') {
-            this.device(`deviceListInfoStatus: ${JSON.stringify(devices)}`);
+        if (this.platformLogging === 'debug') {
+            this.warnLog(`deviceListInfoStatus: ${JSON.stringify(devices)}`);
         }
     }
     async deviceInfo(device) {
-        if (this.config.options?.debug === 'device') {
-            this.device(JSON.stringify(device));
+        if (this.platformLogging === 'debug') {
+            this.warnLog(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)}`);
+                this.warnLog(`${device.deviceName} deviceInfoStatus: ${JSON.stringify(this.deviceStatus)}`);
             }
             else {
-                this.device(`${device.deviceName} deviceInfoStatus: ${JSON.stringify(this.deviceStatus.message)}`);
-                this.device('Unable to retreive deviceInfoStatus.');
+                this.warnLog(`${device.deviceName} deviceInfoStatus: ${JSON.stringify(this.deviceStatus.message)}`);
+                this.warnLog('Unable to retreive deviceInfoStatus.');
             }
         }
     }
     /**
-     * If debug level logging is turned on, log to log.info
+     * If device level logging is turned on, log to log.warn
      * Otherwise send debug logs to log.debug
-     * this.debugMode = process.argv.includes('-D') || process.argv.includes('--debug');
      */
-    debug(...log) {
-        if (this.config.options.debug === 'debug') {
-            this.log.info('[DEBUG]', String(...log));
-        }
-        else {
-            this.log.debug(String(...log));
+    infoLog(...log) {
+        if (this.enablingPlatfromLogging()) {
+            this.log.info(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));
+    warnLog(...log) {
+        if (this.enablingPlatfromLogging()) {
+            this.log.warn(String(...log));
         }
-        else if (this.config.options.debug === 'debug') {
-            this.log.info('[DEBUG]', String(...log));
+    }
+    errorLog(...log) {
+        if (this.enablingPlatfromLogging()) {
+            this.log.error(String(...log));
         }
-        else {
-            this.log.debug(String(...log));
+    }
+    debugLog(...log) {
+        if (this.enablingPlatfromLogging()) {
+            if (this.platformLogging === 'debugMode') {
+                this.log.debug(String(...log));
+            }
+            else if (this.platformLogging === 'debug') {
+                this.log.info('[DEBUG]', String(...log));
+            }
         }
     }
+    enablingPlatfromLogging() {
+        return this.platformLogging?.includes('debug') || this.platformLogging === 'standard';
+    }
 }
 exports.SwitchBotPlatform = SwitchBotPlatform;
 //# sourceMappingURL=platform.js.map