homebridge-nest-accfactory 0.0.5 → 0.2.0

package/dist/streamer.js

@@ -8,12 +8,16 @@
 //
 // The following functions should be overriden in your class which extends this
 //
-// streamer.connect(host)
-// streamer.close(stopStreamFirst)
+// streamer.connect()
+// streamer.close()
 // streamer.talkingAudio(talkingData)
 // streamer.update(deviceData) <- call super after
 //
-// Code version 11/9/2024
+// The following defines should be overriden in your class which extends this
+//
+// blankAudio - Buffer containing a blank audio segment for the type of audio being used
+//
+// Code version 29/9/2024
 // Mark Hulskamp
 'use strict';
 
@@ -27,9 +31,9 @@ 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 H264NALStartcode = Buffer.from([0x00, 0x00, 0x00, 0x01]);
-const AACAudioSilence = Buffer.from([0x21, 0x10, 0x01, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
+const CAMERATRANSFERJPGFILE = 'Nest_camera_transfer.jpg'; // Camera transferring H264 frame file
+const TALKBACKAUDIOTIMEOUT = 1000;
+const H264NALSTARTCODE = Buffer.from([0x00, 0x00, 0x00, 0x01]);
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url)); // Make a defined for JS __dirname
 
@@ -38,15 +42,21 @@ export default class Streamer {
   videoEnabled = undefined; // Video stream on camera enabled or not
   audioEnabled = undefined; // Audio from camera enabled or not
   online = undefined; // Camera online or not
-  host = ''; // Host to connect to or connected too
   uuid = undefined; // UUID of the device connecting
-  connected = false; // Streamer connected to endpoint
+  connected = undefined; // Stream endpoint connection: undefined = not connected , false = connecting , true = connected and streaming
+  blankAudio = undefined; // Blank audio 'frame'
+  codecs = {
+    video: undefined, // Video codec being used
+    audio: undefined, // Audio codec being used
+    talk: undefined, // Talking codec being used
+  };
 
   // Internal data only for this class
   #outputTimer = undefined; // Timer for non-blocking loop to stream output data
   #outputs = {}; // Output streams ie: buffer, live, record
   #cameraOfflineFrame = undefined; // Camera offline video frame
   #cameraVideoOffFrame = undefined; // Video turned off on camera video frame
+  #cameraTransferringFrame = undefined; // Camera transferring between Nest/Google Home video frame
 
   constructor(deviceData, options) {
     // Setup logger object if passed as option
@@ -61,10 +71,11 @@ export default class Streamer {
     }
 
     // Store data we need from the device data passed it
+    this.migrating = deviceData?.migrating === true;
     this.online = deviceData?.online === true;
     this.videoEnabled = deviceData?.streaming_enabled === true;
     this.audioEnabled = deviceData?.audio_enabled === true;
-    this.uuid = deviceData?.uuid;
+    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
@@ -76,22 +87,19 @@ export default class Streamer {
       resourcePath = path.resolve(options.resourcePath);
     }
 
-    // load buffer for camera offline image in .h264 frame
+    // load buffer for camera offline in .h264 frame
     if (fs.existsSync(path.resolve(resourcePath + '/' + CAMERAOFFLINEH264FILE)) === true) {
       this.#cameraOfflineFrame = fs.readFileSync(path.resolve(resourcePath + '/' + CAMERAOFFLINEH264FILE));
-      // remove any H264 NALU from beginning of any video data. We do this as they are added later when output by our ffmpeg router
-      if (this.#cameraOfflineFrame.indexOf(H264NALStartcode) === 0) {
-        this.#cameraOfflineFrame = this.#cameraOfflineFrame.subarray(H264NALStartcode.length);
-      }
     }
 
-    // load buffer for camera stream off image in .h264 frame
+    // 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));
-      // remove any H264 NALU from beginning of any video data. We do this as they are added later when output by our ffmpeg router
-      if (this.#cameraVideoOffFrame.indexOf(H264NALStartcode) === 0) {
-        this.#cameraVideoOffFrame = this.#cameraVideoOffFrame.subarray(H264NALStartcode.length);
-      }
+    }
+
+    // load buffer for camera transferring in .h264 frame
+    if (fs.existsSync(path.resolve(resourcePath + '/' + CAMERATRANSFERJPGFILE)) === true) {
+      this.#cameraTransferringFrame = fs.readFileSync(path.resolve(resourcePath + '/' + CAMERATRANSFERJPGFILE));
     }
 
     // Start a non-blocking loop for output to the various streams which connect to our streamer object
@@ -101,20 +109,26 @@ export default class Streamer {
     let lastTimeVideo = Date.now();
     this.#outputTimer = setInterval(() => {
       let dateNow = Date.now();
-      let outputVideoFrame = dateNow > lastTimeVideo + 90000 / 30; // 30 or 15 fps?
+      let outputVideoFrame = dateNow > lastTimeVideo + 90000 / 30; // 30fps
       Object.values(this.#outputs).forEach((output) => {
-        // Monitor for camera going offline and/or video enabled/disabled
+        // 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
         if (this.online === false && this.#cameraOfflineFrame !== undefined && outputVideoFrame === true) {
           // Camera is offline so feed in our custom h264 frame and AAC silence
-          output.buffer.push({ type: 'video', time: dateNow, data: this.#cameraOfflineFrame });
-          output.buffer.push({ type: 'audio', time: dateNow, data: AACAudioSilence });
+          output.buffer.push({ time: dateNow, type: 'video', data: this.#cameraOfflineFrame });
+          output.buffer.push({ time: dateNow, type: 'audio', data: this.blankAudio });
           lastTimeVideo = 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({ type: 'video', time: dateNow, data: this.#cameraVideoOffFrame });
-          output.buffer.push({ type: 'audio', time: dateNow, data: AACAudioSilence });
+          output.buffer.push({ time: dateNow, type: 'video', data: this.#cameraVideoOffFrame });
+          output.buffer.push({ time: dateNow, type: 'audio', data: this.blankAudio });
+          lastTimeVideo = 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;
         }
 
@@ -125,14 +139,14 @@ export default class Streamer {
           output.buffer.shift();
         }
 
-        // Output the packet data to any streams 'live' or 'recording' streams
+        // Output the packet data to any 'live' or 'recording' streams
         if (output.type === 'live' || output.type === 'record') {
           let packet = output.buffer.shift();
           if (packet?.type === 'video' && typeof output?.video?.write === 'function') {
             // H264 NAL Units '0001' are required to be added to beginning of any video data we output
             // If this is missing, add on beginning of data packet
-            if (packet.data.indexOf(H264NALStartcode) !== 0) {
-              packet.data = Buffer.concat([H264NALStartcode, packet.data]);
+            if (packet.data.indexOf(H264NALSTARTCODE) !== 0) {
+              packet.data = Buffer.concat([H264NALSTARTCODE, packet.data]);
             }
             output.video.write(packet.data);
           }
@@ -152,11 +166,9 @@ export default class Streamer {
   startBuffering() {
     if (this.#outputs?.buffer === undefined) {
       // No active buffer session, start connection to streamer
-      if (this.connected === false && typeof this.host === 'string' && this.host !== '') {
-        if (typeof this.connect === 'function') {
-          this?.log?.debug && this.log.debug('Started buffering from "%s"', this.host);
-          this.connect(this.host);
-        }
+      if (this.connected === undefined && typeof this.connect === 'function') {
+        this?.log?.debug && this.log.debug('Started buffering for uuid "%s"', this.uuid);
+        this.connect();
       }
 
       this.#outputs.buffer = {
@@ -192,23 +204,21 @@ export default class Streamer {
         if (typeof this.talkingAudio === 'function') {
           this.talkingAudio(data);
 
-          talkbackTimeout = clearTimeout(talkbackTimeout);
+          clearTimeout(talkbackTimeout);
           talkbackTimeout = setTimeout(() => {
-            // no audio received in 500ms, so mark end of stream
+            // no audio received in 1000ms, so mark end of stream
             this.talkingAudio(Buffer.alloc(0));
-          }, 500);
+          }, TALKBACKAUDIOTIMEOUT);
         }
       });
     }
 
-    if (this.connected === false && typeof this.host === 'string' && this.host !== '') {
-      // We do not have an active socket connection, so startup connection to host
-      if (typeof this.connect === 'function') {
-        this.connect(this.host);
-      }
+    if (this.connected === undefined && typeof this.connect === 'function') {
+      // We do not have an active connection, so startup connection
+      this.connect();
     }
 
-    // Add video/audio streams for our output loop to handle outputting to
+    // Add video/audio streams for our output loop to handle outputting
     this.#outputs[sessionID] = {
       type: 'live',
       video: videoStream,
@@ -220,8 +230,8 @@ export default class Streamer {
     // finally, we've started live stream
     this?.log?.debug &&
       this.log.debug(
-        'Started live stream from "%s" %s "%s"',
-        this.host,
+        '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,
       );
@@ -241,14 +251,12 @@ export default class Streamer {
       });
     }
 
-    if (this.connected === false && typeof this.host === 'string' && this.host !== '') {
-      // We do not have an active socket connection, so startup connection to host
-      if (typeof this.connect === 'function') {
-        this.connect(this.host);
-      }
+    if (this.connected === undefined && typeof this.connect === 'function') {
+      // We do not have an active connection, so startup connection
+      this.connect();
     }
 
-    // Add video/audio streams for our output loop to handle outputting to
+    // Add video/audio streams for our output loop to handle outputting
     this.#outputs[sessionID] = {
       type: 'record',
       video: videoStream,
@@ -258,44 +266,54 @@ export default class Streamer {
     };
 
     // Finally we've started the recording stream
-    this?.log?.debug && this.log.debug('Started recording stream from "%s" with sesison id of "%s"', this.host, sessionID);
+    this?.log?.debug && this.log.debug('Started recording stream from uuid "%s" with sesison id of "%s"', this.uuid, sessionID);
   }
 
   stopRecordStream(sessionID) {
     // Request to stop a recording stream
-    if (typeof this.#outputs[sessionID] === 'object') {
-      this?.log?.debug && this.log.debug('Stopped recording stream from "%s"', this.host);
+    if (this.#outputs?.[sessionID] !== undefined) {
+      this?.log?.debug && this.log.debug('Stopped recording stream from uuid "%s"', this.uuid);
       delete this.#outputs[sessionID];
     }
 
-    // If we have no more output streams active, we'll close the connection to host
+    // If we have no more output streams active, we'll close the connection
     if (Object.keys(this.#outputs).length === 0 && typeof this.close === 'function') {
-      this.close(true);
+      this.close();
     }
   }
 
   stopLiveStream(sessionID) {
     // Request to stop an active live stream
-    if (typeof this.#outputs[sessionID] === 'object') {
-      this?.log?.debug && this.log.debug('Stopped live stream from "%s"', this.host);
+    if (this.#outputs?.[sessionID] !== undefined) {
+      this?.log?.debug && this.log.debug('Stopped live stream from uuid "%s"', this.uuid);
       delete this.#outputs[sessionID];
     }
 
-    // If we have no more output streams active, we'll close the connection to host
+    // If we have no more output streams active, we'll close the connection
     if (Object.keys(this.#outputs).length === 0 && typeof this.close === 'function') {
-      this.close(true);
+      this.close();
     }
   }
 
   stopBuffering() {
     if (this.#outputs?.buffer !== undefined) {
-      this?.log?.debug && this.log.debug('Stopped buffering from "%s"', this.host);
+      this?.log?.debug && this.log.debug('Stopped buffering from uuid "%s"', this.uuid);
       delete this.#outputs.buffer;
     }
 
-    // If we have no more output streams active, we'll close the connection to host
+    // If we have no more output streams active, we'll close the connection
     if (Object.keys(this.#outputs).length === 0 && typeof this.close === 'function') {
-      this.close(true);
+      this.close();
+    }
+  }
+
+  stopEverything() {
+    if (Object.keys(this.#outputs).length > 0) {
+      this?.log?.debug && 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();
+      }
     }
   }
 
@@ -304,9 +322,20 @@ export default class Streamer {
       return;
     }
 
-    if (this.host !== deviceData.streaming_host) {
-      this.host = deviceData.streaming_host;
-      this?.log?.debug && this.log.debug('New streaming host has been requested for connection. Host requested is "%s"', this.host);
+    this.migrating = deviceData.migrating;
+
+    if (this.uuid !== deviceData?.nest_google_uuid) {
+      this.uuid = deviceData?.nest_google_uuid;
+
+      if (Object.keys(this.#outputs).length > 0) {
+        // Since the uuid has change and a streamer may use this, if there any any active outpuyts, close and connect again
+        if (typeof this.close === 'function') {
+          this.close();
+        }
+        if (typeof this.connect === 'function') {
+          this.connect();
+        }
+      }
     }
 
     if (
@@ -319,23 +348,23 @@ export default class Streamer {
       this.videoEnabled = deviceData?.streaming_enabled === true;
       this.audioEnabled = deviceData?.audio_enabled === true;
       if ((this.online === false || this.videoEnabled === false || this.audioEnabled === false) && typeof this.close === 'function') {
-        this.close(true); // as offline or streaming not enabled, close socket
+        this.close(); // as offline or streaming not enabled, close streamer
       }
-      if (this.online === true && this.videoEnabled === true && typeof this.connect === 'function') {
-        this.connect(this.host); // Connect to host for stream
+      if (this.online === true && this.videoEnabled === true && this.connected === undefined && typeof this.connect === 'function') {
+        this.connect(); // Connect for stream
       }
     }
   }
 
-  addToOutput(type, time, data) {
-    if (typeof type !== 'string' || type === '' || typeof time !== 'number' || time === 0) {
+  addToOutput(type, data) {
+    if (typeof type !== 'string' || type === '' || Buffer.isBuffer(data) === false) {
       return;
     }
 
     Object.values(this.#outputs).forEach((output) => {
       output.buffer.push({
+        time: Date.now(), // Timestamp of when tgis was added to buffer
         type: type,
-        time: time,
         data: data,
       });
     });