warpr 1.0.20 → 1.0.21

package/package.json

@@ -1,11 +1,11 @@
 {
     "name":  "warpr",
-    "version":  "1.0.20",
+    "version":  "1.0.21",
     "license":  "MPL-2.0",
     "description":  "Warper is a WebRTC based ultra-low latency video streaming library.",
     "peerDependencies":  {
-                             "@angular/common":  "^17.3.0",
-                             "@angular/core":  "^17.3.0",
+                             "@angular/common":  "^19.2.6",
+                             "@angular/core":  "^19.2.6",
                              "uuid":  "^11.1.0"
                          },
     "dependencies":  {

package/src/lib/components/stream-host/stream-host.component.ts

@@ -6,7 +6,6 @@ import { CommonModule } from '@angular/common';
 
 @Component({
   selector: 'warpr-stream-host',
-  standalone: true,
   imports: [CommonModule],
   templateUrl: './stream-host.component.html',
   styleUrl: './stream-host.component.scss'
@@ -35,7 +34,7 @@ export class StreamHostComponent {
     private _streamingService: StreamingService) {
     this._streamingService.Connected.Subscribe((sender, eventArgs) => this.OnConnected());
     this._streamingService.FrameReceived.Subscribe((sender, eventArgs) => this.OnFrameReceived(eventArgs));
-    
+
     this._decoder = new VideoDecoder({
       output: (frame) => this.OnFrameDecoded(frame),
       error: (error) => console.log(error)
@@ -73,7 +72,7 @@ export class StreamHostComponent {
     let message = new PointerInputMessage(event, this._pointerStates, this._canvas!.nativeElement, wheelDelta);
     //console.log(message);
 
-    this._streamingService.SendMessage(message);
+    this._streamingService.SendControlMessage(message);
   }
 
   private OnWheelEvent(event: WheelEvent) {
@@ -146,7 +145,7 @@ export class StreamHostComponent {
 
         console.log(`Resized to ${canvasSize.Width} x ${canvasSize.Height}`);
         let message = new ResizeSurfaceMessage(canvasSize.Width, canvasSize.Height);
-        this._streamingService.SendMessage(message);
+        this._streamingService.SendControlMessage(message);
       }
 
       //Draw new frame

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

@@ -12,38 +12,49 @@ import { MessageAssembler } from '../infrastructure/message-assembler';
 export class StreamingService {
 
   private _peerConnection?: RTCPeerConnection;
-  private _reliableConnection?: RTCDataChannel;
-  private _lowLatencyConnection?: RTCDataChannel;
-  private _messageBuilder? : MessageAssembler;
+  private _controlConnection?: RTCDataChannel;
+
+  private _streamConnection?: RTCDataChannel;
+  private _messageBuilder?: MessageAssembler;
+
+  private _auxConnection?: RTCDataChannel;
 
   private readonly _events = new EventOwner();
   public readonly FrameReceived = new EventPublisher<StreamingService, EncodedFrame>(this._events);
   public readonly Connected = new EventPublisher<StreamingService, any>(this._events);
 
+  public readonly ControlMessageReceived = new EventPublisher<StreamingService, any>(this._events);
+  public readonly AuxMessageReceived = new EventPublisher<StreamingService, any>(this._events);
+
   constructor(
     private _messagingService: MessagingService) {
 
-    _messagingService.MessageReceived.Subscribe((sender: IMessagingClient<WarprSignalingMessage>, message: WarprSignalingMessage) => this.OnMessageReceived(sender, message));
+    _messagingService.MessageReceived.Subscribe((sender: IMessagingClient<WarprSignalingMessage>, message: WarprSignalingMessage) => this.OnSignalingMessageReceived(sender, message));
     _messagingService.Connect();
   }
 
   private Reconnect(configuration: RTCConfiguration) {
     console.log("Establishing peer connection...");
 
-    this._reliableConnection?.close();
-    this._lowLatencyConnection?.close();
-    this._peerConnection?.close();
+    this._controlConnection?.close();
+    this._streamConnection?.close();
     this._messageBuilder = new MessageAssembler();
+    this._auxConnection?.close();
+    this._peerConnection?.close();
 
     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();
   }
-  
-  public SendMessage(message: any) {
+
+  public SendControlMessage(message: any) {
     let json = JSON.stringify(message);
-    this._reliableConnection?.send(json);
+    this._controlConnection?.send(json);
+  }
+
+  public SendAuxMessage(message: any) {
+    this._auxConnection?.send(message);
   }
 
   private OnConnectionStateChanged() {
@@ -54,14 +65,22 @@ export class StreamingService {
     console.log(`WebRTC data channel ${event.channel.label} connected.`);
 
     switch (event.channel.label) {
-      case "reliable":
-        this._reliableConnection = event.channel;
+      case "control":
+        this._controlConnection = event.channel;
+        this._controlConnection.binaryType = "arraybuffer"
+        this._controlConnection.onmessage = (event) => this._events.Raise(this.ControlMessageReceived, this, event.data);
         this._events.Raise(this.Connected, this, null);
         break;
-      case "low_latency":
-        this._lowLatencyConnection = event.channel;
-        this._lowLatencyConnection.binaryType = "arraybuffer"
-        this._lowLatencyConnection.onmessage = (event) => this.OnLowLatencyMessage(event);
+      case "stream":
+        this._streamConnection = event.channel;
+        this._streamConnection.binaryType = "arraybuffer"
+        this._streamConnection.onmessage = (event) => this.OnLowLatencyMessage(event);
+        break;
+      case "aux":
+        this._auxConnection = event.channel;
+        this._auxConnection.binaryType = "arraybuffer"
+        this._auxConnection.onmessage = (event) => this._events.Raise(this.AuxMessageReceived, this, event.data);
+        this._events.Raise(this.Connected, this, null);
         break;
     }
   }
@@ -97,7 +116,7 @@ export class StreamingService {
     this._messagingService.SendMessage(message);
   }
 
-  private async OnMessageReceived(sender: IMessagingClient<WarprSignalingMessage>, message: WarprSignalingMessage) {
+  private async OnSignalingMessageReceived(sender: IMessagingClient<WarprSignalingMessage>, message: WarprSignalingMessage) {
 
     switch (message.$type) {
       case WarprSignalingMessageType.PairingCompleteMessage: