@switchbot/homebridge-switchbot 3.5.0-beta.17 → 3.5.0-beta.19

package/src/device/blindtilt.ts

@@ -79,6 +79,8 @@ export class BlindTilt {
   deviceRefreshRate!: number;
   setCloseMode!: string;
   setOpenMode!: string;
+  maxRetries!: number;
+  delayBetweenRetries!: number;
 
   // Updates
   blindTiltUpdateInProgress!: boolean;
@@ -106,6 +108,7 @@ export class BlindTilt {
     this.scan(device);
     this.setupMqtt(device);
     this.deviceContext();
+    this.deviceRetry(device);
     this.deviceConfig(device);
 
     this.mappingMode = (device.blindTilt?.mode as BlindTiltMappingMode) ?? BlindTiltMappingMode.OnlyUp;
@@ -594,9 +597,10 @@ export class BlindTilt {
   async openAPIRefreshStatus(): Promise<void> {
     this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} openAPIRefreshStatus`);
     try {
-      const { body, statusCode } = await request(`${Devices}/${this.device.deviceId}/status`, {
-        headers: this.platform.generateHeaders(),
-      });
+      const { body, statusCode } = await this.platform.retryRequest(this.maxRetries, this.delayBetweenRetries,
+        `${Devices}/${this.device.deviceId}/status`, {
+          headers: this.platform.generateHeaders(),
+        });
       this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} statusCode: ${statusCode}`);
       const deviceStatus: any = await body.json();
       this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} deviceStatus: ${JSON.stringify(deviceStatus)}`);
@@ -1382,6 +1386,23 @@ export class BlindTilt {
     }
   }
 
+  async deviceRetry(device: device & devicesConfig): Promise<void> {
+    if (device.maxRetries === undefined) {
+      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) {
+      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.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Delay Between Retries: ${this.delayBetweenRetries}`);
+    }
+  }
+
   async deviceConfig(device: device & devicesConfig): Promise<void> {
     let config = {};
     if (device.blindTilt) {
@@ -1411,6 +1432,12 @@ export class BlindTilt {
     if (device.webhook !== undefined) {
       config['webhook'] = device.webhook;
     }
+    if (device.maxRetries !== undefined) {
+      config['maxRetries'] = device.maxRetries;
+    }
+    if (device.delayBetweenRetries !== undefined) {
+      config['delayBetweenRetries'] = device.delayBetweenRetries;
+    }
     if (device.blindTilt?.mode === undefined) {
       config['mode'] = BlindTiltMappingMode.OnlyUp;
     } else {

package/src/device/bot.ts

@@ -58,6 +58,8 @@ export class Bot {
   deviceLogging!: string;
   multiPressCount!: number;
   deviceRefreshRate!: number;
+  maxRetries!: number;
+  delayBetweenRetries!: number;
 
   // Updates
   botUpdateInProgress!: boolean;
@@ -88,6 +90,7 @@ export class Bot {
     this.allowPushChanges(device);
     this.deviceContext();
     this.DoublePress(device);
+    this.deviceRetry(device);
     this.deviceConfig(device);
 
     this.multiPressCount = 0;
@@ -623,9 +626,10 @@ export class Bot {
   async openAPIRefreshStatus(): Promise<void> {
     this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} openAPIRefreshStatus`);
     try {
-      const { body, statusCode } = await request(`${Devices}/${this.device.deviceId}/status`, {
-        headers: this.platform.generateHeaders(),
-      });
+      const { body, statusCode } = await this.platform.retryRequest(this.maxRetries, this.delayBetweenRetries,
+        `${Devices}/${this.device.deviceId}/status`, {
+          headers: this.platform.generateHeaders(),
+        });
       this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} statusCode: ${statusCode}`);
       const deviceStatus: any = await body.json();
       this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} deviceStatus: ${JSON.stringify(deviceStatus)}`);
@@ -1483,6 +1487,23 @@ export class Bot {
     }
   }
 
+  async deviceRetry(device: device & devicesConfig): Promise<void> {
+    if (device.maxRetries === undefined) {
+      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) {
+      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.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Delay Between Retries: ${this.delayBetweenRetries}`);
+    }
+  }
+
   async deviceConfig(device: device & devicesConfig): Promise<void> {
     let config = {};
     if (device.bot) {

package/src/device/ceilinglight.ts

@@ -50,6 +50,8 @@ export class CeilingLight {
   deviceLogging!: string;
   deviceRefreshRate!: number;
   adaptiveLightingShift?: number;
+  maxRetries!: number;
+  delayBetweenRetries!: number;
 
   // Adaptive Lighting
   AdaptiveLightingController?: ControllerConstructor | Controller<ControllerServiceMap>;
@@ -85,6 +87,7 @@ export class CeilingLight {
     this.refreshRate(device);
     this.adaptiveLighting(device);
     this.deviceContext();
+    this.deviceRetry(device);
     this.deviceConfig(device);
 
     // this is subject we use to track when we need to POST changes to the SwitchBot API
@@ -461,9 +464,10 @@ export class CeilingLight {
   async openAPIRefreshStatus() {
     this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} openAPIRefreshStatus`);
     try {
-      const { body, statusCode } = await request(`${Devices}/${this.device.deviceId}/status`, {
-        headers: this.platform.generateHeaders(),
-      });
+      const { body, statusCode } = await this.platform.retryRequest(this.maxRetries, this.delayBetweenRetries,
+        `${Devices}/${this.device.deviceId}/status`, {
+          headers: this.platform.generateHeaders(),
+        });
       this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} statusCode: ${statusCode}`);
       const deviceStatus: any = await body.json();
       this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} deviceStatus: ${JSON.stringify(deviceStatus)}`);
@@ -1144,6 +1148,23 @@ export class CeilingLight {
     }
   }
 
+  async deviceRetry(device: device & devicesConfig): Promise<void> {
+    if (device.maxRetries === undefined) {
+      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) {
+      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.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Delay Between Retries: ${this.delayBetweenRetries}`);
+    }
+  }
+
   async deviceConfig(device: device & devicesConfig): Promise<void> {
     let config = {};
     if (device.ceilinglight) {

package/src/device/colorbulb.ts

@@ -58,6 +58,8 @@ export class ColorBulb {
   deviceLogging!: string;
   deviceRefreshRate!: number;
   adaptiveLightingShift?: number;
+  maxRetries!: number;
+  delayBetweenRetries!: number;
 
   // Adaptive Lighting
   AdaptiveLightingController?: ControllerConstructor | Controller<ControllerServiceMap>;
@@ -93,6 +95,7 @@ export class ColorBulb {
     this.refreshRate(device);
     this.adaptiveLighting(device);
     this.deviceContext();
+    this.deviceRetry(device);
     this.deviceConfig(device);
 
     // this is subject we use to track when we need to POST changes to the SwitchBot API
@@ -527,9 +530,10 @@ export class ColorBulb {
   async openAPIRefreshStatus() {
     this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} openAPIRefreshStatus`);
     try {
-      const { body, statusCode } = await request(`${Devices}/${this.device.deviceId}/status`, {
-        headers: this.platform.generateHeaders(),
-      });
+      const { body, statusCode } = await this.platform.retryRequest(this.maxRetries, this.delayBetweenRetries,
+        `${Devices}/${this.device.deviceId}/status`, {
+          headers: this.platform.generateHeaders(),
+        });
       this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} statusCode: ${statusCode}`);
       const deviceStatus: any = await body.json();
       this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} deviceStatus: ${JSON.stringify(deviceStatus)}`);
@@ -1353,6 +1357,23 @@ export class ColorBulb {
     }
   }
 
+  async deviceRetry(device: device & devicesConfig): Promise<void> {
+    if (device.maxRetries === undefined) {
+      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) {
+      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.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Delay Between Retries: ${this.delayBetweenRetries}`);
+    }
+  }
+
   async deviceConfig(device: device & devicesConfig): Promise<void> {
     let config = {};
     if (device.colorbulb) {

package/src/device/contact.ts

@@ -1,4 +1,3 @@
-import { request } from 'undici';
 import { sleep } from '../utils.js';
 import { interval, Subject } from 'rxjs';
 import { skipWhile } from 'rxjs/operators';
@@ -53,6 +52,8 @@ export class Contact {
   scanDuration!: number;
   deviceLogging!: string;
   deviceRefreshRate!: number;
+  maxRetries!: number;
+  delayBetweenRetries!: number;
 
   // Updates
   contactUbpdateInProgress!: boolean;
@@ -79,6 +80,7 @@ export class Contact {
     this.scan(device);
     this.refreshRate(device);
     this.deviceContext();
+    this.deviceRetry(device);
     this.deviceConfig(device);
 
     // this is subject we use to track when we need to POST changes to the SwitchBot API
@@ -437,9 +439,10 @@ export class Contact {
   async openAPIRefreshStatus(): Promise<void> {
     this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} openAPIRefreshStatus`);
     try {
-      const { body, statusCode } = await request(`${Devices}/${this.device.deviceId}/status`, {
-        headers: this.platform.generateHeaders(),
-      });
+      const { body, statusCode } = await this.platform.retryRequest(this.maxRetries, this.delayBetweenRetries,
+        `${Devices}/${this.device.deviceId}/status`, {
+          headers: this.platform.generateHeaders(),
+        });
       this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} statusCode: ${statusCode}`);
       const deviceStatus: any = await body.json();
       this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} deviceStatus: ${JSON.stringify(deviceStatus)}`);
@@ -708,6 +711,23 @@ export class Contact {
     }
   }
 
+  async deviceRetry(device: device & devicesConfig): Promise<void> {
+    if (device.maxRetries === undefined) {
+      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) {
+      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.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Delay Between Retries: ${this.delayBetweenRetries}`);
+    }
+  }
+
   async deviceConfig(device: device & devicesConfig): Promise<void> {
     let config = {};
     if (device.contact) {

package/src/device/curtain.ts

@@ -68,6 +68,8 @@ export class Curtain {
   scanDuration!: number;
   deviceLogging!: string;
   deviceRefreshRate!: number;
+  maxRetries!: number;
+  delayBetweenRetries!: number;
 
   // Updates
   curtainUpdateInProgress!: boolean;
@@ -98,6 +100,7 @@ export class Curtain {
     this.scan(device);
     this.setupMqtt(device);
     this.deviceContext();
+    this.deviceRetry(device);
     this.deviceConfig(device);
 
     // this is subject we use to track when we need to POST changes to the SwitchBot API
@@ -634,9 +637,10 @@ export class Curtain {
   async openAPIRefreshStatus(): Promise<void> {
     this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} openAPIRefreshStatus`);
     try {
-      const { body, statusCode } = await request(`${Devices}/${this.device.deviceId}/status`, {
-        headers: this.platform.generateHeaders(),
-      });
+      const { body, statusCode } = await this.platform.retryRequest(this.maxRetries, this.delayBetweenRetries,
+        `${Devices}/${this.device.deviceId}/status`, {
+          headers: this.platform.generateHeaders(),
+        });
       this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} statusCode: ${statusCode}`);
       const deviceStatus: any = await body.json();
       this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} deviceStatus: ${JSON.stringify(deviceStatus)}`);
@@ -1310,6 +1314,23 @@ export class Curtain {
     }
   }
 
+  async deviceRetry(device: device & devicesConfig): Promise<void> {
+    if (device.maxRetries === undefined) {
+      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) {
+      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.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Delay Between Retries: ${this.delayBetweenRetries}`);
+    }
+  }
+
   async deviceConfig(device: device & devicesConfig): Promise<void> {
     let config = {};
     if (device.curtain) {

package/src/device/hub.ts

@@ -3,7 +3,6 @@ import { CharacteristicValue, PlatformAccessory, Service, Units, API, Logging, H
 import { MqttClient } from 'mqtt';
 import { hostname } from 'os';
 import { interval } from 'rxjs';
-import { request } from 'undici';
 import { SwitchBotPlatform } from '../platform.js';
 import { Devices, device, deviceStatus, devicesConfig, SwitchBotPlatformConfig } from '../settings.js';
 
@@ -46,6 +45,8 @@ export class Hub {
   scanDuration!: number;
   deviceLogging!: string;
   deviceRefreshRate!: number;
+  maxRetries!: number;
+  delayBetweenRetries!: number;
 
   // Connection
   private readonly OpenAPI: boolean;
@@ -69,6 +70,7 @@ export class Hub {
     this.deviceContext();
     this.setupHistoryService(device);
     this.setupMqtt(device);
+    this.deviceRetry(device);
     this.deviceConfig(device);
 
     this.CurrentRelativeHumidity = accessory.context.CurrentRelativeHumidity;
@@ -432,9 +434,10 @@ export class Hub {
   async openAPIRefreshStatus(): Promise<void> {
     this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} openAPIRefreshStatus`);
     try {
-      const { body, statusCode } = await request(`${Devices}/${this.device.deviceId}/status`, {
-        headers: this.platform.generateHeaders(),
-      });
+      const { body, statusCode } = await this.platform.retryRequest(this.maxRetries, this.delayBetweenRetries,
+        `${Devices}/${this.device.deviceId}/status`, {
+          headers: this.platform.generateHeaders(),
+        });
       this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} statusCode: ${statusCode}`);
       const deviceStatus: any = await body.json();
       this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} deviceStatus: ${JSON.stringify(deviceStatus)}`);
@@ -742,6 +745,23 @@ export class Hub {
     }
   }
 
+  async deviceRetry(device: device & devicesConfig): Promise<void> {
+    if (device.maxRetries === undefined) {
+      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) {
+      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.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Delay Between Retries: ${this.delayBetweenRetries}`);
+    }
+  }
+
   async deviceConfig(device: device & devicesConfig): Promise<void> {
     let config = {};
     if (device.hub) {

package/src/device/humidifier.ts

@@ -50,6 +50,8 @@ export class Humidifier {
   scanDuration!: number;
   deviceLogging!: string;
   deviceRefreshRate!: number;
+  maxRetries!: number;
+  delayBetweenRetries!: number;
 
   // Updates
   humidifierUpdateInProgress!: boolean;
@@ -76,6 +78,7 @@ export class Humidifier {
     this.scan(device);
     this.refreshRate(device);
     this.deviceContext();
+    this.deviceRetry(device);
     this.deviceConfig(device);
 
     // this is subject we use to track when we need to POST changes to the SwitchBot API
@@ -429,9 +432,10 @@ export class Humidifier {
   async openAPIRefreshStatus(): Promise<void> {
     this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} openAPIRefreshStatus`);
     try {
-      const { body, statusCode } = await request(`${Devices}/${this.device.deviceId}/status`, {
-        headers: this.platform.generateHeaders(),
-      });
+      const { body, statusCode } = await this.platform.retryRequest(this.maxRetries, this.delayBetweenRetries,
+        `${Devices}/${this.device.deviceId}/status`, {
+          headers: this.platform.generateHeaders(),
+        });
       this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} statusCode: ${statusCode}`);
       const deviceStatus: any = await body.json();
       this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} deviceStatus: ${JSON.stringify(deviceStatus)}`);
@@ -1023,6 +1027,23 @@ export class Humidifier {
     }
   }
 
+  async deviceRetry(device: device & devicesConfig): Promise<void> {
+    if (device.maxRetries === undefined) {
+      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) {
+      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.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Delay Between Retries: ${this.delayBetweenRetries}`);
+    }
+  }
+
   async deviceConfig(device: device & devicesConfig): Promise<void> {
     let config = {};
     if (device.humidifier) {

package/src/device/iosensor.ts

@@ -1,5 +1,4 @@
 import { hostname } from 'os';
-import { request } from 'undici';
 import { sleep } from '../utils.js';
 import { MqttClient } from 'mqtt';
 import asyncmqtt from 'async-mqtt';
@@ -57,6 +56,8 @@ export class IOSensor {
   scanDuration!: number;
   deviceLogging!: string;
   deviceRefreshRate!: number;
+  maxRetries!: number;
+  delayBetweenRetries!: number;
 
   // Updates
   ioSensorUpdateInProgress!: boolean;
@@ -85,6 +86,7 @@ export class IOSensor {
     this.deviceContext();
     this.setupHistoryService(device);
     this.setupMqtt(device);
+    this.deviceRetry(device);
     this.deviceConfig(device);
 
     // this is subject we use to track when we need to POST changes to the SwitchBot API
@@ -409,9 +411,10 @@ export class IOSensor {
   async openAPIRefreshStatus(): Promise<void> {
     this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} openAPIRefreshStatus`);
     try {
-      const { body, statusCode } = await request(`${Devices}/${this.device.deviceId}/status`, {
-        headers: this.platform.generateHeaders(),
-      });
+      const { body, statusCode } = await this.platform.retryRequest(this.maxRetries, this.delayBetweenRetries,
+        `${Devices}/${this.device.deviceId}/status`, {
+          headers: this.platform.generateHeaders(),
+        });
       this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} statusCode: ${statusCode}`);
       const deviceStatus: any = await body.json();
       this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} deviceStatus: ${JSON.stringify(deviceStatus)}`);
@@ -743,6 +746,23 @@ export class IOSensor {
     }
   }
 
+  async deviceRetry(device: device & devicesConfig): Promise<void> {
+    if (device.maxRetries === undefined) {
+      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) {
+      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.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Delay Between Retries: ${this.delayBetweenRetries}`);
+    }
+  }
+
   async deviceConfig(device: device & devicesConfig): Promise<void> {
     let config = {};
     if (device.meter) {

package/src/device/lightstrip.ts

@@ -48,6 +48,8 @@ export class StripLight {
   deviceLogging!: string;
   deviceRefreshRate!: number;
   adaptiveLightingShift?: number;
+  maxRetries!: number;
+  delayBetweenRetries!: number;
 
   // Adaptive Lighting
   AdaptiveLightingController?: ControllerConstructor | Controller<ControllerServiceMap>;
@@ -83,6 +85,7 @@ export class StripLight {
     this.scan(device);
     this.refreshRate(device);
     this.deviceContext();
+    this.deviceRetry(device);
     this.deviceConfig(device);
 
     // this is subject we use to track when we need to POST changes to the SwitchBot API
@@ -441,9 +444,10 @@ export class StripLight {
   async openAPIRefreshStatus(): Promise<void> {
     this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} openAPIRefreshStatus`);
     try {
-      const { body, statusCode } = await request(`${Devices}/${this.device.deviceId}/status`, {
-        headers: this.platform.generateHeaders(),
-      });
+      const { body, statusCode } = await this.platform.retryRequest(this.maxRetries, this.delayBetweenRetries,
+        `${Devices}/${this.device.deviceId}/status`, {
+          headers: this.platform.generateHeaders(),
+        });
       this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} statusCode: ${statusCode}`);
       const deviceStatus: any = await body.json();
       this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} deviceStatus: ${JSON.stringify(deviceStatus)}`);
@@ -1172,6 +1176,23 @@ export class StripLight {
     }
   }
 
+  async deviceRetry(device: device & devicesConfig): Promise<void> {
+    if (device.maxRetries === undefined) {
+      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) {
+      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.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Delay Between Retries: ${this.delayBetweenRetries}`);
+    }
+  }
+
   async deviceConfig(device: device & devicesConfig): Promise<void> {
     let config = {};
     if (device.striplight) {

package/src/device/lock.ts

@@ -44,6 +44,8 @@ export class Lock {
   scanDuration!: number;
   deviceLogging!: string;
   deviceRefreshRate!: number;
+  maxRetries!: number;
+  delayBetweenRetries!: number;
 
   // Updates
   lockUpdateInProgress!: boolean;
@@ -70,6 +72,7 @@ export class Lock {
     this.scan(device);
     this.refreshRate(device);
     this.deviceContext();
+    this.deviceRetry(device);
     this.deviceConfig(device);
 
     // this is subject we use to track when we need to POST changes to the SwitchBot API
@@ -468,9 +471,10 @@ export class Lock {
   async openAPIRefreshStatus(): Promise<void> {
     this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} openAPIRefreshStatus`);
     try {
-      const { body, statusCode } = await request(`${Devices}/${this.device.deviceId}/status`, {
-        headers: this.platform.generateHeaders(),
-      });
+      const { body, statusCode } = await this.platform.retryRequest(this.maxRetries, this.delayBetweenRetries,
+        `${Devices}/${this.device.deviceId}/status`, {
+          headers: this.platform.generateHeaders(),
+        });
       this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} statusCode: ${statusCode}`);
       const deviceStatus: any = await body.json();
       this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} deviceStatus: ${JSON.stringify(deviceStatus)}`);
@@ -847,6 +851,23 @@ export class Lock {
     }
   }
 
+  async deviceRetry(device: device & devicesConfig): Promise<void> {
+    if (device.maxRetries === undefined) {
+      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) {
+      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.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Delay Between Retries: ${this.delayBetweenRetries}`);
+    }
+  }
+
   async deviceConfig(device: device & devicesConfig): Promise<void> {
     let config = {};
     if (device.lock) {