warpr 1.0.10 → 1.0.12

package/package.json

@@ -1,6 +1,6 @@
 {
     "name":  "warpr",
-    "version":  "1.0.10",
+    "version":  "1.0.12",
     "license":  "MPL-2.0",
     "description":  "Warper is a WebRTC based ultra-low latency video streaming library.",
     "peerDependencies":  {

package/src/lib/data/signaling-messages.ts

@@ -11,8 +11,35 @@ export class ConnectionRequest {
   public readonly $type = WarprSignalingMessageType.ConnectionRequest;
   public SessionId?: string;
 }
+
 export class PairingCompleteMessage {
   public readonly $type = WarprSignalingMessageType.PairingCompleteMessage;
+
+  public IceServers?: string[];
+}
+
+export function GetConfiguration(iceServers?: string[]): RTCConfiguration {
+  let result: RTCConfiguration = {};
+  result.iceServers = new Array<RTCIceServer>();
+
+  if (iceServers) {
+    let regex = /^(?<protocol>stun|turn):(?:(?<username>\w+):(?<password>\w+)@)?(?<url>[\w\.:?=&]+)$/im;
+    for (let server of iceServers) {
+      let match = regex.exec(server);
+      if (!match || !match.groups) {
+        console.warn(`Failed to parse ICE server URI ${server}.`);
+        continue;
+      }
+
+      result.iceServers.push({
+        urls: `${match.groups['protocol']}:${match.groups['url']}`,
+        username: match.groups['username'],
+        credential: match.groups['password']
+      });
+    }
+  }
+
+  return result;
 }
 
 export class PeerConnectionDescriptionMessage {

package/src/lib/networking/web-socket-client.ts

@@ -2,17 +2,20 @@ import { EventOwner, EventPublisher, EventArgs } from "../infrastructure/events"
 import { IMessagingClient } from "./messaging-client";
 
 export class WebSocketClient<TMessage> implements IMessagingClient<TMessage> {
-  private readonly _socket: WebSocket;
   private readonly _events = new EventOwner();
 
   public readonly Connected = new EventPublisher<IMessagingClient<TMessage>, EventArgs>(this._events);
   public readonly MessageReceived = new EventPublisher<IMessagingClient<TMessage>, TMessage>(this._events);
   public readonly Disconnected = new EventPublisher<IMessagingClient<TMessage>, EventArgs>(this._events);
 
-  constructor(uri: string) {
-    console.log(`Connecting to ${uri}...`);
+  private _socket?: WebSocket;
 
-    let socket = new WebSocket(uri);
+  constructor(private _uri: string) { }
+
+  Connect(): void {
+    console.log(`Connecting to ${this._uri}...`);
+
+    let socket = new WebSocket(this._uri);
     socket.onopen = () => this.OnConnected();
     socket.onmessage = (e: MessageEvent<string>) => this.OnMessageReceived(e);
     socket.onclose = () => this.OnDisconnected();
@@ -21,26 +24,28 @@ export class WebSocketClient<TMessage> implements IMessagingClient<TMessage> {
   }
 
   SendMessage(message: TMessage): void {
+    if (!this._socket) return;
+
     let content = JSON.stringify(message);
-    console.log(`Sending message: ${content}`);
+    console.debug(`Sending message: ${content}`);
 
     this._socket.send(content);
   }
 
   protected OnConnected(): void {
-    console.log(`Connected to: ${this._socket.url}.`);
+    console.log(`Connected to: ${this._uri}.`);
     this._events.Raise(this.Connected, this, EventArgs.Empty);
   }
 
   protected OnMessageReceived(eventArgs: MessageEvent<string>): void {
-    console.log('Message received: ' + eventArgs.data);
+    console.debug('Message received: ' + eventArgs.data);
 
     let message = JSON.parse(eventArgs.data) as TMessage;
     this._events.Raise(this.MessageReceived, this, message);
   }
 
   protected OnDisconnected(): void {
-    console.log(`Disconnected from: ${this._socket.url}.`);
+    console.log(`Disconnected from: ${this._uri}.`);
     this._events.Raise(this.Disconnected, this, EventArgs.Empty);
   }
 

package/src/lib/services/streaming.service.ts

@@ -1,8 +1,8 @@
 import { Injectable } from '@angular/core';
 import { MessagingService } from './messaging.service';
-import { PeerConnectionCandidateMessage, PeerConnectionDescriptionMessage, WarprSignalingMessage, WarprSignalingMessageType } from '../data/signaling-messages';
+import { GetConfiguration, PairingCompleteMessage, PeerConnectionCandidateMessage, PeerConnectionDescriptionMessage, WarprSignalingMessage, WarprSignalingMessageType } from '../data/signaling-messages';
 import { IMessagingClient } from '../networking/messaging-client';
-import { EncodedFrame, FrameType } from '../data/frames';
+import { EncodedFrame } from '../data/frames';
 import { EventOwner, EventPublisher } from '../infrastructure/events';
 import { MessageAssembler } from '../infrastructure/message-assembler';
 
@@ -20,48 +20,22 @@ export class StreamingService {
   public readonly FrameReceived = new EventPublisher<StreamingService, EncodedFrame>(this._events);
   public readonly Connected = new EventPublisher<StreamingService, any>(this._events);
 
-  private static _config: RTCConfiguration = {
-    iceServers: [
-      { urls: "stun:stun.l.google.com:19302" },
-      { urls: "stun:stun.relay.metered.ca:80" },
-      {
-        urls: "turn:global.relay.metered.ca:80",
-        username: "cb51ef701a61be3cdc89466f",
-        credential: "BBnGCvnTLaxhVbuf"
-      },
-      {
-        urls: "turn:global.relay.metered.ca:80?transport=tcp",
-        username: "cb51ef701a61be3cdc89466f",
-        credential: "BBnGCvnTLaxhVbuf"
-      },
-      {
-        urls: "turn:global.relay.metered.ca:443",
-        username: "cb51ef701a61be3cdc89466f",
-        credential: "BBnGCvnTLaxhVbuf"
-      },
-      {
-        urls: "turns:global.relay.metered.ca:443?transport=tcp",
-        username: "cb51ef701a61be3cdc89466f",
-        credential: "BBnGCvnTLaxhVbuf"
-      }
-    ]
-  };
-
   constructor(
     private _messagingService: MessagingService) {
 
     _messagingService.MessageReceived.Subscribe((sender: IMessagingClient<WarprSignalingMessage>, message: WarprSignalingMessage) => this.OnMessageReceived(sender, message));
-
-    this.Reconnect();
+    _messagingService.Connect();
   }
 
-  private Reconnect() {
+  private Reconnect(configuration: RTCConfiguration) {
+    console.log("Establishing peer connection...");
+
     this._reliableConnection?.close();
     this._lowLatencyConnection?.close();
     this._peerConnection?.close();
     this._messageBuilder = new MessageAssembler();
 
-    this._peerConnection = new RTCPeerConnection(StreamingService._config);
+    this._peerConnection = new RTCPeerConnection(configuration);
     this._peerConnection.onicecandidate = (event) => this.OnIceCandidateAdded(event.candidate?.candidate);
     this._peerConnection.ondatachannel = (event) => this.OnDataChannel(event);
     this._peerConnection.onconnectionstatechange = (event) => this.OnConnectionStateChanged();
@@ -107,7 +81,7 @@ export class StreamingService {
     if (elapsed > 1000) {
       this._lastRefreshTime = now;
 
-      console.log(`Messages: ${this._count / elapsed * 1000} FPS`);
+      console.debug(`Messages: ${this._count / elapsed * 1000} FPS`);
       this._count = 0;
     }
 
@@ -125,13 +99,13 @@ export class StreamingService {
 
   private async OnMessageReceived(sender: IMessagingClient<WarprSignalingMessage>, message: WarprSignalingMessage) {
 
-    if (!this._peerConnection) return;
-
     switch (message.$type) {
       case WarprSignalingMessageType.PairingCompleteMessage:
-        this.Reconnect();
+        this.Reconnect(GetConfiguration(message.IceServers));
         break;
       case WarprSignalingMessageType.PeerConnectionDescriptionMessage:
+        if (!this._peerConnection) return;
+
         await this._peerConnection.setRemoteDescription({ type: "offer", sdp: message.Description });
         let answer = await this._peerConnection.createAnswer();
         await this._peerConnection.setLocalDescription(answer);
@@ -142,6 +116,8 @@ export class StreamingService {
 
         break;
       case WarprSignalingMessageType.PeerConnectionCandidateMessage:
+        if (!this._peerConnection) return;
+
         await this._peerConnection.addIceCandidate({ candidate: message.Candidate, sdpMid: "0" });
         break;
     }