@switchbot/homebridge-switchbot 3.5.0-beta.27 → 3.5.0-beta.29

package/src/device/waterdetector.ts

@@ -101,18 +101,20 @@ export class WaterDetector extends deviceBase {
       });
 
     //regisiter webhook event handler
-    if (this.device.webhook && !this.device.waterdetector?.hide_leak) {
-      this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} is listening webhook.`);
+    if (device.webhook && !this.device.waterdetector?.hide_leak) {
+      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} is listening webhook.`);
       this.platform.webhookEventHandler[this.device.deviceId] = async (context) => {
         try {
           this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} received Webhook: ${JSON.stringify(context)}`);
-          const { status } = context;
+          const { detectionState, battery } = context;
           const { LeakDetected } = this.LeakSensor!;
+          const { BatteryLevel } = this.Battery!;
           this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} ` +
-            '(status) = ' +
-            `Webhook:(${status}), ` +
-            `current:(${LeakDetected})`);
-          this.LeakSensor!.LeakDetected = status;
+            '(detectionState, battery) = ' +
+            `Webhook:(${detectionState}, ${battery}), ` +
+            `current:(${LeakDetected}, ${BatteryLevel})`);
+          this.LeakSensor!.LeakDetected = detectionState;
+          this.Battery!.BatteryLevel = battery;
           this.updateHomeKitCharacteristics();
         } catch (e: any) {
           this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} `
@@ -165,6 +167,11 @@ export class WaterDetector extends deviceBase {
 
     // FirmwareRevision
     this.accessory.context.FirmwareRevision = deviceStatus.body.version;
+    this.accessory
+      .getService(this.hap.Service.AccessoryInformation)!
+      .setCharacteristic(this.hap.Characteristic.FirmwareRevision, this.accessory.context.FirmwareRevision)
+      .getCharacteristic(this.hap.Characteristic.FirmwareRevision)
+      .updateValue(this.accessory.context.FirmwareRevision);
   }
 
   async refreshStatus(): Promise<void> {
@@ -230,7 +237,7 @@ export class WaterDetector extends deviceBase {
       this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} deviceStatus: ${JSON.stringify(deviceStatus)}`);
       this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} deviceStatus statusCode: ${deviceStatus.statusCode}`);
       if ((statusCode === 200 || statusCode === 100) && (deviceStatus.statusCode === 200 || deviceStatus.statusCode === 100)) {
-        this.debugErrorLog(`${this.device.deviceType}: ${this.accessory.displayName} `
+        this.debugSuccessLog(`${this.device.deviceType}: ${this.accessory.displayName} `
           + `statusCode: ${statusCode} & deviceStatus StatusCode: ${deviceStatus.statusCode}`);
         this.openAPIparseStatus(deviceStatus);
         this.updateHomeKitCharacteristics();

package/src/irdevice/airconditioner.ts

@@ -346,9 +346,10 @@ export class AirConditioner extends irdeviceBase {
         this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} deviceStatus: ${JSON.stringify(deviceStatus)}`);
         this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} deviceStatus statusCode: ${deviceStatus.statusCode}`);
         if ((statusCode === 200 || statusCode === 100) && (deviceStatus.statusCode === 200 || deviceStatus.statusCode === 100)) {
-          this.debugErrorLog(`${this.device.remoteType}: ${this.accessory.displayName} `
+          this.debugSuccessLog(`${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.successLog(`${this.device.remoteType}: ${this.accessory.displayName}`
+            + ` request to SwitchBot API, body: ${JSON.stringify(bodyChange)} sent successfully`);
           this.updateHomeKitCharacteristics();
         } else {
           this.statusCode(statusCode);
@@ -616,7 +617,7 @@ export class AirConditioner extends irdeviceBase {
       this.accessory.context.RotationSpeed = this.HeaterCooler.RotationSpeed;
       this.HeaterCooler.Service?.updateCharacteristic(this.hap.Characteristic.RotationSpeed, this.HeaterCooler.RotationSpeed);
       this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic`
-      + ` RotationSpeed: ${this.HeaterCooler.RotationSpeed}`);
+        + ` RotationSpeed: ${this.HeaterCooler.RotationSpeed}`);
     }
     // CurrentTemperature
     if (this.HeaterCooler.CurrentTemperature === undefined) {
@@ -654,7 +655,7 @@ export class AirConditioner extends irdeviceBase {
     // CurrentHeaterCoolerState
     if (this.HeaterCooler.CurrentHeaterCoolerState === undefined) {
       this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}`
-      + ` CurrentHeaterCoolerState: ${this.HeaterCooler.CurrentHeaterCoolerState}`);
+        + ` CurrentHeaterCoolerState: ${this.HeaterCooler.CurrentHeaterCoolerState}`);
     } else {
       this.accessory.context.CurrentHeaterCoolerState = this.HeaterCooler.CurrentHeaterCoolerState;
       this.HeaterCooler.Service?.updateCharacteristic(this.hap.Characteristic.CurrentHeaterCoolerState, this.HeaterCooler.CurrentHeaterCoolerState);

package/src/irdevice/airpurifier.ts

@@ -222,9 +222,10 @@ export class AirPurifier extends irdeviceBase {
         this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} deviceStatus: ${JSON.stringify(deviceStatus)}`);
         this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} deviceStatus statusCode: ${deviceStatus.statusCode}`);
         if ((statusCode === 200 || statusCode === 100) && (deviceStatus.statusCode === 200 || deviceStatus.statusCode === 100)) {
-          this.debugErrorLog(`${this.device.remoteType}: ${this.accessory.displayName} `
+          this.debugSuccessLog(`${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.successLog(`${this.device.remoteType}: ${this.accessory.displayName}`
+            + ` request to SwitchBot API, body: ${JSON.stringify(bodyChange)} sent successfully`);
           this.updateHomeKitCharacteristics();
         } else {
           this.statusCode(statusCode);
@@ -261,7 +262,7 @@ export class AirPurifier extends irdeviceBase {
       this.accessory.context.CurrentAirPurifierState = this.AirPurifier.CurrentAirPurifierState;
       this.AirPurifier.Service.updateCharacteristic(this.hap.Characteristic.CurrentAirPurifierState, this.AirPurifier.CurrentAirPurifierState);
       this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic`
-      + ` CurrentAirPurifierState: ${this.AirPurifier.CurrentAirPurifierState}`);
+        + ` CurrentAirPurifierState: ${this.AirPurifier.CurrentAirPurifierState}`);
     }
     // CurrentHeaterCoolerState
     if (this.CurrentHeaterCoolerState === undefined) {
@@ -281,7 +282,7 @@ export class AirPurifier extends irdeviceBase {
       this.accessory.context.CurrentTemperature = this.TemperatureSensor.CurrentTemperature;
       this.TemperatureSensor.Service.updateCharacteristic(this.hap.Characteristic.CurrentTemperature, this.TemperatureSensor.CurrentTemperature);
       this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic`
-      + ` CurrentTemperature: ${this.TemperatureSensor.CurrentTemperature}`);
+        + ` CurrentTemperature: ${this.TemperatureSensor.CurrentTemperature}`);
     }
   }
 

package/src/irdevice/camera.ts

@@ -68,7 +68,7 @@ export class Camera extends irdeviceBase {
    */
   async pushOnChanges(): Promise<void> {
     this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushOnChanges On: ${this.Switch.On},`
-    + ` disablePushOn: ${this.disablePushOn}`);
+      + ` disablePushOn: ${this.disablePushOn}`);
     if (this.Switch.On && !this.disablePushOn) {
       const commandType: string = await this.commandType();
       const command: string = await this.commandOn();
@@ -112,9 +112,10 @@ export class Camera extends irdeviceBase {
         this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} deviceStatus: ${JSON.stringify(deviceStatus)}`);
         this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} deviceStatus statusCode: ${deviceStatus.statusCode}`);
         if ((statusCode === 200 || statusCode === 100) && (deviceStatus.statusCode === 200 || deviceStatus.statusCode === 100)) {
-          this.debugErrorLog(`${this.device.remoteType}: ${this.accessory.displayName} `
+          this.debugSuccessLog(`${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.successLog(`${this.device.remoteType}: ${this.accessory.displayName}`
+            + ` request to SwitchBot API, body: ${JSON.stringify(bodyChange)} sent successfully`);
           this.updateHomeKitCharacteristics();
         } else {
           this.statusCode(statusCode);

package/src/irdevice/fan.ts

@@ -13,7 +13,7 @@ import { CharacteristicValue, PlatformAccessory, Service } from 'homebridge';
  * An instance of this class is created for each accessory your platform registers
  * Each accessory may expose multiple services of different service types.
  */
-export class Fan extends irdeviceBase {
+export class IRFan extends irdeviceBase {
   // Services
   private Fan: {
     Service: Service;
@@ -231,9 +231,10 @@ export class Fan extends irdeviceBase {
         this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} deviceStatus: ${JSON.stringify(deviceStatus)}`);
         this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} deviceStatus statusCode: ${deviceStatus.statusCode}`);
         if ((statusCode === 200 || statusCode === 100) && (deviceStatus.statusCode === 200 || deviceStatus.statusCode === 100)) {
-          this.debugErrorLog(`${this.device.remoteType}: ${this.accessory.displayName} `
+          this.debugSuccessLog(`${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.successLog(`${this.device.remoteType}: ${this.accessory.displayName}`
+            + ` request to SwitchBot API, body: ${JSON.stringify(bodyChange)} sent successfully`);
           this.updateHomeKitCharacteristics();
         } else {
           this.statusCode(statusCode);

package/src/irdevice/irdevice.ts

@@ -455,22 +455,30 @@ export abstract class irdeviceBase {
         break;
       default:
         this.infoLog(`${this.device.remoteType}: ${this.accessory.displayName} Unknown statusCode: `
-        + `${statusCode}, Submit Bugs Here: ' + 'https://tinyurl.com/SwitchBotBug`);
+          + `${statusCode}, Submit Bugs Here: ' + 'https://tinyurl.com/SwitchBotBug`);
     }
   }
 
   /**
    * Logging for Device
    */
+  infoLog(...log: any[]): void {
+    if (this.enablingDeviceLogging()) {
+      this.log.info(String(...log));
+    }
+  }
+
   successLog(...log: any[]): void {
     if (this.enablingDeviceLogging()) {
       this.platform.log.success(String(...log));
     }
   }
 
-  infoLog(...log: any[]): void {
+  debugSuccessLog(...log: any[]): void {
     if (this.enablingDeviceLogging()) {
-      this.log.info(String(...log));
+      if (this.deviceLogging?.includes('debug')) {
+        this.log.success('[DEBUG]', String(...log));
+      }
     }
   }
 

package/src/irdevice/light.ts

@@ -223,9 +223,10 @@ export class Light extends irdeviceBase {
         this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} deviceStatus: ${JSON.stringify(deviceStatus)}`);
         this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} deviceStatus statusCode: ${deviceStatus.statusCode}`);
         if ((statusCode === 200 || statusCode === 100) && (deviceStatus.statusCode === 200 || deviceStatus.statusCode === 100)) {
-          this.debugErrorLog(`${this.device.remoteType}: ${this.accessory.displayName} `
+          this.debugSuccessLog(`${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.successLog(`${this.device.remoteType}: ${this.accessory.displayName}`
+            + ` request to SwitchBot API, body: ${JSON.stringify(bodyChange)} sent successfully`);
           this.accessory.context.On = this.On;
           this.updateHomeKitCharacteristics();
         } else {

package/src/irdevice/other.ts

@@ -440,7 +440,7 @@ export class Others extends irdeviceBase {
    */
   async pushOnChanges(On: boolean): Promise<void> {
     this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushOnChanges On: ${On},`
-      +` disablePushOn: ${this.disablePushOn}, customize: ${this.device.customize}, customOn: ${this.device.customOn}`);
+      + ` disablePushOn: ${this.disablePushOn}, customize: ${this.device.customize}, customOn: ${this.device.customOn}`);
     if (this.device.customize) {
       if (On === true && !this.disablePushOn) {
         const commandType: string = await this.commandType();
@@ -491,9 +491,10 @@ export class Others extends irdeviceBase {
         this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} deviceStatus: ${JSON.stringify(deviceStatus)}`);
         this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} deviceStatus statusCode: ${deviceStatus.statusCode}`);
         if ((statusCode === 200 || statusCode === 100) && (deviceStatus.statusCode === 200 || deviceStatus.statusCode === 100)) {
-          this.debugErrorLog(`${this.device.remoteType}: ${this.accessory.displayName} `
+          this.debugSuccessLog(`${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.successLog(`${this.device.remoteType}: ${this.accessory.displayName}`
+            + ` request to SwitchBot API, body: ${JSON.stringify(bodyChange)} sent successfully`);
           this.updateHomeKitCharacteristics();
         } else {
           this.statusCode(statusCode);
@@ -502,11 +503,11 @@ export class Others extends irdeviceBase {
       } catch (e: any) {
         this.apiError(e);
         this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} failed pushChanges with ${this.device.connectionType}`
-        + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
+          + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
       }
     } else {
       this.warnLog(`${this.device.remoteType}: ${this.accessory.displayName}`
-      + ` Connection Type: ${this.device.connectionType}, commands will not be sent to OpenAPI`);
+        + ` Connection Type: ${this.device.connectionType}, commands will not be sent to OpenAPI`);
     }
   }
 
@@ -519,12 +520,12 @@ export class Others extends irdeviceBase {
           this.GarageDoor!.Service.updateCharacteristic(this.hap.Characteristic.TargetDoorState, this.hap.Characteristic.TargetDoorState.OPEN);
           this.GarageDoor!.Service.updateCharacteristic(this.hap.Characteristic.CurrentDoorState, this.hap.Characteristic.CurrentDoorState.OPEN);
           this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic`
-          + ` TargetDoorState: Open, CurrentDoorState: Open (${this.GarageDoor!.On})`);
+            + ` TargetDoorState: Open, CurrentDoorState: Open (${this.GarageDoor!.On})`);
         } else {
           this.GarageDoor!.Service.updateCharacteristic(this.hap.Characteristic.TargetDoorState, this.hap.Characteristic.TargetDoorState.CLOSED);
           this.GarageDoor!.Service.updateCharacteristic(this.hap.Characteristic.CurrentDoorState, this.hap.Characteristic.CurrentDoorState.CLOSED);
           this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic`
-          + ` TargetDoorState: Closed, CurrentDoorState: Closed (${this.GarageDoor!.On})`);
+            + ` TargetDoorState: Closed, CurrentDoorState: Closed (${this.GarageDoor!.On})`);
         }
       }
       this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Garage Door On: ${this.GarageDoor!.On}`);
@@ -537,13 +538,13 @@ export class Others extends irdeviceBase {
           this.Door!.Service.updateCharacteristic(this.hap.Characteristic.CurrentPosition, 100);
           this.Door!.Service.updateCharacteristic(this.hap.Characteristic.PositionState, this.hap.Characteristic.PositionState.STOPPED);
           this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic`
-          + ` TargetPosition: 100, CurrentPosition: 100 (${this.Door!.On})`);
+            + ` TargetPosition: 100, CurrentPosition: 100 (${this.Door!.On})`);
         } else {
           this.Door!.Service.updateCharacteristic(this.hap.Characteristic.TargetPosition, 0);
           this.Door!.Service.updateCharacteristic(this.hap.Characteristic.CurrentPosition, 0);
           this.Door!.Service.updateCharacteristic(this.hap.Characteristic.PositionState, this.hap.Characteristic.PositionState.STOPPED);
           this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic`
-          + ` TargetPosition: 0, CurrentPosition: 0 (${this.Door!.On})`);
+            + ` TargetPosition: 0, CurrentPosition: 0 (${this.Door!.On})`);
         }
       }
       this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Door On: ${this.Door!.On}`);
@@ -556,13 +557,13 @@ export class Others extends irdeviceBase {
           this.Window!.Service.updateCharacteristic(this.hap.Characteristic.CurrentPosition, 100);
           this.Window!.Service.updateCharacteristic(this.hap.Characteristic.PositionState, this.hap.Characteristic.PositionState.STOPPED);
           this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic`
-          + ` TargetPosition: 100, CurrentPosition: 100 (${this.Window!.On})`);
+            + ` TargetPosition: 100, CurrentPosition: 100 (${this.Window!.On})`);
         } else {
           this.Window!.Service.updateCharacteristic(this.hap.Characteristic.TargetPosition, 0);
           this.Window!.Service.updateCharacteristic(this.hap.Characteristic.CurrentPosition, 0);
           this.Window!.Service.updateCharacteristic(this.hap.Characteristic.PositionState, this.hap.Characteristic.PositionState.STOPPED);
           this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic`
-          + ` TargetPosition: 0, CurrentPosition: 0 (${this.Window!.On})`);
+            + ` TargetPosition: 0, CurrentPosition: 0 (${this.Window!.On})`);
         }
       }
       this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Window On: ${this.Window!.On}`);
@@ -575,13 +576,13 @@ export class Others extends irdeviceBase {
           this.WindowCovering!.Service.updateCharacteristic(this.hap.Characteristic.CurrentPosition, 100);
           this.WindowCovering!.Service.updateCharacteristic(this.hap.Characteristic.PositionState, this.hap.Characteristic.PositionState.STOPPED);
           this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic`
-          + ` TargetPosition: 100, CurrentPosition: 100 (${this.WindowCovering!.On})`);
+            + ` TargetPosition: 100, CurrentPosition: 100 (${this.WindowCovering!.On})`);
         } else {
           this.WindowCovering!.Service.updateCharacteristic(this.hap.Characteristic.TargetPosition, 0);
           this.WindowCovering!.Service.updateCharacteristic(this.hap.Characteristic.CurrentPosition, 0);
           this.WindowCovering!.Service.updateCharacteristic(this.hap.Characteristic.PositionState, this.hap.Characteristic.PositionState.STOPPED);
           this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic`
-          + ` TargetPosition: 0, CurrentPosition: 0 (${this.WindowCovering!.On})`);
+            + ` TargetPosition: 0, CurrentPosition: 0 (${this.WindowCovering!.On})`);
         }
       }
       this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Window Covering On: ${this.WindowCovering!.On}`);
@@ -593,7 +594,7 @@ export class Others extends irdeviceBase {
           this.Lock!.Service.updateCharacteristic(this.hap.Characteristic.LockTargetState, this.hap.Characteristic.LockTargetState.UNSECURED);
           this.Lock!.Service.updateCharacteristic(this.hap.Characteristic.LockCurrentState, this.hap.Characteristic.LockCurrentState.UNSECURED);
           this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic`
-          + ` LockTargetState: UNSECURED, LockCurrentState: UNSECURE (${this.Lock!.On})`);
+            + ` LockTargetState: UNSECURED, LockCurrentState: UNSECURE (${this.Lock!.On})`);
         } else {
           this.Lock!.Service.updateCharacteristic(this.hap.Characteristic.LockTargetState, this.hap.Characteristic.LockTargetState.SECURED);
           this.Lock!.Service.updateCharacteristic(this.hap.Characteristic.LockCurrentState, this.hap.Characteristic.LockCurrentState.SECURED);
@@ -637,13 +638,13 @@ export class Others extends irdeviceBase {
             this.hap.Characteristic.ProgrammableSwitchEvent.SINGLE_PRESS);
           this.StatefulProgrammableSwitch!.Service.updateCharacteristic(this.hap.Characteristic.ProgrammableSwitchOutputState, 1);
           this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic`
-          + ` ProgrammableSwitchEvent: SINGLE, ProgrammableSwitchOutputState: 1 (${this.StatefulProgrammableSwitch!.On})`);
+            + ` ProgrammableSwitchEvent: SINGLE, ProgrammableSwitchOutputState: 1 (${this.StatefulProgrammableSwitch!.On})`);
         } else {
           this.StatefulProgrammableSwitch!.Service.updateCharacteristic(this.hap.Characteristic.ProgrammableSwitchEvent,
             this.hap.Characteristic.ProgrammableSwitchEvent.SINGLE_PRESS);
           this.StatefulProgrammableSwitch!.Service.updateCharacteristic(this.hap.Characteristic.ProgrammableSwitchOutputState, 0);
           this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic`
-          + ` ProgrammableSwitchEvent: SINGLE, ProgrammableSwitchOutputState: 0 (${this.StatefulProgrammableSwitch!.On})`);
+            + ` ProgrammableSwitchEvent: SINGLE, ProgrammableSwitchOutputState: 0 (${this.StatefulProgrammableSwitch!.On})`);
         }
       }
       this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} StatefulProgrammableSwitch On: ${this.StatefulProgrammableSwitch!.On}`);
@@ -701,90 +702,90 @@ export class Others extends irdeviceBase {
   async removeOutletService(accessory: PlatformAccessory): Promise<void> {
     // If Outlet.Service still present, then remove first
     if (this.Outlet?.Service) {
-    this.Outlet!.Service = this.accessory.getService(this.hap.Service.Outlet) as Service;
-    this.warnLog(`${this.device.remoteType}: ${accessory.displayName} Removing Leftover Outlet Service`);
-    accessory.removeService(this.Outlet!.Service);
+      this.Outlet!.Service = this.accessory.getService(this.hap.Service.Outlet) as Service;
+      this.warnLog(`${this.device.remoteType}: ${accessory.displayName} Removing Leftover Outlet Service`);
+      accessory.removeService(this.Outlet!.Service);
     }
   }
 
   async removeGarageDoorService(accessory: PlatformAccessory): Promise<void> {
     // If GarageDoor.Service still present, then remove first
     if (this.GarageDoor?.Service) {
-    this.GarageDoor!.Service = this.accessory.getService(this.hap.Service.GarageDoorOpener) as Service;
-    this.warnLog(`${this.device.remoteType}: ${accessory.displayName} Removing Leftover Garage Door Service`);
-    accessory.removeService(this.GarageDoor!.Service);
+      this.GarageDoor!.Service = this.accessory.getService(this.hap.Service.GarageDoorOpener) as Service;
+      this.warnLog(`${this.device.remoteType}: ${accessory.displayName} Removing Leftover Garage Door Service`);
+      accessory.removeService(this.GarageDoor!.Service);
     }
   }
 
   async removeDoorService(accessory: PlatformAccessory): Promise<void> {
     // If Door.Service still present, then remove first
     if (this.Door?.Service) {
-    this.Door!.Service = this.accessory.getService(this.hap.Service.Door) as Service;
-    this.warnLog(`${this.device.remoteType}: ${accessory.displayName} Removing Leftover Door Service`);
-    accessory.removeService(this.Door!.Service);
+      this.Door!.Service = this.accessory.getService(this.hap.Service.Door) as Service;
+      this.warnLog(`${this.device.remoteType}: ${accessory.displayName} Removing Leftover Door Service`);
+      accessory.removeService(this.Door!.Service);
     }
   }
 
   async removeLockService(accessory: PlatformAccessory): Promise<void> {
     // If Lock.Service still present, then remove first
     if (this.Lock?.Service) {
-    this.Lock!.Service = this.accessory.getService(this.hap.Service.LockMechanism) as Service;
-    this.warnLog(`${this.device.remoteType}: ${accessory.displayName} Removing Leftover Lock Service`);
-    accessory.removeService(this.Lock!.Service);
+      this.Lock!.Service = this.accessory.getService(this.hap.Service.LockMechanism) as Service;
+      this.warnLog(`${this.device.remoteType}: ${accessory.displayName} Removing Leftover Lock Service`);
+      accessory.removeService(this.Lock!.Service);
     }
   }
 
   async removeFaucetService(accessory: PlatformAccessory): Promise<void> {
     // If Faucet.Service still present, then remove first
     if (this.Faucet?.Service) {
-    this.Faucet!.Service = this.accessory.getService(this.hap.Service.Faucet) as Service;
-    this.warnLog(`${this.device.remoteType}: ${accessory.displayName} Removing Leftover Faucet Service`);
-    accessory.removeService(this.Faucet!.Service);
+      this.Faucet!.Service = this.accessory.getService(this.hap.Service.Faucet) as Service;
+      this.warnLog(`${this.device.remoteType}: ${accessory.displayName} Removing Leftover Faucet Service`);
+      accessory.removeService(this.Faucet!.Service);
     }
   }
 
   async removeFanService(accessory: PlatformAccessory): Promise<void> {
     // If Fan Service still present, then remove first
     if (this.Fan?.Service) {
-    this.Fan!.Service = this.accessory.getService(this.hap.Service.Fan) as Service;
-    this.warnLog(`${this.device.remoteType}: ${accessory.displayName} Removing Leftover Fan Service`);
-    accessory.removeService(this.Fan!.Service);
+      this.Fan!.Service = this.accessory.getService(this.hap.Service.Fan) as Service;
+      this.warnLog(`${this.device.remoteType}: ${accessory.displayName} Removing Leftover Fan Service`);
+      accessory.removeService(this.Fan!.Service);
     }
   }
 
   async removeWindowService(accessory: PlatformAccessory): Promise<void> {
     // If Window.Service still present, then remove first
     if (this.Window?.Service) {
-    this.Window!.Service = this.accessory.getService(this.hap.Service.Window) as Service;
-    this.warnLog(`${this.device.remoteType}: ${accessory.displayName} Removing Leftover Window Service`);
-    accessory.removeService(this.Window!.Service);
+      this.Window!.Service = this.accessory.getService(this.hap.Service.Window) as Service;
+      this.warnLog(`${this.device.remoteType}: ${accessory.displayName} Removing Leftover Window Service`);
+      accessory.removeService(this.Window!.Service);
     }
   }
 
   async removeWindowCoveringService(accessory: PlatformAccessory): Promise<void> {
     // If WindowCovering.Service still present, then remove first
     if (this.WindowCovering?.Service) {
-    this.WindowCovering!.Service = this.accessory.getService(this.hap.Service.WindowCovering) as Service;
-    this.warnLog(`${this.device.remoteType}: ${accessory.displayName} Removing Leftover Window Covering Service`);
-    accessory.removeService(this.WindowCovering!.Service);
+      this.WindowCovering!.Service = this.accessory.getService(this.hap.Service.WindowCovering) as Service;
+      this.warnLog(`${this.device.remoteType}: ${accessory.displayName} Removing Leftover Window Covering Service`);
+      accessory.removeService(this.WindowCovering!.Service);
     }
   }
 
   async removeStatefulProgrammableSwitchService(accessory: PlatformAccessory): Promise<void> {
     // If StatefulProgrammableSwitch.Service still present, then remove first
     if (this.StatefulProgrammableSwitch?.Service) {
-    this.StatefulProgrammableSwitch!.Service = this.accessory.getService(this.hap.Service.StatefulProgrammableSwitch) as Service;
-    this.warnLog(`${this.device.remoteType}: ${accessory.displayName} Removing Leftover Stateful Programmable Switch Service`);
-    accessory.removeService(this.StatefulProgrammableSwitch!.Service);
+      this.StatefulProgrammableSwitch!.Service = this.accessory.getService(this.hap.Service.StatefulProgrammableSwitch) as Service;
+      this.warnLog(`${this.device.remoteType}: ${accessory.displayName} Removing Leftover Stateful Programmable Switch Service`);
+      accessory.removeService(this.StatefulProgrammableSwitch!.Service);
     }
   }
 
   async removeSwitchService(accessory: PlatformAccessory): Promise<void> {
     // If Switch.Service still present, then remove first
     if (this.Switch?.Service) {
-    this.Switch!.Service = this.accessory.getService(this.hap.Service.Switch) as Service;
-    this.warnLog(`${this.device.remoteType}: ${accessory.displayName} Removing Leftover Switch Service`);
-    accessory.removeService(this.Switch!.Service);
+      this.Switch!.Service = this.accessory.getService(this.hap.Service.Switch) as Service;
+      this.warnLog(`${this.device.remoteType}: ${accessory.displayName} Removing Leftover Switch Service`);
+      accessory.removeService(this.Switch!.Service);
     }
   }
 

package/src/irdevice/tv.ts

@@ -388,9 +388,10 @@ export class TV extends irdeviceBase {
         this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} deviceStatus: ${JSON.stringify(deviceStatus)}`);
         this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} deviceStatus statusCode: ${deviceStatus.statusCode}`);
         if ((statusCode === 200 || statusCode === 100) && (deviceStatus.statusCode === 200 || deviceStatus.statusCode === 100)) {
-          this.debugErrorLog(`${this.device.remoteType}: ${this.accessory.displayName} `
+          this.debugSuccessLog(`${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.successLog(`${this.device.remoteType}: ${this.accessory.displayName}`
+            + ` request to SwitchBot API, body: ${JSON.stringify(bodyChange)} sent successfully`);
           this.updateHomeKitCharacteristics();
         } else {
           this.statusCode(statusCode);

package/src/irdevice/vacuumcleaner.ts

@@ -107,9 +107,10 @@ export class VacuumCleaner extends irdeviceBase {
         this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} deviceStatus: ${JSON.stringify(deviceStatus)}`);
         this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} deviceStatus statusCode: ${deviceStatus.statusCode}`);
         if ((statusCode === 200 || statusCode === 100) && (deviceStatus.statusCode === 200 || deviceStatus.statusCode === 100)) {
-          this.debugErrorLog(`${this.device.remoteType}: ${this.accessory.displayName} `
+          this.debugSuccessLog(`${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.successLog(`${this.device.remoteType}: ${this.accessory.displayName}`
+            + ` request to SwitchBot API, body: ${JSON.stringify(bodyChange)} sent successfully`);
           this.updateHomeKitCharacteristics();
         } else {
           this.statusCode(statusCode);

package/src/irdevice/waterheater.ts

@@ -112,9 +112,10 @@ export class WaterHeater extends irdeviceBase {
         this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} deviceStatus: ${JSON.stringify(deviceStatus)}`);
         this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} deviceStatus statusCode: ${deviceStatus.statusCode}`);
         if ((statusCode === 200 || statusCode === 100) && (deviceStatus.statusCode === 200 || deviceStatus.statusCode === 100)) {
-          this.debugErrorLog(`${this.device.remoteType}: ${this.accessory.displayName} `
+          this.debugSuccessLog(`${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.successLog(`${this.device.remoteType}: ${this.accessory.displayName}`
+            + ` request to SwitchBot API, body: ${JSON.stringify(bodyChange)} sent successfully`);
           this.updateHomeKitCharacteristics();
         } else {
           this.statusCode(statusCode);

package/src/platform.ts

@@ -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';
@@ -727,6 +728,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       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;
@@ -747,6 +749,10 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       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
@@ -782,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':
@@ -1814,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}`);
 
@@ -1926,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
@@ -1949,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);
@@ -1975,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