Initialize QUIC support.

Author: jianjunz

src/samples/conference/public/scripts/index.js

@@ -191,7 +191,33 @@ const runSocketIOSample = function() {
                     if(!subscribeForward){
                       if (stream.source.audio === 'mixed' || stream.source.video ===
                         'mixed') {
+<<<<<<< HEAD
                         subscribeAndRenderVideo(stream);
+=======
+                        conference.subscribe(stream, {
+                            audio: {codecs:[{name:'opus'}]},
+                            video: true,
+                            transport: {protocol:'quic'}
+                        }).then((subscription) => {
+                            subscriptionForMixedStream = subscription;
+                            let $video = $(`<video controls autoplay id=${stream.id} style='display:block'>this browser does not supported video tag</video>`);
+                            $video.get(0).srcObject = stream.mediaStream;
+                            $('body').append($video);
+                            subscription.addEventListener('error', (err) => {
+                                console.log('Subscription error: ' + err.error.message);
+                            })
+                        });
+                        for (const resolution of stream.capabilities.video.resolutions) {
+                            const button = $('<button/>', {
+                                text: resolution.width + 'x' +
+                                    resolution.height,
+                                click: () => {
+                                    subscribeDifferentResolution(stream, resolution);
+                                }
+                            });
+                            button.appendTo($('body'));
+                        };
+>>>>>>> d4a3a3c... Initialize QUIC support.
                       }
                     } else if (stream.source.audio !== 'mixed') {
                         subscribeAndRenderVideo(stream);

src/sdk/conference/channel.js

@@ -814,3 +814,100 @@ export class ConferencePeerConnectionChannel extends EventDispatcher {
     return !!param.codec;
   }
 }
+export class ConferenceQuicChannel extends EventDispatcher {
+  // TODO: share code with ConferencePeerConnectionChannel.
+
+  constructor(config, signaling) {
+    super();
+    if (typeof RTCIceTransport !== 'function' || typeof RTCQuicTransport !==
+      'function') {
+      throw new TypeError(
+        'RTCIceTransport or RTCQuicTransport is not supported. Please use WebRTC connection.'
+      )
+    }
+    this._signaling = signaling;
+    this._iceTransport = null;
+    this._quicTransport = null;
+    this._subscribedStream = null;
+    this._subscribePromise = null;
+  }
+
+  subscribe(stream, options) {
+    this._subscribedStream = stream;
+    this._iceTransport = new RTCIceTransport();
+    this._iceTransport.onicecandidate=(event)=>{
+      const candidate=event.candidate;
+      this._signaling.sendSignalingMessage('soac', {
+        id: this._internalId,
+        signaling: {
+          type: 'candidate',
+          candidate: {
+            candidate: 'a=' + candidate.candidate,
+            sdpMid: candidate.sdpMid,
+            sdpMLineIndex: candidate.sdpMLineIndex
+          }
+        }
+      });
+    };
+    const mediaOptions=Object.create({});
+    mediaOptions.audio = {};
+    mediaOptions.audio.from = stream.id;
+    mediaOptions.video = {};
+    mediaOptions.video.from = stream.id;
+    this._signaling.sendSignalingMessage('subscribe', {
+      transport: {protocol:'quic'},
+      media:mediaOptions
+    }).then((data) => {
+      const messageEvent = new MessageEvent('id', {
+        message: data.id,
+        origin: this._remoteId
+      });
+      this.dispatchEvent(messageEvent);
+      this._internalId = data.id;
+      this._signaling.sendSignalingMessage('soac', {
+        id: this._internalId,
+        signaling: {
+          type: 'ice-parameters',
+          parameters: this._iceTransport.getLocalParameters()
+        }
+      });
+    });
+    return new Promise((resolve, reject) => {
+      this._subscribePromise = { resolve: resolve, reject: reject };
+    });
+  }
+
+  onMessage(notification, message) {
+    switch (notification) {
+      case 'progress':
+        if (message.status === 'soac')
+          this._soacHandler(message.data);
+        else if (message.status === 'ready')
+          this._readyHandler();
+        else if(message.status === 'error')
+          this._errorHandler(message.data);
+        break;
+      case 'stream':
+        this._onStreamEvent(message);
+        break;
+      default:
+        Logger.warning('Unknown notification from MCU.');
+    }
+  }
+
+  _soacHandler(data) {
+    if (data.type === 'ice-parameters') {
+      Logger.debug('Username: ' + data.parameters.usernameFragment +
+        ', password:' + data.parameters.password);
+      this._iceTransport.start(data.parameters);
+      this._iceTransport.gather({gatherPolicy:'all', iceServers:[]});
+    } else if (data.type === 'candidate') {
+      const candidate=new RTCIceCandidate({
+        candidate: data.candidate.candidate,
+        sdpMid: data.candidate.sdpMid,
+        sdpMLineIndex: data.candidate.sdpMLineIndex
+      });
+      this._iceTransport.addRemoteCandidate(candidate);
+    }
+  }
+}

src/sdk/conference/client.js

@@ -6,22 +6,19 @@
 
 'use strict';
 
-import * as EventModule from '../base/event.js';
-import {SioSignaling as Signaling} from './signaling.js';
-import Logger from '../base/logger.js';
-import {Base64} from '../base/base64.js';
-import {ConferenceError} from './error.js';
-import * as Utils from '../base/utils.js';
-import * as StreamModule from '../base/stream.js';
-import {Participant} from './participant.js';
-import {ConferenceInfo} from './info.js';
-import {ConferencePeerConnectionChannel} from './channel.js';
-import {
-  RemoteMixedStream,
-  ActiveAudioInputChangeEvent,
-  LayoutChangeEvent,
-} from './mixedstream.js';
-import * as StreamUtilsModule from './streamutils.js';
+import * as EventModule from '../base/event.js'
+import { SioSignaling as Signaling } from './signaling.js'
+import Logger from '../base/logger.js'
+import { Base64 } from '../base/base64.js'
+import { ConferenceError } from './error.js'
+import * as Utils from '../base/utils.js'
+import * as StreamModule from '../base/stream.js'
+import { Participant } from './participant.js'
+import { ConferenceInfo } from './info.js'
+import { ConferencePeerConnectionChannel, ConferenceQuicChannel } from './channel.js'
+import { RemoteMixedStream, ActiveAudioInputChangeEvent, LayoutChangeEvent } from './mixedstream.js'
+import * as StreamUtilsModule from './streamutils.js'
+import { timingSafeEqual } from 'crypto';
 
 const SignalingState = {
   READY: 1,
@@ -297,16 +294,20 @@ export const ConferenceClient = function(config, signalingImpl) {
   }
 
   // eslint-disable-next-line require-jsdoc
-  function createPeerConnectionChannel() {
+  function createPeerConnectionChannel(transport) {
     // Construct an signaling sender/receiver for ConferencePeerConnection.
     const signalingForChannel = Object.create(EventModule.EventDispatcher);
     signalingForChannel.sendSignalingMessage = sendSignalingMessage;
-    const pcc = new ConferencePeerConnectionChannel(
-        config, signalingForChannel);
-    pcc.addEventListener('id', (messageEvent) => {
-      channels.set(messageEvent.message, pcc);
+    let channel;
+    if (transport && transport.protocol === 'quic') {
+      channel = new ConferenceQuicChannel(config, signalingForChannel);
+    } else {
+      channel = new ConferencePeerConnectionChannel(config, signalingForChannel);
+    }
+    channel.addEventListener('id', (messageEvent) => {
+      channels.set(messageEvent.message, channel);
     });
-    return pcc;
+    return channel;
   }
 
   // eslint-disable-next-line require-jsdoc
@@ -422,7 +423,7 @@ export const ConferenceClient = function(config, signalingImpl) {
     if (!(stream instanceof StreamModule.RemoteStream)) {
       return Promise.reject(new ConferenceError('Invalid stream.'));
     }
-    const channel = createPeerConnectionChannel();
+    const channel = createPeerConnectionChannel(options.transport);
     return channel.subscribe(stream, options);
   };