node-red-contrib-homebridge-automation 0.1.12-beta.11 → 0.1.12-beta.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-homebridge-automation",
-  "version": "0.1.12-beta.11",
+  "version": "0.1.12-beta.12",
   "description": "NodeRED Automation for HomeBridge",
   "main": "src/HAP-NodeRed.js",
   "scripts": {
@@ -62,7 +62,7 @@
     ],
     "ext": "js,html",
     "ignore": [],
-    "exec": "DEBUG=hapNodeRed ~/npm/bin/node-red -u test/node-red",
+    "exec": "npm run lint && DEBUG=hapNodeRed ~/npm/bin/node-red -u test/node-red",
     "signal": "SIGTERM",
     "env": {
       "NODE_OPTIONS": "--trace-warnings"

package/src/HAP-NodeRed.js

@@ -3,6 +3,7 @@ var Queue = require('better-queue');
 // var register = require('./lib/register.js');
 
 const HBConfNode = require('./hbConfigNode');
+const HbEventNode = require('./hbEventNode'); // Import the class
 
 module.exports = function (RED) {
   var evDevices = [];
@@ -54,129 +55,14 @@ module.exports = function (RED) {
    * @return {type}   description
    */
 
-  function hbEvent(n) {
-    // debug("hbEvent", n);
+  function hbEventNode(n) {
     RED.nodes.createNode(this, n);
-    this.conf = RED.nodes.getNode(n.conf);
-    this.confId = n.conf;
-    this.device = n.device;
-    this.service = n.Service;
-    this.name = n.name;
-    this.fullName = n.name + ' - ' + n.Service;
-    this.sendInitialState = n.sendInitialState === true;
-    this.state = {};
-
-    var node = this;
-
-    node.command = function (event) {
-      // False messages can be received from accessories with multiple services
-      // if (Object.keys(_convertHBcharactericToNode(event, node)).length > 0) {
-      // debug("hbEvent", node.name, event);
-      if (event.status === true && event.value !== undefined) {
-        node.state = Object.assign(node.state, _convertHBcharactericToNode([event], node));
-        var msg = {
-          name: node.name,
-          payload: node.state,
-          Homebridge: node.hbDevice.homebridge,
-          Manufacturer: node.hbDevice.manufacturer,
-          Service: node.hbDevice.deviceType,
-          _device: node.device,
-          _confId: node.confId,
-          _rawEvent: event
-        };
-        node.status({
-          text: JSON.stringify(msg.payload).slice(0, 30) + '...',
-          shape: 'dot',
-          fill: 'green'
-        });
-        clearTimeout(node.timeout);
-        node.timeout = setTimeout(function () {
-          node.status({});
-        }, 10 * 1000);
-        node.send(msg);
-      } else if (event.status === true) {
-        node.status({
-          text: 'connected',
-          shape: 'dot',
-          fill: 'green'
-        });
-      } else {
-        node.status({
-          text: 'disconnected: ' + event.status,
-          shape: 'ring',
-          fill: 'red'
-        });
-      }
-    };
-    // };
-
-    node.conf.register(node, function () {
-      debug("hbEvent.register", node.fullName);
-      this.hbDevice = hbDevices.findDevice(node.device, {
-        perms: 'pr'
-      });
-      if (this.hbDevice) {
-        node.hbDevice = this.hbDevice;
-        node.deviceType = this.hbDevice.deviceType;
-
-        _status(node.device, node, {
-          perms: 'ev'
-        }, function (err, message) {
-          if (!err) {
-            node.state = _convertHBcharactericToNode(message.characteristics, node);
-            debug("hbEvent received: %s = %s", node.fullName, JSON.stringify(message.characteristics).slice(0, 80) + '...');
-            if (node.sendInitialState) {
-              var msg = {
-                name: node.name,
-                payload: node.state,
-                Homebridge: node.hbDevice.homebridge,
-                Manufacturer: node.hbDevice.manufacturer,
-                Service: node.hbDevice.deviceType,
-                _device: node.device,
-                _confId: node.confId,
-                _rawMessage: message,
-              };
-              node.status({
-                text: JSON.stringify(msg.payload).slice(0, 30) + '...',
-                shape: 'dot',
-                fill: 'green'
-              });
-              clearTimeout(node.timeout);
-              node.timeout = setTimeout(function () {
-                node.status({});
-              }, 10 * 1000);
-              node.send(msg);
-            }
-          } else {
-            node.error("hbEvent _status: error", node.fullName, err);
-          }
-        });
-        // Register for events
-        node.listener = node.command;
-        node.eventName = [];
-        // node.eventName = this.hbDevice.host + this.hbDevice.port + this.hbDevice.aid;
-        // debug("DEVICE", this.hbDevice);
-        this.hbDevice.eventRegisters.forEach(function (event) {
-          homebridge.on(node.hbDevice.id + event.aid + event.iid, node.command);
-          node.eventName.push(node.hbDevice.id + event.aid + event.iid);
-        });
-        // homebridge.on(this.hbDevice.host + this.hbDevice.port + this.hbDevice.aid, node.command);
-        node.status({
-          text: 'connected',
-          shape: 'dot',
-          fill: 'green'
-        });
-      } else {
-        node.error("197:Can't find device " + node.device, null);
-      }
-    }.bind(this));
-
-    node.on('close', function (callback) {
-      node.conf.deregister(node, callback);
-    });
+    
+    // Create instance of HbEventNode class to handle events
+    new HbEventNode(this, n); // Pass current node and config object
   }
 
-  RED.nodes.registerType("hb-event", hbEvent);
+  RED.nodes.registerType("hb-event", hbEventNode);
 
   /**
    * hbResume - description
@@ -199,7 +85,7 @@ module.exports = function (RED) {
    * @return {type}   description
    */
 
-  function hbResume(n) {
+  function hbResumeNode(n) {
     RED.nodes.createNode(this, n);
     this.conf = RED.nodes.getNode(n.conf);
     this.confId = n.conf;

package/src/hbConfigNode.js

@@ -1,32 +1,32 @@
 const HAPNodeJSClient = require('hap-node-client').HAPNodeJSClient;
 const debug = require('debug')('hapNodeRed:hbConfigNode');
-var Homebridges = require('./lib/Homebridges.js').Homebridges;
+const { Homebridges } = require('./lib/Homebridges.js');
 
 class HBConfNode {
-  constructor(n, RED) {
+  constructor(nodeConfig, RED) {
     this.RED = RED;
-    this.username = n.username;
-    this.macAddress = n.macAddress || '';
-    this.password = n.credentials.password;
+    this.username = nodeConfig.username;
+    this.macAddress = nodeConfig.macAddress || '';
+    this.password = nodeConfig.credentials.password;
     this.users = {};
     this.homebridge = null;
 
-    this.initHomebridge(n);
+    this.initHomebridge(nodeConfig);
   }
 
-  initHomebridge(n) {
+  initHomebridge(nodeConfig) {
     if (this.homebridge) {
       if (this.macAddress) {
         // Register additional PIN on existing instance
-        this.homebridge.RegisterPin(this.macAddress, n.username);
+        this.homebridge.RegisterPin(this.macAddress, nodeConfig.username);
       }
     } else {
       this.homebridge = new HAPNodeJSClient({
-        pin: n.username,
+        pin: nodeConfig.username,
         refresh: 900,
         debug: false,
         timeout: 20,
-        reqTimeout: 7000
+        reqTimeout: 7000,
       });
       this.homebridge.on('Ready', this.handleReady.bind(this));
     }
@@ -36,58 +36,59 @@ class HBConfNode {
     const hbDevices = new Homebridges(accessories);
     debug('Discovered %s new evDevices', hbDevices.toList({ perms: 'ev' }).length);
 
-    let list = hbDevices.toList({ perms: 'ev' });
+    const list = hbDevices.toList({ perms: 'ev' });
     this.handleDuplicates(list);
   }
 
   handleDuplicates(list) {
-    let deleteSeen = [];
+    const deleteSeen = new Set();
 
-    for (let i = 0; i < list.length; i++) {
-      const endpoint = list[i];
-      if (deleteSeen[endpoint.fullName]) {
-        console.log("WARNING: Duplicate device name", endpoint.fullName);
+    for (const endpoint of list) {
+      if (deleteSeen.has(endpoint.fullName)) {
+        console.warn('WARNING: Duplicate device name', endpoint.fullName);
       } else {
-        deleteSeen[endpoint.fullName] = true;
+        deleteSeen.add(endpoint.fullName);
       }
     }
 
-    deleteSeen = [];
+    deleteSeen.clear();
 
-    for (let i = 0; i < list.length; i++) {
-      const endpoint = list[i];
-      if (deleteSeen[endpoint.uniqueId]) {
-        console.log("ERROR: Parsing failed, duplicate uniqueID.", endpoint.fullName);
+    for (const endpoint of list) {
+      if (deleteSeen.has(endpoint.uniqueId)) {
+        console.error('ERROR: Parsing failed, duplicate uniqueID.', endpoint.fullName);
       } else {
-        deleteSeen[endpoint.uniqueId] = true;
+        deleteSeen.add(endpoint.uniqueId);
       }
     }
   }
 
   register(deviceNode, callback) {
-    debug("hbConf.register", deviceNode.fullName);
+    debug('hbConf.register', deviceNode.fullName);
     this.users[deviceNode.id] = deviceNode;
-    debug("Register %s -> %s", deviceNode.type, deviceNode.fullName);
-    reqisterQueue.push({
-      that: this,
-      device: deviceNode.device,
-      type: deviceNode.type,
-      name: deviceNode.name,
-      fullName: deviceNode.fullName,
-      node: this
-    }, callback);
+    debug('Register %s -> %s', deviceNode.type, deviceNode.fullName);
+    reqisterQueue.push(
+      {
+        that: this,
+        device: deviceNode.device,
+        type: deviceNode.type,
+        name: deviceNode.name,
+        fullName: deviceNode.fullName,
+        node: this,
+      },
+      callback
+    );
   }
 
   deregister(deviceNode, callback) {
     deviceNode.status({
       text: 'disconnected',
       shape: 'ring',
-      fill: 'red'
+      fill: 'red',
     });
 
-    deviceNode.eventName.forEach((event) => {
+    for (const event of deviceNode.eventName) {
       this.homebridge.removeListener(event, deviceNode.listener);
-    });
+    }
 
     callback();
   }

package/src/hbEventNode.js

@@ -1,130 +1,135 @@
-/**
-   * hbEventNode - Node that listens to HomeKit Events, and sends message into NodeRED
-   *
-   * @param  {type} n description
-   * @return {type}   description
-   */
+const debug = require('debug')('hapNodeRed:hbEventNode');
 
-function hbEventNode(n) {
-  // debug("hbEvent", n);
-  RED.nodes.createNode(this, n);
-  this.conf = RED.nodes.getNode(n.conf);
-  this.confId = n.conf;
-  this.device = n.device;
-  this.service = n.Service;
-  this.name = n.name;
-  this.fullName = n.name + ' - ' + n.Service;
-  this.sendInitialState = n.sendInitialState === true;
-  this.state = {};
+class HbEventNode {
+  constructor(nodeConfig, RED) {
+    this.RED = RED;
+    this.node = nodeConfig;
+    this.conf = RED.nodes.getNode(nodeConfig.conf);
+    this.confId = nodeConfig.conf;
+    this.device = nodeConfig.device;
+    this.service = nodeConfig.Service;
+    this.name = nodeConfig.name;
+    this.fullName = `${nodeConfig.name} - ${nodeConfig.Service}`;
+    this.sendInitialState = nodeConfig.sendInitialState === true;
+    this.state = {};
 
-  var node = this;
+    this.init();
+  }
 
-  node.command = function (event) {
-    // False messages can be received from accessories with multiple services
-    // if (Object.keys(_convertHBcharactericToNode(event, node)).length > 0) {
-    // debug("hbEvent", node.name, event);
+  // Initialize the event handling logic
+  init() {
+    this.node.command = this.command.bind(this);
+
+    // Register the node with the HbConf class
+    this.conf.register(this.node, this.handleDeviceRegistration.bind(this));
+
+    // Clean up when the node is closed
+    this.node.on('close', (callback) => {
+      this.conf.deregister(this.node, callback);
+    });
+  }
+
+  // Handle event command processing
+  command(event) {
     if (event.status === true && event.value !== undefined) {
-      node.state = Object.assign(node.state, _convertHBcharactericToNode([event], node));
-      var msg = {
-        name: node.name,
-        payload: node.state,
-        Homebridge: node.hbDevice.homebridge,
-        Manufacturer: node.hbDevice.manufacturer,
-        Service: node.hbDevice.deviceType,
-        _device: node.device,
-        _confId: node.confId,
-        _rawEvent: event
+      this.state = Object.assign(this.state, _convertHBcharactericToNode([event], this.node));
+      const msg = {
+        name: this.node.name,
+        payload: this.state,
+        Homebridge: this.node.hbDevice.homebridge,
+        Manufacturer: this.node.hbDevice.manufacturer,
+        Service: this.node.hbDevice.deviceType,
+        _device: this.node.device,
+        _confId: this.node.confId,
+        _rawEvent: event,
       };
-      node.status({
-        text: JSON.stringify(msg.payload).slice(0, 30) + '...',
+      this.node.status({
+        text: `${JSON.stringify(msg.payload).slice(0, 30)}...`,
         shape: 'dot',
-        fill: 'green'
+        fill: 'green',
       });
-      clearTimeout(node.timeout);
-      node.timeout = setTimeout(function () {
-        node.status({});
+      clearTimeout(this.node.timeout);
+      this.node.timeout = setTimeout(() => {
+        this.node.status({});
       }, 10 * 1000);
-      node.send(msg);
+      this.node.send(msg);
     } else if (event.status === true) {
-      node.status({
+      this.node.status({
         text: 'connected',
         shape: 'dot',
-        fill: 'green'
+        fill: 'green',
       });
     } else {
-      node.status({
-        text: 'disconnected: ' + event.status,
+      this.node.status({
+        text: `disconnected: ${event.status}`,
         shape: 'ring',
-        fill: 'red'
+        fill: 'red',
       });
     }
-  };
-  // };
+  }
 
-  node.conf.register(node, function () {
-    debug("hbEvent.register", node.fullName);
-    this.hbDevice = hbDevices.findDevice(node.device, {
-      perms: 'pr'
-    });
-    if (this.hbDevice) {
-      node.hbDevice = this.hbDevice;
-      node.deviceType = this.hbDevice.deviceType;
+  // Handle device registration logic
+  handleDeviceRegistration() {
+    debug('hbEvent.register', this.node.fullName);
+    this.node.hbDevice = hbDevices.findDevice(this.node.device, { perms: 'pr' });
+
+    if (this.node.hbDevice) {
+      this.node.deviceType = this.node.hbDevice.deviceType;
 
-      _status(node.device, node, {
-        perms: 'ev'
-      }, function (err, message) {
+      _status(this.node.device, this.node, { perms: 'ev' }, (err, message) => {
         if (!err) {
-          node.state = _convertHBcharactericToNode(message.characteristics, node);
-          debug("hbEvent received: %s = %s", node.fullName, JSON.stringify(message.characteristics).slice(0, 80) + '...');
-          if (node.sendInitialState) {
-            var msg = {
-              name: node.name,
-              payload: node.state,
-              Homebridge: node.hbDevice.homebridge,
-              Manufacturer: node.hbDevice.manufacturer,
-              Service: node.hbDevice.deviceType,
-              _device: node.device,
-              _confId: node.confId,
+          this.state = _convertHBcharactericToNode(message.characteristics, this.node);
+          debug(
+            'hbEvent received: %s = %s',
+            this.node.fullName,
+            `${JSON.stringify(message.characteristics).slice(0, 80)}...`
+          );
+
+          if (this.sendInitialState) {
+            const msg = {
+              name: this.node.name,
+              payload: this.state,
+              Homebridge: this.node.hbDevice.homebridge,
+              Manufacturer: this.node.hbDevice.manufacturer,
+              Service: this.node.hbDevice.deviceType,
+              _device: this.node.device,
+              _confId: this.node.confId,
               _rawMessage: message,
             };
-            node.status({
-              text: JSON.stringify(msg.payload).slice(0, 30) + '...',
+            this.node.status({
+              text: `${JSON.stringify(msg.payload).slice(0, 30)}...`,
               shape: 'dot',
-              fill: 'green'
+              fill: 'green',
             });
-            clearTimeout(node.timeout);
-            node.timeout = setTimeout(function () {
-              node.status({});
+            clearTimeout(this.node.timeout);
+            this.node.timeout = setTimeout(() => {
+              this.node.status({});
             }, 10 * 1000);
-            node.send(msg);
+            this.node.send(msg);
           }
         } else {
-          node.error("hbEvent _status: error", node.fullName, err);
+          this.node.error('hbEvent _status: error', this.node.fullName, err);
         }
       });
+
       // Register for events
-      node.listener = node.command;
-      node.eventName = [];
-      // node.eventName = this.hbDevice.host + this.hbDevice.port + this.hbDevice.aid;
-      // debug("DEVICE", this.hbDevice);
-      this.hbDevice.eventRegisters.forEach(function (event) {
-        homebridge.on(node.hbDevice.id + event.aid + event.iid, node.command);
-        node.eventName.push(node.hbDevice.id + event.aid + event.iid);
+      this.node.listener = this.node.command;
+      this.node.eventName = [];
+
+      this.node.hbDevice.eventRegisters.forEach((event) => {
+        homebridge.on(this.node.hbDevice.id + event.aid + event.iid, this.node.command);
+        this.node.eventName.push(this.node.hbDevice.id + event.aid + event.iid);
       });
-      // homebridge.on(this.hbDevice.host + this.hbDevice.port + this.hbDevice.aid, node.command);
-      node.status({
+
+      this.node.status({
         text: 'connected',
         shape: 'dot',
-        fill: 'green'
+        fill: 'green',
       });
     } else {
-      node.error("197:Can't find device " + node.device, null);
+      this.node.error(`197:Can't find device ${this.node.device}`, null);
     }
-  }.bind(this));
-
-  node.on('close', function (callback) {
-    node.conf.deregister(node, callback);
-  });
+  }
 }
 
-RED.nodes.registerType("hb-event", hbEventNode);
+module.exports = HbEventNode;

package/src/hbResumeNode.js

@@ -0,0 +1,176 @@
+const debug = require('debug')('hapNodeRed:hbResumeNode');
+
+function hbResumeNode(n) {
+  RED.nodes.createNode(this, n);
+  this.conf = RED.nodes.getNode(n.conf);
+  this.confId = n.conf;
+  this.device = n.device;
+  this.service = n.Service;
+  this.name = n.name;
+  this.fullName = n.name + ' - ' + n.Service;
+  var node = this;
+
+  node.state = null;
+  node.lastMessageTime = null;
+  node.lastMessageValue = null;
+  node.lastPayload = {
+    On: false
+  };
+
+  node.on('input', function (msg) {
+    this.msg = msg;
+    debug("hbResume.input: %s input", node.fullName, JSON.stringify(msg));
+    if (typeof msg.payload === "object") {
+      // Using this to validate input message contains valid Accessory Characteristics
+      if (node.hbDevice) { // not populated until initialization is complete
+        var message = _createControlMessage.call(this, msg.payload, node, node.hbDevice);
+
+        if (message.characteristics.length > 0) {
+          var newMsg;
+          if (!msg.payload.On) {
+            // false / Turn Off
+            // debug("hbResume-Node lastPayload %s", JSON.stringify(node.lastPayload));
+            if (node.lastPayload.On) {
+              // last msg was on, restore previous state
+              newMsg = {
+                name: node.name,
+                _device: node.device,
+                _confId: node.confId
+              };
+              if (node.hbDevice) {
+                newMsg.Homebridge = node.hbDevice.homebridge;
+                newMsg.Manufacturer = node.hbDevice.manufacturer;
+                newMsg.Type = node.hbDevice.deviceType;
+              }
+              newMsg.payload = node.state;
+            } else {
+              // last msg was off, pass thru
+              node.state = JSON.parse(JSON.stringify(msg.payload));
+              newMsg = msg;
+            }
+          } else {
+            // True / Turn on
+            newMsg = msg;
+          }
+          // Off messages should not include brightness
+          node.send((newMsg.payload.On ? newMsg : newMsg.payload = {
+            On: false
+          }, newMsg));
+          debug("hbResume.input: %s output", node.fullName, JSON.stringify(newMsg));
+          node.status({
+            text: JSON.stringify(newMsg.payload).slice(0, 30) + '...',
+            shape: 'dot',
+            fill: 'green'
+          });
+          clearTimeout(node.timeout);
+          node.timeout = setTimeout(function () {
+            node.status({});
+          }, 10 * 1000);
+          node.lastMessageValue = newMsg.payload;
+          node.lastMessageTime = Date.now();
+          // debug("hbResume.input: %s updating lastPayload %s", node.fullName, JSON.stringify(msg.payload));
+          node.lastPayload = JSON.parse(JSON.stringify(msg.payload)); // store value not reference
+        }
+      } else {
+        node.error("Homebridge not initialized - 1", this.msg);
+        node.status({
+          text: 'Homebridge not initialized -1',
+          shape: 'ring',
+          fill: 'red'
+        });
+      }
+    } else {
+      node.error("Payload should be an JSON object containing device characteristics and values, ie {\"On\":false, \"Brightness\":0 }\nValid values include: " + node.hbDevice.descriptions, this.msg);
+      node.status({
+        text: 'Invalid payload',
+        shape: 'ring',
+        fill: 'red'
+      });
+    }
+  });
+
+  node.command = function (event) {
+    // debug("hbResume received event: %s ->", node.fullName, event);
+    // debug("hbResume - internals %s millis, old %s, event %s, previous %s", Date.now() - node.lastMessageTime, node.lastMessageValue, event.status, node.state);
+    // Don't update for events originating from here
+    // if Elapsed is greater than 5 seconds, update stored state
+    // if Elapsed is less then 5, and lastMessage doesn't match event update stored state
+
+    var payload = Object.assign({}, node.state);
+
+    // debug("should be true", _getObjectDiff(payload, node.state).length);
+
+    payload = Object.assign(payload, _convertHBcharactericToNode([event], node));
+
+    // debug("should be false", _getObjectDiff(payload, node.state).length);
+
+    debug("hbResume.event: %s %s -> %s", node.fullName, JSON.stringify(node.state), JSON.stringify(payload));
+
+    if (event.status === true && event.value !== undefined) {
+      if ((Date.now() - node.lastMessageTime) > 5000) {
+        debug("hbResume.update: %s - updating stored event >5", node.fullName, payload);
+        node.state = JSON.parse(JSON.stringify(payload));
+      } else if (_getObjectDiff(payload, node.lastMessageValue).length > 0) {
+        // debug("hbResume - updating stored event !=", payload, node.lastMessageValue);
+        // node.state = payload;
+      }
+    } else if (event.status === true) {
+      node.status({
+        text: 'connected',
+        shape: 'dot',
+        fill: 'green'
+      });
+    } else {
+      node.status({
+        text: 'disconnected: ' + event.status,
+        shape: 'ring',
+        fill: 'red'
+      });
+    }
+  };
+
+  node.conf.register(node, function () {
+    debug("hbResume.register:", node.fullName);
+    this.hbDevice = hbDevices.findDevice(node.device, {
+      perms: 'pw'
+    });
+    if (this.hbDevice) {
+      _status(node.device, node, {
+        perms: 'pw'
+      }, function (err, message) {
+        if (!err) {
+          node.state = _convertHBcharactericToNode(message.characteristics, node);
+          debug("hbResume received: %s = %s", node.fullName, JSON.stringify(message.characteristics).slice(0, 80) + '...');
+        } else {
+          node.error(err);
+        }
+      });
+      node.hbDevice = this.hbDevice;
+      node.deviceType = this.hbDevice.deviceType;
+      // Register for events
+      node.listener = node.command;
+      node.eventName = [];
+      // node.eventName = this.hbDevice.host + this.hbDevice.port + this.hbDevice.aid;
+      // homebridge.on(this.hbDevice.host + this.hbDevice.port + this.hbDevice.aid, node.command);
+      this.hbDevice.eventRegisters.forEach(function (event) {
+        homebridge.on(node.hbDevice.id + event.aid + event.iid, node.command);
+        node.eventName.push(node.hbDevice.id + event.aid + event.iid);
+      });
+      node.status({
+        text: 'connected',
+        shape: 'dot',
+        fill: 'green'
+      });
+      clearTimeout(node.timeout);
+      node.timeout = setTimeout(function () {
+        node.status({});
+      }, 30 * 1000);
+    } else {
+      node.error("365:Can't find device " + node.device, null);
+    }
+  }.bind(this));
+
+  node.on('close', function (callback) {
+    node.conf.deregister(node, callback);
+  });
+}