Add TCP+Relay detection event

Frontend/library/src/PeerConnectionController/AggregatedStats.ts

@@ -120,16 +120,10 @@ export class AggregatedStats {
      * @param stat - the stats coming in from ice candidates
      */
     handleCandidatePair(stat: CandidatePairStats) {
-        this.candidatePair.bytesReceived = stat.bytesReceived;
-        this.candidatePair.bytesSent = stat.bytesSent;
-        this.candidatePair.localCandidateId = stat.localCandidateId;
-        this.candidatePair.remoteCandidateId = stat.remoteCandidateId;
-        this.candidatePair.nominated = stat.nominated;
-        this.candidatePair.readable = stat.readable;
-        this.candidatePair.selected = stat.selected;
-        this.candidatePair.writable = stat.writable;
-        this.candidatePair.state = stat.state;
-        this.candidatePair.currentRoundTripTime = stat.currentRoundTripTime;
+        // If the candidate pair has received bytes then set as the candidate pair
+        if (stat.bytesReceived > 0){
+            this.candidatePair = stat;
+        }
     }
 
     /**
@@ -162,6 +156,8 @@ export class AggregatedStats {
         localCandidate.protocol = stat.protocol;
         localCandidate.candidateType = stat.candidateType;
         localCandidate.id = stat.id;
+        localCandidate.relayProtocol = stat.relayProtocol;
+        localCandidate.transportId = stat.transportId;
         this.localCandidates.push(localCandidate);
     }
 
@@ -171,12 +167,14 @@ export class AggregatedStats {
      */
     handleRemoteCandidate(stat: CandidateStat) {
         const RemoteCandidate = new CandidateStat();
-        RemoteCandidate.label = 'local-candidate';
+        RemoteCandidate.label = 'remote-candidate';
         RemoteCandidate.address = stat.address;
         RemoteCandidate.port = stat.port;
         RemoteCandidate.protocol = stat.protocol;
         RemoteCandidate.id = stat.id;
         RemoteCandidate.candidateType = stat.candidateType;
+        RemoteCandidate.relayProtocol = stat.relayProtocol;
+        RemoteCandidate.transportId = stat.transportId
         this.remoteCandidates.push(RemoteCandidate);
     }
 

Frontend/library/src/PeerConnectionController/CandidatePairStats.ts

@@ -6,12 +6,19 @@
 export class CandidatePairStats {
     bytesReceived: number;
     bytesSent: number;
+    currentRoundTripTime: number;
+    id: string;
+    lastPacketReceivedTimestamp: number;
+    lastPacketSentTimestamp: number;
     localCandidateId: string;
-    remoteCandidateId: string;
     nominated: boolean;
+    priority: number;
     readable: boolean;
-    writable: boolean;
+    remoteCandidateId: string;
     selected: boolean;
     state: string;
-    currentRoundTripTime: number;
+    timestamp: number;
+    transportId: string;
+    type: string;
+    writable: boolean;  
 }

Frontend/library/src/PeerConnectionController/CandidateStat.ts

@@ -4,10 +4,12 @@
  * ICE Candidate Stat collected from the RTC Stats Report
  */
 export class CandidateStat {
-    label: string;
-    id: string;
     address: string;
     candidateType: string;
+    id: string;
+    label: string;    
     port: number;
     protocol: 'tcp' | 'udp';
+    relayProtocol: 'tcp' | 'udp' | 'tls';
+    transportId: string;
 }

Frontend/library/src/PixelStreaming/PixelStreaming.ts

@@ -18,6 +18,7 @@ import {
     StreamPreConnectEvent,
     StreamReconnectEvent,
     StreamPreDisconnectEvent,
+    StreamWarningEvent,
     VideoEncoderAvgQPEvent,
     VideoInitializedEvent,
     WebRtcAutoConnectEvent,
@@ -533,6 +534,30 @@ export class PixelStreaming {
         this._eventEmitter.dispatchEvent(
             new StatsReceivedEvent({ aggregatedStats: videoStats })
         );
+
+        // Get the local candidate from the candidate pair
+        let localSelectedCandidate = videoStats.localCandidates.find((candid) => {
+            return candid.id == videoStats.candidatePair.localCandidateId
+        })
+
+        // Check if the local candidate is relaying over TCP
+        if (localSelectedCandidate.candidateType == 'relay' && localSelectedCandidate.relayProtocol == 'tcp'){
+
+            // Send a warning to the logger informing the user the stream will be severely degraded 
+            Logger.Warning(
+                Logger.GetStackTrace(),
+                `Stream quality severely degraded, local connection is relayed over TCP due to the local network environment.`
+            );
+
+            // Emit a stream warning event
+            this._eventEmitter.dispatchEvent(
+                new StreamWarningEvent({ 
+                    candidateType: localSelectedCandidate.candidateType,
+                    protocol: localSelectedCandidate.protocol,
+                    relayProtocol: localSelectedCandidate.relayProtocol,
+                })
+            );
+        }
     }
 
     /**

Frontend/library/src/Util/EventEmitter.ts

@@ -537,6 +537,23 @@ export class PlayerCountEvent extends Event {
     }
 }
 
+/**
+ * An event that is emitted when the stream quality is degraded due to local network environment.
+ */
+export class StreamWarningEvent extends Event {
+    readonly type: 'streamWarning';
+    readonly data: {
+        /** stream warning event */
+        protocol: 'tcp' | 'udp'
+        relayProtocol: 'tcp' | 'udp' | 'tls'
+        candidateType: string
+    };
+    constructor(data: StreamWarningEvent['data']) {
+        super('streamWarning');
+        this.data = data;
+    }
+}
+
 export type PixelStreamingEvent =
     | AfkWarningActivateEvent
     | AfkWarningUpdateEvent
@@ -557,6 +574,7 @@ export type PixelStreamingEvent =
     | StreamPreConnectEvent
     | StreamReconnectEvent
     | StreamPreDisconnectEvent
+    | StreamWarningEvent    
     | PlayStreamErrorEvent
     | PlayStreamEvent
     | PlayStreamRejectedEvent