node-switchbot 1.3.0 → 1.4.2-beta.0

package/lib/switchbot-device-woplugmini.js

@@ -0,0 +1,81 @@
+"use strict";
+const SwitchbotDevice = require("./switchbot-device.js");
+
+/**
+ * @see https://github.com/OpenWonderLabs/SwitchBotAPI-BLE/blob/latest/devicetypes/plugmini.md
+ */
+class SwitchbotDeviceWoPlugMini extends SwitchbotDevice {
+  /**
+   * @returns {Promise<boolean>} resolves with a boolean that tells whether the plug in ON(true) or OFF(false)
+   */
+  readState() {
+    return this._operateBot([0x57, 0x0f, 0x51, 0x01]);
+  }
+
+  /**
+   * @private
+   */
+  _setState(reqByteArray) {
+    const base = [0x57, 0x0f, 0x50, 0x01];
+    return this._operateBot([].concat(base, reqByteArray));
+  }
+
+  /**
+   * @returns {Promise<boolean>} resolves with a boolean that tells whether the plug in ON(true) or OFF(false)
+   */
+  turnOn() {
+    return this._setState([0x01, 0x80]);
+  }
+
+  /**
+   * @returns {Promise<boolean>} resolves with a boolean that tells whether the plug in ON(true) or OFF(false)
+   */
+  turnOff() {
+    return this._setState([0x01, 0x00]);
+  }
+
+  /**
+   * @returns {Promise<boolean>} resolves with a boolean that tells whether the plug in ON(true) or OFF(false)
+   */
+  toggle() {
+    return this._setState([0x02, 0x80]);
+  }
+
+  /**
+   * @private
+   */
+  _operateBot(bytes) {
+    const req_buf = Buffer.from(bytes);
+    return new Promise((resolve, reject) => {
+      this._command(req_buf)
+        .then((res_bytes) => {
+          const res_buf = Buffer.from(res_bytes);
+          if (res_buf.length === 2) {
+            let code = res_buf.readUInt8(1);
+            if (code === 0x00 || code === 0x80) {
+              const is_on = code === 0x80;
+              resolve(is_on);
+            } else {
+              reject(
+                new Error(
+                  "The device returned an error: 0x" + res_buf.toString("hex")
+                )
+              );
+            }
+          } else {
+            reject(
+              new Error(
+                "Expecting a 2-byte response, got instead: 0x" +
+                  res_buf.toString("hex")
+              )
+            );
+          }
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  }
+}
+
+module.exports = SwitchbotDeviceWoPlugMini;

package/lib/switchbot-device-wopresence.js

@@ -1,9 +1,6 @@
-'use strict';
-const SwitchbotDevice = require('./switchbot-device.js');
+"use strict";
+const SwitchbotDevice = require("./switchbot-device.js");
 
-class SwitchbotDeviceWoPresence extends SwitchbotDevice {
+class SwitchbotDeviceWoPresence extends SwitchbotDevice {}
 
-
-}
-
-module.exports = SwitchbotDeviceWoPresence;
+module.exports = SwitchbotDeviceWoPresence;

package/lib/switchbot-device-wosensorth.js

@@ -1,9 +1,6 @@
-'use strict';
-const SwitchbotDevice = require('./switchbot-device.js');
+"use strict";
+const SwitchbotDevice = require("./switchbot-device.js");
 
-class SwitchbotDeviceWoSensorTH extends SwitchbotDevice {
+class SwitchbotDeviceWoSensorTH extends SwitchbotDevice {}
 
-
-}
-
-module.exports = SwitchbotDeviceWoSensorTH;
+module.exports = SwitchbotDeviceWoSensorTH;

package/lib/switchbot-device.js

@@ -1,25 +1,25 @@
-'use strict';
-const parameterChecker = require('./parameter-checker.js');
-const switchbotAdvertising = require('./switchbot-advertising.js');
+"use strict";
+const parameterChecker = require("./parameter-checker.js");
+const switchbotAdvertising = require("./switchbot-advertising.js");
 
 class SwitchbotDevice {
   /* ------------------------------------------------------------------
-  * Constructor
-  *
-  * [Arguments]
-  * - peripheral | Object | Required | The `peripheral` object of noble,
-  *              |        |          | which represents this device
-  * - noble      | Noble  | Required | The Nobel object created by the noble module.
-  * ---------------------------------------------------------------- */
+   * Constructor
+   *
+   * [Arguments]
+   * - peripheral | Object | Required | The `peripheral` object of noble,
+   *              |        |          | which represents this device
+   * - noble      | Noble  | Required | The Nobel object created by the noble module.
+   * ---------------------------------------------------------------- */
   constructor(peripheral, noble) {
     this._peripheral = peripheral;
     this._noble = noble;
     this._chars = null;
 
-    this._SERV_UUID_PRIMARY = 'cba20d00224d11e69fb80002a5d5c51b';
-    this._CHAR_UUID_WRITE = 'cba20002224d11e69fb80002a5d5c51b';
-    this._CHAR_UUID_NOTIFY = 'cba20003224d11e69fb80002a5d5c51b';
-    this._CHAR_UUID_DEVICE = '2a00';
+    this._SERV_UUID_PRIMARY = "cba20d00224d11e69fb80002a5d5c51b";
+    this._CHAR_UUID_WRITE = "cba20002224d11e69fb80002a5d5c51b";
+    this._CHAR_UUID_NOTIFY = "cba20003224d11e69fb80002a5d5c51b";
+    this._CHAR_UUID_DEVICE = "2a00";
 
     this._READ_TIMEOUT_MSEC = 3000;
     this._WRITE_TIMEOUT_MSEC = 3000;
@@ -35,10 +35,10 @@ class SwitchbotDevice {
     this._was_connected_explicitly = false;
     this._connected = false;
 
-    this._onconnect = () => { };
-    this._ondisconnect = () => { };
-    this._ondisconnect_internal = () => { };
-    this._onnotify_internal = () => { };
+    this._onconnect = () => {};
+    this._ondisconnect = () => {};
+    this._ondisconnect_internal = () => {};
+    this._onnotify_internal = () => {};
   }
 
   // Getters
@@ -55,8 +55,8 @@ class SwitchbotDevice {
     return this._modelName;
   }
   get connectionState() {
-    if (!this._connected && this._peripheral.state === 'disconnecting') {
-      return 'disconnected';
+    if (!this._connected && this._peripheral.state === "disconnecting") {
+      return "disconnected";
     } else {
       return this._peripheral.state;
     }
@@ -64,29 +64,29 @@ class SwitchbotDevice {
 
   // Setters
   set onconnect(func) {
-    if (!func || typeof (func) !== 'function') {
-      throw new Error('The `onconnect` must be a function.');
+    if (!func || typeof func !== "function") {
+      throw new Error("The `onconnect` must be a function.");
     }
     this._onconnect = func;
   }
   set ondisconnect(func) {
-    if (!func || typeof (func) !== 'function') {
-      throw new Error('The `ondisconnect` must be a function.');
+    if (!func || typeof func !== "function") {
+      throw new Error("The `ondisconnect` must be a function.");
     }
     this._ondisconnect = func;
   }
 
   /* ------------------------------------------------------------------
-  * connect()
-  * - Connect the device
-  *
-  * [Arguments]
-  * -  none
-  *
-  * [Return value]
-  * - Promise object
-  *   Nothing will be passed to the `resolve()`.
-  * ---------------------------------------------------------------- */
+   * connect()
+   * - Connect the device
+   *
+   * [Arguments]
+   * -  none
+   *
+   * [Return value]
+   * - Promise object
+   *   Nothing will be passed to the `resolve()`.
+   * ---------------------------------------------------------------- */
   connect() {
     this._was_connected_explicitly = true;
     return this._connect();
@@ -95,28 +95,34 @@ class SwitchbotDevice {
   _connect() {
     return new Promise((resolve, reject) => {
       // Check the bluetooth state
-      if (this._noble.state !== 'poweredOn') {
-        reject(new Error('The Bluetooth status is ' + this._noble.state + ', not poweredOn.'));
+      if (this._noble.state !== "poweredOn") {
+        reject(
+          new Error(
+            "The Bluetooth status is " + this._noble.state + ", not poweredOn."
+          )
+        );
         return;
       }
 
       // Check the connection state
       let state = this.connectionState;
-      if (state === 'connected') {
+      if (state === "connected") {
         resolve();
         return;
-      } else if (state === 'connecting' || state === 'disconnecting') {
-        reject(new Error('Now ' + state + '. Wait for a few seconds then try again.'));
+      } else if (state === "connecting" || state === "disconnecting") {
+        reject(
+          new Error("Now " + state + ". Wait for a few seconds then try again.")
+        );
         return;
       }
 
       // Set event handlers for events fired on the `Peripheral` object
-      this._peripheral.once('connect', () => {
+      this._peripheral.once("connect", () => {
         this._connected = true;
         this._onconnect();
       });
 
-      this._peripheral.once('disconnect', () => {
+      this._peripheral.once("disconnect", () => {
         this._connected = false;
         this._chars = null;
         this._peripheral.removeAllListeners();
@@ -130,15 +136,18 @@ class SwitchbotDevice {
           reject(error);
           return;
         }
-        this._getCharacteristics().then((chars) => {
-          this._chars = chars;
-          return this._subscribe();
-        }).then(() => {
-          resolve();
-        }).catch((error) => {
-          this._peripheral.disconnect();
-          reject(error);
-        });
+        this._getCharacteristics()
+          .then((chars) => {
+            this._chars = chars;
+            return this._subscribe();
+          })
+          .then(() => {
+            resolve();
+          })
+          .catch((error) => {
+            this._peripheral.disconnect();
+            reject(error);
+          });
       });
     });
   }
@@ -147,9 +156,11 @@ class SwitchbotDevice {
     return new Promise((resolve, reject) => {
       // Set timeout timer
       let timer = setTimeout(() => {
-        this._ondisconnect_internal = () => { };
+        this._ondisconnect_internal = () => {};
         timer = null;
-        reject(new Error('Failed to discover services and characteristics: TIMEOUT'));
+        reject(
+          new Error("Failed to discover services and characteristics: TIMEOUT")
+        );
       }, 5000);
 
       // Watch the connection state
@@ -157,22 +168,26 @@ class SwitchbotDevice {
         if (timer) {
           clearTimeout(timer);
           timer = null;
-          this._ondisconnect_internal = () => { };
+          this._ondisconnect_internal = () => {};
         }
-        reject(new Error('Failed to discover services and characteristics: DISCONNECTED'));
+        reject(
+          new Error(
+            "Failed to discover services and characteristics: DISCONNECTED"
+          )
+        );
       };
 
       // Discover services and characteristics
       (async () => {
         let service_list = await this._discoverServices();
         if (!timer) {
-          throw new Error('');
+          throw new Error("");
         }
 
         let chars = {
           write: null,
           notify: null,
-          device: null
+          device: null,
         };
 
         for (let service of service_list) {
@@ -192,14 +207,13 @@ class SwitchbotDevice {
         if (chars.write && chars.notify) {
           resolve(chars);
         } else {
-          reject(new Error('No characteristic was found.'));
+          reject(new Error("No characteristic was found."));
         }
-
       })().catch((error) => {
         if (timer) {
           clearTimeout(timer);
           timer = null;
-          this._ondisconnect_internal = () => { };
+          this._ondisconnect_internal = () => {};
           reject(error);
         } else {
           // Do nothing
@@ -226,7 +240,7 @@ class SwitchbotDevice {
         if (service) {
           resolve(service_list);
         } else {
-          reject(new Error('No service was found.'));
+          reject(new Error("No service was found."));
         }
       });
     });
@@ -248,7 +262,7 @@ class SwitchbotDevice {
     return new Promise((resolve, reject) => {
       let char = this._chars.notify;
       if (!char) {
-        reject(new Error('No notify characteristic was found.'));
+        reject(new Error("No notify characteristic was found."));
         return;
       }
       char.subscribe((error) => {
@@ -256,11 +270,11 @@ class SwitchbotDevice {
           reject(error);
           return;
         }
-        char.on('data', (buf) => {
+        char.on("data", (buf) => {
           this._onnotify_internal(buf);
         });
         resolve();
-      })
+      });
     });
   }
 
@@ -279,26 +293,28 @@ class SwitchbotDevice {
   }
 
   /* ------------------------------------------------------------------
-  * disconnect()
-  * - Disconnect the device
-  *
-  * [Arguments]
-  * -  none
-  *
-  * [Return value]
-  * - Promise object
-  *   Nothing will be passed to the `resolve()`.
-  * ---------------------------------------------------------------- */
+   * disconnect()
+   * - Disconnect the device
+   *
+   * [Arguments]
+   * -  none
+   *
+   * [Return value]
+   * - Promise object
+   *   Nothing will be passed to the `resolve()`.
+   * ---------------------------------------------------------------- */
   disconnect() {
     return new Promise((resolve, reject) => {
       this._was_connected_explicitly = false;
       // Check the connection state
       let state = this._peripheral.state;
-      if (state === 'disconnected') {
+      if (state === "disconnected") {
         resolve();
         return;
-      } else if (state === 'connecting' || state === 'disconnecting') {
-        reject(new Error('Now ' + state + '. Wait for a few seconds then try again.'));
+      } else if (state === "connecting" || state === "disconnecting") {
+        reject(
+          new Error("Now " + state + ". Wait for a few seconds then try again.")
+        );
         return;
       }
 
@@ -323,74 +339,93 @@ class SwitchbotDevice {
   }
 
   /* ------------------------------------------------------------------
-  * getDeviceName()
-  * - Retrieve the device name
-  *
-  * [Arguments]
-  * -  none
-  *
-  * [Return value]
-  * - Promise object
-  *   The device name will be passed to the `resolve()`.
-  * ---------------------------------------------------------------- */
+   * getDeviceName()
+   * - Retrieve the device name
+   *
+   * [Arguments]
+   * -  none
+   *
+   * [Return value]
+   * - Promise object
+   *   The device name will be passed to the `resolve()`.
+   * ---------------------------------------------------------------- */
   getDeviceName() {
     return new Promise((resolve, reject) => {
-      let name = '';
-      this._connect().then(() => {
-        if (!this._chars.device) {
-          // Some models of Bot don't seem to support this characteristic UUID
-          throw new Error('The device does not support the characteristic UUID 0x' + this._CHAR_UUID_DEVICE + '.');
-        }
-        return this._read(this._chars.device);
-      }).then((buf) => {
-        name = buf.toString('utf8');
-        return this._disconnect();
-      }).then(() => {
-        resolve(name);
-      }).catch((error) => {
-        reject(error);
-      });
+      let name = "";
+      this._connect()
+        .then(() => {
+          if (!this._chars.device) {
+            // Some models of Bot don't seem to support this characteristic UUID
+            throw new Error(
+              "The device does not support the characteristic UUID 0x" +
+                this._CHAR_UUID_DEVICE +
+                "."
+            );
+          }
+          return this._read(this._chars.device);
+        })
+        .then((buf) => {
+          name = buf.toString("utf8");
+          return this._disconnect();
+        })
+        .then(() => {
+          resolve(name);
+        })
+        .catch((error) => {
+          reject(error);
+        });
     });
   }
 
   /* ------------------------------------------------------------------
-  * setDeviceName(name)
-  * - Set the device name
-  *
-  * [Arguments]
-  * - name | String | Required | Device name. The bytes length of the name
-  *        |        |          | must be in the range of 1 to 20 bytes.
-  *
-  * [Return value]
-  * - Promise object
-  *   Nothing will be passed to the `resolve()`.
-  * ---------------------------------------------------------------- */
+   * setDeviceName(name)
+   * - Set the device name
+   *
+   * [Arguments]
+   * - name | String | Required | Device name. The bytes length of the name
+   *        |        |          | must be in the range of 1 to 20 bytes.
+   *
+   * [Return value]
+   * - Promise object
+   *   Nothing will be passed to the `resolve()`.
+   * ---------------------------------------------------------------- */
   setDeviceName(name) {
     return new Promise((resolve, reject) => {
       // Check the parameters
-      let valid = parameterChecker.check({ name: name }, {
-        name: { required: true, type: 'string', minBytes: 1, maxBytes: 100 }
-      });
+      let valid = parameterChecker.check(
+        { name: name },
+        {
+          name: { required: true, type: "string", minBytes: 1, maxBytes: 100 },
+        }
+      );
 
       if (!valid) {
         reject(new Error(parameterChecker.error.message));
         return;
       }
 
-      let buf = Buffer.from(name, 'utf8');
-      this._connect().then(() => {
-        if (!this._chars.device) {
-          // Some models of Bot don't seem to support this characteristic UUID
-          throw new Error('The device does not support the characteristic UUID 0x' + this._CHAR_UUID_DEVICE + '.');
-        }
-        return this._write(this._chars.device, buf);
-      }).then(() => {
-        return this._disconnect();
-      }).then(() => {
-        resolve();
-      }).catch((error) => {
-        reject(error);
-      });
+      let buf = Buffer.from(name, "utf8");
+      this._connect()
+        .then(() => {
+          if (!this._chars.device) {
+            // Some models of Bot don't seem to support this characteristic UUID
+            throw new Error(
+              "The device does not support the characteristic UUID 0x" +
+                this._CHAR_UUID_DEVICE +
+                "."
+            );
+          }
+          return this._write(this._chars.device, buf);
+        })
+        .then(() => {
+          return this._disconnect();
+        })
+        .then(() => {
+          resolve();
+        })
+        .catch((error) => {
+          reject(error);
+        });
     });
   }
 
@@ -400,24 +435,29 @@ class SwitchbotDevice {
   _command(req_buf) {
     return new Promise((resolve, reject) => {
       if (!Buffer.isBuffer(req_buf)) {
-        reject(new Error('The specified data is not acceptable for writing.'));
+        reject(new Error("The specified data is not acceptable for writing."));
         return;
       }
 
       let res_buf = null;
 
-      this._connect().then(() => {
-        return this._write(this._chars.write, req_buf);
-      }).then(() => {
-        return this._waitCommandResponse();
-      }).then((buf) => {
-        res_buf = buf;
-        return this._disconnect();
-      }).then(() => {
-        resolve(res_buf);
-      }).catch((error) => {
-        reject(error);
-      });
+      this._connect()
+        .then(() => {
+          return this._write(this._chars.write, req_buf);
+        })
+        .then(() => {
+          return this._waitCommandResponse();
+        })
+        .then((buf) => {
+          res_buf = buf;
+          return this._disconnect();
+        })
+        .then(() => {
+          resolve(res_buf);
+        })
+        .catch((error) => {
+          reject(error);
+        });
     });
   }
 
@@ -425,8 +465,8 @@ class SwitchbotDevice {
     return new Promise((resolve, reject) => {
       let timer = setTimeout(() => {
         timer = null;
-        this._onnotify_internal = () => { };
-        reject(new Error('COMMAND_TIMEOUT'));
+        this._onnotify_internal = () => {};
+        reject(new Error("COMMAND_TIMEOUT"));
       }, this._COMMAND_TIMEOUT_MSEC);
 
       this._onnotify_internal = (buf) => {
@@ -434,7 +474,7 @@ class SwitchbotDevice {
           clearTimeout(timer);
           timer = null;
         }
-        this._onnotify_internal = () => { };
+        this._onnotify_internal = () => {};
         resolve(buf);
       };
     });
@@ -445,7 +485,7 @@ class SwitchbotDevice {
     return new Promise((resolve, reject) => {
       // Set a timeout timer
       let timer = setTimeout(() => {
-        reject('READ_TIMEOUT');
+        reject("READ_TIMEOUT");
       }, this._READ_TIMEOUT_MSEC);
 
       // Read charcteristic data
@@ -468,7 +508,7 @@ class SwitchbotDevice {
     return new Promise((resolve, reject) => {
       // Set a timeout timer
       let timer = setTimeout(() => {
-        reject('WRITE_TIMEOUT');
+        reject("WRITE_TIMEOUT");
       }, this._WRITE_TIMEOUT_MSEC);
 
       // write charcteristic data
@@ -485,7 +525,6 @@ class SwitchbotDevice {
       });
     });
   }
-
 }
 
-module.exports = SwitchbotDevice;
+module.exports = SwitchbotDevice;