@switchbot/homebridge-switchbot 3.5.0-beta.20 → 3.5.0-beta.21

package/src/device/bot.ts

@@ -1488,18 +1488,18 @@ export class Bot {
   }
 
   async deviceRetry(device: device & devicesConfig): Promise<void> {
-    if (device.maxRetries === undefined) {
+    if (!device.maxRetries) {
       this.maxRetries = 5; // Maximum number of retries
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Max Retries Not Set, Using: ${this.maxRetries}`);
     } else {
       this.maxRetries = device.maxRetries;
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Max Retries: ${this.maxRetries}`);
     }
-    if (device.delayBetweenRetries === undefined) {
+    if (!device.delayBetweenRetries) {
       this.delayBetweenRetries = 3000; // Delay between retries in milliseconds
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Delay Between Retries Not Set, Using: ${this.delayBetweenRetries}`);
     } else {
-      this.delayBetweenRetries = device.delayBetweenRetries;
+      this.delayBetweenRetries = device.delayBetweenRetries * 1000;
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Delay Between Retries: ${this.delayBetweenRetries}`);
     }
   }

package/src/device/ceilinglight.ts

@@ -1149,18 +1149,18 @@ export class CeilingLight {
   }
 
   async deviceRetry(device: device & devicesConfig): Promise<void> {
-    if (device.maxRetries === undefined) {
+    if (!device.maxRetries) {
       this.maxRetries = 5; // Maximum number of retries
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Max Retries Not Set, Using: ${this.maxRetries}`);
     } else {
       this.maxRetries = device.maxRetries;
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Max Retries: ${this.maxRetries}`);
     }
-    if (device.delayBetweenRetries === undefined) {
+    if (!device.delayBetweenRetries) {
       this.delayBetweenRetries = 3000; // Delay between retries in milliseconds
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Delay Between Retries Not Set, Using: ${this.delayBetweenRetries}`);
     } else {
-      this.delayBetweenRetries = device.delayBetweenRetries;
+      this.delayBetweenRetries = device.delayBetweenRetries * 1000;
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Delay Between Retries: ${this.delayBetweenRetries}`);
     }
   }

package/src/device/colorbulb.ts

@@ -1358,18 +1358,18 @@ export class ColorBulb {
   }
 
   async deviceRetry(device: device & devicesConfig): Promise<void> {
-    if (device.maxRetries === undefined) {
+    if (!device.maxRetries) {
       this.maxRetries = 5; // Maximum number of retries
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Max Retries Not Set, Using: ${this.maxRetries}`);
     } else {
       this.maxRetries = device.maxRetries;
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Max Retries: ${this.maxRetries}`);
     }
-    if (device.delayBetweenRetries === undefined) {
+    if (!device.delayBetweenRetries) {
       this.delayBetweenRetries = 3000; // Delay between retries in milliseconds
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Delay Between Retries Not Set, Using: ${this.delayBetweenRetries}`);
     } else {
-      this.delayBetweenRetries = device.delayBetweenRetries;
+      this.delayBetweenRetries = device.delayBetweenRetries * 1000;
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Delay Between Retries: ${this.delayBetweenRetries}`);
     }
   }

package/src/device/contact.ts

@@ -712,18 +712,18 @@ export class Contact {
   }
 
   async deviceRetry(device: device & devicesConfig): Promise<void> {
-    if (device.maxRetries === undefined) {
+    if (!device.maxRetries) {
       this.maxRetries = 5; // Maximum number of retries
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Max Retries Not Set, Using: ${this.maxRetries}`);
     } else {
       this.maxRetries = device.maxRetries;
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Max Retries: ${this.maxRetries}`);
     }
-    if (device.delayBetweenRetries === undefined) {
+    if (!device.delayBetweenRetries) {
       this.delayBetweenRetries = 3000; // Delay between retries in milliseconds
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Delay Between Retries Not Set, Using: ${this.delayBetweenRetries}`);
     } else {
-      this.delayBetweenRetries = device.delayBetweenRetries;
+      this.delayBetweenRetries = device.delayBetweenRetries * 1000;
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Delay Between Retries: ${this.delayBetweenRetries}`);
     }
   }

package/src/device/curtain.ts

@@ -1315,18 +1315,18 @@ export class Curtain {
   }
 
   async deviceRetry(device: device & devicesConfig): Promise<void> {
-    if (device.maxRetries === undefined) {
+    if (!device.maxRetries) {
       this.maxRetries = 5; // Maximum number of retries
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Max Retries Not Set, Using: ${this.maxRetries}`);
     } else {
       this.maxRetries = device.maxRetries;
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Max Retries: ${this.maxRetries}`);
     }
-    if (device.delayBetweenRetries === undefined) {
+    if (!device.delayBetweenRetries) {
       this.delayBetweenRetries = 3000; // Delay between retries in milliseconds
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Delay Between Retries Not Set, Using: ${this.delayBetweenRetries}`);
     } else {
-      this.delayBetweenRetries = device.delayBetweenRetries;
+      this.delayBetweenRetries = device.delayBetweenRetries * 1000;
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Delay Between Retries: ${this.delayBetweenRetries}`);
     }
   }

package/src/device/hub.ts

@@ -746,18 +746,18 @@ export class Hub {
   }
 
   async deviceRetry(device: device & devicesConfig): Promise<void> {
-    if (device.maxRetries === undefined) {
+    if (!device.maxRetries) {
       this.maxRetries = 5; // Maximum number of retries
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Max Retries Not Set, Using: ${this.maxRetries}`);
     } else {
       this.maxRetries = device.maxRetries;
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Max Retries: ${this.maxRetries}`);
     }
-    if (device.delayBetweenRetries === undefined) {
+    if (!device.delayBetweenRetries) {
       this.delayBetweenRetries = 3000; // Delay between retries in milliseconds
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Delay Between Retries Not Set, Using: ${this.delayBetweenRetries}`);
     } else {
-      this.delayBetweenRetries = device.delayBetweenRetries;
+      this.delayBetweenRetries = device.delayBetweenRetries * 1000;
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Delay Between Retries: ${this.delayBetweenRetries}`);
     }
   }

package/src/device/humidifier.ts

@@ -1028,18 +1028,18 @@ export class Humidifier {
   }
 
   async deviceRetry(device: device & devicesConfig): Promise<void> {
-    if (device.maxRetries === undefined) {
+    if (!device.maxRetries) {
       this.maxRetries = 5; // Maximum number of retries
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Max Retries Not Set, Using: ${this.maxRetries}`);
     } else {
       this.maxRetries = device.maxRetries;
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Max Retries: ${this.maxRetries}`);
     }
-    if (device.delayBetweenRetries === undefined) {
+    if (!device.delayBetweenRetries) {
       this.delayBetweenRetries = 3000; // Delay between retries in milliseconds
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Delay Between Retries Not Set, Using: ${this.delayBetweenRetries}`);
     } else {
-      this.delayBetweenRetries = device.delayBetweenRetries;
+      this.delayBetweenRetries = device.delayBetweenRetries * 1000;
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Delay Between Retries: ${this.delayBetweenRetries}`);
     }
   }

package/src/device/iosensor.ts

@@ -747,18 +747,18 @@ export class IOSensor {
   }
 
   async deviceRetry(device: device & devicesConfig): Promise<void> {
-    if (device.maxRetries === undefined) {
+    if (!device.maxRetries) {
       this.maxRetries = 5; // Maximum number of retries
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Max Retries Not Set, Using: ${this.maxRetries}`);
     } else {
       this.maxRetries = device.maxRetries;
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Max Retries: ${this.maxRetries}`);
     }
-    if (device.delayBetweenRetries === undefined) {
+    if (!device.delayBetweenRetries) {
       this.delayBetweenRetries = 3000; // Delay between retries in milliseconds
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Delay Between Retries Not Set, Using: ${this.delayBetweenRetries}`);
     } else {
-      this.delayBetweenRetries = device.delayBetweenRetries;
+      this.delayBetweenRetries = device.delayBetweenRetries * 1000;
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Delay Between Retries: ${this.delayBetweenRetries}`);
     }
   }

package/src/device/lightstrip.ts

@@ -1177,18 +1177,18 @@ export class StripLight {
   }
 
   async deviceRetry(device: device & devicesConfig): Promise<void> {
-    if (device.maxRetries === undefined) {
+    if (!device.maxRetries) {
       this.maxRetries = 5; // Maximum number of retries
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Max Retries Not Set, Using: ${this.maxRetries}`);
     } else {
       this.maxRetries = device.maxRetries;
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Max Retries: ${this.maxRetries}`);
     }
-    if (device.delayBetweenRetries === undefined) {
+    if (!device.delayBetweenRetries) {
       this.delayBetweenRetries = 3000; // Delay between retries in milliseconds
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Delay Between Retries Not Set, Using: ${this.delayBetweenRetries}`);
     } else {
-      this.delayBetweenRetries = device.delayBetweenRetries;
+      this.delayBetweenRetries = device.delayBetweenRetries * 1000;
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Delay Between Retries: ${this.delayBetweenRetries}`);
     }
   }

package/src/device/lock.ts

@@ -852,18 +852,18 @@ export class Lock {
   }
 
   async deviceRetry(device: device & devicesConfig): Promise<void> {
-    if (device.maxRetries === undefined) {
+    if (!device.maxRetries) {
       this.maxRetries = 5; // Maximum number of retries
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Max Retries Not Set, Using: ${this.maxRetries}`);
     } else {
       this.maxRetries = device.maxRetries;
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Max Retries: ${this.maxRetries}`);
     }
-    if (device.delayBetweenRetries === undefined) {
+    if (!device.delayBetweenRetries) {
       this.delayBetweenRetries = 3000; // Delay between retries in milliseconds
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Delay Between Retries Not Set, Using: ${this.delayBetweenRetries}`);
     } else {
-      this.delayBetweenRetries = device.delayBetweenRetries;
+      this.delayBetweenRetries = device.delayBetweenRetries * 1000;
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Delay Between Retries: ${this.delayBetweenRetries}`);
     }
   }

package/src/device/meter.ts

@@ -740,18 +740,18 @@ export class Meter {
   }
 
   async deviceRetry(device: device & devicesConfig): Promise<void> {
-    if (device.maxRetries === undefined) {
+    if (!device.maxRetries) {
       this.maxRetries = 5; // Maximum number of retries
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Max Retries Not Set, Using: ${this.maxRetries}`);
     } else {
       this.maxRetries = device.maxRetries;
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Max Retries: ${this.maxRetries}`);
     }
-    if (device.delayBetweenRetries === undefined) {
+    if (!device.delayBetweenRetries) {
       this.delayBetweenRetries = 3000; // Delay between retries in milliseconds
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Delay Between Retries Not Set, Using: ${this.delayBetweenRetries}`);
     } else {
-      this.delayBetweenRetries = device.delayBetweenRetries;
+      this.delayBetweenRetries = device.delayBetweenRetries * 1000;
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Delay Between Retries: ${this.delayBetweenRetries}`);
     }
   }

package/src/device/meterplus.ts

@@ -755,18 +755,18 @@ export class MeterPlus {
   }
 
   async deviceRetry(device: device & devicesConfig): Promise<void> {
-    if (device.maxRetries === undefined) {
+    if (!device.maxRetries) {
       this.maxRetries = 5; // Maximum number of retries
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Max Retries Not Set, Using: ${this.maxRetries}`);
     } else {
       this.maxRetries = device.maxRetries;
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Max Retries: ${this.maxRetries}`);
     }
-    if (device.delayBetweenRetries === undefined) {
+    if (!device.delayBetweenRetries) {
       this.delayBetweenRetries = 3000; // Delay between retries in milliseconds
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Delay Between Retries Not Set, Using: ${this.delayBetweenRetries}`);
     } else {
-      this.delayBetweenRetries = device.delayBetweenRetries;
+      this.delayBetweenRetries = device.delayBetweenRetries * 1000;
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Delay Between Retries: ${this.delayBetweenRetries}`);
     }
   }

package/src/device/motion.ts

@@ -669,18 +669,18 @@ export class Motion {
   }
 
   async deviceRetry(device: device & devicesConfig): Promise<void> {
-    if (device.maxRetries === undefined) {
+    if (!device.maxRetries) {
       this.maxRetries = 5; // Maximum number of retries
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Max Retries Not Set, Using: ${this.maxRetries}`);
     } else {
       this.maxRetries = device.maxRetries;
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Max Retries: ${this.maxRetries}`);
     }
-    if (device.delayBetweenRetries === undefined) {
+    if (!device.delayBetweenRetries) {
       this.delayBetweenRetries = 3000; // Delay between retries in milliseconds
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Delay Between Retries Not Set, Using: ${this.delayBetweenRetries}`);
     } else {
-      this.delayBetweenRetries = device.delayBetweenRetries;
+      this.delayBetweenRetries = device.delayBetweenRetries * 1000;
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Delay Between Retries: ${this.delayBetweenRetries}`);
     }
   }

package/src/device/plug.ts

@@ -696,18 +696,18 @@ export class Plug {
   }
 
   async deviceRetry(device: device & devicesConfig): Promise<void> {
-    if (device.maxRetries === undefined) {
+    if (!device.maxRetries) {
       this.maxRetries = 5; // Maximum number of retries
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Max Retries Not Set, Using: ${this.maxRetries}`);
     } else {
       this.maxRetries = device.maxRetries;
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Max Retries: ${this.maxRetries}`);
     }
-    if (device.delayBetweenRetries === undefined) {
+    if (!device.delayBetweenRetries) {
       this.delayBetweenRetries = 3000; // Delay between retries in milliseconds
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Delay Between Retries Not Set, Using: ${this.delayBetweenRetries}`);
     } else {
-      this.delayBetweenRetries = device.delayBetweenRetries;
+      this.delayBetweenRetries = device.delayBetweenRetries * 1000;
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Delay Between Retries: ${this.delayBetweenRetries}`);
     }
   }

package/src/device/robotvacuumcleaner.ts

@@ -857,18 +857,18 @@ export class RobotVacuumCleaner {
   }
 
   async deviceRetry(device: device & devicesConfig): Promise<void> {
-    if (device.maxRetries === undefined) {
+    if (!device.maxRetries) {
       this.maxRetries = 5; // Maximum number of retries
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Max Retries Not Set, Using: ${this.maxRetries}`);
     } else {
       this.maxRetries = device.maxRetries;
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Max Retries: ${this.maxRetries}`);
     }
-    if (device.delayBetweenRetries === undefined) {
+    if (!device.delayBetweenRetries) {
       this.delayBetweenRetries = 3000; // Delay between retries in milliseconds
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Delay Between Retries Not Set, Using: ${this.delayBetweenRetries}`);
     } else {
-      this.delayBetweenRetries = device.delayBetweenRetries;
+      this.delayBetweenRetries = device.delayBetweenRetries * 1000;
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Delay Between Retries: ${this.delayBetweenRetries}`);
     }
   }

package/src/device/waterdetector.ts

@@ -593,18 +593,18 @@ export class WaterDetector {
   }
 
   async deviceRetry(device: device & devicesConfig): Promise<void> {
-    if (device.maxRetries === undefined) {
+    if (!device.maxRetries) {
       this.maxRetries = 5; // Maximum number of retries
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Max Retries Not Set, Using: ${this.maxRetries}`);
     } else {
       this.maxRetries = device.maxRetries;
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Max Retries: ${this.maxRetries}`);
     }
-    if (device.delayBetweenRetries === undefined) {
+    if (!device.delayBetweenRetries) {
       this.delayBetweenRetries = 3000; // Delay between retries in milliseconds
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Delay Between Retries Not Set, Using: ${this.delayBetweenRetries}`);
     } else {
-      this.delayBetweenRetries = device.delayBetweenRetries;
+      this.delayBetweenRetries = device.delayBetweenRetries * 1000;
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Delay Between Retries: ${this.delayBetweenRetries}`);
     }
   }

package/src/platform.ts

@@ -39,7 +39,7 @@ 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';
 import { UrlObject } from 'url';
 import { sleep } from './utils.js';
 
@@ -58,6 +58,8 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
   version!: string;
   Logging?: string;
   debugMode!: boolean;
+  maxRetries!: number;
+  delayBetweenRetries!: number;
   platformConfig!: SwitchBotPlatformConfig['options'];
   platformLogging!: SwitchBotPlatformConfig['logging'];
   config!: SwitchBotPlatformConfig;
@@ -106,7 +108,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);
 
@@ -385,6 +386,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) {
@@ -495,8 +511,8 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
   async discoverDevices() {
     if (this.config.credentials?.token) {
       let retryCount = 0;
-      const maxRetries = 5; // Maximum number of retries
-      const delayBetweenRetries = 5000; // Delay between retries in milliseconds
+      const maxRetries = this.maxRetries; // Maximum number of retries
+      const delayBetweenRetries = this.delayBetweenRetries; // Delay between retries in milliseconds
       while (retryCount < maxRetries) {
         try {
           const { body, statusCode } = await request(Devices, {

package/src/settings.ts

@@ -36,6 +36,8 @@ export type credentials = {
 export type options = {
   refreshRate?: number;
   pushRate?: number;
+  maxRetries?: number;
+  delayBetweenRetries?: number;
   logging?: string;
   devices?: Array<devicesConfig>;
   irdevices?: Array<irDevicesConfig>;