homebridge-nest-accfactory 0.0.4-a → 0.0.6

package/dist/nexustalk.js

@@ -3,61 +3,31 @@
 //
 // Handles connection and data from Nest 'nexus' systems
 //
-// Code version 6/9/2024
+// Credit to https://github.com/Brandawg93/homebridge-nest-cam for the work on the Nest Camera comms code on which this is based
+//
+// Code version 14/9/2024
 // Mark Hulskamp
 'use strict';
 
 // Define external library requirements
-import protoBuf from 'pbf'; // Proto buffer
+import protobuf from 'protobufjs';
 
 // Define nodejs module requirements
 import { Buffer } from 'node:buffer';
 import { setInterval, clearInterval, setTimeout, clearTimeout } from 'node:timers';
+import fs from 'node:fs';
+import path from 'node:path';
 import tls from 'tls';
 import crypto from 'crypto';
+import { fileURLToPath } from 'node:url';
 
 // Define our modules
 import Streamer from './streamer.js';
 
 // Define constants
 const PINGINTERVAL = 15000; // Ping interval to nexus server while stream active
-
-const CodecType = {
-  SPEEX: 0,
-  PCM_S16_LE: 1,
-  H264: 2,
-  AAC: 3,
-  OPUS: 4,
-  META: 5,
-  DIRECTORS_CUT: 6,
-};
-
-const StreamProfile = {
-  AVPROFILE_MOBILE_1: 1,
-  AVPROFILE_HD_MAIN_1: 2,
-  AUDIO_AAC: 3,
-  AUDIO_SPEEX: 4,
-  AUDIO_OPUS: 5,
-  VIDEO_H264_50KBIT_L12: 6,
-  VIDEO_H264_530KBIT_L31: 7,
-  VIDEO_H264_100KBIT_L30: 8,
-  VIDEO_H264_2MBIT_L40: 9,
-  VIDEO_H264_50KBIT_L12_THUMBNAIL: 10,
-  META: 11,
-  DIRECTORS_CUT: 12,
-  AUDIO_OPUS_LIVE: 13,
-  VIDEO_H264_L31: 14,
-  VIDEO_H264_L40: 15,
-};
-
-const ErrorCode = {
-  ERROR_CAMERA_NOT_CONNECTED: 1,
-  ERROR_ILLEGAL_PACKET: 2,
-  ERROR_AUTHORIZATION_FAILED: 3,
-  ERROR_NO_TRANSCODER_AVAILABLE: 4,
-  ERROR_TRANSCODE_PROXY_ERROR: 5,
-  ERROR_INTERNAL: 6,
-};
+const USERAGENT = 'Nest/5.78.0 (iOScom.nestlabs.jasper.release) os=18.0'; // User Agent string
+const __dirname = path.dirname(fileURLToPath(import.meta.url)); // Make a defined for JS __dirname
 
 const PacketType = {
   PING: 1,
@@ -85,48 +55,37 @@ const PacketType = {
   AUTHORIZE_REQUEST: 212,
 };
 
-const ProtocolVersion = {
-  VERSION_1: 1,
-  VERSION_2: 2,
-  VERSION_3: 3,
-};
-
-const ClientType = {
-  ANDROID: 1,
-  IOS: 2,
-  WEB: 3,
-};
-
 // nexusTalk object
 export default class NexusTalk extends Streamer {
   token = undefined;
   tokenType = undefined;
-  uuid = undefined;
-  id = undefined; // Session ID
-  authorised = false; // Have wee been authorised
   pingTimer = undefined; // Timer object for ping interval
   stalledTimer = undefined; // Timer object for no received data
-  packets = []; // Incoming packets
-  messages = []; // Incoming messages
   video = {}; // Video stream details
   audio = {}; // Audio stream details
+  host = ''; // Host to connect to or connected too
+
+  // Internal data only for this class
+  #protobufNexusTalk = undefined; // Protobuf for NexusTalk
+  #socket = undefined; // TCP socket object
+  #packets = []; // Incoming packets
+  #messages = []; // Incoming messages
+  #authorised = false; // Have we been authorised
+  #id = undefined; // Session ID
 
   constructor(deviceData, options) {
     super(deviceData, options);
 
-    // Store data we need from the device data passed it
-    this.token = deviceData?.apiAccess.token;
-    if (deviceData?.apiAccess?.key === 'Authorization') {
-      this.tokenType = 'google';
-    }
-    if (deviceData?.apiAccess?.key === 'cookie') {
-      this.tokenType = 'nest';
+    if (fs.existsSync(path.resolve(__dirname + '/protobuf/nest/nexustalk.proto')) === true) {
+      protobuf.util.Long = null;
+      protobuf.configure();
+      this.#protobufNexusTalk = protobuf.loadSync(path.resolve(__dirname + '/protobuf/nest/nexustalk.proto'));
     }
-    this.uuid = deviceData?.uuid;
-    this.host = deviceData?.streaming_host; // Host we'll connect to
 
-    this.pendingHost = null;
-    this.weDidClose = true; // Flag if we did the socket close gracefully
+    // Store data we need from the device data passed it
+    this.token = deviceData?.apiAccess?.token;
+    this.tokenType = deviceData?.apiAccess?.oauth2 !== undefined ? 'google' : 'nest';
+    this.host = deviceData?.streaming_host; // Host we'll connect to
 
     // If specified option to start buffering, kick off
     if (typeof options?.buffer === 'boolean' && options.buffer === true) {
@@ -140,7 +99,7 @@ export default class NexusTalk extends Streamer {
     this.pingTimer = clearInterval(this.pingTimer);
     this.stalledTimer = clearInterval(this.stalledTimer);
 
-    this.id = undefined; // No session ID yet
+    this.#id = undefined; // No session ID yet
 
     if (this.online === true && this.videoEnabled === true) {
       if (typeof host === 'undefined' || host === null) {
@@ -148,47 +107,37 @@ export default class NexusTalk extends Streamer {
         host = this.host;
       }
 
-      if (this.pendingHost !== null) {
-        host = this.pendingHost;
-        this.pendingHost = null;
-      }
-
       this?.log?.debug && this.log.debug('Starting connection to "%s"', host);
 
-      this.socket = tls.connect({ host: host, port: 1443 }, () => {
+      this.#socket = tls.connect({ host: host, port: 1443 }, () => {
         // Opened connection to Nexus server, so now need to authenticate ourselves
         this?.log?.debug && this.log.debug('Connection established to "%s"', host);
 
-        this.socket.setKeepAlive(true); // Keep socket connection alive
+        this.#socket.setKeepAlive(true); // Keep socket connection alive
         this.host = host; // update internal host name since we've connected
+        this.connected = true;
         this.#Authenticate(false);
       });
 
-      this.socket.on('error', () => {});
+      this.#socket.on('error', () => {});
 
-      this.socket.on('end', () => {});
+      this.#socket.on('end', () => {});
 
-      this.socket.on('data', (data) => {
+      this.#socket.on('data', (data) => {
         this.#handleNexusData(data);
       });
 
-      this.socket.on('close', (hadError) => {
-        if (hadError === true) {
-          //
-        }
-        let normalClose = this.weDidClose; // Cache this, so can reset it below before we take action
+      this.#socket.on('close', (hadError) => {
+        this?.log?.debug && this.log.debug('Connection closed to "%s"', host);
 
         this.stalledTimer = clearTimeout(this.stalledTimer); // Clear stalled timer
         this.pingTimer = clearInterval(this.pingTimer); // Clear ping timer
-        this.authorised = false; // Since connection close, we can't be authorised anymore
-        this.socket = null; // Clear socket object
-        this.id = undefined; // Not an active session anymore
+        this.#authorised = false; // Since connection close, we can't be authorised anymore
+        this.#socket = undefined; // Clear socket object
+        this.connected = false;
+        this.#id = undefined; // Not an active session anymore
 
-        this.weDidClose = false; // Reset closed flag
-
-        this?.log?.debug && this.log.debug('Connection closed to "%s"', host);
-
-        if (normalClose === false && this.haveOutputs() === true) {
+        if (hadError === true && this.haveOutputs() === true) {
           // We still have either active buffering occuring or output streams running
           // so attempt to restart connection to existing host
           this.connect(host);
@@ -199,20 +148,19 @@ export default class NexusTalk extends Streamer {
 
   close(stopStreamFirst) {
     // Close an authenicated socket stream gracefully
-    if (this.socket !== null) {
+    if (this.#socket !== undefined) {
       if (stopStreamFirst === true) {
         // Send a notifcation to nexus we're finished playback
         this.#stopNexusData();
       }
-      this.socket.destroy();
+      this.#socket.destroy();
     }
 
-    this.socket = null;
-    this.id = undefined; // Not an active session anymore
-    this.packets = [];
-    this.messages = [];
-
-    this.weDidClose = true; // Flag we did the socket close
+    this.connected = false;
+    this.#socket = undefined;
+    this.#id = undefined; // Not an active session anymore
+    this.#packets = [];
+    this.#messages = [];
   }
 
   update(deviceData) {
@@ -224,62 +172,84 @@ export default class NexusTalk extends Streamer {
       // access token has changed so re-authorise
       this.token = deviceData.apiAccess.token;
 
-      if (this.socket !== null) {
+      if (this.#socket !== undefined) {
         this.#Authenticate(true); // Update authorisation only if connected
       }
     }
 
+    if (this.host !== deviceData.streaming_host) {
+      this.host = deviceData.streaming_host;
+      this?.log?.debug && this.log.debug('New host has been requested for connection. Host requested is "%s"', this.host);
+    }
+
     // Let our parent handle the remaining updates
     super.update(deviceData);
   }
 
   talkingAudio(talkingData) {
     // Encode audio packet for sending to camera
-    let audioBuffer = new protoBuf();
-    audioBuffer.writeBytesField(1, talkingData); // audio data
-    audioBuffer.writeVarintField(2, this.id); // session ID
-    audioBuffer.writeVarintField(3, CodecType.SPEEX); // codec
-    audioBuffer.writeVarintField(4, 16000); // sample rate, 16k
-    //audioBuffer.writeVarintField(5, ????);  // Latency measure tag. What does this do?
-    this.#sendMessage(PacketType.AUDIO_PAYLOAD, audioBuffer.finish());
+    if (typeof talkingData === 'object' && this.#protobufNexusTalk !== undefined) {
+      let TraitMap = this.#protobufNexusTalk.lookup('nest.nexustalk.v1.AudioPayload');
+      if (TraitMap !== null) {
+        let encodedData = TraitMap.encode(
+          TraitMap.fromObject({
+            payload: talkingData,
+            sessionId: this.#id,
+            codec: 'SPEEX',
+            sampleRate: 16000,
+          }),
+        ).finish();
+        this.#sendMessage(PacketType.AUDIO_PAYLOAD, encodedData);
+      }
+    }
   }
 
   #startNexusData() {
-    if (this.videoEnabled === false || this.online === false) {
+    if (this.videoEnabled === false || this.online === false || this.#protobufNexusTalk === undefined) {
       return;
     }
 
     // Setup streaming profiles
     // We'll use the highest profile as the main, with others for fallback
-    let otherProfiles = [];
-    otherProfiles.push(StreamProfile.VIDEO_H264_530KBIT_L31); // Medium quality
-    otherProfiles.push(StreamProfile.VIDEO_H264_100KBIT_L30); // Low quality
+    let otherProfiles = ['VIDEO_H264_530KBIT_L31', 'VIDEO_H264_100KBIT_L30'];
 
     if (this.audioEnabled === true) {
       // Include AAC profile if audio is enabled on camera
-      otherProfiles.push(StreamProfile.AUDIO_AAC);
+      otherProfiles.push('AUDIO_AAC');
     }
 
-    let startBuffer = new protoBuf();
-    startBuffer.writeVarintField(1, Math.floor(Math.random() * (100 - 1) + 1)); // Random session ID between 1 and 100);
-    startBuffer.writeVarintField(2, StreamProfile.VIDEO_H264_2MBIT_L40); // Default profile. ie: high quality
-    otherProfiles.forEach((otherProfile) => {
-      startBuffer.writeVarintField(6, otherProfile); // Other supported profiles
-    });
-
-    this.#sendMessage(PacketType.START_PLAYBACK, startBuffer.finish());
+    let TraitMap = this.#protobufNexusTalk.lookup('nest.nexustalk.v1.StartPlayback');
+    if (TraitMap !== null) {
+      let encodedData = TraitMap.encode(
+        TraitMap.fromObject({
+          sessionId: Math.floor(Math.random() * (100 - 1) + 1),
+          profile: 'VIDEO_H264_2MBIT_L40',
+          otherProfiles: otherProfiles,
+          profileNotFoundAction: 'REDIRECT',
+        }),
+      ).finish();
+      this.#sendMessage(PacketType.START_PLAYBACK, encodedData);
+    }
   }
 
   #stopNexusData() {
-    let stopBuffer = new protoBuf();
-    stopBuffer.writeVarintField(1, this.id); // Session ID
-    this.#sendMessage(PacketType.STOP_PLAYBACK, stopBuffer.finish());
+    if (this.#id !== undefined && this.#protobufNexusTalk !== undefined) {
+      let TraitMap = this.#protobufNexusTalk.lookup('nest.nexustalk.v1.StopPlayback');
+      if (TraitMap !== null) {
+        let encodedData = TraitMap.encode(
+          TraitMap.fromObject({
+            sessionId: this.#id,
+          }),
+        ).finish();
+        this.#sendMessage(PacketType.STOP_PLAYBACK, encodedData);
+      }
+    }
   }
 
   #sendMessage(type, data) {
-    if (this.socket === null || this.socket.readyState !== 'open' || (type !== PacketType.HELLO && this.authorised === false)) {
+    if (this.#socket?.readyState !== 'open' || (type !== PacketType.HELLO && this.#authorised === false)) {
       // We're not connect and/or authorised yet, so 'cache' message for processing once this occurs
-      this.messages.push({ type: type, data: data });
+      this.#messages.push({ type: type, data: data });
       return;
     }
 
@@ -296,61 +266,60 @@ export default class NexusTalk extends Streamer {
     }
 
     // write our composed message out to the socket back to NexusTalk
-    this.socket.write(Buffer.concat([header, Buffer.from(data)]), () => {
+    this.#socket.write(Buffer.concat([header, Buffer.from(data)]), () => {
       // Message sent. Don't do anything?
     });
   }
 
   #Authenticate(reauthorise) {
     // Authenticate over created socket connection
-    let tokenBuffer = new protoBuf();
-    let helloBuffer = new protoBuf();
+    if (this.#protobufNexusTalk !== undefined) {
+      this.#authorised = false; // We're nolonger authorised
+
+      let authoriseRequest = null;
+      let TraitMap = this.#protobufNexusTalk.lookup('nest.nexustalk.v1.AuthoriseRequest');
+      if (TraitMap !== null) {
+        authoriseRequest = TraitMap.encode(
+          TraitMap.fromObject(
+            this.tokenType === 'nest' ? { sessionToken: this.token } : this.tokenType === 'google' ? { oliveToken: this.token } : {},
+          ),
+        ).finish();
+      }
 
-    this.authorised = false; // We're nolonger authorised
+      if (reauthorise === true && authoriseRequest !== null) {
+        // Request to re-authorise only
+        this?.log?.debug && this.log.debug('Re-authentication requested to "%s"', this.host);
+        this.#sendMessage(PacketType.AUTHORIZE_REQUEST, authoriseRequest);
+      }
 
-    if (this.tokenType === 'nest') {
-      tokenBuffer.writeStringField(1, this.token); // Tag 1, session token, Nest auth accounts
-      helloBuffer.writeStringField(4, this.token); // Tag 4, session token, Nest auth accounts
-    }
-    if (this.tokenType === 'google') {
-      tokenBuffer.writeStringField(4, this.token); // Tag 4, olive token, Google auth accounts
-      helloBuffer.writeBytesField(12, tokenBuffer.finish()); // Tag 12, olive token, Google auth accounts
-    }
-    if (typeof reauthorise === 'boolean' && reauthorise === true) {
-      // Request to re-authorise only
-      this?.log?.debug && this.log.debug('Re-authentication requested to "%s"', this.host);
-      this.#sendMessage(PacketType.AUTHORIZE_REQUEST, tokenBuffer.finish());
-    } else {
-      // This isn't a re-authorise request, so perform 'Hello' packet
-      this?.log?.debug && this.log.debug('Performing authentication to "%s"', this.host);
-      helloBuffer.writeVarintField(1, ProtocolVersion.VERSION_3);
-      helloBuffer.writeStringField(2, this.uuid.split('.')[1]); // UUID should be 'quartz.xxxxxx'. We want the xxxxxx part
-      helloBuffer.writeBooleanField(3, false); // Doesnt required a connected camera
-      helloBuffer.writeStringField(6, crypto.randomUUID()); // Random UUID for this connection attempt
-      helloBuffer.writeStringField(7, 'Nest/5.75.0 (iOScom.nestlabs.jasper.release) os=17.4.1');
-      helloBuffer.writeVarintField(9, ClientType.IOS);
-      this.#sendMessage(PacketType.HELLO, helloBuffer.finish());
+      if (reauthorise === false && authoriseRequest !== null) {
+        // This isn't a re-authorise request, so perform 'Hello' packet
+        let TraitMap = this.#protobufNexusTalk.lookup('nest.nexustalk.v1.Hello');
+        if (TraitMap !== null) {
+          this?.log?.debug && this.log.debug('Performing authentication to "%s"', this.host);
+
+          let encodedData = TraitMap.encode(
+            TraitMap.fromObject({
+              protocolVersion: 'VERSION_3',
+              uuid: this.uuid.split(/[._]+/)[1],
+              requireConnectedCamera: false,
+              userAgent: USERAGENT,
+              deviceId: crypto.randomUUID(),
+              ClientType: 'IOS',
+              authoriseRequest: authoriseRequest,
+            }),
+          ).finish();
+          this.#sendMessage(PacketType.HELLO, encodedData);
+        }
+      }
     }
   }
 
   #handleRedirect(payload) {
     let redirectToHost = undefined;
-    if (typeof payload === 'object') {
-      // Payload parameter is an object, we'll assume its a payload packet
-      // Decode redirect packet to determine new host
-      let packet = payload.readFields(
-        (tag, obj, protoBuf) => {
-          if (tag === 1) {
-            obj.new_host = protoBuf.readString(); // new host
-          }
-          if (tag === 2) {
-            obj.is_transcode = protoBuf.readBoolean();
-          }
-        },
-        { new_host: '', is_transcode: false },
-      );
-
-      redirectToHost = packet.new_host;
+    if (typeof payload === 'object' && this.#protobufNexusTalk !== undefined) {
+      let decodedMessage = this.#protobufNexusTalk.lookup('nest.nexustalk.v1.Redirect').decode(payload).toJSON();
+      redirectToHost = decodedMessage?.newHost;
     }
     if (typeof payload === 'string') {
       // Payload parameter is a string, we'll assume this is a direct hostname
@@ -364,316 +333,157 @@ export default class NexusTalk extends Streamer {
     this?.log?.debug && this.log.debug('Redirect requested from "%s" to "%s"', this.host, redirectToHost);
 
     // Setup listener for socket close event. Once socket is closed, we'll perform the redirect
-    this.socket &&
-      this.socket.on('close', () => {
+    this.#socket &&
+      this.#socket.on('close', () => {
         this.connect(redirectToHost); // Connect to new host
       });
     this.close(true); // Close existing socket
   }
 
   #handlePlaybackBegin(payload) {
-    // Decode playback begin packet
-    let packet = payload.readFields(
-      (tag, obj, protoBuf) => {
-        if (tag === 1) {
-          obj.session_id = protoBuf.readVarint();
-        }
-        if (tag === 2) {
-          obj.channels.push(
-            protoBuf.readFields(
-              (tag, obj, protoBuf) => {
-                if (tag === 1) {
-                  obj.channel_id = protoBuf.readVarint();
-                }
-                if (tag === 2) {
-                  obj.codec_type = protoBuf.readVarint();
-                }
-                if (tag === 3) {
-                  obj.sample_rate = protoBuf.readVarint();
-                }
-                if (tag === 4) {
-                  obj.private_data.push(protoBuf.readBytes());
-                }
-                if (tag === 5) {
-                  obj.start_time = protoBuf.readDouble();
-                }
-                if (tag === 6) {
-                  obj.udp_ssrc = protoBuf.readVarint();
-                }
-                if (tag === 7) {
-                  obj.rtp_start_time = protoBuf.readVarint();
-                }
-                if (tag === 8) {
-                  obj.profile = protoBuf.readVarint();
-                }
-              },
-              { channel_id: 0, codec_type: 0, sample_rate: 0, private_data: [], start_time: 0, udp_ssrc: 0, rtp_start_time: 0, profile: 3 },
-              protoBuf.readVarint() + protoBuf.pos,
-            ),
-          );
-        }
-        if (tag === 3) {
-          obj.srtp_master_key = protoBuf.readBytes();
-        }
-        if (tag === 4) {
-          obj.srtp_master_salt = protoBuf.readBytes();
-        }
-        if (tag === 5) {
-          obj.fec_k_val = protoBuf.readVarint();
-        }
-        if (tag === 6) {
-          obj.fec_n_val = protoBuf.readVarint();
-        }
-      },
-      { session_id: 0, channels: [], srtp_master_key: null, srtp_master_salt: null, fec_k_val: 0, fec_n_val: 0 },
-    );
-
-    packet.channels &&
-      packet.channels.forEach((stream) => {
+    if (typeof payload === 'object' && this.#protobufNexusTalk !== undefined) {
+      let decodedMessage = this.#protobufNexusTalk.lookup('nest.nexustalk.v1.PlaybackBegin').decode(payload).toJSON();
+      decodedMessage.channels.forEach((stream) => {
         // Find which channels match our video and audio streams
-        if (stream.codec_type === CodecType.H264) {
+        if (stream.codecType === 'H264') {
           this.video = {
-            channel_id: stream.channel_id,
-            start_time: Date.now() + stream.start_time,
-            sample_rate: stream.sample_rate,
+            channel_id: stream.channelId,
+            start_time: Date.now() + stream.startTime,
+            sample_rate: stream.sampleRate,
             timestamp_delta: 0,
           };
         }
-        if (stream.codec_type === CodecType.AAC || stream.codec_type === CodecType.OPUS || stream.codec_type === CodecType.SPEEX) {
+        if (stream.codecType === 'AAC' || stream.codecType === 'OPUS' || stream.codecType === 'SPEEX') {
           this.audio = {
-            channel_id: stream.channel_id,
-            start_time: Date.now() + stream.start_time,
-            sample_rate: stream.sample_rate,
+            channel_id: stream.channelId,
+            start_time: Date.now() + stream.startTime,
+            sample_rate: stream.sampleRate,
             timestamp_delta: 0,
           };
         }
       });
 
-    // Since this is the beginning of playback, clear any active buffers contents
-    this.id = packet.session_id;
-    this.packets = [];
-    this.messages = [];
+      // Since this is the beginning of playback, clear any active buffers contents
+      this.#id = decodedMessage.sessionId;
+      this.#packets = [];
+      this.#messages = [];
 
-    this?.log?.debug && this.log.debug('Playback started from "%s" with session ID "%s"', this.host, this.id);
+      this?.log?.debug && this.log.debug('Playback started from "%s" with session ID "%s"', this.host, this.#id);
+    }
   }
 
   #handlePlaybackPacket(payload) {
     // Decode playback packet
-    let packet = payload.readFields(
-      (tag, obj, protoBuf) => {
-        if (tag === 1) {
-          obj.session_id = protoBuf.readVarint();
-        }
-        if (tag === 2) {
-          obj.channel_id = protoBuf.readVarint();
-        }
-        if (tag === 3) {
-          obj.timestamp_delta = protoBuf.readSVarint();
-        }
-        if (tag === 4) {
-          obj.payload = protoBuf.readBytes();
-        }
-        if (tag === 5) {
-          obj.latency_rtp_sequence = protoBuf.readVarint();
-        }
-        if (tag === 6) {
-          obj.latency_rtp_ssrc = protoBuf.readVarint();
-        }
-        if (tag === 7) {
-          obj.directors_cut_regions.push(
-            protoBuf.readFields(
-              (tag, obj, protoBuf) => {
-                if (tag === 1) {
-                  obj.id = protoBuf.readVarint();
-                }
-                if (tag === 2) {
-                  obj.left = protoBuf.readVarint();
-                }
-                if (tag === 3) {
-                  obj.right = protoBuf.readVarint();
-                }
-                if (tag === 4) {
-                  obj.top = protoBuf.readVarint();
-                }
-                if (tag === 5) {
-                  obj.bottom = protoBuf.readVarint();
-                }
-              },
-              {
-                // Defaults
-                id: 0,
-                left: 0,
-                right: 0,
-                top: 0,
-                bottom: 0,
-              },
-              protoBuf.readVarint() + protoBuf.pos,
-            ),
-          );
-        }
-      },
-      {
-        // Defaults
-        session_id: 0,
-        channel_id: 0,
-        timestamp_delta: 0,
-        payload: null,
-        latency_rtp_sequence: 0,
-        latency_rtp_ssrc: 0,
-        directors_cut_regions: [],
-      },
-    );
-
-    // Setup up a timeout to monitor for no packets recieved in a certain period
-    // If its trigger, we'll attempt to restart the stream and/or connection
-    // <-- testing to see how often this occurs first
-    this.stalledTimer = clearTimeout(this.stalledTimer);
-    this.stalledTimer = setTimeout(() => {
-      this?.log?.debug && this.log.debug('We have not received any data from nexus in the past "%s" seconds. Attempting restart', 8);
-
-      // Setup listener for socket close event. Once socket is closed, we'll perform the re-connection
-      this.socket &&
-        this.socket.on('close', () => {
-          this.connect(this.host); // try reconnection
-        });
-      this.close(false); // Close existing socket
-    }, 8000);
-
-    // Handle video packet
-    if (packet.channel_id === this.video.channel_id) {
-      this.video.timestamp_delta += packet.timestamp_delta;
-      this.addToOutput('video', this.video.start_time + this.video.timestamp_delta, packet.payload);
-    }
+    if (typeof payload === 'object' && this.#protobufNexusTalk !== undefined) {
+      let decodedMessage = this.#protobufNexusTalk.lookup('nest.nexustalk.v1.PlaybackPacket').decode(payload).toJSON();
+
+      // Setup up a timeout to monitor for no packets recieved in a certain period
+      // If its trigger, we'll attempt to restart the stream and/or connection
+      // <-- testing to see how often this occurs first
+      this.stalledTimer = clearTimeout(this.stalledTimer);
+      this.stalledTimer = setTimeout(() => {
+        this?.log?.debug && this.log.debug('We have not received any data from nexus in the past "%s" seconds. Attempting restart', 8);
+
+        // Setup listener for socket close event. Once socket is closed, we'll perform the re-connection
+        this.#socket &&
+          this.#socket.on('close', () => {
+            this.connect(); // try reconnection
+          });
+        this.close(false); // Close existing socket
+      }, 8000);
+
+      // Handle video packet
+      if (decodedMessage.channelId === this.video.channel_id) {
+        this.video.timestamp_delta += decodedMessage.timestampDelta;
+        this.addToOutput('video', this.video.start_time + this.video.timestamp_delta, Buffer.from(decodedMessage.payload, 'base64'));
+      }
 
-    // Handle audio packet
-    if (packet.channel_id === this.audio.channel_id) {
-      this.audio.timestamp_delta += packet.timestamp_delta;
-      this.addToOutput('audio', this.audio.start_time + this.audio.timestamp_delta, packet.payload);
+      // Handle audio packet
+      if (decodedMessage.channelId === this.audio.channel_id) {
+        this.audio.timestamp_delta += decodedMessage.timestampDelta;
+        this.addToOutput('audio', this.audio.start_time + this.audio.timestamp_delta, Buffer.from(decodedMessage.payload, 'base64'));
+      }
     }
   }
 
   #handlePlaybackEnd(payload) {
     // Decode playpack ended packet
-    let packet = payload.readFields(
-      (tag, obj, protoBuf) => {
-        if (tag === 1) {
-          obj.session_id = protoBuf.readVarint();
-        }
-        if (tag === 2) {
-          obj.reason = protoBuf.readVarint();
-        }
-      },
-      { session_id: 0, reason: 0 },
-    );
+    if (typeof payload === 'object' && this.#protobufNexusTalk !== undefined) {
+      let decodedMessage = this.#protobufNexusTalk.lookup('nest.nexustalk.v1.PlaybackEnd').decode(payload).toJSON();
 
-    if (this.id !== null && packet.reason === 0) {
-      // Normal playback ended ie: when we stopped playback
-      this?.log?.debug && this.log.debug('Playback ended on "%s"', this.host);
-    }
-
-    if (packet.reason !== 0) {
-      // Error during playback, so we'll attempt to restart by reconnection to host
-      this?.log?.debug && this.log.debug('Playback ended on "%s" with error "%s". Attempting reconnection', this.host, packet.reason);
+      if (this.#id !== undefined && decodedMessage.reason === 'USER_ENDED_SESSION') {
+        // Normal playback ended ie: when we stopped playback
+        this?.log?.debug && this.log.debug('Playback ended on "%s"', this.host);
+      }
 
-      // Setup listener for socket close event. Once socket is closed, we'll perform the re-connection
-      this.socket &&
-        this.socket.on('close', () => {
-          this.connect(this.host); // try reconnection to existing host
-        });
-      this.close(false); // Close existing socket
+      if (decodedMessage.reason !== 'USER_ENDED_SESSION') {
+        // Error during playback, so we'll attempt to restart by reconnection to host
+        this?.log?.debug &&
+          this.log.debug('Playback ended on "%s" with error "%s". Attempting reconnection', this.host, decodedMessage.reason);
+
+        // Setup listener for socket close event. Once socket is closed, we'll perform the re-connection
+        this.#socket &&
+          this.#socket.on('close', () => {
+            this.connect(); // try reconnection to existing host
+          });
+        this.close(false); // Close existing socket
+      }
     }
   }
 
   #handleNexusError(payload) {
     // Decode error packet
-    let packet = payload.readFields(
-      (tag, obj, protoBuf) => {
-        if (tag === 1) {
-          obj.code = protoBuf.readVarint();
-        }
-        if (tag === 2) {
-          obj.message = protoBuf.readString();
-        }
-      },
-      { code: 1, message: '' },
-    );
-
-    if (packet.code === ErrorCode.ERROR_AUTHORIZATION_FAILED) {
-      // NexusStreamer Updating authentication
-      this.#Authenticate(true); // Update authorisation only
-    } else {
-      // NexusStreamer Error, packet.message contains the message
-      this?.log?.debug && this.log.debug('Error', packet.message);
+    if (typeof payload === 'object' && this.#protobufNexusTalk !== undefined) {
+      let decodedMessage = this.#protobufNexusTalk.lookup('nest.nexustalk.v1.Error').decode(payload).toJSON();
+      if (decodedMessage.code === 'ERROR_AUTHORIZATION_FAILED') {
+        // NexusStreamer Updating authentication
+        this.#Authenticate(true); // Update authorisation only
+      } else {
+        // NexusStreamer Error, packet.message contains the message
+        this?.log?.debug && this.log.debug('Error', decodedMessage.message);
+      }
     }
   }
 
   #handleTalkbackBegin(payload) {
     // Decode talk begin packet
-    let packet = payload.readFields(
-      (tag, obj, protoBuf) => {
-        if (tag === 1) {
-          obj.user_id = protoBuf.readString();
-        }
-        if (tag === 2) {
-          obj.session_id = protoBuf.readVarint();
-        }
-        if (tag === 3) {
-          obj.quick_action_id = protoBuf.readVarint();
-        }
-        if (tag === 4) {
-          obj.device_id = protoBuf.readString();
-        }
-      },
-      { user_id: '', session_id: 0, quick_action_id: 0, device_id: '' },
-    );
-
-    this?.log?.debug && this.log.debug('Talkback started on "%s"', packet.device_id);
+    if (typeof payload === 'object' && this.#protobufNexusTalk !== undefined) {
+      let decodedMessage = this.#protobufNexusTalk.lookup('nest.nexustalk.v1.TalkbackBegin').decode(payload).toJSON();
+      this?.log?.debug && this.log.debug('Talkback started to uuid "%s" with id of "%s"', this.uuid, decodedMessage.deviceId);
+    }
   }
 
   #handleTalkbackEnd(payload) {
     // Decode talk end packet
-    let packet = payload.readFields(
-      (tag, obj, protoBuf) => {
-        if (tag === 1) {
-          obj.user_id = protoBuf.readString();
-        }
-        if (tag === 2) {
-          obj.session_id = protoBuf.readVarint();
-        }
-        if (tag === 3) {
-          obj.quick_action_id = protoBuf.readVarint();
-        }
-        if (tag === 4) {
-          obj.device_id = protoBuf.readString();
-        }
-      },
-      { user_id: '', session_id: 0, quick_action_id: 0, device_id: '' },
-    );
-
-    this?.log?.debug && this.log.debug('Talkback ended on "%s"', packet.device_id);
+    if (typeof payload === 'object' && this.#protobufNexusTalk !== undefined) {
+      let decodedMessage = this.#protobufNexusTalk.lookup('nest.nexustalk.v1.TalkbackEnd').decode(payload).toJSON();
+      this?.log?.debug && this.log.debug('Talkback ended from uuid "%s" with id of "%s"', this.uuid, decodedMessage.deviceId);
+    }
   }
 
   #handleNexusData(data) {
     // Process the rawdata from our socket connection and convert into nexus packets to take action against
-    this.packets = this.packets.length === 0 ? data : Buffer.concat([this.packets, data]);
+    this.#packets = this.#packets.length === 0 ? data : Buffer.concat([this.#packets, data]);
 
-    while (this.packets.length >= 3) {
+    while (this.#packets.length >= 3) {
       let headerSize = 3;
-      let packetType = this.packets.readUInt8(0);
-      let packetSize = this.packets.readUInt16BE(1);
+      let packetType = this.#packets.readUInt8(0);
+      let packetSize = this.#packets.readUInt16BE(1);
 
       if (packetType === PacketType.LONG_PLAYBACK_PACKET) {
         headerSize = 5;
-        packetSize = this.packets.readUInt32BE(1);
+        packetSize = this.#packets.readUInt32BE(1);
       }
 
-      if (this.packets.length < headerSize + packetSize) {
+      if (this.#packets.length < headerSize + packetSize) {
         // We dont have enough data in the buffer yet to process the full packet
         // so, exit loop and await more data
         break;
       }
 
-      let protoBufPayload = new protoBuf(this.packets.slice(headerSize, headerSize + packetSize));
+      let protoBufPayload = this.#packets.subarray(headerSize, headerSize + packetSize);
+      this.#packets = this.#packets.subarray(headerSize + packetSize);
+
       switch (packetType) {
         case PacketType.PING: {
           break;
@@ -681,8 +491,8 @@ export default class NexusTalk extends Streamer {
 
         case PacketType.OK: {
           // process any pending messages we have stored
-          this.authorised = true; // OK message, means we're connected and authorised to Nexus
-          for (let message = this.messages.shift(); message; message = this.messages.shift()) {
+          this.#authorised = true; // OK message, means we're connected and authorised to Nexus
+          for (let message = this.#messages.shift(); message; message = this.#messages.shift()) {
             this.#sendMessage(message.type, message.data);
           }
 
@@ -733,9 +543,6 @@ export default class NexusTalk extends Streamer {
           break;
         }
       }
-
-      // Remove the section of data we've just processed from our pending buffer
-      this.packets = this.packets.slice(headerSize + packetSize);
     }
   }
 }