@switchbot/homebridge-switchbot 1.6.2-beta.0 → 1.6.3

package/src/devices/bots.ts

@@ -213,8 +213,6 @@ export class Bot {
     }
   }
 
-
-
   logs() {
     if (this.platform.debugMode) {
       this.deviceLogging = this.accessory.context.logging = 'debug';
@@ -324,76 +322,80 @@ export class Bot {
   }
 
   private connectBLE() {
-    let Switchbot: any;
-    try {
-      Switchbot = require('node-switchbot');
-      const switchbot = new Switchbot();
-      this.device.bleMac = ((this.device.deviceId!.match(/.{1,2}/g))!.join(':')).toLowerCase();
-      this.debugLog(`Bot: ${this.accessory.displayName} BLE Address: ${this.device.bleMac}`);
-      return switchbot;
-    } catch (e) {
-      Switchbot = false;
-    }
+    // 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}`);
+    const switchbot = this.platform.connectBLE();
+    return switchbot;
   }
 
   private async BLERefreshStatus() {
     this.debugLog(`Bot: ${this.accessory.displayName} BLE refreshStatus`);
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
+
+    // Convert to BLE Address
     const switchbot = this.connectBLE();
     // Start to monitor advertisement packets
-    switchbot.startScan({
-      model: 'H',
-      id: this.device.bleMac,
-    }).then(() => {
-      // Set an event hander
-      switchbot.onadvertisement = (ad: ad) => {
-        this.serviceData = ad.serviceData;
-        this.mode = ad.serviceData.mode;
-        this.state = ad.serviceData.state;
-        this.battery = ad.serviceData.battery;
-        this.debugLog(`Bot: ${this.accessory.displayName} serviceData: ${JSON.stringify(ad.serviceData)}`);
-        this.debugLog(`Bot: ${this.accessory.displayName}, model: ${ad.serviceData.model}, modelName: ${ad.serviceData.modelName},`
-          + ` mode: ${ad.serviceData.mode}, state: ${ad.serviceData.state}, battery: ${ad.serviceData.battery}`);
-
-        if (this.serviceData) {
-          this.connected = true;
-          this.debugLog(`Bot: ${this.accessory.displayName} connected: ${this.connected}`);
+    if (switchbot !== false) {
+      switchbot.startScan({
+        model: 'H',
+        id: this.device.bleMac,
+      }).then(() => {
+        // Set an event hander
+        switchbot.onadvertisement = (ad: ad) => {
+          this.serviceData = ad.serviceData;
+          this.mode = ad.serviceData.mode;
+          this.state = ad.serviceData.state;
+          this.battery = ad.serviceData.battery;
+          this.debugLog(`Bot: ${this.accessory.displayName} serviceData: ${JSON.stringify(ad.serviceData)}`);
+          this.debugLog(`Bot: ${this.accessory.displayName}, model: ${ad.serviceData.model}, modelName: ${ad.serviceData.modelName},`
+            + ` mode: ${ad.serviceData.mode}, state: ${ad.serviceData.state}, battery: ${ad.serviceData.battery}`);
+
+          if (this.serviceData) {
+            this.connected = true;
+            this.debugLog(`Bot: ${this.accessory.displayName} connected: ${this.connected}`);
+          } else {
+            this.connected = false;
+            this.debugLog(`Bot: ${this.accessory.displayName} connected: ${this.connected}`);
+          }
+        };
+        // Wait 2 seconds
+        return switchbot.wait(this.scanDuration * 1000);
+      }).then(async () => {
+        // Stop to monitor
+        switchbot.stopScan();
+        if (this.connected) {
+          this.parseStatus();
+          this.updateHomeKitCharacteristics();
         } else {
-          this.connected = false;
-          this.debugLog(`Bot: ${this.accessory.displayName} connected: ${this.connected}`);
+          await this.BLEconnection();
+        }
+      }).catch(async (e: any) => {
+        this.errorLog(`Bot: ${this.accessory.displayName} failed refreshStatus with BLE Connection`);
+        if (this.deviceLogging === 'debug') {
+          this.errorLog(`Bot: ${this.accessory.displayName} failed refreshStatus with BLE Connection,`
+            + ` Error Message: ${JSON.stringify(e.message)}`);
+        }
+        if (this.platform.debugMode) {
+          this.errorLog(`Bot: ${this.accessory.displayName} failed refreshStatus with BLE Connection,`
+            + ` Error: ${JSON.stringify(e)}`);
         }
-      };
-      // Wait 2 seconds
-      return switchbot.wait(this.scanDuration * 1000);
-    }).then(async () => {
-      // Stop to monitor
-      switchbot.stopScan();
-      if (this.connected) {
-        this.parseStatus();
-        this.updateHomeKitCharacteristics();
-      } else {
-        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`);
           await this.openAPIRefreshStatus();
         }
-      }
-    }).catch(async (e: any) => {
-      this.errorLog(`Bot: ${this.accessory.displayName} failed refreshStatus with BLE Connection`);
-      if (this.deviceLogging === 'debug') {
-        this.errorLog(`Bot: ${this.accessory.displayName} failed refreshStatus with BLE Connection,`
-          + ` Error Message: ${JSON.stringify(e.message)}`);
-      }
-      if (this.platform.debugMode) {
-        this.errorLog(`Bot: ${this.accessory.displayName} failed refreshStatus with BLE Connection,`
-          + ` Error: ${JSON.stringify(e)}`);
-      }
-      if (this.platform.config.credentials?.openToken) {
-        this.warnLog(`Bot: ${this.accessory.displayName} Using OpenAPI Connection`);
-        await this.openAPIRefreshStatus();
-      }
-      this.apiError(e);
-    });
+        this.apiError(e);
+      });
+    } else {
+      await this.BLEconnection();
+    }
+  }
+
+  private async BLEconnection() {
+    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`);
+      await this.openAPIRefreshStatus();
+    }
   }
 
   private async openAPIRefreshStatus() {
@@ -444,25 +446,51 @@ export class Bot {
     if (this.On !== this.OnCached) {
       this.debugLog(`Bot: ${this.accessory.displayName} BLE pushChanges`);
       const switchbot = this.connectBLE();
-      if (this.botMode === 'press') {
-        this.debugLog(`Bot: ${this.accessory.displayName} Bot Mode: ${this.botMode}`);
-        switchbot.discover({ model: 'H', quick: true, id: this.device.bleMac })
-          .then((device_list: { press: (arg0: { id: string | undefined; }) => any; }[]) => {
+      if (switchbot !== false) {
+        if (this.botMode === 'press') {
+          this.debugLog(`Bot: ${this.accessory.displayName} Bot Mode: ${this.botMode}`);
+          switchbot.discover({ model: 'H', quick: true, id: this.device.bleMac })
+            .then((device_list: { press: (arg0: { id: string | undefined; }) => any; }[]) => {
+              this.infoLog(`Bot: ${this.accessory.displayName} On: ${this.On}`);
+              return device_list[0].press({ id: this.device.bleMac });
+            }).then(() => {
+              this.debugLog(`Bot: ${this.accessory.displayName} Done.`);
+              this.On = false;
+              this.OnCached = this.On;
+              this.accessory.context.On = this.OnCached;
+              setTimeout(() => {
+                if (this.device.bot?.deviceType === 'switch') {
+                  this.switchService?.getCharacteristic(this.platform.Characteristic.On).updateValue(this.On);
+                } else {
+                  this.outletService?.getCharacteristic(this.platform.Characteristic.On).updateValue(this.On);
+                }
+                this.debugLog(`Bot: ${this.accessory.displayName} On: ${this.On}, Switch Timeout`);
+              }, 500);
+            }).catch(async (e: any) => {
+              this.errorLog(`Bot: ${this.accessory.displayName} failed pushChanges with BLE Connection`);
+              if (this.deviceLogging === 'debug') {
+                this.errorLog(`Bot: ${this.accessory.displayName} failed pushChanges with BLE Connection,`
+                  + ` Error Message: ${JSON.stringify(e.message)}`);
+              }
+              if (this.platform.debugMode) {
+                this.errorLog(`Bot: ${this.accessory.displayName} failed pushChanges with BLE Connection,`
+                  + ` Error: ${JSON.stringify(e)}`);
+              }
+              if (this.platform.config.credentials?.openToken) {
+                this.warnLog(`Bot: ${this.accessory.displayName} Using OpenAPI Connection`);
+                await this.openAPIpushChanges();
+              }
+              this.apiError(e);
+            });
+        } else if (this.botMode === 'switch') {
+          this.debugLog(`Bot: ${this.accessory.displayName} Press Mode: ${this.botMode}`);
+          switchbot.discover({ model: 'H', quick: true, id: this.device.bleMac }).then((device_list: any) => {
             this.infoLog(`Bot: ${this.accessory.displayName} On: ${this.On}`);
-            return device_list[0].press({ id: this.device.bleMac });
+            return this.turnOnOff(device_list);
           }).then(() => {
             this.debugLog(`Bot: ${this.accessory.displayName} Done.`);
-            this.On = false;
             this.OnCached = this.On;
             this.accessory.context.On = this.OnCached;
-            setTimeout(() => {
-              if (this.device.bot?.deviceType === 'switch') {
-                this.switchService?.getCharacteristic(this.platform.Characteristic.On).updateValue(this.On);
-              } else {
-                this.outletService?.getCharacteristic(this.platform.Characteristic.On).updateValue(this.On);
-              }
-              this.debugLog(`Bot: ${this.accessory.displayName} On: ${this.On}, Switch Timeout`);
-            }, 500);
           }).catch(async (e: any) => {
             this.errorLog(`Bot: ${this.accessory.displayName} failed pushChanges with BLE Connection`);
             if (this.deviceLogging === 'debug') {
@@ -479,33 +507,15 @@ export class Bot {
             }
             this.apiError(e);
           });
-      } else if (this.botMode === 'switch') {
-        this.debugLog(`Bot: ${this.accessory.displayName} Press Mode: ${this.botMode}`);
-        switchbot.discover({ model: 'H', quick: true, id: this.device.bleMac }).then((device_list: any) => {
-          this.infoLog(`Bot: ${this.accessory.displayName} On: ${this.On}`);
-          return this.turnOnOff(device_list);
-        }).then(() => {
-          this.debugLog(`Bot: ${this.accessory.displayName} Done.`);
-          this.OnCached = this.On;
-          this.accessory.context.On = this.OnCached;
-        }).catch(async (e: any) => {
-          this.errorLog(`Bot: ${this.accessory.displayName} failed pushChanges with BLE Connection`);
-          if (this.deviceLogging === 'debug') {
-            this.errorLog(`Bot: ${this.accessory.displayName} failed pushChanges with BLE Connection,`
-              + ` Error Message: ${JSON.stringify(e.message)}`);
-          }
-          if (this.platform.debugMode) {
-            this.errorLog(`Bot: ${this.accessory.displayName} failed pushChanges with BLE Connection,`
-              + ` Error: ${JSON.stringify(e)}`);
-          }
-          if (this.platform.config.credentials?.openToken) {
-            this.warnLog(`Bot: ${this.accessory.displayName} Using OpenAPI Connection`);
-            await this.openAPIpushChanges();
-          }
-          this.apiError(e);
-        });
+        } else {
+          throw new Error(`Bot: ${this.accessory.displayName} Bot Mode: ${this.botMode}`);
+        }
       } else {
-        throw new Error(`Bot: ${this.accessory.displayName} Bot Mode: ${this.botMode}`);
+        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`);
+          await this.openAPIpushChanges();
+        }
       }
     }
     this.OnCached = this.On;

package/src/devices/contact.ts

@@ -162,12 +162,12 @@ export class Contact {
     if (this.device.scanDuration) {
       this.scanDuration = this.accessory.context.scanDuration = this.device.scanDuration;
       if (this.platform.debugMode || (this.deviceLogging === 'debug')) {
-        this.warnLog(`Bot: ${this.accessory.displayName} Using Device Config scanDuration: ${this.scanDuration}`);
+        this.warnLog(`Contact Sensor: ${this.accessory.displayName} Using Device Config scanDuration: ${this.scanDuration}`);
       }
     } else {
       this.scanDuration = this.accessory.context.scanDuration = 1;
       if (this.platform.debugMode || (this.deviceLogging === 'debug')) {
-        this.warnLog(`Bot: ${this.accessory.displayName} Using Default scanDuration: ${this.scanDuration}`);
+        this.warnLog(`Contact Sensor: ${this.accessory.displayName} Using Default scanDuration: ${this.scanDuration}`);
       }
     }
   }
@@ -274,16 +274,11 @@ export class Contact {
   }
 
   private connectBLE() {
-    let Switchbot: any;
-    try {
-      Switchbot = require('node-switchbot');
-      const switchbot = new Switchbot();
-      this.device.bleMac = ((this.device.deviceId!.match(/.{1,2}/g))!.join(':')).toLowerCase();
-      this.debugLog(`Bot: ${this.accessory.displayName} BLE Address: ${this.device.bleMac}`);
-      return switchbot;
-    } catch (e) {
-      Switchbot = false;
-    }
+    // Convert to BLE Address
+    this.device.bleMac = ((this.device.deviceId!.match(/.{1,2}/g))!.join(':')).toLowerCase();
+    this.debugLog(`Contact Sensor: ${this.accessory.displayName} BLE Address: ${this.device.bleMac}`);
+    const switchbot = this.platform.connectBLE();
+    return switchbot;
   }
 
   private async BLERefreshStatus() {
@@ -291,60 +286,72 @@ export class Contact {
     // eslint-disable-next-line @typescript-eslint/no-var-requires
     const switchbot = this.connectBLE();
     // Start to monitor advertisement packets
-    switchbot.startScan({
-      model: 'd',
-      id: this.device.bleMac,
-    }).then(() => {
-      // Set an event hander
-      switchbot.onadvertisement = (ad: any) => {
-        this.serviceData = ad.serviceData;
-        this.movement = ad.serviceData.movement;
-        this.doorState = ad.serviceData.doorState;
-        this.lightLevel = ad.serviceData.lightLevel;
-        this.battery = ad.serviceData.battery;
-        this.debugLog(`Contact Sensor: ${this.accessory.displayName} serviceData: ${JSON.stringify(ad.serviceData)}`);
-        this.debugLog(`Contact Sensor: ${this.accessory.displayName} movement: ${ad.serviceData.movement}, doorState: `
-          + `${ad.serviceData.doorState}, lightLevel: ${ad.serviceData.lightLevel}, battery: ${ad.serviceData.battery}`);
-
-        if (this.serviceData) {
-          this.connected = true;
-          this.debugLog(`Contact Sensor: ${this.accessory.displayName} connected: ${this.connected}`);
+    if (switchbot !== false) {
+      switchbot.startScan({
+        model: 'd',
+        id: this.device.bleMac,
+      }).then(() => {
+        // Set an event hander
+        switchbot.onadvertisement = (ad: any) => {
+          this.serviceData = ad.serviceData;
+          this.movement = ad.serviceData.movement;
+          this.doorState = ad.serviceData.doorState;
+          this.lightLevel = ad.serviceData.lightLevel;
+          this.battery = ad.serviceData.battery;
+          this.debugLog(`Contact Sensor: ${this.accessory.displayName} serviceData: ${JSON.stringify(ad.serviceData)}`);
+          this.debugLog(`Contact Sensor: ${this.accessory.displayName} movement: ${ad.serviceData.movement}, doorState: `
+            + `${ad.serviceData.doorState}, lightLevel: ${ad.serviceData.lightLevel}, battery: ${ad.serviceData.battery}`);
+
+          if (this.serviceData) {
+            this.connected = true;
+            this.debugLog(`Contact Sensor: ${this.accessory.displayName} connected: ${this.connected}`);
+          } else {
+            this.connected = false;
+            this.debugLog(`Contact Sensor: ${this.accessory.displayName} connected: ${this.connected}`);
+          }
+        };
+        // Wait 2 seconds
+        return switchbot.wait(this.scanDuration * 1000);
+      }).then(async () => {
+        // Stop to monitor
+        switchbot.stopScan();
+        if (this.connected) {
+          this.parseStatus();
+          this.updateHomeKitCharacteristics();
         } else {
-          this.connected = false;
-          this.debugLog(`Contact Sensor: ${this.accessory.displayName} connected: ${this.connected}`);
+          this.errorLog(`Contact Sensor: ${this.accessory.displayName} wasn't able to establish BLE Connection`);
+          if (this.platform.config.credentials?.openToken) {
+            this.warnLog(`Contact Sensor: ${this.accessory.displayName} Using OpenAPI Connection`);
+            await this.openAPIRefreshStatus();
+          }
+        }
+      }).catch(async (e: any) => {
+        this.errorLog(`Contact Sensor: ${this.accessory.displayName} failed refreshStatus with BLE Connection`);
+        if (this.deviceLogging === 'debug') {
+          this.errorLog(`Contact Sensor: ${this.accessory.displayName} failed refreshStatus with BLE Connection,`
+            + ` Error Message: ${JSON.stringify(e.message)}`);
+        }
+        if (this.platform.debugMode) {
+          this.errorLog(`Contact Sensor: ${this.accessory.displayName} failed refreshStatus with BLE Connection,`
+            + ` Error: ${JSON.stringify(e)}`);
         }
-      };
-      // Wait 2 seconds
-      return switchbot.wait(this.scanDuration * 1000);
-    }).then(async () => {
-      // Stop to monitor
-      switchbot.stopScan();
-      if (this.connected) {
-        this.parseStatus();
-        this.updateHomeKitCharacteristics();
-      } else {
-        this.errorLog(`Contact Sensor: ${this.accessory.displayName} wasn't able to establish BLE Connection`);
         if (this.platform.config.credentials?.openToken) {
           this.warnLog(`Contact Sensor: ${this.accessory.displayName} Using OpenAPI Connection`);
           await this.openAPIRefreshStatus();
         }
-      }
-    }).catch(async (e: any) => {
-      this.errorLog(`Contact Sensor: ${this.accessory.displayName} failed refreshStatus with BLE Connection`);
-      if (this.deviceLogging === 'debug') {
-        this.errorLog(`Contact Sensor: ${this.accessory.displayName} failed refreshStatus with BLE Connection,`
-          + ` Error Message: ${JSON.stringify(e.message)}`);
-      }
-      if (this.platform.debugMode) {
-        this.errorLog(`Contact Sensor: ${this.accessory.displayName} failed refreshStatus with BLE Connection,`
-          + ` Error: ${JSON.stringify(e)}`);
-      }
-      if (this.platform.config.credentials?.openToken) {
-        this.warnLog(`Contact Sensor: ${this.accessory.displayName} Using OpenAPI Connection`);
-        await this.openAPIRefreshStatus();
-      }
-      this.apiError(e);
-    });
+        this.apiError(e);
+      });
+    } else {
+      await this.BLEconnection();
+    }
+  }
+
+  private async BLEconnection() {
+    this.errorLog(`Contact Sensor: ${this.accessory.displayName} wasn't able to establish BLE Connection`);
+    if (this.platform.config.credentials?.openToken) {
+      this.warnLog(`Contact Sensor: ${this.accessory.displayName} Using OpenAPI Connection`);
+      await this.openAPIRefreshStatus();
+    }
   }
 
   private async openAPIRefreshStatus() {

package/src/devices/curtains.ts

@@ -224,12 +224,12 @@ export class Curtain {
     if (this.device.scanDuration) {
       this.scanDuration = this.accessory.context.scanDuration = this.device.scanDuration;
       if (this.platform.debugMode || (this.deviceLogging === 'debug')) {
-        this.warnLog(`Bot: ${this.accessory.displayName} Using Device Config scanDuration: ${this.scanDuration}`);
+        this.warnLog(`Curtain: ${this.accessory.displayName} Using Device Config scanDuration: ${this.scanDuration}`);
       }
     } else {
       this.scanDuration = this.accessory.context.scanDuration = 1;
       if (this.platform.debugMode || (this.deviceLogging === 'debug')) {
-        this.warnLog(`Bot: ${this.accessory.displayName} Using Default scanDuration: ${this.scanDuration}`);
+        this.warnLog(`Curtain: ${this.accessory.displayName} Using Default scanDuration: ${this.scanDuration}`);
       }
     }
   }
@@ -254,16 +254,11 @@ export class Curtain {
   }
 
   private connectBLE() {
-    let Switchbot: any;
-    try {
-      Switchbot = require('node-switchbot');
-      const switchbot = new Switchbot();
-      this.device.bleMac = ((this.device.deviceId!.match(/.{1,2}/g))!.join(':')).toLowerCase();
-      this.debugLog(`Bot: ${this.accessory.displayName} BLE Address: ${this.device.bleMac}`);
-      return switchbot;
-    } catch (e) {
-      Switchbot = false;
-    }
+    // 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}`);
+    const switchbot = this.platform.connectBLE();
+    return switchbot;
   }
 
   private minStep(): number {
@@ -459,60 +454,72 @@ export class Curtain {
     // eslint-disable-next-line @typescript-eslint/no-var-requires
     const switchbot = this.connectBLE();
     // Start to monitor advertisement packets
-    switchbot.startScan({
-      model: 'c',
-      id: this.device.bleMac,
-    }).then(() => {
-      // Set an event hander
-      switchbot.onadvertisement = (ad: any) => {
-        this.serviceData = ad.serviceData;
-        this.calibration = ad.serviceData.calibration;
-        this.battery = ad.serviceData.battery;
-        this.position = ad.serviceData.position;
-        this.lightLevel = ad.serviceData.lightLevel;
-        this.debugLog(`Curtain: ${this.accessory.displayName} serviceData: ${JSON.stringify(ad.serviceData)}`);
-        this.debugLog(`Curtain: ${this.accessory.displayName} calibration: ${ad.serviceData.calibration}, `
-          + `position: ${ad.serviceData.position}, lightLevel: ${ad.serviceData.lightLevel}, battery: ${ad.serviceData.battery}`);
-
-        if (this.serviceData) {
-          this.connected = true;
-          this.debugLog(`Curtain: ${this.accessory.displayName} connected: ${this.connected}`);
+    if (switchbot !== false) {
+      switchbot.startScan({
+        model: 'c',
+        id: this.device.bleMac,
+      }).then(() => {
+        // Set an event hander
+        switchbot.onadvertisement = (ad: any) => {
+          this.serviceData = ad.serviceData;
+          this.calibration = ad.serviceData.calibration;
+          this.battery = ad.serviceData.battery;
+          this.position = ad.serviceData.position;
+          this.lightLevel = ad.serviceData.lightLevel;
+          this.debugLog(`Curtain: ${this.accessory.displayName} serviceData: ${JSON.stringify(ad.serviceData)}`);
+          this.debugLog(`Curtain: ${this.accessory.displayName} calibration: ${ad.serviceData.calibration}, `
+            + `position: ${ad.serviceData.position}, lightLevel: ${ad.serviceData.lightLevel}, battery: ${ad.serviceData.battery}`);
+
+          if (this.serviceData) {
+            this.connected = true;
+            this.debugLog(`Curtain: ${this.accessory.displayName} connected: ${this.connected}`);
+          } else {
+            this.connected = false;
+            this.debugLog(`Curtain: ${this.accessory.displayName} connected: ${this.connected}`);
+          }
+        };
+        // Wait 2 seconds
+        return switchbot.wait(this.scanDuration * 1000);
+      }).then(async () => {
+        // Stop to monitor
+        switchbot.stopScan();
+        if (this.connected) {
+          this.parseStatus();
+          this.updateHomeKitCharacteristics();
         } else {
-          this.connected = false;
-          this.debugLog(`Curtain: ${this.accessory.displayName} connected: ${this.connected}`);
+          this.errorLog(`Curtain: ${this.accessory.displayName} wasn't able to establish BLE Connection`);
+          if (this.platform.config.credentials?.openToken) {
+            this.warnLog(`Curtain: ${this.accessory.displayName} Using OpenAPI Connection`);
+            await this.openAPIRefreshStatus();
+          }
+        }
+      }).catch(async (e: any) => {
+        this.errorLog(`Curtain: ${this.accessory.displayName} failed refreshStatus with BLE Connection`);
+        if (this.deviceLogging === 'debug') {
+          this.errorLog(`Curtain: ${this.accessory.displayName} failed refreshStatus with BLE Connection,`
+            + ` Error Message: ${JSON.stringify(e.message)}`);
+        }
+        if (this.platform.debugMode) {
+          this.errorLog(`Curtain: ${this.accessory.displayName} failed refreshStatus with BLE Connection,`
+            + ` Error: ${JSON.stringify(e)}`);
         }
-      };
-      // Wait 2 seconds
-      return switchbot.wait(this.scanDuration * 1000);
-    }).then(async () => {
-      // Stop to monitor
-      switchbot.stopScan();
-      if (this.connected) {
-        this.parseStatus();
-        this.updateHomeKitCharacteristics();
-      } else {
-        this.errorLog(`Curtain: ${this.accessory.displayName} wasn't able to establish BLE Connection`);
         if (this.platform.config.credentials?.openToken) {
           this.warnLog(`Curtain: ${this.accessory.displayName} Using OpenAPI Connection`);
           await this.openAPIRefreshStatus();
         }
-      }
-    }).catch(async (e: any) => {
-      this.errorLog(`Curtain: ${this.accessory.displayName} failed refreshStatus with BLE Connection`);
-      if (this.deviceLogging === 'debug') {
-        this.errorLog(`Curtain: ${this.accessory.displayName} failed refreshStatus with BLE Connection,`
-          + ` Error Message: ${JSON.stringify(e.message)}`);
-      }
-      if (this.platform.debugMode) {
-        this.errorLog(`Curtain: ${this.accessory.displayName} failed refreshStatus with BLE Connection,`
-          + ` Error: ${JSON.stringify(e)}`);
-      }
-      if (this.platform.config.credentials?.openToken) {
-        this.warnLog(`Curtain: ${this.accessory.displayName} Using OpenAPI Connection`);
-        await this.openAPIRefreshStatus();
-      }
-      this.apiError(e);
-    });
+        this.apiError(e);
+      });
+    } else {
+      await this.BLEconnection();
+    }
+  }
+
+  private async BLEconnection() {
+    this.errorLog(`Curtain: ${this.accessory.displayName} wasn't able to establish BLE Connection`);
+    if (this.platform.config.credentials?.openToken) {
+      this.warnLog(`Curtain: ${this.accessory.displayName} Using OpenAPI Connection`);
+      await this.openAPIRefreshStatus();
+    }
   }
 
   private async openAPIRefreshStatus() {
@@ -542,7 +549,7 @@ export class Curtain {
     if (this.device.ble) {
       await this.BLEpushChanges();
     } else {
-      await this.OpenAPIpushChanges();
+      await this.openAPIpushChanges();
     }
     interval(5000)
       .pipe(skipWhile(() => this.curtainUpdateInProgress))
@@ -556,34 +563,42 @@ export class Curtain {
     if (this.TargetPosition !== this.CurrentPosition) {
       this.debugLog(`Curtain: ${this.accessory.displayName} BLE pushChanges`);
       const switchbot = this.connectBLE();
-      switchbot.discover({ model: 'c', quick: true, id: this.device.bleMac }).then((device_list) => {
-        this.infoLog(`${this.accessory.displayName} Target Position: ${this.TargetPosition}`);
-        return device_list[0].runToPos(100 - Number(this.TargetPosition));
-      }).then(() => {
-        this.debugLog(`Curtain: ${this.accessory.displayName} Done.`);
-      }).catch(async (e: any) => {
-        this.errorLog(`Curtain: ${this.accessory.displayName} failed pushChanges with BLE Connection`);
-        if (this.deviceLogging === 'debug') {
-          this.errorLog(`Curtain: ${this.accessory.displayName} failed pushChanges with BLE Connection,`
-            + ` Error Message: ${JSON.stringify(e.message)}`);
-        }
-        if (this.platform.debugMode) {
-          this.errorLog(`Curtain: ${this.accessory.displayName} failed pushChanges with BLE Connection,`
-            + ` Error: ${JSON.stringify(e)}`);
-        }
+      if (switchbot !== false) {
+        switchbot.discover({ model: 'c', quick: true, id: this.device.bleMac }).then((device_list) => {
+          this.infoLog(`${this.accessory.displayName} Target Position: ${this.TargetPosition}`);
+          return device_list[0].runToPos(100 - Number(this.TargetPosition));
+        }).then(() => {
+          this.debugLog(`Curtain: ${this.accessory.displayName} Done.`);
+        }).catch(async (e: any) => {
+          this.errorLog(`Curtain: ${this.accessory.displayName} failed pushChanges with BLE Connection`);
+          if (this.deviceLogging === 'debug') {
+            this.errorLog(`Curtain: ${this.accessory.displayName} failed pushChanges with BLE Connection,`
+              + ` Error Message: ${JSON.stringify(e.message)}`);
+          }
+          if (this.platform.debugMode) {
+            this.errorLog(`Curtain: ${this.accessory.displayName} failed pushChanges with BLE Connection,`
+              + ` Error: ${JSON.stringify(e)}`);
+          }
+          if (this.platform.config.credentials?.openToken) {
+            this.warnLog(`Curtain: ${this.accessory.displayName} Using OpenAPI Connection`);
+            await this.openAPIpushChanges();
+          }
+          this.apiError(e);
+        });
+      } else {
+        this.errorLog(`Curtain: ${this.accessory.displayName} wasn't able to establish BLE Connection`);
         if (this.platform.config.credentials?.openToken) {
           this.warnLog(`Curtain: ${this.accessory.displayName} Using OpenAPI Connection`);
-          await this.OpenAPIpushChanges();
+          await this.openAPIpushChanges();
         }
-        this.apiError(e);
-      });
+      }
     } else {
       this.debugLog(`Curtain: ${this.accessory.displayName} No BLE Changes, CurrentPosition & TargetPosition Are the Same.`
         + `  CurrentPosition: ${this.CurrentPosition}, TargetPosition  ${this.TargetPosition}`);
     }
   }
 
-  private async OpenAPIpushChanges() {
+  private async openAPIpushChanges() {
     if (this.platform.config.credentials?.openToken) {
       try {
         this.debugLog(`Curtain: ${this.accessory.displayName} OpenAPI pushChanges`);