eufy-security-client 3.8.0-dev.15 → 3.8.0-dev.17

package/build/p2p/interfaces.d.ts

@@ -149,6 +149,15 @@ export interface StreamMetadata {
     videoHeight: number;
     audioCodec: AudioCodec;
 }
+/** Configurable timeout values for P2P streaming. All values in milliseconds. */
+export interface StreamTimeoutOptions {
+    /** Max time to wait for stream data before auto-stopping. Default: 5000ms. */
+    streamDataWait?: number;
+    /** Time to wait for first audio frame before declaring no audio. Default: 650ms. */
+    audioCodecAnalyze?: number;
+    /** Max time to wait for an expected sequence number. Default: 20000ms. */
+    expectedSeqNoWait?: number;
+}
 export interface DeviceSerial {
     [index: number]: {
         sn: string;

package/build/p2p/session.d.ts

@@ -2,7 +2,7 @@ import { TypedEmitter } from "tiny-typed-emitter";
 import * as NodeRSA from "node-rsa";
 import { Address, CustomData } from "./models";
 import { CommandType, P2PDataType, P2PConnectionType } from "./types";
-import { P2PClientProtocolEvents, P2PCommand } from "./interfaces";
+import { P2PClientProtocolEvents, P2PCommand, StreamTimeoutOptions } from "./interfaces";
 import { StationListResponse } from "../http/models";
 import { HTTPApi } from "../http/api";
 export declare class P2PClientProtocol extends TypedEmitter<P2PClientProtocolEvents> {
@@ -24,6 +24,7 @@ export declare class P2PClientProtocol extends TypedEmitter<P2PClientProtocolEve
     private readonly ESD_DISCONNECT_TIMEOUT;
     private readonly MAX_STREAM_DATA_WAIT;
     private readonly RESEND_NOT_ACKNOWLEDGED_COMMAND;
+    private streamTimeouts;
     private readonly UDP_RECVBUFFERSIZE_BYTES;
     private readonly MAX_PAYLOAD_BYTES;
     private readonly MAX_PACKET_BYTES;
@@ -162,6 +163,7 @@ export declare class P2PClientProtocol extends TypedEmitter<P2PClientProtocolEve
     private emitStreamStopEvent;
     isStreaming(channel: number, datatype: P2PDataType): boolean;
     isLiveStreaming(channel: number): boolean;
+    setStreamTimeouts(options: StreamTimeoutOptions): void;
     private isCurrentlyStreaming;
     isRTSPLiveStreaming(channel: number): boolean;
     isDownloading(channel: number): boolean;

package/build/p2p/session.js

@@ -38,6 +38,11 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
     ESD_DISCONNECT_TIMEOUT = 30 * 1000;
     MAX_STREAM_DATA_WAIT = 5 * 1000;
     RESEND_NOT_ACKNOWLEDGED_COMMAND = 100;
+    streamTimeouts = {
+        streamDataWait: this.MAX_STREAM_DATA_WAIT,
+        audioCodecAnalyze: this.AUDIO_CODEC_ANALYZE_TIMEOUT,
+        expectedSeqNoWait: this.MAX_EXPECTED_SEQNO_WAIT,
+    };
     UDP_RECVBUFFERSIZE_BYTES = 1048576;
     MAX_PAYLOAD_BYTES = 1028;
     MAX_PACKET_BYTES = 1024;
@@ -1241,7 +1246,7 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                         this.currentMessageState[dataType].waitForSeqNoTimeout = setTimeout(() => {
                             this.endStream(dataType, true);
                             this.currentMessageState[dataType].waitForSeqNoTimeout = undefined;
-                        }, this.MAX_EXPECTED_SEQNO_WAIT);
+                        }, this.streamTimeouts.expectedSeqNoWait);
                     if (!this.currentMessageState[dataType].queuedData.get(message.seqNo)) {
                         this.currentMessageState[dataType].queuedData.set(message.seqNo, message);
                         logging_1.rootP2PLogger.trace(`Received message - DATA ${types_1.P2PDataType[message.type]} - Received not expected sequence, added to the queue for future processing`, {
@@ -1771,6 +1776,7 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
     }
     isIFrame(data, isKeyFrame) {
         if (this.rawStation.station_sn.startsWith("T8410") ||
+            this.rawStation.station_sn.startsWith("T8417") ||
             this.rawStation.station_sn.startsWith("T8400") ||
             this.rawStation.station_sn.startsWith("T8401") ||
             this.rawStation.station_sn.startsWith("T8411") ||
@@ -1802,9 +1808,9 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
             clearTimeout(this.currentMessageState[dataType].p2pStreamingTimeout);
         }
         this.currentMessageState[dataType].p2pStreamingTimeout = setTimeout(() => {
-            logging_1.rootP2PLogger.info(`Stopping the station stream for the device ${this.deviceSNs[this.currentMessageState[dataType].p2pStreamChannel]?.sn}, because we haven't received any data for ${this.MAX_STREAM_DATA_WAIT / 1000} seconds`);
+            logging_1.rootP2PLogger.info(`Stopping the station stream for the device ${this.deviceSNs[this.currentMessageState[dataType].p2pStreamChannel]?.sn}, because we haven't received any data for ${this.streamTimeouts.streamDataWait / 1000} seconds`);
             this.endStream(dataType, sendStopCommand);
-        }, this.MAX_STREAM_DATA_WAIT);
+        }, this.streamTimeouts.streamDataWait);
     }
     handleDataBinaryAndVideo(message) {
         if (!this.currentMessageState[message.dataType].invalidStream) {
@@ -1884,6 +1890,7 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                     this.currentMessageState[message.dataType].p2pStreamMetadata.videoWidth = videoMetaData.videoWidth;
                     if (!this.currentMessageState[message.dataType].p2pStreamFirstVideoDataReceived) {
                         if (this.rawStation.station_sn.startsWith("T8410") ||
+                            this.rawStation.station_sn.startsWith("T8417") ||
                             this.rawStation.station_sn.startsWith("T8400") ||
                             this.rawStation.station_sn.startsWith("T8401") ||
                             this.rawStation.station_sn.startsWith("T8411") ||
@@ -1973,7 +1980,7 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                                     this.currentMessageState[message.dataType].p2pStreamNotStarted) {
                                     this.emitStreamStartEvent(message.dataType);
                                 }
-                            }, this.AUDIO_CODEC_ANALYZE_TIMEOUT);
+                            }, this.streamTimeouts.audioCodecAnalyze);
                         }
                     }
                     if (this.currentMessageState[message.dataType].p2pStreamNotStarted) {
@@ -2856,11 +2863,16 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                                     this.emit("garage door status", message.channel, payload.door_id, payload.type);
                                 }
                             }
-                            else if (json.cmd === types_1.CommandType.CMD_STORAGE_INFO_HB3) {
+                            else if (json.cmd === 6246) {
                                 const payload = json.payload;
-                                logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD StorageInfo HB3 update`, { stationSN: this.rawStation.station_sn, body: payload?.body });
-                                if (payload) {
-                                    this.emit("storage info hb3", message.channel, payload.body);
+                                logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Livestream status`, { stationSN: this.rawStation.station_sn, payload: payload });
+                                if (payload?.num !== undefined) {
+                                    if (payload.num > 0) {
+                                        this.emit("rtsp livestream started", message.channel);
+                                    }
+                                    else {
+                                        this.emit("rtsp livestream stopped", message.channel);
+                                    }
                                 }
                             }
                             else if (json.cmd === types_1.CommandType.CMD_HUB_NOTIFY_UPDATE) {
@@ -3549,6 +3561,9 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
     isLiveStreaming(channel) {
         return this.isStreaming(channel, types_1.P2PDataType.VIDEO);
     }
+    setStreamTimeouts(options) {
+        this.streamTimeouts = { ...this.streamTimeouts, ...options };
+    }
     isCurrentlyStreaming() {
         for (const element of Object.values(this.currentMessageState)) {
             if (element.p2pStreaming || element.p2pTalkback)