@switchbot/homebridge-switchbot 1.6.4-beta.5 → 1.7.1-beta.10

package/src/devices/bots.ts

@@ -4,7 +4,7 @@ import { interval, Subject } from 'rxjs';
 import { SwitchBotPlatform } from '../platform';
 import { debounceTime, skipWhile, take, tap } from 'rxjs/operators';
 import { Service, PlatformAccessory, CharacteristicValue } from 'homebridge';
-import { DeviceURL, device, devicesConfig, serviceData, ad, switchbot, deviceStatusResponse, payload } from '../settings';
+import { DeviceURL, device, devicesConfig, serviceData, ad, switchbot, deviceStatusResponse, payload, deviceStatus } from '../settings';
 
 /**
  * Platform Accessory
@@ -13,12 +13,17 @@ import { DeviceURL, device, devicesConfig, serviceData, ad, switchbot, deviceSta
  */
 export class Bot {
   // Services
-  private switchService?: Service;
+  private fanService?: Service;
   private doorService?: Service;
   private lockService?: Service;
-  private garageDoorService?: Service;
+  private faucetService?: Service;
+  private windowService?: Service;
+  private switchService?: Service;
   private outletService?: Service;
   private batteryService?: Service;
+  private garageDoorService?: Service;
+  private windowCoveringService?: Service;
+  private statefulProgrammableSwitchService?: Service;
 
 
   // Characteristic Values
@@ -28,11 +33,13 @@ export class Bot {
   StatusLowBattery!: CharacteristicValue;
 
   // OpenAPI Others
+  power: deviceStatus['power'];
   deviceStatus!: deviceStatusResponse;
 
   // BLE Others
   connected?: boolean;
   switchbot!: switchbot;
+  SwitchToOpenAPI?: boolean;
   serviceData!: serviceData;
   mode!: serviceData['mode'];
   state!: serviceData['state'];
@@ -61,7 +68,7 @@ export class Bot {
     this.scan();
     this.refreshRate();
     this.PressOrSwitch();
-
+    this.config(device);
     if (this.On === undefined) {
       this.On = false;
       this.accessory.context.On = this.On;
@@ -77,10 +84,6 @@ export class Bot {
     this.BatteryLevel = 100;
     this.StatusLowBattery = 0;
 
-    // Bot Config
-    this.debugLog(`Bot: ${this.accessory.displayName} Config: (ble: ${device.ble}, offline: ${device.offline}, mode: ${device.bot?.mode},`
-      + ` deviceType: ${device.bot?.deviceType}, doublePress: ${this.doublePress})`);
-
     // this is subject we use to track when we need to POST changes to the SwitchBot API
     this.doBotUpdate = new Subject();
     this.botUpdateInProgress = false;
@@ -98,10 +101,15 @@ export class Bot {
     // get the LightBulb service if it exists, otherwise create a new LightBulb service
     // you can create multiple services for each accessory
     if (device.bot?.deviceType === 'switch') {
+      this.removeFanService(accessory);
       this.removeLockService(accessory);
       this.removeDoorService(accessory);
+      this.removeFaucetService(accessory);
       this.removeOutletService(accessory);
+      this.removeWindowService(accessory);
       this.removeGarageDoorService(accessory);
+      this.removeWindowCoveringService(accessory);
+      this.removeStatefulProgrammableSwitchService(accessory);
 
       // Add switchService
       (this.switchService =
@@ -112,10 +120,15 @@ export class Bot {
       this.switchService.setCharacteristic(this.platform.Characteristic.Name, accessory.displayName);
       this.switchService.getCharacteristic(this.platform.Characteristic.On).onSet(this.handleOnSet.bind(this));
     } else if (device.bot?.deviceType === 'garagedoor') {
+      this.removeFanService(accessory);
       this.removeLockService(accessory);
       this.removeDoorService(accessory);
+      this.removeFaucetService(accessory);
       this.removeOutletService(accessory);
       this.removeSwitchService(accessory);
+      this.removeWindowService(accessory);
+      this.removeWindowCoveringService(accessory);
+      this.removeStatefulProgrammableSwitchService(accessory);
 
       // Add switchService
       (this.garageDoorService =
@@ -127,10 +140,15 @@ export class Bot {
       this.garageDoorService.getCharacteristic(this.platform.Characteristic.TargetDoorState).onSet(this.handleOnSet.bind(this));
       this.garageDoorService.setCharacteristic(this.platform.Characteristic.ObstructionDetected, false);
     } else if (device.bot?.deviceType === 'door') {
+      this.removeFanService(accessory);
       this.removeLockService(accessory);
       this.removeOutletService(accessory);
+      this.removeFaucetService(accessory);
       this.removeSwitchService(accessory);
+      this.removeWindowService(accessory);
       this.removeGarageDoorService(accessory);
+      this.removeWindowCoveringService(accessory);
+      this.removeStatefulProgrammableSwitchService(accessory);
 
       // Add switchService
       (this.doorService =
@@ -147,11 +165,68 @@ export class Bot {
           minStep: 100,
         }).onSet(this.handleOnSet.bind(this));
       this.doorService.setCharacteristic(this.platform.Characteristic.PositionState, this.platform.Characteristic.PositionState.STOPPED);
+    } else if (device.bot?.deviceType === 'window') {
+      this.removeFanService(accessory);
+      this.removeLockService(accessory);
+      this.removeDoorService(accessory);
+      this.removeOutletService(accessory);
+      this.removeFaucetService(accessory);
+      this.removeSwitchService(accessory);
+      this.removeGarageDoorService(accessory);
+      this.removeWindowCoveringService(accessory);
+      this.removeStatefulProgrammableSwitchService(accessory);
+
+      // Add switchService
+      (this.windowService =
+        accessory.getService(this.platform.Service.Window) ||
+        accessory.addService(this.platform.Service.Window)), `${accessory.displayName} Window`;
+      this.infoLog(`Bot: ${accessory.displayName} Displaying as Window`);
+
+      this.windowService.setCharacteristic(this.platform.Characteristic.Name, accessory.displayName);
+      this.windowService.getCharacteristic(this.platform.Characteristic.TargetPosition)
+        .setProps({
+          validValues: [0, 100],
+          minValue: 0,
+          maxValue: 100,
+          minStep: 100,
+        }).onSet(this.handleOnSet.bind(this));
+      this.windowService.setCharacteristic(this.platform.Characteristic.PositionState, this.platform.Characteristic.PositionState.STOPPED);
+    } else if (device.bot?.deviceType === 'windowcovering') {
+      this.removeFanService(accessory);
+      this.removeLockService(accessory);
+      this.removeDoorService(accessory);
+      this.removeOutletService(accessory);
+      this.removeFaucetService(accessory);
+      this.removeSwitchService(accessory);
+      this.removeWindowService(accessory);
+      this.removeGarageDoorService(accessory);
+      this.removeStatefulProgrammableSwitchService(accessory);
+
+      // Add switchService
+      (this.windowCoveringService =
+        accessory.getService(this.platform.Service.WindowCovering) ||
+        accessory.addService(this.platform.Service.WindowCovering)), `${accessory.displayName} Window Covering`;
+      this.infoLog(`Bot: ${accessory.displayName} Displaying as Window Covering`);
+
+      this.windowCoveringService.setCharacteristic(this.platform.Characteristic.Name, accessory.displayName);
+      this.windowCoveringService.getCharacteristic(this.platform.Characteristic.TargetPosition)
+        .setProps({
+          validValues: [0, 100],
+          minValue: 0,
+          maxValue: 100,
+          minStep: 100,
+        }).onSet(this.handleOnSet.bind(this));
+      this.windowCoveringService.setCharacteristic(this.platform.Characteristic.PositionState, this.platform.Characteristic.PositionState.STOPPED);
     } else if (device.bot?.deviceType === 'lock') {
+      this.removeFanService(accessory);
       this.removeDoorService(accessory);
       this.removeOutletService(accessory);
       this.removeSwitchService(accessory);
+      this.removeFaucetService(accessory);
+      this.removeWindowService(accessory);
       this.removeGarageDoorService(accessory);
+      this.removeWindowCoveringService(accessory);
+      this.removeStatefulProgrammableSwitchService(accessory);
 
       // Add switchService
       (this.lockService =
@@ -161,11 +236,74 @@ export class Bot {
 
       this.lockService.setCharacteristic(this.platform.Characteristic.Name, accessory.displayName);
       this.lockService.getCharacteristic(this.platform.Characteristic.LockTargetState).onSet(this.handleOnSet.bind(this));
+    } else if (device.bot?.deviceType === 'faucet') {
+      this.removeFanService(accessory);
+      this.removeLockService(accessory);
+      this.removeDoorService(accessory);
+      this.removeOutletService(accessory);
+      this.removeSwitchService(accessory);
+      this.removeWindowService(accessory);
+      this.removeGarageDoorService(accessory);
+      this.removeWindowCoveringService(accessory);
+      this.removeStatefulProgrammableSwitchService(accessory);
+
+      // Add switchService
+      (this.faucetService =
+        accessory.getService(this.platform.Service.Faucet) ||
+        accessory.addService(this.platform.Service.Faucet)), `${accessory.displayName} Faucet`;
+      this.infoLog(`Bot: ${accessory.displayName} Displaying as Faucet`);
+
+      this.faucetService.setCharacteristic(this.platform.Characteristic.Name, accessory.displayName);
+      this.faucetService.getCharacteristic(this.platform.Characteristic.Active).onSet(this.handleOnSet.bind(this));
+    } else if (device.bot?.deviceType === 'fan') {
+      this.removeLockService(accessory);
+      this.removeDoorService(accessory);
+      this.removeFaucetService(accessory);
+      this.removeOutletService(accessory);
+      this.removeSwitchService(accessory);
+      this.removeWindowService(accessory);
+      this.removeGarageDoorService(accessory);
+      this.removeWindowCoveringService(accessory);
+      this.removeStatefulProgrammableSwitchService(accessory);
+
+      // Add switchService
+      (this.fanService =
+        accessory.getService(this.platform.Service.Fan) ||
+        accessory.addService(this.platform.Service.Fan)), `${accessory.displayName} Fan`;
+      this.infoLog(`Bot: ${accessory.displayName} Displaying as Fan`);
+
+      this.fanService.setCharacteristic(this.platform.Characteristic.Name, accessory.displayName);
+      this.fanService.getCharacteristic(this.platform.Characteristic.On).onSet(this.handleOnSet.bind(this));
+    } else if (device.bot?.deviceType === 'stateful') {
+      this.removeFanService(accessory);
+      this.removeLockService(accessory);
+      this.removeDoorService(accessory);
+      this.removeFaucetService(accessory);
+      this.removeOutletService(accessory);
+      this.removeSwitchService(accessory);
+      this.removeWindowService(accessory);
+      this.removeGarageDoorService(accessory);
+      this.removeWindowCoveringService(accessory);
+
+      // Add switchService
+      (this.statefulProgrammableSwitchService =
+        accessory.getService(this.platform.Service.StatefulProgrammableSwitch) ||
+        accessory.addService(this.platform.Service.StatefulProgrammableSwitch)), `${accessory.displayName} Stateful Programmable Switch`;
+      this.infoLog(`Bot: ${accessory.displayName} Displaying as Stateful Programmable Switch`);
+
+      this.statefulProgrammableSwitchService.setCharacteristic(this.platform.Characteristic.Name, accessory.displayName);
+      this.statefulProgrammableSwitchService.getCharacteristic(this.platform.Characteristic.ProgrammableSwitchOutputState)
+        .onSet(this.handleOnSet.bind(this));
     } else {
+      this.removeFanService(accessory);
       this.removeLockService(accessory);
       this.removeDoorService(accessory);
+      this.removeFaucetService(accessory);
       this.removeSwitchService(accessory);
+      this.removeWindowService(accessory);
       this.removeGarageDoorService(accessory);
+      this.removeWindowCoveringService(accessory);
+      this.removeStatefulProgrammableSwitchService(accessory);
 
       // Add outletService
       (this.outletService =
@@ -177,12 +315,21 @@ export class Bot {
       this.outletService.getCharacteristic(this.platform.Characteristic.On).onSet(this.handleOnSet.bind(this));
     }
 
-    if (device.ble) {
+    // Battery Service
+    if (!device.ble) {
+      this.debugLog(`Bot: ${accessory.displayName} Removing Battery Service`);
+      this.batteryService = this.accessory.getService(this.platform.Service.Battery);
+      accessory.removeService(this.batteryService!);
+    } else if (device.ble && !this.batteryService) {
+      this.debugLog(`Bot: ${accessory.displayName} Add Battery Service`);
       (this.batteryService =
-        accessory.getService(this.platform.Service.Battery) ||
-        accessory.addService(this.platform.Service.Battery)), `${accessory.displayName} Battery`;
+        this.accessory.getService(this.platform.Service.Battery) ||
+        this.accessory.addService(this.platform.Service.Battery)), `${accessory.displayName} Battery`;
 
       this.batteryService.setCharacteristic(this.platform.Characteristic.Name, `${accessory.displayName} Battery`);
+
+    } else {
+      this.debugLog(`Bot: ${accessory.displayName} Battery Service Not Added`);
     }
 
     // Retrieve initial values and updateHomekit
@@ -226,7 +373,13 @@ export class Bot {
       });
   }
 
-  private removeOutletService(accessory: PlatformAccessory) {
+  config(device: device & devicesConfig) {
+    if (device.bot !== undefined || device.ble !== undefined) {
+      this.warnLog(`Bot: ${this.accessory.displayName} Config: ${JSON.stringify(device.bot)}, BLE: ${device.ble}`);
+    }
+  }
+
+  public removeOutletService(accessory: PlatformAccessory) {
     // If outletService still pressent, then remove first
     this.outletService = this.accessory.getService(this.platform.Service.Outlet);
     if (this.outletService) {
@@ -235,7 +388,7 @@ export class Bot {
     accessory.removeService(this.outletService!);
   }
 
-  private removeGarageDoorService(accessory: PlatformAccessory) {
+  public removeGarageDoorService(accessory: PlatformAccessory) {
     // If garageDoorService still pressent, then remove first
     this.garageDoorService = this.accessory.getService(this.platform.Service.GarageDoorOpener);
     if (this.garageDoorService) {
@@ -244,7 +397,7 @@ export class Bot {
     accessory.removeService(this.garageDoorService!);
   }
 
-  private removeDoorService(accessory: PlatformAccessory) {
+  public removeDoorService(accessory: PlatformAccessory) {
     // If doorService still pressent, then remove first
     this.doorService = this.accessory.getService(this.platform.Service.Door);
     if (this.doorService) {
@@ -253,7 +406,7 @@ export class Bot {
     accessory.removeService(this.doorService!);
   }
 
-  private removeLockService(accessory: PlatformAccessory) {
+  public removeLockService(accessory: PlatformAccessory) {
     // If lockService still pressent, then remove first
     this.lockService = this.accessory.getService(this.platform.Service.LockMechanism);
     if (this.lockService) {
@@ -262,7 +415,52 @@ export class Bot {
     accessory.removeService(this.lockService!);
   }
 
-  private removeSwitchService(accessory: PlatformAccessory) {
+  public removeFaucetService(accessory: PlatformAccessory) {
+    // If faucetService still pressent, then remove first
+    this.faucetService = this.accessory.getService(this.platform.Service.Faucet);
+    if (this.faucetService) {
+      this.warnLog(`Bot: ${accessory.displayName} Removing Leftover Faucet Service`);
+    }
+    accessory.removeService(this.faucetService!);
+  }
+
+  public removeFanService(accessory: PlatformAccessory) {
+    // If fanService still pressent, then remove first
+    this.fanService = this.accessory.getService(this.platform.Service.Fan);
+    if (this.fanService) {
+      this.warnLog(`Bot: ${accessory.displayName} Removing Leftover Fan Service`);
+    }
+    accessory.removeService(this.fanService!);
+  }
+
+  public removeWindowService(accessory: PlatformAccessory) {
+    // If windowService still pressent, then remove first
+    this.windowService = this.accessory.getService(this.platform.Service.Window);
+    if (this.windowService) {
+      this.warnLog(`Bot: ${accessory.displayName} Removing Leftover Window Service`);
+    }
+    accessory.removeService(this.windowService!);
+  }
+
+  public removeWindowCoveringService(accessory: PlatformAccessory) {
+    // If windowCoveringService still pressent, then remove first
+    this.windowCoveringService = this.accessory.getService(this.platform.Service.WindowCovering);
+    if (this.windowCoveringService) {
+      this.warnLog(`Bot: ${accessory.displayName} Removing Leftover Window Covering Service`);
+    }
+    accessory.removeService(this.windowCoveringService!);
+  }
+
+  public removeStatefulProgrammableSwitchService(accessory: PlatformAccessory) {
+    // If statefulProgrammableSwitchService still pressent, then remove first
+    this.statefulProgrammableSwitchService = this.accessory.getService(this.platform.Service.StatefulProgrammableSwitch);
+    if (this.statefulProgrammableSwitchService) {
+      this.warnLog(`Bot: ${accessory.displayName} Removing Leftover Stateful Programmable Switch Service`);
+    }
+    accessory.removeService(this.statefulProgrammableSwitchService!);
+  }
+
+  public removeSwitchService(accessory: PlatformAccessory) {
     // If switchService still pressent, then remove first
     this.switchService = this.accessory.getService(this.platform.Service.Switch);
     if (this.switchService) {
@@ -274,12 +472,12 @@ export class Bot {
   refreshRate() {
     if (this.device.refreshRate) {
       this.deviceRefreshRate = this.accessory.context.refreshRate = this.device.refreshRate;
-      if (this.platform.debugMode || (this.deviceLogging === 'debug')) {
+      if (this.deviceLogging === 'debug' || this.deviceLogging === 'standard') {
         this.warnLog(`Bot: ${this.accessory.displayName} Using Device Config refreshRate: ${this.deviceRefreshRate}`);
       }
     } else if (this.platform.config.options!.refreshRate) {
       this.deviceRefreshRate = this.accessory.context.refreshRate = this.platform.config.options!.refreshRate;
-      if (this.platform.debugMode || (this.deviceLogging === 'debug')) {
+      if (this.deviceLogging === 'debug') {
         this.warnLog(`Bot: ${this.accessory.displayName} Using Platform Config refreshRate: ${this.deviceRefreshRate}`);
       }
     }
@@ -288,12 +486,12 @@ export class Bot {
   scan() {
     if (this.device.scanDuration) {
       this.scanDuration = this.accessory.context.scanDuration = this.device.scanDuration;
-      if (this.platform.debugMode || (this.deviceLogging === 'debug')) {
+      if (this.device.ble && (this.deviceLogging === 'debug' || this.deviceLogging === 'standard')) {
         this.warnLog(`Bot: ${this.accessory.displayName} Using Device Config scanDuration: ${this.scanDuration}`);
       }
     } else {
       this.scanDuration = this.accessory.context.scanDuration = 1;
-      if (this.platform.debugMode || (this.deviceLogging === 'debug')) {
+      if (this.device.ble && this.deviceLogging === 'debug') {
         this.warnLog(`Bot: ${this.accessory.displayName} Using Default scanDuration: ${this.scanDuration}`);
       }
     }
@@ -338,10 +536,10 @@ export class Bot {
    * Parse the device status from the SwitchBot api
    */
   async parseStatus() {
-    if (this.device.ble) {
-      await this.BLEparseStatus();
-    } else {
+    if (this.SwitchToOpenAPI || !this.device.ble) {
       await this.openAPIparseStatus();
+    } else {
+      await this.BLEparseStatus();
     }
   }
 
@@ -375,6 +573,9 @@ export class Bot {
   }
 
   private async openAPIparseStatus() {
+    if (this.device.ble) {
+      this.SwitchToOpenAPI = false;
+    }
     if (this.platform.config.credentials?.openToken) {
       this.debugLog(`Bot: ${this.accessory.displayName} OpenAPI parseStatus`);
       if (this.botMode === 'press') {
@@ -382,7 +583,7 @@ export class Bot {
         this.OnCached = this.On;
         this.accessory.context.On = this.OnCached;
       } else {
-        if (this.deviceStatus.body.power === 'on') {
+        /*if (this.power === 'on') {
           this.On = true;
           this.OnCached = this.On;
           this.accessory.context.On = this.OnCached;
@@ -390,6 +591,11 @@ export class Bot {
           this.On = false;
           this.OnCached = this.On;
           this.accessory.context.On = this.OnCached;
+        }*/
+        this.OnCached = this.On;
+        this.accessory.context.On = this.OnCached;
+        if (this.On === undefined) {
+          this.On = false;
         }
       }
       this.debugLog(`Bot: ${this.accessory.displayName} On: ${this.On}`);
@@ -407,35 +613,12 @@ export class Bot {
     }
   }
 
-  public async connectBLE() {
-    let switchbot: any;
-    try {
-      // eslint-disable-next-line @typescript-eslint/no-var-requires
-      const Switchbot = require('node-switchbot');
-      switchbot = new Switchbot();
-      // Convert to BLE Address
-      this.device.bleMac = ((this.device.deviceId!.match(/.{1,2}/g))!.join(':')).toLowerCase();
-      this.debugLog(`Bot: ${this.accessory.displayName} BLE Address: ${this.device.bleMac}`);
-    } catch (e: any) {
-      switchbot = false;
-      this.errorLog(`Bot: ${this.accessory.displayName} 'node-switchbot' found: ${switchbot}`);
-      if (this.deviceLogging === 'debug') {
-        this.errorLog(`Bot: ${this.accessory.displayName} 'node-switchbot' found: ${switchbot},`
-          + ` Error Message: ${JSON.stringify(e.message)}`);
-      }
-      if (this.platform.debugMode) {
-        this.errorLog(`Bot: ${this.accessory.displayName} 'node-switchbot' found: ${switchbot},`
-          + ` Error: ${JSON.stringify(e)}`);
-      }
-    }
-    return switchbot;
-  }
-
   private async BLERefreshStatus() {
     this.debugLog(`Bot: ${this.accessory.displayName} BLE refreshStatus`);
-
+    const switchbot = await this.platform.connectBLE();
     // Convert to BLE Address
-    const switchbot = await this.connectBLE();
+    this.device.bleMac = ((this.device.deviceId!.match(/.{1,2}/g))!.join(':')).toLowerCase();
+    this.debugLog(`Curtain: ${this.accessory.displayName} BLE Address: ${this.device.bleMac}`);
     // Start to monitor advertisement packets
     if (switchbot === false) {
       this.errorLog(`Bot: ${this.accessory.displayName} wasn't able to establish BLE Connection: ${switchbot}`);
@@ -474,6 +657,7 @@ export class Bot {
         this.errorLog(`Bot: ${this.accessory.displayName} wasn't able to establish BLE Connection`);
         if (this.platform.config.credentials?.openToken) {
           this.warnLog(`Bot: ${this.accessory.displayName} Using OpenAPI Connection`);
+          this.SwitchToOpenAPI = true;
           await this.openAPIRefreshStatus();
         }
       }
@@ -489,6 +673,7 @@ export class Bot {
       }
       if (this.platform.config.credentials?.openToken) {
         this.warnLog(`Bot: ${this.accessory.displayName} Using OpenAPI Connection`);
+        this.SwitchToOpenAPI = true;
         await this.openAPIRefreshStatus();
       }
       this.apiError(e);
@@ -501,6 +686,7 @@ export class Bot {
       try {
         this.deviceStatus = (await this.platform.axios.get(`${DeviceURL}/${this.device.deviceId}/status`)).data;
         this.debugLog(`Bot: ${this.accessory.displayName} refreshStatus: ${JSON.stringify(this.deviceStatus)}`);
+        this.power = this.deviceStatus.body.power;
         this.parseStatus();
         this.updateHomeKitCharacteristics();
       } catch (e: any) {
@@ -543,7 +729,10 @@ export class Bot {
     this.debugLog(`Bot: ${this.accessory.displayName} BLE pushChanges On: ${this.On} OnCached: ${this.OnCached}`);
     if (this.On !== this.OnCached) {
       this.debugLog(`Bot: ${this.accessory.displayName} BLE pushChanges`);
-      const switchbot = await this.connectBLE();
+      const switchbot = await this.platform.connectBLE();
+      // Convert to BLE Address
+      this.device.bleMac = ((this.device.deviceId!.match(/.{1,2}/g))!.join(':')).toLowerCase();
+      this.debugLog(`Curtain: ${this.accessory.displayName} BLE Address: ${this.device.bleMac}`);
       //if (switchbot !== false) {
       if (this.botMode === 'press') {
         this.debugLog(`Bot: ${this.accessory.displayName} Bot Mode: ${this.botMode}`);
@@ -721,6 +910,44 @@ export class Bot {
         }
       }
       this.debugLog(`Bot: ${this.accessory.displayName} Door On: ${this.On}`);
+    } else if (this.device.bot?.deviceType === 'window') {
+      if (this.On === undefined) {
+        this.debugLog(`Bot: ${this.accessory.displayName} On: ${this.On}`);
+      } else {
+        if (this.On) {
+          this.windowService?.updateCharacteristic(this.platform.Characteristic.TargetPosition, 100);
+          this.windowService?.updateCharacteristic(this.platform.Characteristic.CurrentPosition, 100);
+          this.windowService?.updateCharacteristic(this.platform.Characteristic.PositionState,
+            this.platform.Characteristic.PositionState.STOPPED);
+          this.debugLog(`Bot: ${this.accessory.displayName} updateCharacteristic TargetPosition: 100, CurrentPosition: 100`);
+        } else {
+          this.windowService?.updateCharacteristic(this.platform.Characteristic.TargetPosition, 0);
+          this.windowService?.updateCharacteristic(this.platform.Characteristic.CurrentPosition, 0);
+          this.windowService?.updateCharacteristic(this.platform.Characteristic.PositionState,
+            this.platform.Characteristic.PositionState.STOPPED);
+          this.debugLog(`Bot: ${this.accessory.displayName} updateCharacteristic TargetPosition: 0, CurrentPosition: 0`);
+        }
+      }
+      this.debugLog(`Bot: ${this.accessory.displayName} Window On: ${this.On}`);
+    } else if (this.device.bot?.deviceType === 'windowcovering') {
+      if (this.On === undefined) {
+        this.debugLog(`Bot: ${this.accessory.displayName} On: ${this.On}`);
+      } else {
+        if (this.On) {
+          this.windowCoveringService?.updateCharacteristic(this.platform.Characteristic.TargetPosition, 100);
+          this.windowCoveringService?.updateCharacteristic(this.platform.Characteristic.CurrentPosition, 100);
+          this.windowCoveringService?.updateCharacteristic(this.platform.Characteristic.PositionState,
+            this.platform.Characteristic.PositionState.STOPPED);
+          this.debugLog(`Bot: ${this.accessory.displayName} updateCharacteristic TargetPosition: 100, CurrentPosition: 100`);
+        } else {
+          this.windowCoveringService?.updateCharacteristic(this.platform.Characteristic.TargetPosition, 0);
+          this.windowCoveringService?.updateCharacteristic(this.platform.Characteristic.CurrentPosition, 0);
+          this.windowCoveringService?.updateCharacteristic(this.platform.Characteristic.PositionState,
+            this.platform.Characteristic.PositionState.STOPPED);
+          this.debugLog(`Bot: ${this.accessory.displayName} updateCharacteristic TargetPosition: 0, CurrentPosition: 0`);
+        }
+      }
+      this.debugLog(`Bot: ${this.accessory.displayName} Window Covering On: ${this.On}`);
     } else if (this.device.bot?.deviceType === 'lock') {
       if (this.On === undefined) {
         this.debugLog(`Bot: ${this.accessory.displayName} On: ${this.On}`);
@@ -740,6 +967,51 @@ export class Bot {
         }
       }
       this.debugLog(`Bot: ${this.accessory.displayName} Lock On: ${this.On}`);
+    } else if (this.device.bot?.deviceType === 'faucet') {
+      if (this.On === undefined) {
+        this.debugLog(`Bot: ${this.accessory.displayName} On: ${this.On}`);
+      } else {
+        if (this.On) {
+          this.faucetService?.updateCharacteristic(this.platform.Characteristic.Active,
+            this.platform.Characteristic.Active.ACTIVE);
+          this.debugLog(`Bot: ${this.accessory.displayName} updateCharacteristic Active: ${this.On}`);
+        } else {
+          this.faucetService?.updateCharacteristic(this.platform.Characteristic.Active,
+            this.platform.Characteristic.Active.INACTIVE);
+          this.debugLog(`Bot: ${this.accessory.displayName} updateCharacteristic Active: ${this.On}`);
+        }
+      }
+      this.debugLog(`Bot: ${this.accessory.displayName} Faucet On: ${this.On}`);
+    } else if (this.device.bot?.deviceType === 'fan') {
+      if (this.On === undefined) {
+        this.debugLog(`Bot: ${this.accessory.displayName} On: ${this.On}`);
+      } else {
+        if (this.On) {
+          this.fanService?.updateCharacteristic(this.platform.Characteristic.On, this.On);
+          this.debugLog(`Bot: ${this.accessory.displayName} updateCharacteristic On: ${this.On}`);
+        } else {
+          this.fanService?.updateCharacteristic(this.platform.Characteristic.On, this.On);
+          this.debugLog(`Bot: ${this.accessory.displayName} updateCharacteristic On: ${this.On}`);
+        }
+      }
+      this.debugLog(`Bot: ${this.accessory.displayName} Fan On: ${this.On}`);
+    } else if (this.device.bot?.deviceType === 'stateful') {
+      if (this.On === undefined) {
+        this.debugLog(`Bot: ${this.accessory.displayName} On: ${this.On}`);
+      } else {
+        if (this.On) {
+          this.statefulProgrammableSwitchService?.updateCharacteristic(this.platform.Characteristic.ProgrammableSwitchEvent,
+            this.platform.Characteristic.ProgrammableSwitchEvent.SINGLE_PRESS);
+          this.statefulProgrammableSwitchService?.updateCharacteristic(this.platform.Characteristic.ProgrammableSwitchOutputState, 1);
+          this.debugLog(`Bot: ${this.accessory.displayName} updateCharacteristic ProgrammableSwitchEvent: SINGLE, ProgrammableSwitchOutputState: 1`);
+        } else {
+          this.statefulProgrammableSwitchService?.updateCharacteristic(this.platform.Characteristic.ProgrammableSwitchEvent,
+            this.platform.Characteristic.ProgrammableSwitchEvent.SINGLE_PRESS);
+          this.statefulProgrammableSwitchService?.updateCharacteristic(this.platform.Characteristic.ProgrammableSwitchOutputState, 0);
+          this.debugLog(`Bot: ${this.accessory.displayName} updateCharacteristic ProgrammableSwitchEvent: SINGLE, ProgrammableSwitchOutputState: 0`);
+        }
+      }
+      this.debugLog(`Bot: ${this.accessory.displayName} StatefulProgrammableSwitch On: ${this.On}`);
     } else if (this.device.bot?.deviceType === 'switch') {
       if (this.On === undefined) {
         this.debugLog(`Bot: ${this.accessory.displayName} On: ${this.On}`);
@@ -780,9 +1052,24 @@ export class Bot {
       this.doorService?.updateCharacteristic(this.platform.Characteristic.TargetPosition, e);
       this.doorService?.updateCharacteristic(this.platform.Characteristic.CurrentPosition, e);
       this.doorService?.updateCharacteristic(this.platform.Characteristic.PositionState, e);
+    } else if (this.device.bot?.deviceType === 'window') {
+      this.windowService?.updateCharacteristic(this.platform.Characteristic.TargetPosition, e);
+      this.windowService?.updateCharacteristic(this.platform.Characteristic.CurrentPosition, e);
+      this.windowService?.updateCharacteristic(this.platform.Characteristic.PositionState, e);
+    } else if (this.device.bot?.deviceType === 'windowcovering') {
+      this.windowCoveringService?.updateCharacteristic(this.platform.Characteristic.TargetPosition, e);
+      this.windowCoveringService?.updateCharacteristic(this.platform.Characteristic.CurrentPosition, e);
+      this.windowCoveringService?.updateCharacteristic(this.platform.Characteristic.PositionState, e);
     } else if (this.device.bot?.deviceType === 'lock') {
       this.doorService?.updateCharacteristic(this.platform.Characteristic.LockTargetState, e);
       this.doorService?.updateCharacteristic(this.platform.Characteristic.LockCurrentState, e);
+    } else if (this.device.bot?.deviceType === 'faucet') {
+      this.faucetService?.updateCharacteristic(this.platform.Characteristic.Active, e);
+    } else if (this.device.bot?.deviceType === 'fan') {
+      this.fanService?.updateCharacteristic(this.platform.Characteristic.On, e);
+    } else if (this.device.bot?.deviceType === 'stateful') {
+      this.statefulProgrammableSwitchService?.updateCharacteristic(this.platform.Characteristic.ProgrammableSwitchEvent, e);
+      this.statefulProgrammableSwitchService?.updateCharacteristic(this.platform.Characteristic.ProgrammableSwitchOutputState, e);
     } else if (this.device.bot?.deviceType === 'switch') {
       this.switchService?.updateCharacteristic(this.platform.Characteristic.On, e);
     } else {
@@ -848,7 +1135,9 @@ export class Bot {
       } else {
         this.On = true;
       }
-    } else if (this.device.bot?.deviceType === 'door') {
+    } else if (this.device.bot?.deviceType === 'door'
+      || this.device.bot?.deviceType === 'window'
+      || this.device.bot?.deviceType === 'windowcovering') {
       this.debugLog(`Bot: ${this.accessory.displayName} TargetPosition: ${value}`);
       if (value === 0) {
         this.On = false;
@@ -862,6 +1151,20 @@ export class Bot {
       } else {
         this.On = true;
       }
+    } else if (this.device.bot?.deviceType === 'faucet') {
+      this.debugLog(`Bot: ${this.accessory.displayName} Active: ${value}`);
+      if (value === this.platform.Characteristic.Active.INACTIVE) {
+        this.On = false;
+      } else {
+        this.On = true;
+      }
+    } else if (this.device.bot?.deviceType === 'stateful') {
+      this.debugLog(`Bot: ${this.accessory.displayName} ProgrammableSwitchOutputState: ${value}`);
+      if (value === 0) {
+        this.On = false;
+      } else {
+        this.On = true;
+      }
     } else {
       this.debugLog(`Bot: ${this.accessory.displayName} On: ${value}`);
       this.On = value;