node-red-contrib-homebridge-automation 0.1.12-beta.34 → 0.1.12-beta.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-homebridge-automation",
-  "version": "0.1.12-beta.34",
+  "version": "0.1.12-beta.36",
   "description": "NodeRED Automation for HomeBridge",
   "main": "src/HAP-NodeRed.js",
   "scripts": {
@@ -46,7 +46,7 @@
   "dependencies": {
     "better-queue": ">=3.8.12",
     "debug": "^4.3.5",
-    "@homebridge/hap-client": "2.0.5-beta.12"
+    "@homebridge/hap-client": "2.0.5-beta.18"
   },
   "author": "NorthernMan54",
   "license": "ISC",

package/src/hbBaseNode.js

@@ -18,7 +18,7 @@ class HbBaseNode {
     this.fullName = `${config.name} - ${config.Service}`;
     this.hbDevice = null;
 
-    this.hbConfigNode?.register(this);
+    this.hbConfigNode?.registerClientNode(this);
 
     if (this.handleInput) {
       this.on('input', this.handleInput.bind(this));
@@ -61,20 +61,34 @@ class HbBaseNode {
   statusText(message) {
     return message.slice(0, 20)
   }
+
   /**
    * 
    * @param {*} warning - Message to log and display in debug panel
    * @param {*} statusText - Message to display under Node ( If not present, uses warning message text)
    */
-  handleError(warning, statusText) {
+  handleWarning(warning, statusText) {
     this.warn(warning);
     this.status({
       text: (statusText ? statusText : warning).slice(0, 20),
       shape: 'ring',
-      fill: 'red',
+      fill: 'yellow',
     });
   }
 
+  /**
+   * 
+   * @param {*} warning - Message to log and display in debug panel
+   * @param {*} statusText - Message to display under Node ( If not present, uses warning message text)
+   */
+  handleError(error, statusText) {
+    this.error(error);
+    this.status({
+      text: (statusText ? statusText : error).slice(0, 20),
+      shape: 'ring',
+      fill: 'red',
+    });
+  }
 }
 
 module.exports = HbBaseNode;

package/src/hbConfigNode.js

@@ -1,7 +1,6 @@
 const { HapClient } = require('@homebridge/hap-client');
 const debug = require('debug')('hapNodeRed:hbConfigNode');
 const { Log } = require('./lib/logger.js');
-const Queue = require('better-queue');
 
 class HBConfigNode {
   constructor(config, RED) {
@@ -17,21 +16,9 @@ class HBConfigNode {
       this.ctDevices = [];
       this.hbDevices = [];
       this.clientNodes = [];
-      this.monitorNodes = [];
       this.log = new Log(console, true);
       this.discoveryTimeout = null;
 
-      // Initialize queue
-      this.reqisterQueue = new Queue(this._register.bind(this), {
-        concurrent: 1,
-        autoResume: false,
-        maxRetries: 1000,
-        retryDelay: 30000,
-        batchDelay: 2000,
-        batchSize: 150,
-      });
-      this.reqisterQueue.pause();
-
       // Initialize HAP client
       this.hapClient = new HapClient({
         config: { debug: true },
@@ -42,44 +29,73 @@ class HBConfigNode {
       this.hapClient.on('instance-discovered', this.waitForNoMoreDiscoveries);
       this.waitForNoMoreDiscoveries();
       this.on('close', this.close.bind(this));
+      this.refreshInProcess = true; // Prevents multiple refreshes, hapClient kicks of a discovery on start
     }
   }
 
+  /**
+   * Start device discovery after monitor reports issues
+   */
+
+  refreshDevices = () => {
+    if (!this.refreshInProcess) {
+
+      this.monitor.finish();
+      this.log.debug('Monitor reported homebridge stability issues, refreshing devices');
+      this.hapClient.on('instance-discovered', this.waitForNoMoreDiscoveries);
+      this.hapClient.resetInstancePool();
+      this.waitForNoMoreDiscoveries();
+    }
+  };
+
+  /**
+   * Wait for no more instance discoveries to be made before publishing services
+   */
   waitForNoMoreDiscoveries = () => {
     if (!this.discoveryTimeout) {
       clearTimeout(this.discoveryTimeout);
       this.discoveryTimeout = setTimeout(() => {
         this.log.debug('No more instances discovered, publishing services');
         this.hapClient.removeListener('instance-discovered', this.waitForNoMoreDiscoveries);
-        this.hapClient.on('instance-discovered', async (instance) => { debug('instance-discovered', instance); await this.monitorDevices(); });
-        this.hapClient.on('discovery-ended', async () => { debug('discovery-ended'); });
         this.handleReady();
         this.discoveryTimeout = null;
-      }, 5000);
+        this.refreshInProcess = false;
+      }, 20000);  // resetInstancePool() triggers a discovery after 6 seconds.  Need to wait for it to finish.
     }
   };
 
+  /**
+   * Populate the list of devices and handle duplicates
+   */
   async handleReady() {
-    this.hbDevices = await this.hapClient.getAllServices();
+    const updatedDevices = await this.hapClient.getAllServices();
+    updatedDevices.forEach((updatedService, index) => {
+      if (this.hbDevices.find(service => service.uniqueId === updatedService.uniqueId)) {
+        const update = this.hbDevices.find(service => service.uniqueId === updatedService.uniqueId);
+        update.instance = updatedService.instance;
+      } else {
+        this.hbDevices.push(updatedService);
+      }
+    });
+
     this.evDevices = this.toList({ perms: 'ev' });
     this.ctDevices = this.toList({ perms: 'pw' });
     this.log.info(`Devices initialized: evDevices: ${this.evDevices.length}, ctDevices: ${this.ctDevices.length}`);
     this.handleDuplicates(this.evDevices);
-    debug('Queue stats:', this.reqisterQueue.getStats());
-    this.reqisterQueue.resume();
+    this.connectClientNodes();
   }
 
   toList(perms) {
-    const supportedTypes = [
-      'Battery', 'Carbon Dioxide Sensor', 'Carbon Monoxide Sensor', 'Camera Rtp Stream Management', 'Doorbell',
-      'Fan', 'Fanv2', 'Garage Door Opener', 'Humidity Sensor', 'Input Source',
+    const supportedTypes = new Set([
+      'Battery', 'Carbon Dioxide Sensor', 'Carbon Monoxide Sensor', 'Camera Rtp Stream Management',
+      'Doorbell', 'Fan', 'Fanv2', 'Garage Door Opener', 'Humidity Sensor', 'Input Source',
       'Leak Sensor', 'Lightbulb', 'Lock Mechanism', 'Motion Sensor', 'Occupancy Sensor',
       'Outlet', 'Smoke Sensor', 'Speaker', 'Stateless Programmable Switch', 'Switch',
       'Television', 'Temperature Sensor', 'Thermostat', 'Contact Sensor',
-    ];
+    ]);
 
     return filterUnique(this.hbDevices)
-      .filter(service => supportedTypes.includes(service.humanType))
+      .filter(service => supportedTypes.has(service.humanType))
       .map(service => ({
         name: service.serviceName,
         fullName: `${service.serviceName} - ${service.type}`,
@@ -92,31 +108,35 @@ class HBConfigNode {
       .sort((a, b) => a.sortName.localeCompare(b.sortName));
   }
 
+
   handleDuplicates(list) {
-    const seenFullNames = new Set();
-    const seenUniqueIds = new Set();
+    const seen = new Map();
 
     list.forEach(endpoint => {
-      if (!seenFullNames.add(endpoint.fullName)) {
-        console.warn('WARNING: Duplicate device name', endpoint.fullName);
-      }
+      const { fullName, uniqueId } = endpoint;
 
-      if (!seenUniqueIds.add(endpoint.uniqueId)) {
-        console.error('ERROR: Duplicate uniqueId detected.', endpoint.fullName);
+      if (seen.has(fullName)) {
+        this.log.warn(`Duplicate device name detected: ${fullName}`);
       }
+      if (seen.has(uniqueId)) {
+        this.log.error(`Duplicate uniqueId detected: ${uniqueId}`);
+      }
+
+      seen.set(fullName, true);
+      seen.set(uniqueId, true);
     });
   }
 
-  register(clientNode) {
+  registerClientNode(clientNode) {
     debug('Register: %s type: %s', clientNode.type, clientNode.name);
     this.clientNodes[clientNode.id] = clientNode;
-    this.reqisterQueue.push(clientNode);
     clientNode.status({ fill: 'yellow', shape: 'ring', text: 'connecting' });
   }
 
-  async _register(clientNodes, cb) {
-    for (const clientNode of clientNodes) {
-      debug('_Register: %s type: %s', clientNode.type, clientNode.name, clientNode.instance);
+  async connectClientNodes() {
+    debug('connect %s nodes', Object.keys(this.clientNodes).length);
+    for (const [key, clientNode] of Object.entries(this.clientNodes)) {
+      // debug('_Register: %s type: %s', clientNode.type, clientNode.name, clientNode.instance);
       const matchedDevice = this.hbDevices.find(service =>
         clientNode.device === `${service.instance.name}${service.instance.username}${service.accessoryInformation.Manufacturer}${service.serviceName}${service.uuid.slice(0, 8)}`
       );
@@ -126,23 +146,32 @@ class HBConfigNode {
         clientNode.status({ fill: 'green', shape: 'dot', text: 'connected' });
         clientNode.emit('hbReady', matchedDevice);
         debug('_Registered: %s type: %s', matchedDevice.type, matchedDevice.serviceName, matchedDevice.instance);
-        if (clientNode.config.type === 'hb-status' || clientNode.config.type === 'hb-event') {
-          this.monitorNodes[clientNode.device] = matchedDevice;
-        }
       } else {
         console.error('ERROR: Device registration failed', clientNode.name);
       }
-    }
+    };
 
     await this.monitorDevices();
-
-    cb(null);
   }
 
   async monitorDevices() {
-    debug('monitorDevices', Object.keys(this.monitorNodes).length);
-    if (Object.keys(this.monitorNodes).length) {
-      this.monitor = await this.hapClient.monitorCharacteristics(Object.values(this.monitorNodes));
+    if (Object.keys(this.clientNodes).length) {
+      const uniqueDevices = new Set();
+
+      const monitorNodes = Object.values(this.clientNodes)
+        .filter(node => ['hb-status', 'hb-control'].includes(node.type)) // Filter by type
+        .filter(node => {
+          if (uniqueDevices.has(node.device)) {
+            return false; // Exclude duplicates
+          }
+          uniqueDevices.add(node.device);
+          return true; // Include unique devices
+        })
+        .map(node => node.hbDevice) // Map to hbDevice property
+        .filter(Boolean); // Remove any undefined or null values, if present;
+      debug('monitorNodes', Object.keys(monitorNodes).length);
+      // console.log('monitorNodes', monitorNodes);
+      this.monitor = await this.hapClient.monitorCharacteristics(monitorNodes);
       this.monitor.on('service-update', (services) => {
         services.forEach(service => {
           const eventNodes = Object.values(this.clientNodes).filter(clientNode =>
@@ -151,15 +180,29 @@ class HBConfigNode {
           eventNodes.forEach(eventNode => eventNode.emit('hbEvent', service));
         });
       });
-      this.monitor.on('monitor-close', (hadError) => {
-        debug('monitor-close', hadError)
-        if (!this.hapClient.this.discoveryInProgress) {
-          this.monitor.finish();
-          this.hapClient.resetInstancePool();
-        }
+      this.monitor.on('monitor-close', (instance, hadError) => {
+        debug('monitor-close', instance.name, instance.ipAddress, instance.port, hadError)
+        this.disconnectClientNodes(instance);
+        this.refreshDevices();
+      })
+      this.monitor.on('monitor-error', (instance, hadError) => {
+        debug('monitor-error', instance, hadError)
       })
     }
   }
+
+  disconnectClientNodes(instance) {
+    debug('disconnectClientNodes', `${instance.ipAddress}:${instance.port}`);
+    const clientNodes = Object.values(this.clientNodes).filter(clientNode => {
+      return `${clientNode.hbDevice.instance.ipAddress}:${clientNode.hbDevice.instance.port}` === `${instance.ipAddress}:${instance.port}`;
+    });
+
+    clientNodes.forEach(clientNode => {
+      clientNode.status({ fill: 'red', shape: 'ring', text: 'disconnected' });
+      clientNode.emit('hbDisconnected', instance);
+    });
+  }
+
   close() {
     debug('hb-config: close');
     this.hapClient?.destroy();

package/src/hbControlNode.js

@@ -10,7 +10,7 @@ class HbControlNode extends hbBaseNode {
     debug('handleInput', message.payload, this.name);
 
     if (!this.hbDevice) {
-      this.handleError('HB not initialized');
+      this.handleWarning('HB not initialized');
       return;
     }
 
@@ -58,6 +58,7 @@ class HbControlNode extends hbBaseNode {
             this.error(`Failed to set value for "${key}": ${error.message}`);
             results.push({ [key]: `Error: ${error.message}` });
             fill = 'red';
+            this.hbConfigNode.disconnectClientNodes(this.hbDevice.instance);
           }
         }
       }
@@ -67,8 +68,7 @@ class HbControlNode extends hbBaseNode {
       this.status({ text: statusText, shape: 'dot', fill });
       done
     } catch (error) {
-      this.error(`Unhandled error: ${error.message}`);
-      this.status({ text: 'Unhandled error', shape: 'dot', fill: 'red' });
+      this.handleError(error, 'Unhandled error');
       done(`Unhandled error: ${error.message}`);
     }
   }

package/src/hbResumeNode.js

@@ -12,7 +12,7 @@ class HbResumeNode extends HbBaseNode {
     debug('handleInput', message.payload, this.name);
 
     if (!this.hbDevice) {
-      this.handleError('HB not initialized');
+      this.handleWarning('HB not initialized');
       return;
     }
 
@@ -20,7 +20,7 @@ class HbResumeNode extends HbBaseNode {
       const validNames = Object.keys(this.hbDevice.values)
         .filter(key => key !== 'ConfiguredName')
         .join(', ');
-      this.handleError(
+      this.handleWarning(
         `Invalid payload. Expected: {"On": false, "Brightness": 0}. Valid values: ${validNames}`,
         'Invalid payload'
       );

package/src/hbStatusNode.js

@@ -10,7 +10,7 @@ class HbStatusNode extends HbBaseNode {
     debug('handleInput', message.payload, this.name);
 
     if (!this.hbDevice) {
-      this.handleError('HB not initialized');
+      this.handleWarning('HB not initialized');
       return;
     }
 
@@ -27,6 +27,7 @@ class HbStatusNode extends HbBaseNode {
     } else {
       this.status({ fill: "red", shape: "ring", text: "disconnected" });
       this.error("No response from device", this.name);
+      this.hbConfigNode.disconnectClientNodes(this.hbDevice.instance);
       done("No response from device");
     }