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

package/src/device/plug.ts

@@ -30,6 +30,8 @@ export class Plug {
   scanDuration!: number;
   deviceLogging!: string;
   deviceRefreshRate!: number;
+  maxRetries!: number;
+  delayBetweenRetries!: number;
 
   // Updates
   plugUpdateInProgress!: boolean;
@@ -56,6 +58,7 @@ export class Plug {
     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
@@ -297,9 +300,10 @@ export class Plug {
   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)}`);
@@ -386,6 +390,8 @@ export class Plug {
         })
         .then(() => {
           this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Done.`);
+          this.successLog(`${this.device.deviceType}: ${this.accessory.displayName} `
+              + `On: ${this.On} sent over BLE,  sent successfully`);
           this.On = false;
         })
         .catch(async (e: any) => {
@@ -432,6 +438,8 @@ export class Plug {
         if ((statusCode === 200 || statusCode === 100) && (deviceStatus.statusCode === 200 || deviceStatus.statusCode === 100)) {
           this.debugErrorLog(`${this.device.deviceType}: ${this.accessory.displayName} `
             + `statusCode: ${statusCode} & deviceStatus StatusCode: ${deviceStatus.statusCode}`);
+          this.successLog(`${this.device.deviceType}: ${this.accessory.displayName} `
+                + `request to SwitchBot API, body: ${deviceStatus} sent successfully`);
         } else {
           this.statusCode(statusCode);
           this.statusCode(deviceStatus.statusCode);
@@ -687,6 +695,23 @@ export class Plug {
     }
   }
 
+  async deviceRetry(device: device & devicesConfig): Promise<void> {
+    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) {
+      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 * 1000;
+      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.plug) {
@@ -740,6 +765,12 @@ export class Plug {
   /**
    * Logging for Device
    */
+  successLog(...log: any[]): void {
+    if (this.enablingDeviceLogging()) {
+      this.platform.log.success(String(...log));
+    }
+  }
+
   infoLog(...log: any[]): void {
     if (this.enablingDeviceLogging()) {
       this.platform.log.info(String(...log));

package/src/device/robotvacuumcleaner.ts

@@ -37,6 +37,8 @@ export class RobotVacuumCleaner {
   scanDuration!: number;
   deviceLogging!: string;
   deviceRefreshRate!: number;
+  maxRetries!: number;
+  delayBetweenRetries!: number;
 
   // Updates
   robotVacuumCleanerUpdateInProgress!: boolean;
@@ -63,6 +65,7 @@ export class RobotVacuumCleaner {
     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
@@ -344,9 +347,10 @@ export class RobotVacuumCleaner {
   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)}`);
@@ -434,6 +438,8 @@ export class RobotVacuumCleaner {
         })
         .then(() => {
           this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Done.`);
+          this.successLog(`${this.device.deviceType}: ${this.accessory.displayName} `
+              + `On: ${this.On} sent over BLE,  sent successfully`);
           this.On = false;
         })
         .catch(async (e: any) => {
@@ -480,6 +486,8 @@ export class RobotVacuumCleaner {
         if ((statusCode === 200 || statusCode === 100) && (deviceStatus.statusCode === 200 || deviceStatus.statusCode === 100)) {
           this.debugErrorLog(`${this.device.deviceType}: ${this.accessory.displayName} `
             + `statusCode: ${statusCode} & deviceStatus StatusCode: ${deviceStatus.statusCode}`);
+          this.successLog(`${this.device.deviceType}: ${this.accessory.displayName} `
+            + `request to SwitchBot API, body: ${bodyChange} sent successfully`);
         } else {
           this.statusCode(statusCode);
           this.statusCode(deviceStatus.statusCode);
@@ -502,10 +510,11 @@ export class RobotVacuumCleaner {
 
   async openAPIpushBrightnessChanges() {
     this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} openAPIpushBrightnessChanges`);
-    const body = await this.brightnessCommands();
-    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Sending request to SwitchBot API, body: ${body},`);
+    const bodyChange = this.brightnessCommands();
+    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Sending request to SwitchBot API, body: ${bodyChange},`);
     try {
       const { body, statusCode } = await request(`${Devices}/${this.device.deviceId}/commands`, {
+        body: bodyChange,
         method: 'POST',
         headers: this.platform.generateHeaders(),
       });
@@ -516,6 +525,8 @@ export class RobotVacuumCleaner {
       if ((statusCode === 200 || statusCode === 100) && (deviceStatus.statusCode === 200 || deviceStatus.statusCode === 100)) {
         this.debugErrorLog(`${this.device.deviceType}: ${this.accessory.displayName} `
           + `statusCode: ${statusCode} & deviceStatus StatusCode: ${deviceStatus.statusCode}`);
+        this.successLog(`${this.device.deviceType}: ${this.accessory.displayName} `
+            + `request to SwitchBot API, body: ${deviceStatus} sent successfully`);
       } else {
         this.statusCode(statusCode);
         this.statusCode(deviceStatus.statusCode);
@@ -566,12 +577,12 @@ export class RobotVacuumCleaner {
       command = 'dock';
       parameter = 'default';
     }
-    const body = JSON.stringify({
+    const bodyChange = JSON.stringify({
       command: `${command}`,
       parameter: `${parameter}`,
       commandType: 'command',
     });
-    return body;
+    return bodyChange;
   }
 
   /**
@@ -845,6 +856,23 @@ export class RobotVacuumCleaner {
     }
   }
 
+  async deviceRetry(device: device & devicesConfig): Promise<void> {
+    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) {
+      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 * 1000;
+      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.plug) {
@@ -898,6 +926,12 @@ export class RobotVacuumCleaner {
   /**
    * Logging for Device
    */
+  successLog(...log: any[]): void {
+    if (this.enablingDeviceLogging()) {
+      this.platform.log.success(String(...log));
+    }
+  }
+
   infoLog(...log: any[]): void {
     if (this.enablingDeviceLogging()) {
       this.platform.log.info(String(...log));

package/src/device/waterdetector.ts

@@ -1,13 +1,12 @@
 import { hostname } from 'os';
-import { request } from 'undici';
 import { sleep } from '../utils.js';
 import { MqttClient } from 'mqtt';
 import asyncmqtt from 'async-mqtt';
 import { interval, Subject } from 'rxjs';
 import { skipWhile } from 'rxjs/operators';
 import { SwitchBotPlatform } from '../platform.js';
-import { Service, PlatformAccessory, Units, CharacteristicValue, API, Logging, HAP } from 'homebridge';
-import { device, devicesConfig, serviceData, temperature, deviceStatus, Devices, SwitchBotPlatformConfig } from '../settings.js';
+import { Service, PlatformAccessory, CharacteristicValue, API, Logging, HAP } from 'homebridge';
+import { device, devicesConfig, serviceData, deviceStatus, Devices, SwitchBotPlatformConfig } from '../settings.js';
 
 /**
  * Platform Accessory
@@ -22,8 +21,6 @@ export class WaterDetector {
   // Services
   leakService?: Service;
   batteryService: Service;
-  humidityservice?: Service;
-  temperatureservice?: Service;
 
   // Characteristic Values
   StatusActive!: CharacteristicValue;
@@ -32,21 +29,15 @@ export class WaterDetector {
   ChargingState!: CharacteristicValue;
   StatusLowBattery!: CharacteristicValue;
   FirmwareRevision!: CharacteristicValue;
-  CurrentTemperature!: CharacteristicValue;
-  CurrentRelativeHumidity!: CharacteristicValue;
 
   // OpenAPI Status
   OpenAPI_BatteryLevel: deviceStatus['battery'];
   OpenAPI_FirmwareRevision: deviceStatus['version'];
-  OpenAPI_CurrentTemperature: deviceStatus['temperature'];
-  OpenAPI_CurrentRelativeHumidity: deviceStatus['humidity'];
+  OpenAPI_LeakDetected: deviceStatus['status'];
 
   // BLE Status
-  BLE_Celsius!: temperature['c'];
-  BLE_Fahrenheit!: temperature['f'];
   BLE_BatteryLevel!: serviceData['battery'];
-  BLE_CurrentTemperature!: serviceData['temperature'];
-  BLE_CurrentRelativeHumidity!: serviceData['humidity'];
+  BLE_LeakDetected!: number;//serviceData['status'];
 
   // BLE Others
   BLE_IsConnected?: boolean;
@@ -61,6 +52,8 @@ export class WaterDetector {
   scanDuration!: number;
   deviceLogging!: string;
   deviceRefreshRate!: number;
+  maxRetries!: number;
+  delayBetweenRetries!: number;
 
   // Updates
   WaterDetectorUpdateInProgress!: boolean;
@@ -89,6 +82,7 @@ export class WaterDetector {
     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
@@ -125,64 +119,6 @@ export class WaterDetector {
       this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Leak Sensor Service Not Added`);
     }
 
-    // Temperature Sensor Service
-    if (device.waterdetector?.hide_temperature) {
-      this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Removing Temperature Sensor Service`);
-      this.temperatureservice = this.accessory.getService(this.hap.Service.TemperatureSensor);
-      accessory.removeService(this.temperatureservice!);
-    } else if (!this.temperatureservice) {
-      this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Add Temperature Sensor Service`);
-      const temperatureservice = `${accessory.displayName} Temperature Sensor`;
-      (this.temperatureservice = this.accessory.getService(this.hap.Service.TemperatureSensor)
-        || this.accessory.addService(this.hap.Service.TemperatureSensor)), temperatureservice;
-
-      this.temperatureservice.setCharacteristic(this.hap.Characteristic.Name, `${accessory.displayName} Temperature Sensor`);
-      if (!this.temperatureservice.testCharacteristic(this.hap.Characteristic.ConfiguredName)) {
-        this.temperatureservice.addCharacteristic(this.hap.Characteristic.ConfiguredName, `${accessory.displayName} Temperature Sensor`);
-      }
-      this.temperatureservice
-        .getCharacteristic(this.hap.Characteristic.CurrentTemperature)
-        .setProps({
-          unit: Units['CELSIUS'],
-          validValueRanges: [-273.15, 100],
-          minValue: -273.15,
-          maxValue: 100,
-          minStep: 0.1,
-        })
-        .onGet(() => {
-          return this.CurrentTemperature!;
-        });
-    } else {
-      this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Temperature Sensor Service Not Added`);
-    }
-
-    // Humidity Sensor Service
-    if (device.waterdetector?.hide_humidity) {
-      this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Removing Humidity Sensor Service`);
-      this.humidityservice = this.accessory.getService(this.hap.Service.HumiditySensor);
-      accessory.removeService(this.humidityservice!);
-    } else if (!this.humidityservice) {
-      this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Add Humidity Sensor Service`);
-      const humidityservice = `${accessory.displayName} Humidity Sensor`;
-      (this.humidityservice = this.accessory.getService(this.hap.Service.HumiditySensor)
-        || this.accessory.addService(this.hap.Service.HumiditySensor)), humidityservice;
-
-      this.humidityservice.setCharacteristic(this.hap.Characteristic.Name, `${accessory.displayName} Humidity Sensor`);
-      if (!this.humidityservice.testCharacteristic(this.hap.Characteristic.ConfiguredName)) {
-        this.humidityservice.addCharacteristic(this.hap.Characteristic.ConfiguredName, `${accessory.displayName} Humidity Sensor`);
-      }
-      this.humidityservice
-        .getCharacteristic(this.hap.Characteristic.CurrentRelativeHumidity)
-        .setProps({
-          minStep: 0.1,
-        })
-        .onGet(() => {
-          return this.CurrentRelativeHumidity;
-        });
-    } else {
-      this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Humidity Sensor Service Not Added`);
-    }
-
     // Battery Service
     const batteryService = `${accessory.displayName} Battery`;
     (this.batteryService = this.accessory.getService(this.hap.Service.Battery)
@@ -210,17 +146,14 @@ export class WaterDetector {
       this.platform.webhookEventHandler[this.device.deviceId] = async (context) => {
         try {
           this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} received Webhook: ${JSON.stringify(context)}`);
-          if (context.scale === 'CELSIUS') {
-            const { temperature, humidity } = context;
-            const { CurrentTemperature, CurrentRelativeHumidity } = this;
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} ` +
-              '(temperature, humidity) = ' +
-              `Webhook:(${temperature}, ${humidity}), ` +
-              `current:(${CurrentTemperature}, ${CurrentRelativeHumidity})`);
-            this.CurrentRelativeHumidity = humidity;
-            this.CurrentTemperature = temperature;
-            this.updateHomeKitCharacteristics();
-          }
+          const { status } = context;
+          const { LeakDetected } = this;
+          this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} ` +
+              '(status) = ' +
+              `Webhook:(${status}), ` +
+              `current:(${LeakDetected})`);
+          this.LeakDetected = status;
+          this.updateHomeKitCharacteristics();
         } catch (e: any) {
           this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} `
             + `failed to handle webhook. Received: ${JSON.stringify(context)} Error: ${e}`);
@@ -259,55 +192,31 @@ export class WaterDetector {
     }
     this.debugLog(`${this.accessory.displayName} BatteryLevel: ${this.BatteryLevel}, StatusLowBattery: ${this.StatusLowBattery}`);
 
-    // Humidity
-    if (!this.device.waterdetector?.hide_humidity) {
-      this.CurrentRelativeHumidity = this.BLE_CurrentRelativeHumidity!;
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Humidity: ${this.CurrentRelativeHumidity}%`);
-    }
-
-    // Current Temperature
-    if (!this.device.waterdetector?.hide_temperature) {
-      this.BLE_Celsius < 0 ? 0 : this.BLE_Celsius > 100 ? 100 : this.BLE_Celsius;
-      this.CurrentTemperature = this.BLE_Celsius;
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Temperature: ${this.CurrentTemperature}°c`);
-    }
+    // LeakDetected
+    this.LeakDetected = this.BLE_LeakDetected!;
+    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LeakDetected: ${this.LeakDetected}`);
   }
 
   async openAPIparseStatus(): Promise<void> {
     this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} openAPIparseStatus`);
-    // Battery
+    // StatusLowBattery
     this.BatteryLevel = Number(this.OpenAPI_BatteryLevel);
-    if (this.BatteryLevel < 15) {
+    if (this.BatteryLevel < 10) {
       this.StatusLowBattery = this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_LOW;
     } else {
       this.StatusLowBattery = this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL;
     }
     this.debugLog(`${this.accessory.displayName} BatteryLevel: ${this.BatteryLevel}, StatusLowBattery: ${this.StatusLowBattery}`);
 
-    // Current Relative Humidity
-    if (!this.device.waterdetector?.hide_humidity) {
-      this.CurrentRelativeHumidity = this.OpenAPI_CurrentRelativeHumidity!;
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Humidity: ${this.CurrentRelativeHumidity}%`);
-    }
-
-    // Current Temperature
-    if (!this.device.waterdetector?.hide_temperature) {
-      this.CurrentTemperature = this.OpenAPI_CurrentTemperature!;
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Temperature: ${this.CurrentTemperature}°c`);
-    }
-
     // BatteryLevel
-    this.BatteryLevel = Number(this.OpenAPI_BatteryLevel);
-    if (this.BatteryLevel < 10) {
-      this.StatusLowBattery = this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_LOW;
-    } else {
-      this.StatusLowBattery = this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL;
-    }
     if (Number.isNaN(this.BatteryLevel)) {
       this.BatteryLevel = 100;
     }
-    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BatteryLevel: ${this.BatteryLevel},`
-      + ` StatusLowBattery: ${this.StatusLowBattery}`);
+    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BatteryLevel: ${this.BatteryLevel}`);
+
+    // LeakDetected
+    this.LeakDetected = this.OpenAPI_LeakDetected!;
+    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LeakDetected: ${this.LeakDetected}`);
 
     // FirmwareRevision
     this.FirmwareRevision = this.OpenAPI_FirmwareRevision!;
@@ -347,18 +256,16 @@ export class WaterDetector {
     (async () => {
       // Start to monitor advertisement packets
       await switchbot.startScan({
-        model: 'w',
+        model: 'l',
         id: this.device.bleMac,
       });
       // Set an event handler
       switchbot.onadvertisement = (ad: any) => {
         this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} ${JSON.stringify(ad, null, '  ')}`);
         this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} address: ${ad.address}, model: ${ad.serviceData.model}`);
-        if (this.device.bleMac === ad.address && ad.serviceData.model === 'w') {
+        if (this.device.bleMac === ad.address && ad.serviceData.model === 'l') {
           this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} serviceData: ${JSON.stringify(ad.serviceData)}`);
-          this.BLE_CurrentTemperature = ad.serviceData.temperature;
-          this.BLE_Celsius = ad.serviceData.temperature!.c;
-          this.BLE_Fahrenheit = ad.serviceData.temperature!.f;
+          this.BLE_LeakDetected = ad.serviceData.status;
           this.BLE_BatteryLevel = ad.serviceData.battery;
         } else {
           this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} serviceData: ${JSON.stringify(ad.serviceData)}`);
@@ -372,69 +279,15 @@ export class WaterDetector {
       await this.BLEparseStatus();
       await this.updateHomeKitCharacteristics();
     })();
-    /*if (switchbot !== false) {
-      switchbot
-        .startScan({
-          model: 'w',
-          id: this.device.bleMac,
-        })
-        .then(async () => {
-          // Set an event handler
-          switchbot.onadvertisement = async (ad: ad) => {
-            this.debugLog(
-              `${this.device.deviceType}: ${this.accessory.displayName} Config BLE Address: ${this.device.bleMac},` +
-              ` BLE Address Found: ${ad.address}`,
-            );
-            if (ad.serviceData.humidity! > 0) {
-              // reject unreliable data
-              this.BLE_CurrentRelativeHumidity = ad.serviceData.humidity;
-            }
-            this.BLE_CurrentTemperature = ad.serviceData.temperature;
-            this.BLE_Celsius = ad.serviceData.temperature!.c;
-            this.BLE_Fahrenheit = ad.serviceData.temperature!.f;
-            this.BLE_BatteryLevel = ad.serviceData.battery;
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} serviceData: ${JSON.stringify(ad.serviceData)}`);
-            this.debugLog(
-              `${this.device.deviceType}: ${this.accessory.displayName} model: ${ad.serviceData.model}, modelName: ${ad.serviceData.modelName}, ` +
-              `temperature: ${JSON.stringify(ad.serviceData.temperature?.c)}, humidity: ${ad.serviceData.humidity}, ` +
-              `battery: ${ad.serviceData.battery}`,
-            );
-
-            if (ad.serviceData) {
-              this.BLE_IsConnected = true;
-              this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} connected: ${this.BLE_IsConnected}`);
-              await this.stopScanning(switchbot);
-            } else {
-              this.BLE_IsConnected = false;
-              this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} connected: ${this.BLE_IsConnected}`);
-            }
-          };
-          // Wait
-          return await sleep(this.scanDuration * 1000);
-        })
-        .then(async () => {
-          // Stop to monitor
-          await this.stopScanning(switchbot);
-        })
-        .catch(async (e: any) => {
-          this.apiError(e);
-          this.errorLog(
-            `${this.device.deviceType}: ${this.accessory.displayName} failed BLERefreshStatus with ${this.device.connectionType}` +
-            ` Connection, Error Message: ${JSON.stringify(e.message)}`,
-          );
-          await this.BLERefreshConnection(switchbot);
-        });
-    } else {
-      await this.BLERefreshConnection(switchbot);
-    }*/
   }
 
   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)}`);
@@ -442,8 +295,7 @@ export class WaterDetector {
       if ((statusCode === 200 || statusCode === 100) && (deviceStatus.statusCode === 200 || deviceStatus.statusCode === 100)) {
         this.debugErrorLog(`${this.device.deviceType}: ${this.accessory.displayName} `
           + `statusCode: ${statusCode} & deviceStatus StatusCode: ${deviceStatus.statusCode}`);
-        this.OpenAPI_CurrentRelativeHumidity = deviceStatus.body.humidity!;
-        this.OpenAPI_CurrentTemperature = deviceStatus.body.temperature!;
+        this.OpenAPI_LeakDetected = deviceStatus.body.status;
         this.OpenAPI_BatteryLevel = deviceStatus.body.battery;
         this.OpenAPI_FirmwareRevision = deviceStatus.body.version;
         this.openAPIparseStatus();
@@ -482,39 +334,6 @@ export class WaterDetector {
         this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic LeakDetected: ${this.LeakDetected}`);
       }
     }
-    if (!this.device.waterdetector?.hide_humidity) {
-      if (this.CurrentRelativeHumidity === undefined) {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} CurrentRelativeHumidity: ${this.CurrentRelativeHumidity}`);
-      } else {
-        this.accessory.context.CurrentRelativeHumidity = this.CurrentRelativeHumidity;
-        this.humidityservice?.updateCharacteristic(this.hap.Characteristic.CurrentRelativeHumidity, this.CurrentRelativeHumidity);
-        this.debugLog(
-          `${this.device.deviceType}: ${this.accessory.displayName}` +
-          ` updateCharacteristic CurrentRelativeHumidity: ${this.CurrentRelativeHumidity}`,
-        );
-        if (this.device.mqttURL) {
-          mqttmessage.push(`"humidity": ${this.CurrentRelativeHumidity}`);
-        }
-        if (this.device.history) {
-          entry['humidity'] = this.CurrentRelativeHumidity;
-        }
-      }
-    }
-    if (!this.device.waterdetector?.hide_temperature) {
-      if (this.CurrentTemperature === undefined) {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} CurrentTemperature: ${this.CurrentTemperature}`);
-      } else {
-        if (this.device.mqttURL) {
-          mqttmessage.push(`"temperature": ${this.CurrentTemperature}`);
-        }
-        if (this.device.history) {
-          entry['temp'] = this.CurrentTemperature;
-        }
-        this.accessory.context.CurrentTemperature = this.CurrentTemperature;
-        this.temperatureservice?.updateCharacteristic(this.hap.Characteristic.CurrentTemperature, this.CurrentTemperature);
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic CurrentTemperature: ${this.CurrentTemperature}`);
-      }
-    }
     if (this.BatteryLevel === undefined) {
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BatteryLevel: ${this.BatteryLevel}`);
     } else {
@@ -538,7 +357,7 @@ export class WaterDetector {
     if (this.device.mqttURL) {
       this.mqttPublish(`{${mqttmessage.join(',')}}`);
     }
-    if (Number(this.CurrentRelativeHumidity) > 0) {
+    if (Number(this.LeakDetected) > 0) {
       // reject unreliable data
       if (this.device.history) {
         this.historyService?.addEntry(entry);
@@ -736,26 +555,15 @@ export class WaterDetector {
     if (!this.device.waterdetector?.hide_leak) {
       this.leakService?.updateCharacteristic(this.hap.Characteristic.LeakDetected, e);
     }
-    if (!this.device.waterdetector?.hide_humidity) {
-      this.humidityservice?.updateCharacteristic(this.hap.Characteristic.CurrentRelativeHumidity, e);
-    }
-    if (!this.device.waterdetector?.hide_temperature) {
-      this.temperatureservice?.updateCharacteristic(this.hap.Characteristic.CurrentTemperature, e);
-    }
     this.batteryService?.updateCharacteristic(this.hap.Characteristic.BatteryLevel, e);
     this.batteryService?.updateCharacteristic(this.hap.Characteristic.StatusLowBattery, e);
   }
 
   async deviceContext() {
-    if (this.CurrentRelativeHumidity === undefined) {
-      this.CurrentRelativeHumidity = 0;
-    } else {
-      this.CurrentRelativeHumidity = this.accessory.context.CurrentRelativeHumidity;
-    }
-    if (this.CurrentTemperature === undefined) {
-      this.CurrentTemperature = 0;
+    if (this.LeakDetected === undefined) {
+      this.LeakDetected = 0;
     } else {
-      this.CurrentTemperature = this.accessory.context.CurrentTemperature;
+      this.LeakDetected = this.accessory.context.LeakDetected;
     }
     if (this.BatteryLevel === undefined) {
       this.BatteryLevel = 100;
@@ -784,6 +592,23 @@ export class WaterDetector {
     }
   }
 
+  async deviceRetry(device: device & devicesConfig): Promise<void> {
+    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) {
+      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 * 1000;
+      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.waterdetector) {
@@ -834,6 +659,12 @@ export class WaterDetector {
   /**
    * Logging for Device
    */
+  successLog(...log: any[]): void {
+    if (this.enablingDeviceLogging()) {
+      this.platform.log.success(String(...log));
+    }
+  }
+
   infoLog(...log: any[]): void {
     if (this.enablingDeviceLogging()) {
       this.platform.log.info(String(...log));

package/src/index.ts

@@ -1,4 +1,4 @@
-/* Copyright(C) 2021-2023, SwitchBot (https://github.com/SwitchBot). All rights reserved.
+/* Copyright(C) 2021-2024, SwitchBot (https://github.com/SwitchBot). All rights reserved.
  *
  * index.ts: @switchbot/homebridge-switchbot plugin registration.
  */

package/src/irdevice/airconditioner.ts

@@ -275,6 +275,7 @@ export class AirConditioner {
         if ((statusCode === 200 || statusCode === 100) && (deviceStatus.statusCode === 200 || deviceStatus.statusCode === 100)) {
           this.debugErrorLog(`${this.device.remoteType}: ${this.accessory.displayName} `
             + `statusCode: ${statusCode} & deviceStatus StatusCode: ${deviceStatus.statusCode}`);
+          this.successLog(`${this.device.remoteType}: ${this.accessory.displayName} request to SwitchBot API, body: ${bodyChange} sent successfully`);
           this.updateHomeKitCharacteristics();
         } else {
           this.statusCode(statusCode);
@@ -799,6 +800,12 @@ export class AirConditioner {
   /**
    * Logging for Device
    */
+  successLog(...log: any[]): void {
+    if (this.enablingDeviceLogging()) {
+      this.platform.log.success(String(...log));
+    }
+  }
+
   infoLog(...log: any[]): void {
     if (this.enablingDeviceLogging()) {
       this.platform.log.info(String(...log));