Use FBS Transport::Tuple everywhere

node/src/Transport.ts

@@ -1310,14 +1310,38 @@ export function parseSctpState(fbsSctpState: FbsSctpState): SctpState
 	}
 }
 
+export function parseProtocol(protocol: FbsTransport.Protocol): TransportProtocol
+{
+	switch (protocol)
+	{
+		case FbsTransport.Protocol.UDP:
+			return 'udp';
+
+		case FbsTransport.Protocol.TCP:
+			return 'tcp';
+	}
+}
+
+export function serializeProtocol(protocol: TransportProtocol): FbsTransport.Protocol
+{
+	switch (protocol)
+	{
+		case 'udp':
+			return FbsTransport.Protocol.UDP;
+
+		case 'tcp':
+			return FbsTransport.Protocol.TCP;
+	}
+}
+
 export function parseTuple(binary: FbsTransport.Tuple): TransportTuple
 {
 	return {
 		localIp    : binary.localIp()!,
 		localPort  : binary.localPort(),
 		remoteIp   : binary.remoteIp() ?? undefined,
 		remotePort : binary.remotePort(),
-		protocol   : binary.protocol()! as TransportProtocol
+		protocol   : parseProtocol(binary.protocol())
 	};
 }
 

node/src/WebRtcTransport.ts

@@ -4,6 +4,7 @@ import {
 	parseSctpState,
 	parseBaseTransportDump,
 	parseBaseTransportStats,
+	parseProtocol,
 	parseTransportTraceEventData,
 	parseTuple,
 	BaseTransportDump,
@@ -741,7 +742,7 @@ function parseIceCandidate(binary: FbsWebRtcTransport.IceCandidate): IceCandidat
 		foundation : binary.foundation()!,
 		priority   : binary.priority(),
 		ip         : binary.ip()!,
-		protocol   : binary.protocol() as TransportProtocol,
+		protocol   : parseProtocol(binary.protocol()),
 		port       : binary.port(),
 		type       : 'host',
 		tcpType    : binary.tcpType() === 'passive' ? 'passive' : undefined

node/src/tests/test-WebRtcTransport.ts

@@ -5,6 +5,7 @@ import * as mediasoup from '../';
 import { Notification, Body as NotificationBody, Event } from '../fbs/notification';
 import * as FbsTransport from '../fbs/transport';
 import * as FbsWebRtcTransport from '../fbs/web-rtc-transport';
+import { serializeProtocol, TransportTuple } from '../Transport';
 
 const { createWorker } = mediasoup;
 
@@ -517,7 +518,7 @@ test('WebRtcTransport events succeed', async () =>
 	builder.clear();
 
 	const onIceSelectedTuple = jest.fn();
-	const iceSelectedTuple =
+	const iceSelectedTuple: TransportTuple =
 	{
 		localIp    : '1.1.1.1',
 		localPort  : 1111,
@@ -536,7 +537,7 @@ test('WebRtcTransport events succeed', async () =>
 				iceSelectedTuple.localPort,
 				iceSelectedTuple.remoteIp,
 				iceSelectedTuple.remotePort,
-				iceSelectedTuple.protocol)
+				serializeProtocol(iceSelectedTuple.protocol))
 		);
 
 	notificationOffset = Notification.createNotification(

rust/src/data_structures.rs

@@ -147,12 +147,10 @@ pub enum Protocol {
 }
 
 impl Protocol {
-    // TODO: Use the Protocol FBS type.
-    pub(crate) fn from_fbs(protocol: &str) -> Self {
+    pub(crate) fn from_fbs(protocol: transport::Protocol) -> Self {
         match protocol {
-            "tcp" => Protocol::Tcp,
-            "udp" => Protocol::Udp,
-            _ => todo!(),
+            transport::Protocol::Tcp => Protocol::Tcp,
+            transport::Protocol::Udp => Protocol::Udp,
         }
     }
 }
@@ -284,12 +282,12 @@ impl TransportTuple {
                     .parse()
                     .expect("Error parsing IP address"),
                 remote_port: tuple.remote_port,
-                protocol: Protocol::from_fbs(tuple.protocol.as_str()),
+                protocol: Protocol::from_fbs(tuple.protocol),
             },
             None => TransportTuple::LocalOnly {
                 local_ip: tuple.local_ip.parse().expect("Error parsing IP address"),
                 local_port: tuple.local_port,
-                protocol: Protocol::from_fbs(tuple.protocol.as_str()),
+                protocol: Protocol::from_fbs(tuple.protocol),
             },
         }
     }