homebridge-nest-accfactory 0.2.11 → 0.3.0

package/dist/protobuf/wdl.proto

@@ -171,8 +171,9 @@ message WdlCommandOptions {
     bool extendable = 5;
     uint32 reservedTagMin = 6;
     uint32 reservedTagMax = 7;
-    string pb_extends = 8;
+    string extends = 8;
     string completionEvent = 11;
+    WdlPermission permission = 20;
 }
 
 message WdlEventOptions {
@@ -181,7 +182,7 @@ message WdlEventOptions {
     bool extendable = 5;
     uint32 reservedTagMin = 6;
     uint32 reservedTagMax = 7;
-    string pb_extends = 8;
+    string extends = 8;
     EventImportance eventImportance = 9;
 }
 
@@ -373,6 +374,8 @@ message WdlTraitOptions {
     uint32 reservedCommandTagMax = 11;
     uint32 reservedEventTagMin = 12;
     uint32 reservedEventTagMax = 13;
+    WdlPermission permissionRead = 20;
+    WdlPermission permissionUpdate = 21;
 }
 
 message WdlTypespaceOptions {
@@ -440,6 +443,19 @@ message WdlServiceOptions {
     WdlResourceOptions resource = 3;
 }
 
+message WdlFileOptions {
+}
+
+message WdlPermission {
+    string permission = 1;
+    repeated Override permissionOverrides = 2;
+
+    message Override {
+        string resourceType = 1;
+        string permission = 2;
+    }
+}
+
 message CaspianOptions {
     bool ignore = 1;
 }

package/dist/protobuf/weave/common.proto

@@ -71,6 +71,7 @@ enum QuantityType {
     PPM = 48;
     PIRMEASUREMENT = 256;
     NORMALIZED = 257;
+    ANGLE = 259;
 }
 
 message ResourceId {
@@ -141,4 +142,4 @@ message TimeOfDay {
     uint32 hour = 5;
     uint32 minute = 6;
     uint32 second = 7;
-}
+}

package/dist/protobuf/weave/trait/heartbeat.proto

@@ -17,6 +17,15 @@ message LivenessTrait {
     google.protobuf.BoolValue commandRequestUnresponsiveness = 8;
     google.protobuf.Timestamp commandRequestUnresponsivenessTimeStatusChanged = 9;
     google.protobuf.StringValue publisherName = 10;
+    google.protobuf.BoolValue tunnelDisconnected = 11;
+    google.protobuf.Timestamp tunnelDisconnectedTimeStatusChanged = 12;
+    google.protobuf.Timestamp lastContactedTime = 13;
+    google.protobuf.Timestamp lastWdmHeartbeatTime = 14;
+    google.protobuf.Timestamp tunnelClosedTime = 15;
+    repeated DeviceFrontendType frontend = 16;
+    google.protobuf.BoolValue disconnected = 17;
+    google.protobuf.Timestamp disconnectedTimeStatusChanged = 18;
+    google.protobuf.Timestamp connectionClosedTime = 19;
 
     enum LivenessDeviceStatus {
         LIVENESS_DEVICE_STATUS_UNSPECIFIED = 0;
@@ -28,11 +37,42 @@ message LivenessTrait {
         LIVENESS_DEVICE_STATUS_SCHEDULED_DOWN = 6;
     }
 
+    enum DeviceFrontendType {
+        DEVICE_FRONTEND_TYPE_UNSPECIFIED = 0;
+        DEVICE_FRONTEND_TYPE_LYCRA = 1;
+        DEVICE_FRONTEND_TYPE_WEAVE_FE_1 = 2;
+    }
+
     message LivenessChangeEvent {
         LivenessDeviceStatus status = 1;
         LivenessDeviceStatus heartbeatStatus = 2;
         google.protobuf.BoolValue notifyRequestUnresponsiveness = 3;
         google.protobuf.BoolValue commandRequestUnresponsiveness = 4;
         LivenessDeviceStatus prevStatus = 5;
+        google.protobuf.BoolValue tunnelDisconnected = 6;
+        google.protobuf.Timestamp lastContactedTime = 7;
+        google.protobuf.Timestamp lastWdmHeartbeatTime = 8;
+        google.protobuf.Timestamp tunnelClosedTime = 9;
+        google.protobuf.Timestamp timeStatusChanged = 10;
+        google.protobuf.Timestamp timePrevStatusChanged = 11;
+        repeated DeviceFrontendType frontend = 12;
+        google.protobuf.BoolValue disconnected = 13;
+        google.protobuf.Timestamp disconnectedTimeStatusChanged = 14;
+        google.protobuf.Timestamp connectionClosedTime = 15;
+        google.protobuf.StringValue traitLabel = 16;
+    }
+
+    message LivenessConnectedSignalEvent {
+        string connectionId = 1;
+        DeviceFrontendType frontend = 2;
+        google.protobuf.Timestamp occurrenceTime = 3;
+        google.protobuf.StringValue connectionTag = 4;
+    }
+
+    message LivenessDisconnectedSignalEvent {
+        string connectionId = 1;
+        DeviceFrontendType frontend = 2;
+        google.protobuf.Timestamp occurrenceTime = 3;
+        google.protobuf.StringValue connectionTag = 4;
     }
-}
+}

package/dist/protobuf/weave/trait/power.proto

@@ -45,6 +45,7 @@ message PowerSourceCapabilitiesTrait {
     enum PowerSourceType {
         POWER_SOURCE_TYPE_UNSPECIFIED = 0;
         POWER_SOURCE_TYPE_BATTERY = 1;
+        POWER_SOURCE_TYPE_RECHARGEABLE_BATTERY = 2;
     }
 
     enum PowerSourceCurrentType {

package/dist/protobuf/weave/trait/security.proto

@@ -249,12 +249,21 @@ message TamperTrait {
         TAMPER_STATE_UNKNOWN = 3;
     }
 
+    enum TamperStateChangeReason {
+        TAMPER_STATE_CHANGE_REASON_UNSPECIFIED = 0;
+        TAMPER_STATE_CHANGE_REASON_CLEAR_SECURE = 1;
+        TAMPER_STATE_CHANGE_REASON_CLEAR_DISARM = 2;
+        TAMPER_STATE_CHANGE_REASON_CLEAR_SNOOZE = 3;
+    }
+
     message ResetTamperRequest {
     }
 
     message TamperStateChangeEvent {
         TamperState tamperState = 1;
         TamperState priorTamperState = 2;
+        TamperStateChangeReason reason = 3;
+        google.protobuf.Timestamp tamperStateChangeTime = 4;
     }
 }
 
@@ -340,4 +349,4 @@ message UserPincodesCapabilitiesTrait {
     uint32 minPincodeLength = 1;
     uint32 maxPincodeLength = 2;
     uint32 maxPincodesSupported = 3;
-}
+}

package/dist/streamer.js

@@ -17,7 +17,7 @@
 //
 // blankAudio - Buffer containing a blank audio segment for the type of audio being used
 //
-// Code version 2025/03/25
+// Code version 2025.06.12
 // Mark Hulskamp
 'use strict';
 
@@ -29,16 +29,28 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 // Define constants
-const CAMERAOFFLINEH264FILE = 'Nest_camera_offline.h264'; // Camera offline H264 frame file
-const CAMERAOFFH264FILE = 'Nest_camera_off.h264'; // Camera off H264 frame file
-const CAMERATRANSFERJPGFILE = 'Nest_camera_transfer.jpg'; // Camera transferring H264 frame file
+const CAMERARESOURCE = {
+  offline: 'Nest_camera_offline.h264',
+  off: 'Nest_camera_off.h264',
+  transfer: 'Nest_camera_transfer.h264',
+};
 const TALKBACKAUDIOTIMEOUT = 1000;
 const H264NALSTARTCODE = Buffer.from([0x00, 0x00, 0x00, 0x01]);
-
+const MAXBUFFERAGE = 5000; // Keep last 5s of media in buffer
+const STREAMFRAMEINTERVAL = 1000 / 30; // 30fps approx
+const RESOURCEPATH = './res';
 const __dirname = path.dirname(fileURLToPath(import.meta.url)); // Make a defined for JS __dirname
+const LOGLEVELS = {
+  info: 'info',
+  success: 'success',
+  warn: 'warn',
+  error: 'error',
+  debug: 'debug',
+};
 
 // Streamer object
 export default class Streamer {
+  log = undefined; // Logging function object
   videoEnabled = undefined; // Video stream on camera enabled or not
   audioEnabled = undefined; // Audio from camera enabled or not
   online = undefined; // Camera online or not
@@ -60,13 +72,7 @@ export default class Streamer {
 
   constructor(deviceData, options) {
     // Setup logger object if passed as option
-    if (
-      typeof options?.log?.info === 'function' &&
-      typeof options?.log?.success === 'function' &&
-      typeof options?.log?.warn === 'function' &&
-      typeof options?.log?.error === 'function' &&
-      typeof options?.log?.debug === 'function'
-    ) {
+    if (Object.keys(LOGLEVELS).every((fn) => typeof options?.log?.[fn] === 'function')) {
       this.log = options.log;
     }
 
@@ -77,39 +83,30 @@ export default class Streamer {
     this.audioEnabled = deviceData?.audio_enabled === true;
     this.uuid = deviceData?.nest_google_uuid;
 
-    // Setup location for *.h264 frame files. This can be overriden by a passed in option
-    let resourcePath = path.resolve(__dirname + '/res'); // Default location for *.h264 files
-    if (
-      typeof options?.resourcePath === 'string' &&
-      options.resourcePath !== '' &&
-      fs.existsSync(path.resolve(options.resourcePath)) === true
-    ) {
-      resourcePath = path.resolve(options.resourcePath);
-    }
-
-    // load buffer for camera offline in .h264 frame
-    if (fs.existsSync(path.resolve(resourcePath + '/' + CAMERAOFFLINEH264FILE)) === true) {
-      this.#cameraOfflineFrame = fs.readFileSync(path.resolve(resourcePath + '/' + CAMERAOFFLINEH264FILE));
-    }
-
-    // load buffer for camera stream off in .h264 frame
-    if (fs.existsSync(path.resolve(resourcePath + '/' + CAMERAOFFH264FILE)) === true) {
-      this.#cameraVideoOffFrame = fs.readFileSync(path.resolve(resourcePath + '/' + CAMERAOFFH264FILE));
-    }
+    // Load support video frame files as required
+    const loadFrameIfExists = (filename, label) => {
+      let buffer = undefined;
+      let file = path.resolve(__dirname, RESOURCEPATH, filename);
+      if (fs.existsSync(file) === true) {
+        buffer = fs.readFileSync(file);
+      } else {
+        this.log?.warn?.('Failed to load %s video resource for "%s"', label, deviceData.description);
+      }
+      return buffer;
+    };
 
-    // load buffer for camera transferring in .h264 frame
-    if (fs.existsSync(path.resolve(resourcePath + '/' + CAMERATRANSFERJPGFILE)) === true) {
-      this.#cameraTransferringFrame = fs.readFileSync(path.resolve(resourcePath + '/' + CAMERATRANSFERJPGFILE));
-    }
+    this.#cameraOfflineFrame = loadFrameIfExists(CAMERARESOURCE.offline, 'offline');
+    this.#cameraVideoOffFrame = loadFrameIfExists(CAMERARESOURCE.off, 'video off');
+    this.#cameraTransferringFrame = loadFrameIfExists(CAMERARESOURCE.transfer, 'transferring');
 
     // Start a non-blocking loop for output to the various streams which connect to our streamer object
     // This process will also handle the rolling-buffer size we require
     // Record streams will always start from the beginning of the buffer (tail)
     // Live streams will always start from the end of the buffer (head)
-    let lastTimeVideo = Date.now();
+    let lastVideoFrameTime = Date.now();
     this.#outputTimer = setInterval(() => {
       let dateNow = Date.now();
-      let outputVideoFrame = dateNow > lastTimeVideo + 90000 / 30; // 30fps
+      let outputVideoFrame = dateNow - lastVideoFrameTime >= STREAMFRAMEINTERVAL;
       Object.values(this.#outputs).forEach((output) => {
         // Monitor for camera going offline, video enabled/disabled or being transferred between Nest/Google Home
         // We'll insert the appropriate video frame into the stream
@@ -117,26 +114,28 @@ export default class Streamer {
           // Camera is offline so feed in our custom h264 frame and AAC silence
           output.buffer.push({ time: dateNow, type: 'video', data: this.#cameraOfflineFrame });
           output.buffer.push({ time: dateNow, type: 'audio', data: this.blankAudio });
-          lastTimeVideo = dateNow;
+          lastVideoFrameTime = dateNow;
         }
         if (this.online === true && this.videoEnabled === false && this.#cameraVideoOffFrame !== undefined && outputVideoFrame === true) {
           // Camera video is turned off so feed in our custom h264 frame and AAC silence
           output.buffer.push({ time: dateNow, type: 'video', data: this.#cameraVideoOffFrame });
           output.buffer.push({ time: dateNow, type: 'audio', data: this.blankAudio });
-          lastTimeVideo = dateNow;
+          lastVideoFrameTime = dateNow;
         }
         if (this.migrating === true && this.#cameraTransferringFrame !== undefined && outputVideoFrame === true) {
           // Camera video is turned off so feed in our custom h264 frame and AAC silence
           output.buffer.push({ time: dateNow, type: 'video', data: this.#cameraTransferringFrame });
           output.buffer.push({ time: dateNow, type: 'audio', data: this.blankAudio });
-          lastTimeVideo = dateNow;
+          lastVideoFrameTime = dateNow;
         }
 
         // Keep our 'main' rolling buffer under a certain size
         // Live/record buffers will always reduce in length in the next section
-        // <---- maybe make this time based x time since first packet in buffer?
-        if (output.type === 'buffer' && output.buffer.length > 1250) {
-          output.buffer.shift();
+        if (output.type === 'buffer') {
+          let cutoffTime = dateNow - MAXBUFFERAGE;
+          while (output.buffer.length > 0 && output.buffer[0].time < cutoffTime) {
+            output.buffer.shift();
+          }
         }
 
         // Output the packet data to any 'live' or 'recording' streams
@@ -151,7 +150,7 @@ export default class Streamer {
           }
         }
       });
-    }, 0);
+    }, 10); // Every 10ms, rather than "next tick"
   }
 
   // Class functions
@@ -163,7 +162,7 @@ export default class Streamer {
     if (this.#outputs?.buffer === undefined) {
       // No active buffer session, start connection to streamer
       if (this.online === true && this.videoEnabled === true && this.connected === undefined && typeof this.connect === 'function') {
-        this?.log?.debug && this.log.debug('Started buffering for uuid "%s"', this.uuid);
+        this?.log?.debug?.('Started buffering for uuid "%s"', this.uuid);
         this.connect();
       }
 
@@ -209,10 +208,8 @@ export default class Streamer {
       });
     }
 
-    if (this.online === true && this.videoEnabled === true && this.connected === undefined && typeof this.connect === 'function') {
-      // We do not have an active connection, so startup connection
-      this.connect();
-    }
+    // We do not have an active connection, so startup connection
+    this.#doConnect();
 
     // Add video/audio streams for our output loop to handle outputting
     this.#outputs[sessionID] = {
@@ -224,13 +221,12 @@ export default class Streamer {
     };
 
     // finally, we've started live stream
-    this?.log?.debug &&
-      this.log.debug(
-        'Started live stream from uuid "%s" %s "%s"',
-        this.uuid,
-        talkbackStream !== null && typeof talkbackStream === 'object' ? 'with two-way audio and sesssion id of' : 'and sesssion id of',
-        sessionID,
-      );
+    this?.log?.debug?.(
+      'Started live stream from uuid "%s" %s "%s"',
+      this.uuid,
+      talkbackStream !== null && typeof talkbackStream === 'object' ? 'with two-way audio and session id of' : 'and session id of',
+      sessionID,
+    );
   }
 
   startRecordStream(sessionID, videoStream, audioStream) {
@@ -247,10 +243,8 @@ export default class Streamer {
       });
     }
 
-    if (this.connected === undefined && typeof this.connect === 'function' && this.online === true && this.videoEnabled === true) {
-      // We do not have an active connection, so startup connection
-      this.connect();
-    }
+    // We do not have an active connection, so startup connection
+    this.#doConnect();
 
     // Add video/audio streams for our output loop to handle outputting
     this.#outputs[sessionID] = {
@@ -262,13 +256,13 @@ export default class Streamer {
     };
 
     // Finally we've started the recording stream
-    this?.log?.debug && this.log.debug('Started recording stream from uuid "%s" with sesison id of "%s"', this.uuid, sessionID);
+    this?.log?.debug?.('Started recording stream from uuid "%s" with session id of "%s"', this.uuid, sessionID);
   }
 
   stopRecordStream(sessionID) {
     // Request to stop a recording stream
     if (this.#outputs?.[sessionID] !== undefined) {
-      this?.log?.debug && this.log.debug('Stopped recording stream from uuid "%s"', this.uuid);
+      this?.log?.debug?.('Stopped recording stream from uuid "%s"', this.uuid);
       delete this.#outputs[sessionID];
     }
 
@@ -281,7 +275,7 @@ export default class Streamer {
   stopLiveStream(sessionID) {
     // Request to stop an active live stream
     if (this.#outputs?.[sessionID] !== undefined) {
-      this?.log?.debug && this.log.debug('Stopped live stream from uuid "%s"', this.uuid);
+      this?.log?.debug?.('Stopped live stream from uuid "%s"', this.uuid);
       delete this.#outputs[sessionID];
     }
 
@@ -293,7 +287,7 @@ export default class Streamer {
 
   stopBuffering() {
     if (this.#outputs?.buffer !== undefined) {
-      this?.log?.debug && this.log.debug('Stopped buffering from uuid "%s"', this.uuid);
+      this?.log?.debug?.('Stopped buffering from uuid "%s"', this.uuid);
       delete this.#outputs.buffer;
     }
 
@@ -305,7 +299,7 @@ export default class Streamer {
 
   stopEverything() {
     if (this.haveOutputs() === true) {
-      this?.log?.debug && this.log.debug('Stopped buffering, live and recording from uuid "%s"', this.uuid);
+      this?.log?.debug?.('Stopped buffering, live and recording from uuid "%s"', this.uuid);
       this.#outputs = {}; // No more outputs
       if (typeof this.close === 'function') {
         this.close();
@@ -328,9 +322,7 @@ export default class Streamer {
         if (typeof this.close === 'function') {
           this.close();
         }
-        if (this.online === true && this.videoEnabled === true && this.connected === undefined && typeof this.connect === 'function') {
-          this.connect();
-        }
+        this.#doConnect();
       }
     }
 
@@ -339,7 +331,7 @@ export default class Streamer {
       this.videoEnabled !== deviceData.streaming_enabled ||
       this.audioEnabled !== deviceData?.audio_enabled
     ) {
-      // Online status or streaming status has changed has changed
+      // Online status or streaming status has changed
       this.online = deviceData?.online === true;
       this.videoEnabled = deviceData?.streaming_enabled === true;
       this.audioEnabled = deviceData?.audio_enabled === true;
@@ -349,9 +341,7 @@ export default class Streamer {
         if ((this.online === false || this.videoEnabled === false || this.audioEnabled === false) && typeof this.close === 'function') {
           this.close(); // as offline or streaming not enabled, close streamer
         }
-        if (this.online === true && this.videoEnabled === true && this.connected === undefined && typeof this.connect === 'function') {
-          this.connect(); // Connect for stream
-        }
+        this.#doConnect();
       }
     }
   }
@@ -378,4 +368,10 @@ export default class Streamer {
   haveOutputs() {
     return Object.keys(this.#outputs).length > 0;
   }
+
+  #doConnect() {
+    if (this.online === true && this.videoEnabled === true && this.connected === undefined && typeof this.connect === 'function') {
+      this.connect();
+    }
+  }
 }