@switchbot/homebridge-switchbot 3.5.0-beta.3 → 3.5.0-beta.31

package/src/platform.ts

@@ -1,4 +1,4 @@
-/* Copyright(C) 2017-2023, donavanbecker (https://github.com/donavanbecker). All rights reserved.
+/* Copyright(C) 2017-2024, donavanbecker (https://github.com/donavanbecker). All rights reserved.
  *
  * platform.ts: @switchbot/homebridge-switchbot platform class.
  */
@@ -20,8 +20,9 @@ import { CeilingLight } from './device/ceilinglight.js';
 import { StripLight } from './device/lightstrip.js';
 import { Humidifier } from './device/humidifier.js';
 import { RobotVacuumCleaner } from './device/robotvacuumcleaner.js';
+import { Fan } from './device/fan.js';
 import { TV } from './irdevice/tv.js';
-import { Fan } from './irdevice/fan.js';
+import { IRFan } from './irdevice/fan.js';
 import { Light } from './irdevice/light.js';
 import { Others } from './irdevice/other.js';
 import { Camera } from './irdevice/camera.js';
@@ -32,16 +33,16 @@ import { VacuumCleaner } from './irdevice/vacuumcleaner.js';
 import { AirConditioner } from './irdevice/airconditioner.js';
 import * as http from 'http';
 import { Buffer } from 'buffer';
-import { request } from 'undici';
+import { Dispatcher, request } from 'undici';
 import { MqttClient } from 'mqtt';
 import { queueScheduler } from 'rxjs';
 import fakegato from 'fakegato-history';
 import asyncmqtt from 'async-mqtt';
 import crypto, { randomUUID } from 'crypto';
 import { readFileSync, writeFileSync } from 'fs';
-import hbLib from 'homebridge-lib';
-
-
+import { EveHomeKitTypes } from 'homebridge-lib/EveHomeKitTypes';
+import { UrlObject } from 'url';
+import { sleep } from './utils.js';
 
 /**
  * HomebridgePlatform
@@ -56,6 +57,8 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
   version!: string;
   Logging?: string;
   debugMode!: boolean;
+  maxRetries!: number;
+  delayBetweenRetries!: number;
   platformConfig!: SwitchBotPlatformConfig['options'];
   platformLogging!: SwitchBotPlatformConfig['logging'];
   config!: SwitchBotPlatformConfig;
@@ -104,7 +107,6 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
     }
 
     // import fakegato-history module and EVE characteristics
-    const { EveHomeKitTypes } = hbLib;
     this.fakegatoAPI = fakegato(api);
     this.eve = new EveHomeKitTypes(api);
 
@@ -383,6 +385,21 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       this.debugWarnLog('Using Default Push Rate.');
     }
 
+    if (!this.config.options.maxRetries) {
+      this.config.options.maxRetries = 5;
+      this.debugWarnLog('Using Default Max Retries.');
+    } else {
+      this.maxRetries = this.config.options.maxRetries;
+    }
+
+    if (!this.config.options.delayBetweenRetries) {
+      // default 3 seconds
+      this.config.options!.delayBetweenRetries! = 3000;
+      this.debugWarnLog('Using Default Delay Between Retries.');
+    } else {
+      this.delayBetweenRetries = this.config.options.delayBetweenRetries * 1000;
+    }
+
     if (!this.config.credentials && !this.config.options) {
       this.debugWarnLog('Missing Credentials');
     } else if (this.config.credentials && !this.config.credentials.notice) {
@@ -492,44 +509,98 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
    */
   async discoverDevices() {
     if (this.config.credentials?.token) {
-      try {
-        const { body, statusCode } = await request(Devices, {
-          headers: this.generateHeaders(),
-        });
-        this.debugWarnLog(`statusCode: ${statusCode}`);
-        const devicesAPI: any = await body.json();
-        this.debugWarnLog(`devicesAPI: ${JSON.stringify(devicesAPI)}`);
-        this.debugWarnLog(`devicesAPI Body: ${JSON.stringify(devicesAPI.body)}`);
-        this.debugWarnLog(`devicesAPI StatusCode: ${devicesAPI.statusCode}`);
-        if ((statusCode === 200 || statusCode === 100) && (devicesAPI.statusCode === 200 || devicesAPI.statusCode === 100)) {
-          this.debugErrorLog(`statusCode: ${statusCode} & devicesAPI StatusCode: ${devicesAPI.statusCode}`);
-          // SwitchBot Devices
-          const deviceLists = devicesAPI.body.deviceList;
-          this.debugWarnLog(`DeviceLists: ${JSON.stringify(deviceLists)}`);
-          this.debugWarnLog(`DeviceLists Length: ${deviceLists.length}`);
-          if (!this.config.options?.devices) {
-            this.debugLog(`SwitchBot Device Config Not Set: ${JSON.stringify(this.config.options?.devices)}`);
-            if (deviceLists.length === 0) {
-              this.debugLog(`SwitchBot API Currently Doesn't Have Any Devices With Cloud Services Enabled: ${JSON.stringify(devicesAPI.body)}`);
-            } else {
-              const devices = deviceLists.map((v: any) => v);
-              for (const device of devices) {
-                if (device.deviceType) {
-                  if (device.configDeviceName) {
-                    device.deviceName = device.configDeviceName;
+      let retryCount = 0;
+      const maxRetries = this.maxRetries; // Maximum number of retries
+      const delayBetweenRetries = this.delayBetweenRetries; // Delay between retries in milliseconds
+      this.debugWarnLog(`Retry Count: ${retryCount}`);
+      this.debugWarnLog(`Max Retries: ${maxRetries}`);
+      this.debugWarnLog(`Delay Between Retries: ${delayBetweenRetries}`);
+      while (retryCount < maxRetries) {
+        try {
+          const { body, statusCode } = await request(Devices, {
+            headers: this.generateHeaders(),
+          });
+          this.debugWarnLog(`statusCode: ${statusCode}`);
+          const devicesAPI: any = await body.json();
+          this.debugWarnLog(`devicesAPI: ${JSON.stringify(devicesAPI)}`);
+          this.debugWarnLog(`devicesAPI Body: ${JSON.stringify(devicesAPI.body)}`);
+          this.debugWarnLog(`devicesAPI StatusCode: ${devicesAPI.statusCode}`);
+          if ((statusCode === 200 || statusCode === 100) && (devicesAPI.statusCode === 200 || devicesAPI.statusCode === 100)) {
+            this.debugErrorLog(`statusCode: ${statusCode} & devicesAPI StatusCode: ${devicesAPI.statusCode}`);
+            // SwitchBot Devices
+            const deviceLists = devicesAPI.body.deviceList;
+            this.debugWarnLog(`DeviceLists: ${JSON.stringify(deviceLists)}`);
+            this.debugWarnLog(`DeviceLists Length: ${deviceLists.length}`);
+            if (!this.config.options?.devices) {
+              this.debugLog(`SwitchBot Device Config Not Set: ${JSON.stringify(this.config.options?.devices)}`);
+              if (deviceLists.length === 0) {
+                this.debugLog(`SwitchBot API Currently Doesn't Have Any Devices With Cloud Services Enabled: ${JSON.stringify(devicesAPI.body)}`);
+              } else {
+                const devices = deviceLists.map((v: any) => v);
+                for (const device of devices) {
+                  if (device.deviceType) {
+                    if (device.configDeviceName) {
+                      device.deviceName = device.configDeviceName;
+                    }
+                    this.createDevice(device);
                   }
-                  this.createDevice(device);
                 }
               }
+            } else if (this.config.credentials?.token && this.config.options.devices) {
+              this.debugLog(`SwitchBot Device Config Set: ${JSON.stringify(this.config.options?.devices)}`);
+              if (deviceLists.length === 0) {
+                this.debugLog(`SwitchBot API Currently Doesn't Have Any Devices With Cloud Services Enabled: ${JSON.stringify(devicesAPI.body)}`);
+              } else {
+                const deviceConfigs = this.config.options?.devices;
+
+                const mergeBydeviceId = (a1: { deviceId: string }[], a2: any[]) =>
+                  a1.map((itm: { deviceId: string }) => ({
+                    ...a2.find(
+                      (item: { deviceId: string }) =>
+                        item.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') === itm.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') && item,
+                    ),
+                    ...itm,
+                  }));
+
+                const devices = mergeBydeviceId(deviceLists, deviceConfigs);
+                this.debugLog(`SwitchBot Devices: ${JSON.stringify(devices)}`);
+                for (const device of devices) {
+                  if (!device.deviceType) {
+                    device.deviceType = device.configDeviceType;
+                    this.errorLog(`API has displaying no deviceType: ${device.deviceType}, So using configDeviceType: ${device.configDeviceType}`);
+                  }
+                  if (device.deviceType) {
+                    if (device.configDeviceName) {
+                      device.deviceName = device.configDeviceName;
+                    }
+                    this.createDevice(device);
+                  }
+                }
+              }
+            } else {
+              this.errorLog('SwitchBot Token Supplied, Issue with Auth.');
             }
-          } else if (this.config.credentials?.token && this.config.options.devices) {
-            this.debugLog(`SwitchBot Device Config Set: ${JSON.stringify(this.config.options?.devices)}`);
-            if (deviceLists.length === 0) {
-              this.debugLog(`SwitchBot API Currently Doesn't Have Any Devices With Cloud Services Enabled: ${JSON.stringify(devicesAPI.body)}`);
+            if (devicesAPI.body.deviceList.length !== 0) {
+              this.infoLog(`Total SwitchBot Devices Found: ${devicesAPI.body.deviceList.length}`);
             } else {
-              const deviceConfigs = this.config.options?.devices;
+              this.debugLog(`Total SwitchBot Devices Found: ${devicesAPI.body.deviceList.length}`);
+            }
 
-              const mergeBydeviceId = (a1: { deviceId: string }[], a2: any[]) =>
+            // IR Devices
+            const irDeviceLists = devicesAPI.body.infraredRemoteList;
+            if (!this.config.options?.irdevices) {
+              this.debugLog(`IR Device Config Not Set: ${JSON.stringify(this.config.options?.irdevices)}`);
+              const devices = irDeviceLists.map((v: any) => v);
+              for (const device of devices) {
+                if (device.remoteType) {
+                  this.createIRDevice(device);
+                }
+              }
+            } else {
+              this.debugLog(`IR Device Config Set: ${JSON.stringify(this.config.options?.irdevices)}`);
+              const irDeviceConfig = this.config.options?.irdevices;
+
+              const mergeIRBydeviceId = (a1: { deviceId: string }[], a2: any[]) =>
                 a1.map((itm: { deviceId: string }) => ({
                   ...a2.find(
                     (item: { deviceId: string }) =>
@@ -538,73 +609,34 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
                   ...itm,
                 }));
 
-              const devices = mergeBydeviceId(deviceLists, deviceConfigs);
-              this.debugLog(`SwitchBot Devices: ${JSON.stringify(devices)}`);
+              const devices = mergeIRBydeviceId(irDeviceLists, irDeviceConfig);
+              this.debugLog(`IR Devices: ${JSON.stringify(devices)}`);
               for (const device of devices) {
-                if (!device.deviceType) {
-                  device.deviceType = device.configDeviceType;
-                  this.errorLog(`API has displaying no deviceType: ${device.deviceType}, So using configDeviceType: ${device.configDeviceType}`);
-                }
-                if (device.deviceType) {
-                  if (device.configDeviceName) {
-                    device.deviceName = device.configDeviceName;
-                  }
-                  this.createDevice(device);
-                }
-              }
-            }
-          } else {
-            this.errorLog('SwitchBot Token Supplied, Issue with Auth.');
-          }
-          if (devicesAPI.body.deviceList.length !== 0) {
-            this.infoLog(`Total SwitchBot Devices Found: ${devicesAPI.body.deviceList.length}`);
-          } else {
-            this.debugLog(`Total SwitchBot Devices Found: ${devicesAPI.body.deviceList.length}`);
-          }
-
-          // IR Devices
-          const irDeviceLists = devicesAPI.body.infraredRemoteList;
-          if (!this.config.options?.irdevices) {
-            this.debugLog(`IR Device Config Not Set: ${JSON.stringify(this.config.options?.irdevices)}`);
-            const devices = irDeviceLists.map((v: any) => v);
-            for (const device of devices) {
-              if (device.remoteType) {
                 this.createIRDevice(device);
               }
             }
-          } else {
-            this.debugLog(`IR Device Config Set: ${JSON.stringify(this.config.options?.irdevices)}`);
-            const irDeviceConfig = this.config.options?.irdevices;
-
-            const mergeIRBydeviceId = (a1: { deviceId: string }[], a2: any[]) =>
-              a1.map((itm: { deviceId: string }) => ({
-                ...a2.find(
-                  (item: { deviceId: string }) =>
-                    item.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') === itm.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') && item,
-                ),
-                ...itm,
-              }));
-
-            const devices = mergeIRBydeviceId(irDeviceLists, irDeviceConfig);
-            this.debugLog(`IR Devices: ${JSON.stringify(devices)}`);
-            for (const device of devices) {
-              this.createIRDevice(device);
+            if (devicesAPI.body.infraredRemoteList.length !== 0) {
+              this.infoLog(`Total IR Devices Found: ${devicesAPI.body.infraredRemoteList.length}`);
+            } else {
+              this.debugLog(`Total IR Devices Found: ${devicesAPI.body.infraredRemoteList.length}`);
             }
-          }
-          if (devicesAPI.body.infraredRemoteList.length !== 0) {
-            this.infoLog(`Total IR Devices Found: ${devicesAPI.body.infraredRemoteList.length}`);
+            break;
           } else {
-            this.debugLog(`Total IR Devices Found: ${devicesAPI.body.infraredRemoteList.length}`);
+            this.statusCode(statusCode);
+            this.statusCode(devicesAPI.statusCode);
+            if (statusCode === 500) {
+              retryCount++;
+              this.infoLog(`statusCode: ${statusCode} Attempt ${retryCount} of ${maxRetries}`);
+              await sleep(delayBetweenRetries);
+            }
           }
-        } else {
-          this.statusCode(statusCode);
-          this.statusCode(devicesAPI.statusCode);
+        } catch (e: any) {
+          retryCount++;
+          this.debugErrorLog(
+            `Failed to Discover Devices, Error Message: ${JSON.stringify(e.message)}, Submit Bugs Here: ` + 'https://tinyurl.com/SwitchBotBug',
+          );
+          this.debugErrorLog(`Failed to Discover Devices, Error: ${e}`);
         }
-      } catch (e: any) {
-        this.debugErrorLog(
-          `Failed to Discover Devices, Error Message: ${JSON.stringify(e.message)}, Submit Bugs Here: ` + 'https://tinyurl.com/SwitchBotBug',
-        );
-        this.debugErrorLog(`Failed to Discover Devices, Error: ${e}`);
       }
     } else if (!this.config.credentials?.token && this.config.options?.devices) {
       this.debugLog(`SwitchBot Device Manual Config Set: ${JSON.stringify(this.config.options?.devices)}`);
@@ -691,10 +723,12 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
         this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
         this.createColorBulb(device);
         break;
+      case 'K10+':
       case 'WoSweeper':
       case 'WoSweeperMini':
       case 'Robot Vacuum Cleaner S1':
       case 'Robot Vacuum Cleaner S1 Plus':
+      case 'Robot Vacuum Cleaner S10':
         this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
         this.createRobotVacuumCleaner(device);
         break;
@@ -712,8 +746,13 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
         this.warnLog(`Device: ${device.deviceName} with Device Type: ${device.deviceType}, is currently not supported.`);
         break;
       case 'Remote':
+      case 'remote with screen+':
         this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId} is Not Supported.`);
         break;
+      case 'Battery Circulator Fan':
+        this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+        this.createFan(device);
+        break;
       default:
         this.warnLog(`Device: ${device.deviceName} with Device Type: ${device.deviceType}, is currently not supported.`);
         // eslint-disable-next-line max-len
@@ -749,7 +788,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       case 'Fan':
       case 'DIY Fan':
         this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
-        this.createFan(device);
+        this.createIRFan(device);
         break;
       case 'Air Conditioner':
       case 'DIY Air Conditioner':
@@ -1781,6 +1820,66 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
     }
   }
 
+  private async createFan(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 (await this.registerDevice(device)) {
+        // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
+        existingAccessory.context.model = device.deviceType;
+        existingAccessory.context.deviceID = device.deviceId;
+        existingAccessory.displayName = device.configDeviceName || device.deviceName;
+        if (device.firmware) {
+          existingAccessory.context.FirmwareRevision = device.firmware;
+        }
+        existingAccessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
+        this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+        existingAccessory.context.connectionType = await this.connectionType(device);
+        this.api.updatePlatformAccessories([existingAccessory]);
+        // create the accessory handler for the restored accessory
+        // this is imported from `platformAccessory.ts`
+        new Fan(this, existingAccessory, device);
+        this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+      } else {
+        this.unregisterPlatformAccessories(existingAccessory);
+      }
+    } else if (await this.registerDevice(device)) {
+      // the accessory does not yet exist, so we need to create it
+      if (!device.external) {
+        this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+      }
+
+      // create a new accessory
+      const accessory = new this.api.platformAccessory(device.deviceName, uuid);
+
+      // store a copy of the device object in the `accessory.context`
+      // the `context` property can be used to store any data about the accessory you may need
+      accessory.context.device = device;
+      accessory.context.model = device.deviceType;
+      accessory.context.deviceID = device.deviceId;
+      if (device.firmware) {
+        accessory.context.FirmwareRevision = device.firmware;
+      }
+      accessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
+      accessory.context.connectionType = await this.connectionType(device);
+      // create the accessory handler for the newly create accessory
+      // this is imported from `platformAccessory.ts`
+      new Fan(this, accessory, device);
+      this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+
+      // publish device externally or link the accessory to your platform
+      this.externalOrPlatform(device, accessory);
+      this.accessories.push(accessory);
+    } else {
+      this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+    }
+  }
+
   private async createRobotVacuumCleaner(device: device & devicesConfig) {
     const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.deviceType}`);
 
@@ -1893,7 +1992,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
     }
   }
 
-  private async createFan(device: irdevice & devicesConfig) {
+  private async createIRFan(device: irdevice & devicesConfig) {
     const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.remoteType}`);
 
     // see if an accessory with the same uuid has already been registered and restored from
@@ -1916,7 +2015,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
         this.api.updatePlatformAccessories([existingAccessory]);
         // create the accessory handler for the restored accessory
         // this is imported from `platformAccessory.ts`
-        new Fan(this, existingAccessory, device);
+        new IRFan(this, existingAccessory, device);
         this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
       } else {
         this.unregisterPlatformAccessories(existingAccessory);
@@ -1942,7 +2041,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       accessory.context.connectionType = device.connectionType;
       // create the accessory handler for the newly create accessory
       // this is imported from `platformAccessory.ts`
-      new Fan(this, accessory, device);
+      new IRFan(this, accessory, device);
       this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
 
       // publish device externally or link the accessory to your platform
@@ -2626,6 +2725,30 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
     }
   }
 
+  async retryRequest(deviceMaxRetries: number, deviceDelayBetweenRetries: number, url: string | URL | UrlObject,
+    options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.RequestOptions,
+      'origin' | 'path' | 'method'> & Partial<Pick<Dispatcher.RequestOptions, 'method'>>): Promise<{ body: any; statusCode: number }> {
+    let retryCount = 0;
+    const maxRetries = deviceMaxRetries;
+    const delayBetweenRetries = deviceDelayBetweenRetries;
+    while (retryCount < maxRetries) {
+      try {
+        const { body, statusCode } = await request(url, options);
+        if (statusCode === 200 || statusCode === 100) {
+          return { body, statusCode };
+        } else {
+          this.debugLog(`Received status code: ${statusCode}`);
+        }
+      } catch (error: any) {
+        this.errorLog(`Error making request: ${error.message}`);
+      }
+      retryCount++;
+      this.debugLog(`Retry attempt ${retryCount} of ${maxRetries}`);
+      await sleep(delayBetweenRetries);
+    }
+    return { body: null, statusCode: -1 };
+  }
+
   // BLE Connection
   async connectBLE() {
     let switchbot: any;
@@ -2662,6 +2785,22 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       if (this.config.options.pushRate) {
         platformConfig.pushRate = this.config.options.pushRate;
       }
+      if (this.config.options.maxRetries) {
+        this.maxRetries = this.config.options.maxRetries;
+        platformConfig.maxRetries = this.config.options.maxRetries;
+      } else {
+        this.maxRetries = 3;
+        this.debugWarnLog('Using Default Max Retries');
+        platformConfig.maxRetries = this.maxRetries;
+      }
+      if (this.config.options.delayBetweenRetries) {
+        this.delayBetweenRetries = this.config.options.delayBetweenRetries * 1000;
+        platformConfig.delayBetweenRetries = this.config.options.delayBetweenRetries;
+      } else {
+        this.delayBetweenRetries = 3000;
+        this.debugWarnLog('Using Default Delay Between Retries');
+        platformConfig.delayBetweenRetries = this.delayBetweenRetries / 1000;
+      }
       if (Object.entries(platformConfig).length !== 0) {
         this.debugLog(`Platform Config: ${JSON.stringify(platformConfig)}`);
       }
@@ -2687,6 +2826,12 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
    * If device level logging is turned on, log to log.warn
    * Otherwise send debug logs to log.debug
    */
+  successLog(...log: any[]): void {
+    if (this.enablingPlatformLogging()) {
+      this.log.success(String(...log));
+    }
+  }
+
   infoLog(...log: any[]): void {
     if (this.enablingPlatformLogging()) {
       this.log.info(String(...log));