@switchbot/homebridge-switchbot 1.4.0 → 1.4.1-beta.3

package/src/platform.ts

@@ -6,7 +6,6 @@ import { Motion } from './devices/motion';
 import { Contact } from './devices/contact';
 import { Curtain } from './devices/curtains';
 import { ColorBulb } from './devices/colorbulb';
-import { IndoorCam } from './devices/indoorcam';
 import { Humidifier } from './devices/humidifiers';
 import { TV } from './irdevices/tvs';
 import { Fan } from './irdevices/fans';
@@ -37,14 +36,15 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
     responseType: 'json',
   });
 
-  // debugMode!: boolean;
   version = require('../package.json').version; // eslint-disable-line @typescript-eslint/no-var-requires
   deviceStatus!: deviceResponses;
   registeringDevice!: boolean;
   debugMode!: boolean;
+  platformLogging?: string;
 
   constructor(public readonly log: Logger, public readonly config: SwitchBotPlatformConfig, public readonly api: API) {
-    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;
@@ -59,15 +59,15 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
     // verify the config
     try {
       this.verifyConfig();
-      this.log.debug('Config OK');
+      this.debugLog('Config OK');
     } catch (e: any) {
-      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: AxiosRequestConfig) => {
       request.headers!.Authorization = this.config.credentials?.openToken;
@@ -80,23 +80,43 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
     // 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: any) {
-        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: PlatformAccessory) {
-    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);
@@ -111,7 +131,6 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
      * 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) {
 
@@ -127,7 +146,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
             }
             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');
               }
             }
           }
@@ -139,10 +158,10 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
         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.');
             }
           }
         }
@@ -156,21 +175,25 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
     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.debugMode) {
+        this.warnLog('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.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.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.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');
+      }
     }
   }
 
@@ -182,13 +205,13 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       if (this.config.credentials?.openToken) {
         const devicesAPI: any = (await this.axios.get(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: any) => v);
           for (const device of devices) {
             if (device.deviceType) {
@@ -199,7 +222,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
             }
           }
         } 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: { deviceId: string; }[], a2: any[]) =>
@@ -210,7 +233,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
             }));
 
           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) {
@@ -220,13 +243,13 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
             }
           }
         } 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: any) => v);
           for (const device of devices) {
             if (device.remoteType) {
@@ -234,7 +257,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
             }
           }
         } 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: { deviceId: string; }[], a2: any[]) =>
@@ -245,7 +268,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
             }));
 
           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);
@@ -253,7 +276,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
           }
         }
       } 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: any) => v);
         for (const device of devices) {
@@ -264,99 +287,105 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
           }
         }
       } 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: any) {
-      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.');
-      } 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.');
-      } 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.');
-      } 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.');
-      } 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.');
-      } 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.');
-      } 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 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.');
-      } 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.');
-      } else {
-        this.log.error('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.config.options?.debug === 'debug' || this.debugMode) {
-        this.log.error(`Failed to Discover Devices, Error: ${JSON.stringify(e)}`);
-      }
+      this.deviceError(e);
+    }
+  }
+
+  deviceError(e: any) {
+    if (e.message.includes('400')) {
+      this.errorLog('Failed to Discover Devices: Bad Request');
+      this.debugLog('The client has issued an invalid request. This is commonly used to specify validation errors in a request payload.');
+    } else if (e.message.includes('401')) {
+      this.errorLog('Failed to Discover Devices: Unauthorized Request');
+      this.debugLog('Authorization for the API is required, but the request has not been authenticated.');
+    } else if (e.message.includes('403')) {
+      this.errorLog('Failed to Discover Devices: Forbidden Request');
+      this.debugLog('The request has been authenticated but does not have appropriate permissions, or a requested resource is not found.');
+    } else if (e.message.includes('404')) {
+      this.errorLog('Failed to Discover Devices: Requst Not Found');
+      this.debugLog('Specifies the requested path does not exist.');
+    } else if (e.message.includes('406')) {
+      this.errorLog('Failed to Discover Devices: Request Not Acceptable');
+      this.debugLog('The client has requested a MIME type via the Accept header for a value not supported by the server.');
+    } else if (e.message.includes('415')) {
+      this.errorLog('Failed to Discover Devices: Unsupported Requst Header');
+      this.debugLog('The client has defined a contentType header that is not supported by the server.');
+    } else if (e.message.includes('422')) {
+      this.errorLog('Failed to Discover Devices: Unprocessable Entity');
+      this.debugLog('The client has made a valid request, but the server cannot process it.'
+        + ' This is often used for APIs for which certain limits have been exceeded.');
+    } else if (e.message.includes('429')) {
+      this.errorLog('Failed to Discover Devices: Too Many Requests');
+      this.debugLog('The client has exceeded the number of requests allowed for a given time window.');
+    } else if (e.message.includes('500')) {
+      this.errorLog('Failed to Discover Devices: Internal Server Error');
+      this.debugLog('An unexpected error on the SmartThings servers has occurred. These errors should be rare.');
+    } else {
+      this.errorLog('Failed to Discover Devices');
+    }
+    if (this.platformLogging === 'debug') {
+      this.errorLog(`Failed to Discover Devices, Error Message: ${JSON.stringify(e.message)}`);
+    }
+    if (this.platformLogging === 'debugMode') {
+      this.errorLog(`Failed to Discover Devices, Error: ${JSON.stringify(e)}`);
     }
   }
 
   private createDevice(device: device & devicesConfig) {
     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');
     }
   }
 
@@ -374,67 +403,68 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       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');
     }
   }
 
   private registerDevice(device: device & devicesConfig) {
     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;
   }
@@ -449,7 +479,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
     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;
@@ -463,13 +493,13 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
         // create the accessory handler for the restored accessory
         // this is imported from `platformAccessory.ts`
         new 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);
       }
     } 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);
@@ -485,13 +515,13 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       // create the accessory handler for the newly create accessory
       // this is imported from `platformAccessory.ts`
       new 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(PLUGIN_NAME, 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}`);
     }
   }
 
@@ -505,9 +535,9 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
     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}`);
 
-        this.debug(JSON.stringify(device.bot?.mode));
+        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;
@@ -520,15 +550,15 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
         // create the accessory handler for the restored accessory
         // this is imported from `platformAccessory.ts`
         new 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);
       }
     } 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}`);
 
-      this.debug(JSON.stringify(device.bot?.mode));
+      this.debugLog(JSON.stringify(device.bot?.mode));
 
       // create a new accessory
       const accessory = new this.api.platformAccessory(device.deviceName, uuid);
@@ -545,13 +575,13 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       // create the accessory handler for the newly create accessory
       // this is imported from `platformAccessory.ts`
       new 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(PLUGIN_NAME, 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}`);
     }
   }
 
@@ -565,7 +595,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
     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;
@@ -578,13 +608,13 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
         // create the accessory handler for the restored accessory
         // this is imported from `platformAccessory.ts`
         new 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);
       }
     } 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);
@@ -600,13 +630,13 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       // create the accessory handler for the newly create accessory
       // this is imported from `platformAccessory.ts`
       new 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(PLUGIN_NAME, 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}`);
     }
   }
 
@@ -620,7 +650,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
     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;
@@ -633,13 +663,13 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
         // create the accessory handler for the restored accessory
         // this is imported from `platformAccessory.ts`
         new 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);
       }
     } 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);
@@ -655,13 +685,13 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       // create the accessory handler for the newly create accessory
       // this is imported from `platformAccessory.ts`
       new 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(PLUGIN_NAME, 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}`);
     }
   }
 
@@ -675,7 +705,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
     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;
@@ -688,13 +718,13 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
         // create the accessory handler for the restored accessory
         // this is imported from `platformAccessory.ts`
         new 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);
       }
     } 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);
@@ -710,13 +740,13 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       // create the accessory handler for the newly create accessory
       // this is imported from `platformAccessory.ts`
       new 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(PLUGIN_NAME, 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}`);
     }
   }
 
@@ -730,7 +760,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
     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;
@@ -743,21 +773,22 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
         // create the accessory handler for the restored accessory
         // this is imported from `platformAccessory.ts`
         new 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);
       }
     } 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}`);
         }
       }
 
@@ -775,25 +806,25 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       // create the accessory handler for the newly create accessory
       // this is imported from `platformAccessory.ts`
       new 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(PLUGIN_NAME, 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}`);
     }
   }
 
   private isCurtainGrouped(device: device & devicesConfig) {
-    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);
     }
   }
@@ -808,7 +839,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
     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;
@@ -821,13 +852,13 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
         // create the accessory handler for the restored accessory
         // this is imported from `platformAccessory.ts`
         new 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);
       }
     } 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);
@@ -843,13 +874,13 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       // create the accessory handler for the newly create accessory
       // this is imported from `platformAccessory.ts`
       new 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(PLUGIN_NAME, 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}`);
     }
   }
 
@@ -863,7 +894,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
     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;
@@ -876,13 +907,13 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
         // create the accessory handler for the restored accessory
         // this is imported from `platformAccessory.ts`
         new 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);
       }
     } 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);
@@ -898,68 +929,13 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       // create the accessory handler for the newly create accessory
       // this is imported from `platformAccessory.ts`
       new ColorBulb(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(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
       this.accessories.push(accessory);
     } else {
-      this.device(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
-    }
-  }
-
-  private async createIndoorCam(device: device & devicesConfig) {
-    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(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(this, accessory, device);
-      this.debug(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
-
-      // link the accessory to your platform
-      this.api.registerPlatformAccessories(PLUGIN_NAME, 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}`);
     }
   }
 
@@ -971,7 +947,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
     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;
@@ -979,15 +955,15 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       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 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);
@@ -999,11 +975,11 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       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 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
@@ -1013,7 +989,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       this.api.publishExternalAccessories(PLUGIN_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}`);
     }
   }
 
@@ -1027,7 +1003,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
     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.:
 
@@ -1036,18 +1012,18 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
         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 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);
       }
     } 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);
@@ -1059,17 +1035,17 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       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 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(PLUGIN_NAME, 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}`);
     }
   }
 
@@ -1083,7 +1059,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
     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;
@@ -1091,18 +1067,18 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
         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 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);
       }
     } 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);
@@ -1114,17 +1090,17 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       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 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(PLUGIN_NAME, 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}`);
     }
   }
 
@@ -1138,7 +1114,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
     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;
@@ -1146,18 +1122,18 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
         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 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);
       }
     } 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);
@@ -1169,17 +1145,17 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       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 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(PLUGIN_NAME, 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}`);
     }
   }
 
@@ -1193,7 +1169,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
     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;
@@ -1201,18 +1177,18 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
         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 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);
       }
     } 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);
@@ -1224,17 +1200,17 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       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 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(PLUGIN_NAME, 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}`);
     }
   }
 
@@ -1248,7 +1224,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
     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;
@@ -1256,18 +1232,18 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
         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 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);
       }
     } 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);
@@ -1279,17 +1255,17 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       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 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(PLUGIN_NAME, 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}`);
     }
   }
 
@@ -1303,7 +1279,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
     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;
@@ -1311,18 +1287,18 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
         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 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);
       }
     } 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);
@@ -1334,17 +1310,17 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       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 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(PLUGIN_NAME, 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}`);
     }
   }
 
@@ -1358,7 +1334,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
     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;
@@ -1366,18 +1342,18 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
         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 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);
       }
     } 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);
@@ -1389,17 +1365,17 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       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 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(PLUGIN_NAME, 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}`);
     }
   }
 
@@ -1413,7 +1389,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
     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;
@@ -1421,18 +1397,18 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
         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(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);
       }
     } 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);
@@ -1444,17 +1420,17 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       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(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(PLUGIN_NAME, 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}`);
     }
   }
 
@@ -1480,13 +1456,11 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
   }
 
   public async connectionTypeNewIRAccessory(
-    device: irdevice & devicesConfig,
     accessory: PlatformAccessory) {
     accessory.context.connectionType = 'IR wirth OpenAPI';
   }
 
   public async connectionTypeExistingIRAccessory(
-    device: irdevice & devicesConfig,
     existingAccessory: PlatformAccessory,
   ) {
     existingAccessory.context.connectionType = 'IR with OpenAPI';
@@ -1495,52 +1469,61 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
   public unregisterPlatformAccessories(existingAccessory: PlatformAccessory) {
     // remove platform accessories when no longer present
     this.api.unregisterPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [existingAccessory]);
-    this.log.info('Removing existing accessory from cache:', existingAccessory.displayName);
+    this.infoLog('Removing existing accessory from cache:', existingAccessory.displayName);
   }
 
   public deviceListInfo(devices: deviceResponses) {
-    if (this.config.options?.debug === 'device') {
-      this.device(`deviceListInfoStatus: ${JSON.stringify(devices)}`);
+    if (this.platformLogging === 'debug') {
+      this.warnLog(`deviceListInfoStatus: ${JSON.stringify(devices)}`);
     }
   }
 
   public async deviceInfo(device: irdevice & devicesConfig | device & devicesConfig) {
-    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(`${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: any[]) {
-    if (this.config.options!.debug === 'debug') {
-      this.log.info('[DEBUG]', String(...log));
-    } else {
-      this.log.debug(String(...log));
+  infoLog(...log: any[]) {
+    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: any[]) {
-    if (this.config.options!.debug === 'device') {
-      this.log.warn('[DEVICE]', String(...log));
-    } else if (this.config.options!.debug === 'debug') {
-      this.log.info('[DEBUG]', String(...log));
-    } else {
-      this.log.debug(String(...log));
+  warnLog(...log: any[]) {
+    if (this.enablingPlatfromLogging()) {
+      this.log.warn(String(...log));
+    }
+  }
+
+  errorLog(...log: any[]) {
+    if (this.enablingPlatfromLogging()) {
+      this.log.error(String(...log));
     }
   }
+
+  debugLog(...log: any[]) {
+    if (this.enablingPlatfromLogging()) {
+      if (this.platformLogging === 'debugMode') {
+        this.log.debug(String(...log));
+      } else if (this.platformLogging === 'debug') {
+        this.log.info('[DEBUG]', String(...log));
+      }
+    }
+  }
+
+  enablingPlatfromLogging(): boolean {
+    return this.platformLogging?.includes('debug') || this.platformLogging === 'standard';
+  }
 }