homebridge-nest-accfactory 0.3.0 → 0.3.2

package/dist/plugins/weather.js

@@ -6,22 +6,22 @@
 
 // Define our modules
 import HomeKitDevice from '../HomeKitDevice.js';
+import { processCommonData, adjustTemperature, crc24 } from '../utils.js';
+
+// Define constants
+import { DATA_SOURCE, DEVICE_TYPE, NESTLABS_MAC_PREFIX } from '../consts.js';
 
 export default class NestWeather extends HomeKitDevice {
   static TYPE = 'Weather';
-  static VERSION = '2025.06.11';
+  static VERSION = '2025.08.04'; // Code version
 
   batteryService = undefined;
   airPressureService = undefined;
   temperatureService = undefined;
   humidityService = undefined;
 
-  constructor(accessory, api, log, eventEmitter, deviceData) {
-    super(accessory, api, log, eventEmitter, deviceData);
-  }
-
   // Class functions
-  setupDevice() {
+  onAdd() {
     // Setup temperature service if not already present on the accessory
     this.temperatureService = this.addHKService(this.hap.Service.TemperatureSensor, '', 1);
     this.temperatureService.setPrimaryService();
@@ -29,13 +29,14 @@ export default class NestWeather extends HomeKitDevice {
     // Setup humidity service if not already present on the accessory
     this.humidityService = this.addHKService(this.hap.Service.HumiditySensor, '', 1);
 
-    // Setup battery service if not already present on the accessory
+    // Setup battery service if not already present on the accessory (required for EveHome support)
     this.batteryService = this.addHKService(this.hap.Service.Battery, '', 1);
     this.batteryService.setHiddenService(true);
 
     // Add custom weather service and characteristics if they have been defined
     if (this.hap.Service?.EveAirPressureSensor !== undefined) {
-      this.airPressureService = this.addHKService(this.hap.Service.EveAirPressureSensor, '', 1);
+      // This will be linked to the Eve app if configured to do so
+      this.airPressureService = this.addHKService(this.hap.Service.EveAirPressureSensor, '', 1, {});
     }
 
     if (this.hap.Characteristic?.ForecastDay !== undefined) {
@@ -60,22 +61,22 @@ export default class NestWeather extends HomeKitDevice {
       this.addHKCharacteristic(this.temperatureService, this.hap.Characteristic.SunsetTime);
     }
 
-    // Setup linkage to EveHome app if configured todo so
-    if (
-      this.deviceData?.eveHistory === true &&
-      this.airPressureService !== undefined &&
-      typeof this.historyService?.linkToEveHome === 'function'
-    ) {
-      this.historyService.linkToEveHome(this.airPressureService, {
-        description: this.deviceData.description,
-      });
-    }
-
     // Extra setup details for output
     this.deviceData?.elevation !== undefined && this.postSetupDetail('Elevation of ' + this.deviceData.elevation + 'm');
   }
 
-  updateDevice(deviceData) {
+  onRemove() {
+    this.accessory.removeService(this.temperatureService);
+    this.accessory.removeService(this.humidityService);
+    this.accessory.removeService(this.batteryService);
+    this.accessory.removeService(this.airPressureService);
+    this.temperatureService = undefined;
+    this.humidityService = undefined;
+    this.batteryService = undefined;
+    this.airPressureService = undefined;
+  }
+
+  onUpdate(deviceData) {
     if (
       typeof deviceData !== 'object' ||
       this.temperatureService === undefined ||
@@ -97,7 +98,7 @@ export default class NestWeather extends HomeKitDevice {
     this.humidityService.updateCharacteristic(this.hap.Characteristic.CurrentRelativeHumidity, deviceData.current_humidity);
 
     if (this.airPressureService !== undefined) {
-      //this.airPressureService.updateCharacteristic(this.hap.Characteristic.EveAirPressure, 0);   // Where from??
+      // this.airPressureService.updateCharacteristic(this.hap.Characteristic.EveAirPressure, 0);   // Where from??
       this.airPressureService.updateCharacteristic(this.hap.Characteristic.EveElevation, deviceData.elevation);
     }
 
@@ -155,17 +156,111 @@ export default class NestWeather extends HomeKitDevice {
     }
 
     // If we have the history service running, record temperature and humity every 5mins
-    if (this.airPressureService !== undefined && typeof this.historyService?.addHistory === 'function') {
-      this.historyService.addHistory(
-        this.airPressureService,
-        {
-          time: Math.floor(Date.now() / 1000),
-          temperature: deviceData.current_temperature,
-          humidity: deviceData.current_humidity,
-          pressure: 0,
-        },
-        300,
-      );
-    }
+    this.history(
+      this.airPressureService,
+      { temperature: deviceData.current_temperature, humidity: deviceData.current_humidity, pressure: 0 },
+      { timegap: 300, force: true },
+    );
   }
 }
+
+// Function to process our RAW Nest or Google for this device type
+export function processRawData(log, rawData, config, deviceType = undefined) {
+  if (
+    rawData === null ||
+    typeof rawData !== 'object' ||
+    rawData?.constructor !== Object ||
+    typeof config !== 'object' ||
+    config?.constructor !== Object
+  ) {
+    return;
+  }
+
+  // Process data for any structure(s) for both Nest and Protobuf API data
+  // We use this to created virtual weather station(s) for each structure that has location data
+  let devices = {};
+  Object.entries(rawData)
+    .filter(
+      ([key]) => (key.startsWith('structure.') === true || key.startsWith('STRUCTURE_') === true) && config?.options?.weather === true, // Only if weather enabled
+    )
+    .forEach(([object_key, value]) => {
+      let tempDevice = {};
+      try {
+        // For a Google API source data, we use the Nest API structure ID. This will ensure we generate the same serial number
+        // This should prevent two 'wether' objects from being created
+        // Nest API uses the structure id only
+        let serialNumber =
+          value?.source === DATA_SOURCE.GOOGLE &&
+          typeof value.value?.structure_info?.rtsStructureId === 'string' &&
+          value.value.structure_info.rtsStructureId !== ''
+            ? value.value.structure_info.rtsStructureId.trim() // Google API STRUCTURE_xxx, translated Nest API structure.xxx
+            : value?.source === DATA_SOURCE.NEST
+              ? object_key // Nest API structure.xxx
+              : undefined;
+
+        let description =
+          value?.source === DATA_SOURCE.GOOGLE
+            ? (value.value?.structure_location?.city?.value?.trim() ?? '') !== '' &&
+              (value.value?.structure_location?.state?.value?.trim() ?? '') !== ''
+                ? value.value.structure_location.city.value.trim() + ' - ' + value.value.structure_location.state.value.trim()
+                : (value.value?.structure_info?.name?.trim() ?? '') !== ''
+                    ? value.value.structure_info.name.trim()
+                    : undefined
+            : value?.source === DATA_SOURCE.NEST
+              ? (value.value?.city?.trim() ?? '') !== '' && (value.value?.state?.trim() ?? '') !== ''
+                  ? value.value.city.trim() + ' - ' + value.value.state.trim()
+                  : (value.value?.name?.trim() ?? '') !== ''
+                      ? value.value.name.trim()
+                      : undefined
+              : undefined;
+
+        if (serialNumber !== undefined && description !== undefined) {
+          tempDevice = processCommonData(
+            object_key,
+            {
+              type: DEVICE_TYPE.WEATHER,
+              model: 'Weather',
+              softwareVersion: NestWeather.VERSION, // We'll use our class version here now
+              serialNumber: NESTLABS_MAC_PREFIX + crc24(serialNumber.toUpperCase()).toUpperCase(),
+              description: description,
+              current_temperature:
+                isNaN(value.value?.weather?.current_temperature) === false
+                  ? adjustTemperature(Number(value.value.weather.current_temperature), 'C', 'C', true)
+                  : 0.0,
+              current_humidity: isNaN(value.value?.weather?.current_humidity) === false ? Number(value.value.weather.current_humidity) : 0,
+              condition: value.value?.weather?.condition?.trim() ?? '',
+              wind_direction: value.value?.weather?.wind_direction?.trim() ?? '',
+              wind_speed: isNaN(value.value?.weather?.wind_speed) === false ? Number(value.value.weather.wind_speed) : 0,
+              sunrise: isNaN(value.value?.weather?.sunrise) === false ? Number(value.value.weather.sunrise) : '---',
+              sunset: isNaN(value.value?.weather?.sunset) === false ? Number(value.value.weather.sunset) : '---',
+              station: value.value?.weather?.station?.trim() ?? '',
+              forecast: value.value?.weather?.forecast?.trim() ?? '',
+            },
+            config,
+          );
+        }
+        // eslint-disable-next-line no-unused-vars
+      } catch (error) {
+        log?.debug?.('Error processing weather data for "%s"', object_key);
+      }
+
+      if (
+        Object.entries(tempDevice).length !== 0 &&
+        typeof devices[tempDevice.serialNumber] === 'undefined' &&
+        (deviceType === undefined || (typeof deviceType === 'string' && deviceType !== '' && tempDevice.type === deviceType))
+      ) {
+        let deviceOptions = config?.devices?.find(
+          (device) => device?.serialNumber?.toUpperCase?.() === tempDevice?.serialNumber?.toUpperCase?.(),
+        );
+        // Insert any extra options we've read in from configuration file for this device
+        tempDevice.eveHistory = config.options.eveHistory === true || deviceOptions?.eveHistory === true;
+        tempDevice.elevation =
+          isNaN(deviceOptions?.elevation) === false && Number(deviceOptions?.elevation) >= 0 && Number(deviceOptions?.elevation) <= 8848
+            ? Number(deviceOptions?.elevation)
+            : config.options.elevation;
+        devices[tempDevice.serialNumber] = tempDevice; // Store processed device
+      }
+    });
+
+  return devices;
+}

package/dist/protobuf/nest/services/apigateway.proto

@@ -1,7 +1,7 @@
 syntax = "proto3";
 
 import "google/protobuf/timestamp.proto";
-import "weave/common.proto";
+import "../../weave/common.proto";
 
 package nest.services.apigateway;
 

package/dist/protobuf/nestlabs/gateway/v2.proto

@@ -100,5 +100,5 @@ message ObserveResponse {
 }
 
 service GatewayService {
-    rpc Observe(ObserveRequest) returns (ObserveResponse);
+  rpc Observe (ObserveRequest) returns (stream ObserveResponse);
 }

package/dist/protobuf/root.proto

@@ -37,5 +37,6 @@ import "weave/trait/power.proto";
 import "weave/trait/schedule.proto";
 import "weave/trait/security.proto";
 import "weave/trait/time.proto";
+import "nest/services/apigateway.proto";
 import "nestlabs/gateway/v2.proto";
 import "nestlabs/history/v1.proto";

package/dist/rtpmuxer.js

@@ -0,0 +1,186 @@
+// rtpmuxer.js
+// Unified RTP Muxer + Stream Engine with FFmpeg support
+// Part of homebridge-nest-accfactory
+//
+// Code version 2025.07.04
+// Mark Hulskamp
+'use strict';
+
+// Define nodejs module requirements
+import dgram from 'dgram';
+import { Writable } from 'stream';
+import { Buffer } from 'node:buffer';
+import { setInterval, clearInterval } from 'node:timers';
+
+// Define constants
+const LOG_LEVELS = {
+  INFO: 'info',
+  SUCCESS: 'success',
+  WARN: 'warn',
+  ERROR: 'error',
+  DEBUG: 'debug',
+};
+const RTP_PACKET_HEADER_SIZE = 12;
+
+export default class RTPMuxer {
+  static RTP_PORT_START = 50000;
+  static RTP_PORT_END = 51000;
+  static SAMPLE_RATE_VIDEO = 90000;
+  static SAMPLE_RATE_AUDIO = 48000;
+  static PAYLOAD_TYPE_H264 = 96;
+  static PAYLOAD_TYPE_OPUS = 111;
+
+  static STREAM_TYPE = {
+    BUFFER: 'buffer',
+    LIVE: 'live',
+    RECORD: 'record',
+    TALK: 'talk',
+  };
+
+  log = undefined; // Logging function object
+
+  #udpServer = undefined; // UDP server for RTP packets
+  #port = undefined; // UDP port for RTP packets
+  #outputSessions = new Map(); // Output sessions for RTP streams
+  #buffer = []; // Buffer for RTP packets
+  #bufferDuration = 5000;
+  #bufferTimer = undefined; // Timer for buffer cleanup
+  #ffmpeg = undefined; // FFmpeg instance for processing RTP streams
+
+  constructor(options) {
+    // Setup logger object if passed as option
+    if (Object.values(LOG_LEVELS).every((fn) => typeof options?.log?.[fn] === 'function')) {
+      this.log = options.log;
+    }
+
+    this.#ffmpeg = options.ffmpeg; // pass instance of FFmpeg from ffmpeg.js
+  }
+
+  async start() {
+    this.#port = await this.#allocatePort();
+    this.#udpServer = dgram.createSocket('udp4');
+    this.#udpServer.on('message', (msg) => this.#handleRTP(msg));
+    this.#udpServer.bind(this.#port);
+    this.#startBufferLoop();
+  }
+
+  stop(uuid) {
+    if (this.#udpServer) {
+      this.#udpServer.close();
+      this.#udpServer = undefined;
+    }
+
+    clearInterval(this.#bufferTimer);
+    this.#outputSessions.clear();
+
+    this.#ffmpeg?.killAllSessions?.(uuid);
+  }
+
+  getPort() {
+    return this.#port;
+  }
+
+  getSDP(kind) {
+    let sdp = '';
+    if (kind === 'video') {
+      sdp += 'm=video ' + this.#port + ' RTP/AVP ' + RTPMuxer.PAYLOAD_TYPE_H264 + '\r\n';
+      sdp += 'a=rtpmap:' + RTPMuxer.PAYLOAD_TYPE_H264 + ' H264/' + RTPMuxer.SAMPLE_RATE_VIDEO + '\r\n';
+    } else if (kind === 'audio') {
+      sdp += 'm=audio ' + this.#port + ' RTP/AVP ' + RTPMuxer.PAYLOAD_TYPE_OPUS + '\r\n';
+      sdp += 'a=rtpmap:' + RTPMuxer.PAYLOAD_TYPE_OPUS + ' opus/' + RTPMuxer.SAMPLE_RATE_AUDIO + '/2\r\n';
+    }
+    return sdp;
+  }
+
+  attachOutput(sessionID, writableStream, options = {}) {
+    this.#outputSessions.set(sessionID, {
+      stream: writableStream,
+      kind: options.kind,
+      isRecording: options.isRecording === true,
+    });
+  }
+
+  detachOutput(sessionID) {
+    this.#outputSessions.delete(sessionID);
+  }
+
+  getWritableStream(type) {
+    return new Writable({
+      write: (chunk, encoding, callback) => {
+        if (type === RTPMuxer.STREAM_TYPE.BUFFER) {
+          this.#buffer.push({ time: Date.now(), data: chunk });
+        }
+        for (let session of this.#outputSessions.values()) {
+          if (session.kind === type || session.kind === undefined) {
+            session.stream.write(chunk);
+          }
+        }
+        callback();
+      },
+    });
+  }
+
+  getBufferedPackets(kind) {
+    let now = Date.now();
+    return this.#buffer.filter((p) => p.kind === kind && now - p.timestamp <= this.#bufferDuration).map((p) => p.packet);
+  }
+
+  startSession(uuid, sessionID, args, sessionType = 'live', errorCallback, pipeCount = 4) {
+    return this.#ffmpeg?.createSession?.(uuid, sessionID, args, sessionType, errorCallback, pipeCount);
+  }
+
+  stopSession(uuid, sessionID, sessionType = 'live') {
+    return this.#ffmpeg?.killSession?.(uuid, sessionID, sessionType);
+  }
+
+  processRTP(packet) {
+    this.#handleRTP(packet);
+  }
+
+  #handleRTP(packet) {
+    if (Buffer.isBuffer(packet) === false || packet.length < RTP_PACKET_HEADER_SIZE) {
+      return;
+    }
+
+    let payloadType = packet[1] & 0x7f;
+    let kind = payloadType === RTPMuxer.PAYLOAD_TYPE_H264 ? 'video' : payloadType === RTPMuxer.PAYLOAD_TYPE_OPUS ? 'audio' : undefined;
+    if (kind === undefined) {
+      return;
+    }
+
+    let copy = Buffer.from(packet);
+    this.#buffer.push({ kind, timestamp: Date.now(), packet: copy });
+
+    for (let session of this.#outputSessions.values()) {
+      if (session.kind === kind || session.kind === undefined) {
+        session.stream.write(copy);
+      }
+    }
+  }
+
+  #startBufferLoop() {
+    this.#bufferTimer = setInterval(() => {
+      let now = Date.now();
+      this.#buffer = this.#buffer.filter((p) => now - p.timestamp <= this.#bufferDuration);
+    }, 1000);
+  }
+
+  async #allocatePort() {
+    for (let port = RTPMuxer.RTP_PORT_START; port <= RTPMuxer.RTP_PORT_END; port += 2) {
+      try {
+        await new Promise((resolve, reject) => {
+          let socket = dgram.createSocket('udp4');
+          socket.once('error', reject);
+          socket.bind(port, () => {
+            socket.close();
+            resolve();
+          });
+        });
+        return port;
+      } catch {
+        // try next port
+      }
+    }
+    throw new Error('No available UDP port');
+  }
+}