node-red-contrib-homebridge-automation 0.1.12-beta.25 → 0.1.12-beta.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-homebridge-automation",
-  "version": "0.1.12-beta.25",
+  "version": "0.1.12-beta.27",
   "description": "NodeRED Automation for HomeBridge",
   "main": "src/HAP-NodeRed.js",
   "scripts": {

package/src/hbBaseNode.js

@@ -23,6 +23,9 @@ class HbBaseNode {
     if (this.handleInput) {
       this.on('input', this.handleInput.bind(this));
     }
+    if (this.handleHbReady) {
+      this.on('hbReady', this.handleHbReady.bind(this))
+    }
     this.on('close', this.handleClose.bind(this));
     this.on('hbEvent', this.handleHBEventMessage.bind(this));
   }
@@ -38,127 +41,133 @@ class HbBaseNode {
     this.send({ payload: service.values });
   }
 
-  createMessage(event, isInitialState = false) {
+  createMessage(service) {
     return {
-      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: isInitialState ? event : undefined,
+      name: this.name,
+      payload: service.values,
+      Homebridge: service.instance.name,
+      Manufacturer: service.accessoryInformation.Manufacturer,
+      Service: service.type,
+      _device: this.device,
+      _confId: this.confId,
     };
   }
 
-  registerNode() {
-    debug("Registering node:", this.fullName);
-    this.hbDevice = hbDevices.findDevice(this.device);
-
-    if (!this.hbDevice) {
-      this.error(`Device not found: ${this.device}`);
-    } else {
-      this.deviceType = this.hbDevice.deviceType;
-    }
-  }
-
-  handleClose(callback) {
+  handleClose(removed, done) {
     debug('close', this.name);
-    callback();
+    done();
   }
 
-  _convertHBcharacteristicToNode(hbMessage, node) {
-    let payload = {};
-    if (!hbMessage.payload) {
-      const device = hbDevices.findDevice(node.device);
-      if (device) {
-        hbMessage.forEach(characteristic => {
-          const charKey = `${characteristic.aid}.${characteristic.iid}`;
-          if (device.characteristics[charKey]) {
-            payload[device.characteristics[charKey].characteristic] = characteristic.value;
-          }
-        });
+  /*
+    registerNode() {
+      debug("Registering node:", this.fullName);
+      this.hbDevice = hbDevices.findDevice(this.device);
+  
+      if (!this.hbDevice) {
+        this.error(`Device not found: ${this.device}`);
+      } else {
+        this.deviceType = this.hbDevice.deviceType;
       }
-    } else {
-      payload = hbMessage.payload;
     }
-    return payload;
-  }
-
-  _createControlMessage(payload, node, device) {
-    const response = [];
-    for (const key in payload) {
-      const characteristic = this._getKey(device.characteristics, key);
-      if (characteristic) {
-        response.push({
-          aid: device.aid,
-          iid: characteristic.iid,
-          value: payload[key],
-        });
+  
+    handleClose(callback) {
+      debug('close', this.name);
+      callback();
+    }
+  
+    _convertHBcharacteristicToNode(hbMessage, node) {
+      let payload = {};
+      if (!hbMessage.payload) {
+        const device = hbDevices.findDevice(node.device);
+        if (device) {
+          hbMessage.forEach(characteristic => {
+            const charKey = `${characteristic.aid}.${characteristic.iid}`;
+            if (device.characteristics[charKey]) {
+              payload[device.characteristics[charKey].characteristic] = characteristic.value;
+            }
+          });
+        }
       } else {
-        this.warn(`Invalid characteristic: '${key}'. Available: ${device.descriptions}`);
-        node.status({ text: `Invalid characteristic: ${key}`, shape: 'ring', fill: 'yellow' });
+        payload = hbMessage.payload;
       }
+      return payload;
     }
-    return { characteristics: response };
-  }
-
-  async _status(nrDevice, node, perms) {
-    try {
-      const device = hbDevices.findDevice(node.device, perms);
-      if (!device) throw new Error(`Device not found: ${nrDevice}`);
-
-      const message = device.type === "00000110" || device.type === "00000111"
-        ? { "resource-type": "image", "image-width": 1920, "image-height": 1080 }
-        : `?id=${device.getCharacteristics}`;
-
-      const status = device.type === "00000110" || device.type === "00000111"
-        ? await this.HAPresourceByDeviceIDAsync(device.id, JSON.stringify(message))
-        : await this.HAPstatusByDeviceIDAsync(device.id, message);
-
-      node.status({ text: 'Success', shape: 'dot', fill: 'green' });
-      return device.type === "00000110" || device.type === "00000111"
-        ? { characteristics: { payload: this.btoa(status) } }
-        : status;
-    } catch (err) {
-      debug("Error in _status:", err);
-      node.status({ text: 'Error retrieving status', shape: 'ring', fill: 'red' });
-      throw err;
+  
+    _createControlMessage(payload, node, device) {
+      const response = [];
+      for (const key in payload) {
+        const characteristic = this._getKey(device.characteristics, key);
+        if (characteristic) {
+          response.push({
+            aid: device.aid,
+            iid: characteristic.iid,
+            value: payload[key],
+          });
+        } else {
+          this.warn(`Invalid characteristic: '${key}'. Available: ${device.descriptions}`);
+          node.status({ text: `Invalid characteristic: ${key}`, shape: 'ring', fill: 'yellow' });
+        }
+      }
+      return { characteristics: response };
     }
-  }
-
-  async _register(node) {
-    try {
-      const device = hbDevices.findDevice(node.device, { perms: 'ev' });
-      if (device) {
-        const message = { characteristics: device.eventRegisters };
-        await hapEventByDeviceIDAsync(device.id, JSON.stringify(message));
+  
+    async _status(nrDevice, node, perms) {
+      try {
+        const device = hbDevices.findDevice(node.device, perms);
+        if (!device) throw new Error(`Device not found: ${nrDevice}`);
+  
+        const message = device.type === "00000110" || device.type === "00000111"
+          ? { "resource-type": "image", "image-width": 1920, "image-height": 1080 }
+          : `?id=${device.getCharacteristics}`;
+  
+        const status = device.type === "00000110" || device.type === "00000111"
+          ? await this.HAPresourceByDeviceIDAsync(device.id, JSON.stringify(message))
+          : await this.HAPstatusByDeviceIDAsync(device.id, message);
+  
+        node.status({ text: 'Success', shape: 'dot', fill: 'green' });
+        return device.type === "00000110" || device.type === "00000111"
+          ? { characteristics: { payload: this.btoa(status) } }
+          : status;
+      } catch (err) {
+        debug("Error in _status:", err);
+        node.status({ text: 'Error retrieving status', shape: 'ring', fill: 'red' });
+        throw err;
       }
-    } catch (err) {
-      debug("Error in _register:", err);
-      node.status({ text: 'Register error', shape: 'ring', fill: 'red' });
     }
-  }
-
-  _getKey(obj, value) {
-    return Object.values(obj).find(char => char.characteristic.toLowerCase() === value.toLowerCase()) || null;
-  }
-
-  btoa(str) {
-    return Buffer.from(str.toString(), 'binary').toString('base64');
-  }
-
-  async HAPresourceByDeviceIDAsync(deviceId, message) {
-    return new Promise((resolve, reject) => {
-      homebridge.HAPresourceByDeviceID(deviceId, message, (err, status) => err ? reject(err) : resolve(status));
-    });
-  }
-
-  async HAPstatusByDeviceIDAsync(deviceId, message) {
-    return new Promise((resolve, reject) => {
-      homebridge.HAPstatusByDeviceID(deviceId, message, (err, status) => err ? reject(err) : resolve(status));
-    });
-  }
+  
+    async _register(node) {
+      try {
+        const device = hbDevices.findDevice(node.device, { perms: 'ev' });
+        if (device) {
+          const message = { characteristics: device.eventRegisters };
+          await hapEventByDeviceIDAsync(device.id, JSON.stringify(message));
+        }
+      } catch (err) {
+        debug("Error in _register:", err);
+        node.status({ text: 'Register error', shape: 'ring', fill: 'red' });
+      }
+    }
+  
+    _getKey(obj, value) {
+      return Object.values(obj).find(char => char.characteristic.toLowerCase() === value.toLowerCase()) || null;
+    }
+  
+    btoa(str) {
+      return Buffer.from(str.toString(), 'binary').toString('base64');
+    }
+  
+    async HAPresourceByDeviceIDAsync(deviceId, message) {
+      return new Promise((resolve, reject) => {
+        homebridge.HAPresourceByDeviceID(deviceId, message, (err, status) => err ? reject(err) : resolve(status));
+      });
+    }
+  
+    async HAPstatusByDeviceIDAsync(deviceId, message) {
+      return new Promise((resolve, reject) => {
+        homebridge.HAPstatusByDeviceID(deviceId, message, (err, status) => err ? reject(err) : resolve(status));
+      });
+    }
+    */
 }
 
 module.exports = HbBaseNode;

package/src/hbConfigNode.js

@@ -152,17 +152,18 @@ class HBConfigNode {
     }
     cb(null);
   }
-
-  deregister(clientNode) {
-    clientNode.status({ text: 'disconnected', shape: 'ring', fill: 'red' });
-    delete this.clientNodes[clientNode.id];
-  }
-
+  /*
+    deregister(clientNode) {
+      clientNode.status({ text: 'disconnected', shape: 'ring', fill: 'red' });
+      delete this.clientNodes[clientNode.id];
+    }
+  */
   close() {
     if (this.hapClient) {
       this.hapClient.destroy();
     }
   }
+
 }
 
 module.exports = HBConfigNode;

package/src/hbControlNode.js

@@ -6,7 +6,7 @@ class HbControlNode extends hbBaseNode {
     super(config, RED);
   }
 
-  async handleInput(message) {
+  async handleInput(message, send) {
     debug('handleInput', message.payload, this.name);
     if (!this.hbDevice) {
       this.error('HB not initialized');

package/src/hbEventNode.js

@@ -5,19 +5,19 @@ class HbEventNode extends hbBaseNode {
   constructor(config, RED) {
     super(config, RED);
     this.sendInitialState = config.sendInitialState === true;
-    this.on('hbReady', this.handleHbReady.bind(this))
   }
 
   handleHbReady(service) {
-    this.status({
-      text: JSON.stringify(service.values),
-      shape: 'dot',
-      fill: 'green',
-    });
-    this.send({ payload: service.values });
+    debug('handleHbReady', this.id, this.name, service.values)
+    if (this.sendInitialState) {
+      this.status({
+        text: JSON.stringify(service.values),
+        shape: 'dot',
+        fill: 'green',
+      });
+      this.send({ ...this.createMessage(service) });
+    }
   }
-  // Create a message payload for event or initial state
-
 }
 
 module.exports = HbEventNode;

package/src/hbResumeNode.js

@@ -5,12 +5,7 @@ class HbResumeNode extends HbBaseNode {
   constructor(config, RED) {
     super(config, RED);
 
-
-    this.state = null;
-    this.lastMessageTime = null;
-    this.lastMessageValue = null;
-    this.lastPayload = { On: false };
-    this.timeout = null;
+    this.storedState = null;
 
     // Set up input and command handlers
     // this.on('input', this.handleInput.bind(this));
@@ -18,127 +13,45 @@ class HbResumeNode extends HbBaseNode {
 
     // Handle device registration
     debug('hbResume - hbConfigNode', this.hbConfigNode);
-    // debug('hbResume - hbConfigNode', this.configNode.hbConfigNode);
-
   }
 
-  handleHBEventMessage(service) {
-    debug('topic for', this.id, service.serviceName, service.values);
+  handleInput(message, send) {
+    debug('handleInput', message.payload, this.name);
 
-    this.status({
-      text: JSON.stringify(service.values),
-      shape: 'dot',
-      fill: 'green',
-    });
-    this.send({ payload: service.values });
-  }
-
-  handleInput(msg, send) {
-    this.msg = msg;
-    debug("hbResume.input: %s input", this.fullName, JSON.stringify(msg));
-
-    if (typeof msg.payload === "object") {
-      if (this.hbDevice) {
-        const message = this._createControlMessage.call(this, msg.payload, this, this.hbDevice);
-
-        if (message.characteristics.length > 0) {
-          let newMsg;
-          if (!msg.payload.On) {
-            if (this.lastPayload.On) {
-              newMsg = {
-                name: this.name,
-                _device: this.device,
-                _confId: this.confId,
-                payload: this.state,
-                Homebridge: this.hbDevice?.homebridge,
-                Manufacturer: this.hbDevice?.manufacturer,
-                Type: this.hbDevice?.deviceType,
-              };
-            } else {
-              this.state = JSON.parse(JSON.stringify(msg.payload));
-              newMsg = msg;
-            }
-          } else {
-            newMsg = msg;
-          }
-
-          send(newMsg.payload.On ? newMsg : { ...newMsg, payload: { On: false } });
-          debug("hbResume.input: %s output", this.fullName, JSON.stringify(newMsg));
-          this.updateStatus(newMsg.payload);
-          this.lastMessageValue = newMsg.payload;
-          this.lastMessageTime = Date.now();
-          this.lastPayload = JSON.parse(JSON.stringify(msg.payload));
-        }
-      } else {
-        this.handleError("Homebridge not initialized - 1");
-      }
-    } else {
-      this.handleError(
-        "Payload should be a JSON object containing device characteristics and values, e.g., {\"On\":false, \"Brightness\":0 }"
-      );
+    if (!this.hbDevice) {
+      this.warn('HB not initialized');
+      this.status({ text: 'HB not initialized', shape: 'ring', fill: 'red' });
+      return;
     }
-  }
-
-  handleCommand(event) {
-    const payload = { ...this.state, ...this._convertHBcharactericToNode([event], this) };
-    debug("hbResume.event: %s %s -> %s", this.fullName, JSON.stringify(this.state), JSON.stringify(payload));
 
-    if (event.status === true && event.value !== undefined) {
-      if (Date.now() - this.lastMessageTime > 5000) {
-        debug("hbResume.update: %s - updating stored event >5", this.fullName, payload);
-        this.state = JSON.parse(JSON.stringify(payload));
-      }
-    } else if (event.status === true) {
-      this.updateStatus({ text: 'connected', shape: 'dot', fill: 'green' });
-    } else {
-      this.updateStatus({ text: `disconnected: ${event.status}`, shape: 'ring', fill: 'red' });
+    if (typeof message.payload !== 'object') {
+      const validNames = Object.keys(this.hbDevice.values)
+        .filter(key => key !== 'ConfiguredName')
+        .join(', ');
+      this.warn(`Payload should be a JSON object containing device characteristics and values, e.g. {"On":false, "Brightness":0}. Valid values: ${validNames}`);
+      this.status({ text: 'Invalid payload', shape: 'dot', fill: 'red' });
+      return;
     }
-  }
-
-  handleDeviceRegistration() {
-    debug("hbResume.register:", this.fullName);
-    this.hbDevice = hbDevices.findDevice(this.device, { perms: 'pw' });
-
-    if (this.hbDevice) {
-      this._status(this.device, this, { perms: 'pw' }, (err, message) => {
-        if (!err) {
-          this.state = this._convertHBcharactericToNode(message.characteristics, this);
-          debug("hbResume received: %s = %s", this.fullName, JSON.stringify(message.characteristics).slice(0, 80) + '...');
-        } else {
-          this.error(err);
-        }
-      });
-
-      this.deviceType = this.hbDevice.deviceType;
-      this.listener = this.command;
-      this.eventName = [];
 
-      this.hbDevice.eventRegisters.forEach((event) => {
-        homebridge.on(this.hbDevice.id + event.aid + event.iid, this.command);
-        this.eventName.push(this.hbDevice.id + event.aid + event.iid);
-      });
+    // if on, store the current values object to storedState before passing
+    // if off, if storedState, then send stored state else passthru
 
-      this.updateStatus({ text: 'connected', shape: 'dot', fill: 'green' });
-      this.resetTimeout(30000);
-    } else {
-      this.error(`Can't find device ${this.device}`);
+    if (message.payload.On) {
+      this.storedState = this.hbDevice.values;
+      debug('Storing', this.storedState);
+    } else if (!message.payload.On && this.storedState) {
+      debug('Restoring', this.storedState)
+      message.payload = { ...message.payload, ...this.storedState }
+      this.storedState = null;
     }
+    this.status({
+      text: JSON.stringify(message.payload),
+      shape: 'dot',
+      fill: 'green',
+    });
+    send(message);
   }
 
-  updateStatus(status) {
-    this.status(status);
-    this.resetTimeout(10000);
-  }
-
-  resetTimeout(duration) {
-    clearTimeout(this.timeout);
-    this.timeout = setTimeout(() => this.status({}), duration);
-  }
-
-  handleError(message) {
-    this.error(message, this.msg);
-    this.updateStatus({ text: message, shape: 'ring', fill: 'red' });
-  }
 }
 
 module.exports = HbResumeNode;

package/src/hbStatusNode.js

@@ -22,8 +22,7 @@ class HbStatusNode extends HbBaseNode {
       fill: 'green'
     });
 
-    message.payload = result.values;
-    send(message);
+    send(Object.assign(message, this.createMessage(result)));
   }
 }
 

package/test/node-red/flows.json

@@ -22,8 +22,8 @@
         "tosidebar": true,
         "console": false,
         "tostatus": true,
-        "complete": "payload",
-        "targetType": "msg",
+        "complete": "true",
+        "targetType": "full",
         "statusVal": "payload",
         "statusType": "auto",
         "x": 800,
@@ -39,8 +39,8 @@
         "tosidebar": true,
         "console": false,
         "tostatus": true,
-        "complete": "payload",
-        "targetType": "msg",
+        "complete": "true",
+        "targetType": "full",
         "statusVal": "payload",
         "statusType": "auto",
         "x": 800,
@@ -72,8 +72,7 @@
         "y": 140,
         "wires": [
             [
-                "3d7babac3a298e60",
-                "452e3e6171aa7a25"
+                "3d7babac3a298e60"
             ]
         ]
     },
@@ -169,9 +168,7 @@
         "x": 210,
         "y": 460,
         "wires": [
-            [
-                "452e3e6171aa7a25"
-            ]
+            []
         ]
     },
     {