@webex/plugin-meetings 3.0.0-beta.1 → 3.0.0-beta.2

package/src/media/index.js

@@ -7,15 +7,15 @@ import LoggerProxy from '../common/logs/logger-proxy';
 import {
   AUDIO_INPUT,
   VIDEO_INPUT,
-  PEER_CONNECTION_STATE,
-  MEDIA_TRACK_CONSTRAINT
+  MEDIA_TRACK_CONSTRAINT,
 } from '../constants';
 import Config from '../config';
-import PeerConnectionManager from '../peer-connection-manager';
-import ReconnectionError from '../common/errors/reconnection';
+import StaticConfig from '../common/config';
 import MediaError from '../common/errors/media';
 import BrowserDetection from '../common/browser-detection';
 
+import {RoapMediaConnection, MultistreamRoapMediaConnection} from './internal-media-core-wrapper';
+
 const {isBrowser} = BrowserDetection();
 
 /**
@@ -64,32 +64,6 @@ Media.setLocalTrack = (enabled, track) => {
   return false;
 };
 
-/**
- * @param {RTCPeerConnection} peerConnection
- * @param {Object} meetingProperties
- * @param {string} meetingProperties.meetingId
- * @param {string} meetingProperties.remoteQualityLevel LOW|MEDIUM|HIGH
- * @returns {Promise}
- */
-Media.reconnectMedia = (peerConnection, {
-  meetingId,
-  remoteQualityLevel,
-  enableRtx,
-  enableExtmap
-}) => {
-  if (peerConnection.connectionState === PEER_CONNECTION_STATE.CLOSED ||
-    peerConnection.connectionState === PEER_CONNECTION_STATE.FAILED) {
-    return Promise.reject(new ReconnectionError('Reinitiate peerconnection'));
-  }
-
-  return PeerConnectionManager.createOffer(peerConnection, {
-    meetingId,
-    remoteQualityLevel,
-    enableRtx,
-    enableExtmap
-  });
-};
-
 /**
  * format the media array for send
  * @param {String} mediaId
@@ -141,186 +115,78 @@ Media.getLocalMedia = (options, config) => {
 
   return Promise.resolve(undefined);
 };
-/**
- * Returns the direction and tracks
- * @param {string} trackType type of track (audio/video)
- * @param {object}  track  tracks passed
- * @param {boolean} receiveTracks do you want to receive tracks from the remote side
- * @returns {Object} returns direction tracks to be added in transceiver
- */
-Media.checkTracks = (trackType, track, receiveTracks) => {
-  const getDirection = (sendTracks, receiveTracks) => {
-    if (sendTracks && receiveTracks) {
-      return 'sendrecv';
-    } if (sendTracks && !receiveTracks) {
-      return 'sendonly';
-    } if (!sendTracks && receiveTracks) {
-      return 'recvonly';
-    }
-
-    return 'inactive';
-  };
-
-  if (track) {
-    return {track, direction: getDirection(!!track, receiveTracks)};
-  }
-
-  return {track: trackType, direction: getDirection(!!track, receiveTracks)};
-};
-/**
- * creates peerconnection and attaches streams
- * @param {MediaDirection} mediaProperties
- * @param {Object} meetingProperties
- * @param {string} meetingProperties.meetingId
- * @param {string} meetingProperties.remoteQualityLevel LOW|MEDIUM|HIGH
- * @returns {Array} [peerConnection, ]
- */
-Media.attachMedia = (mediaProperties, {
-  meetingId,
-  remoteQualityLevel,
-  enableRtx,
-  enableExtmap
-}) => {
-  const {
-    mediaDirection,
-    audioTrack,
-    videoTrack,
-    shareTrack,
-    peerConnection
-  } = mediaProperties;
-
-  let result = null;
-
-  // Add Transceiver for audio
-  result = Media.checkTracks('audio', mediaDirection.sendAudio && audioTrack, mediaDirection.receiveAudio);
-  peerConnection.audioTransceiver = peerConnection.addTransceiver(result.track, {direction: result.direction});
-
-  // Add Transceiver for video
-  result = Media.checkTracks('video', mediaDirection.sendVideo && videoTrack, mediaDirection.receiveVideo);
-  peerConnection.videoTransceiver = peerConnection.addTransceiver(result.track, {direction: result.direction});
-
-  // Add Transceiver for share
-  result = Media.checkTracks('video', mediaDirection.sendShare && shareTrack, mediaDirection.receiveShare);
-  peerConnection.shareTransceiver = peerConnection.addTransceiver(result.track, {direction: result.direction});
-
-  peerConnection.onnegotiationneeded = (event) => {
-    LoggerProxy.logger.info(`Media:index#attachMedia --> onnegotiationneeded#PeerConnection: ${event}`);
-  };
-
-  return PeerConnectionManager.createOffer(peerConnection, {
-    meetingId,
-    remoteQualityLevel,
-    enableRtx,
-    enableExtmap
-  });
-};
 
 /**
- * updates all the media streams and creates a new media offer
- * @param {MediaDirection} mediaProperties
- * @param {Object} meetingProperties
- * @param {string} meetingProperties.meetingId
- * @param {string} meetingProperties.remoteQualityLevel LOW|MEDIUM|HIGH
- * @returns {Promise}
+ * creates a webrtc media connection with provided tracks and mediaDirection configuration
+ * @param {Object} mediaProperties only applicable to non-multistream connections, contains mediaDirection and local tracks:
+ *                                 audioTrack, videoTrack and shareTrack
+ * @param {Object} options
+ * @param {boolean} options.isMultistream
+ * @param {string} [options.remoteQualityLevel] LOW|MEDIUM|HIGH applicable only to non-multistream connections
+ * @param {boolean} [options.enableRtx] applicable only to non-multistream connections
+ * @param {boolean} [options.enableExtmap] applicable only to non-multistream connections
+ * @param {Object} [options.turnServerInfo]
+ * @returns {RoapMediaConnection}
  */
-Media.updateMedia = (mediaProperties, {
-  meetingId,
+Media.createMediaConnection = (mediaProperties, {
+  isMultistream,
   remoteQualityLevel,
   enableRtx,
-  enableExtmap
+  enableExtmap,
+  turnServerInfo
 }) => {
   const {
     mediaDirection,
     audioTrack,
     videoTrack,
-    shareTrack,
-    peerConnection
+    shareTrack
   } = mediaProperties;
 
-  // update audio transceiver
-  Media.setTrackOnTransceiver(peerConnection.audioTransceiver, {
-    type: 'audio',
-    track: audioTrack,
-    sendTrack: mediaDirection.sendAudio && audioTrack,
-    receiveTrack: mediaDirection.receiveAudio
-  });
-
-  // update video transceiver
-  Media.setTrackOnTransceiver(peerConnection.videoTransceiver, {
-    type: 'video',
-    track: videoTrack,
-    sendTrack: mediaDirection.sendVideo && videoTrack,
-    receiveTrack: mediaDirection.receiveVideo
-  });
-
-  // update content transceiver
-  Media.setTrackOnTransceiver(peerConnection.shareTransceiver, {
-    type: 'video',
-    track: shareTrack,
-    sendTrack: mediaDirection.sendShare && shareTrack,
-    receiveTrack: mediaDirection.receiveShare
-  });
-  peerConnection.onnegotiationneeded = (event) => {
-    LoggerProxy.logger.info(`Media:index#updateMedia --> onnegotiationneeded#PeerConnection: ${event}`);
-  };
-
-  return PeerConnectionManager.createOffer(peerConnection, {
-    meetingId,
-    remoteQualityLevel,
-    enableRtx,
-    enableExtmap
-  });
-};
-
-/**
- * @param {RTCRtpTransceiver} transceiver
- * @param {Object} options
- * @param {MediaStreamTrack} options.track
- * @returns {undefined}
- */
-Media.setTrackOnTransceiver = (transceiver, options) => {
-  const {
-    type, track, sendTrack, receiveTrack
-  } = options;
-
-  try {
-    const result = Media.checkTracks(type, sendTrack && track, receiveTrack);
+  const iceServers = [];
 
-    transceiver.direction = result.direction;
-    if (options.track) {
-      transceiver.sender.replaceTrack(track);
-    }
+  if (turnServerInfo) {
+    iceServers.push({
+      urls: turnServerInfo.url,
+      username: turnServerInfo.username || '',
+      credential: turnServerInfo.password || ''
+    });
   }
-  catch (e) {
-    LoggerProxy.logger.error(`Media:index#setTrackOnTransceiver --> ${e}`);
-    throw e;
+
+  if (isMultistream) {
+    return new MultistreamRoapMediaConnection({
+      iceServers,
+    }, 'mc');
   }
-};
 
-/**
- * creates a new offer
- * @param {Object} meetingProperties
- * @param {string} meetingProperties.meetingId
- * @param {string} meetingProperties.remoteQualityLevel LOW|MEDIUM|HIGH
- * @param {RTCPeerConnection} peerConnection
- * @param {RTCRtpTransceiver} transceiver
- * @param {Object} options see #Media.setTrackOnTransceiver
- * @returns {Promise}
- */
-Media.updateTransceiver = ({
-  meetingId,
-  remoteQualityLevel,
-  enableRtx,
-  enableExtmap
-}, peerConnection, transceiver, options) => {
-  Media.setTrackOnTransceiver(transceiver, options);
-
-  return PeerConnectionManager.createOffer(peerConnection, {
-    meetingId,
-    remoteQualityLevel,
-    enableRtx,
-    enableExtmap
-  });
+  return new RoapMediaConnection({
+    iceServers,
+    skipInactiveTransceivers: false,
+    requireH264: true,
+    sdpMunging: {
+      convertPort9to0: false,
+      addContentSlides: true,
+      bandwidthLimits: {
+        audio: StaticConfig.meetings.bandwidth.audio,
+        video: StaticConfig.meetings.bandwidth.video,
+      },
+      startBitrate: StaticConfig.meetings.bandwidth.startBitrate,
+      periodicKeyframes: 20, // it's always been hardcoded in SDK so for now keeping it that way
+      disableExtmap: !enableExtmap,
+      disableRtx: !enableRtx, // see https://bugs.chromium.org/p/chromium/issues/detail?id=1020642 why we might want to remove RTX from SDP
+    }
+  }, {
+    send: {
+      audio: audioTrack,
+      video: videoTrack,
+      screenShareVideo: shareTrack
+    },
+    receive: {
+      audio: mediaDirection.receiveAudio,
+      video: mediaDirection.receiveVideo,
+      screenShareVideo: mediaDirection.receiveShare,
+      remoteQualityLevel
+    }
+  }, 'mc');
 };
 
 /**

package/src/media/internal-media-core-wrapper.ts

@@ -0,0 +1,9 @@
+import {MediaConnection as MC} from '@webex/internal-media-core';
+
+/* We have this wrapper just because otherwise it's impossible to mock
+ * RoapMediaConnection and MultistreamRoapMediaConnection constructors in unit tests,
+ * because they are exported by @webex/internal-media-core as non-writable, non-configurable
+ * properties of MediaConnection and sinon doesn't allow spying on them or stubbing them.
+ */
+export const RoapMediaConnection = MC.RoapMediaConnection;
+export const MultistreamRoapMediaConnection = MC.MultistreamRoapMediaConnection;

package/src/media/properties.js

@@ -1,13 +1,12 @@
+import {MediaConnection as MC} from '@webex/internal-media-core';
+
 import {
-  ICE_STATE,
   MEETINGS,
   PC_BAIL_TIMEOUT,
   QUALITY_LEVELS
 } from '../constants';
 import LoggerProxy from '../common/logs/logger-proxy';
 
-import MediaUtil from './util';
-
 /**
  * @class MediaProperties
  */
@@ -19,7 +18,7 @@ export default class MediaProperties {
    * @returns {MediaProperties}
    */
   constructor(options = {}) {
-    this.peerConnection = MediaUtil.createPeerConnection();
+    this.webrtcMediaConnection = null;
     this.mediaDirection = options.mediaDirection;
     this.videoTrack = options.videoTrack;
     this.audioTrack = options.audioTrack;
@@ -49,8 +48,8 @@ export default class MediaProperties {
     this.mediaSettings[type] = values;
   }
 
-  setMediaPeerConnection(peerConnection) {
-    this.peerConnection = peerConnection;
+  setMediaPeerConnection(mediaPeerConnection) {
+    this.webrtcMediaConnection = mediaPeerConnection;
   }
 
   setLocalVideoTrack(videoTrack) {
@@ -105,11 +104,7 @@ export default class MediaProperties {
   }
 
   unsetPeerConnection() {
-    this.peerConnection = null;
-  }
-
-  reInitiatePeerconnection(turnServerInfo) {
-    this.peerConnection = MediaUtil.createPeerConnection(turnServerInfo);
+    this.webrtcMediaConnection = null;
   }
 
   unsetLocalVideoTrack() {
@@ -199,39 +194,38 @@ export default class MediaProperties {
   }
 
   /**
-   * Waits until ice connection is established
+   * Waits for the webrtc media connection to be connected.
    *
    * @returns {Promise<void>}
    */
-  waitForIceConnectedState() {
-    const isIceConnected = () => (
-      this.peerConnection.iceConnectionState === ICE_STATE.CONNECTED ||
-        this.peerConnection.iceConnectionState === ICE_STATE.COMPLETED
+  waitForMediaConnectionConnected() {
+    const isConnected = () => (
+      this.webrtcMediaConnection.getConnectionState() === MC.ConnectionState.Connected
     );
 
-    if (isIceConnected()) {
+    if (isConnected()) {
       return Promise.resolve();
     }
 
     return new Promise((resolve, reject) => {
       let timer;
 
-      const iceListener = () => {
-        LoggerProxy.logger.log(`Media:properties#waitForIceConnectedState --> ice state: ${this.peerConnection.iceConnectionState}, conn state: ${this.peerConnection.connectionState}`);
+      const connectionStateListener = () => {
+        LoggerProxy.logger.log(`Media:properties#waitForMediaConnectionConnected --> connection state: ${this.webrtcMediaConnection.getConnectionState()}`);
 
-        if (isIceConnected()) {
+        if (isConnected()) {
           clearTimeout(timer);
-          this.peerConnection.removeEventListener('iceconnectionstatechange', iceListener);
+          this.webrtcMediaConnection.off(MC.Event.CONNECTION_STATE_CHANGED, connectionStateListener);
           resolve();
         }
       };
 
       timer = setTimeout(() => {
-        this.peerConnection.removeEventListener('iceconnectionstatechange', iceListener);
+        this.webrtcMediaConnection.off(MC.Event.CONNECTION_STATE_CHANGED, connectionStateListener);
         reject();
       }, PC_BAIL_TIMEOUT);
 
-      this.peerConnection.addEventListener('iceconnectionstatechange', iceListener);
+      this.webrtcMediaConnection.on(MC.Event.CONNECTION_STATE_CHANGED, connectionStateListener);
     });
   }
 
@@ -242,13 +236,13 @@ export default class MediaProperties {
    */
   async getCurrentConnectionType() {
     // we can only get the connection type after ICE connection has been established
-    await this.waitForIceConnectedState();
+    await this.waitForMediaConnectionConnected();
 
     const allStatsReports = [];
 
     try {
       // eslint-disable-next-line no-await-in-loop
-      const statsResult = await this.peerConnection.getStats();
+      const statsResult = await this.webrtcMediaConnection.getStats();
 
       statsResult.forEach((report) => allStatsReports.push(report));
     }

package/src/media/util.js

@@ -1,31 +1,9 @@
 /* globals MediaStream */
-import window from 'global/window';
 
-import BrowserDetection from '../common/browser-detection';
 import LoggerProxy from '../common/logs/logger-proxy';
 
-const {isBrowser} = BrowserDetection();
-
 const MediaUtil = {};
 
-MediaUtil.createPeerConnection = (turnServerInfo) => {
-  const config = {iceServers: []};
-
-  if (turnServerInfo) {
-    config.iceServers.push({
-      urls: turnServerInfo.url,
-      username: turnServerInfo.username || '',
-      credential: turnServerInfo.password || ''
-    });
-  }
-  if (isBrowser('firefox')) {
-    config.bundlePolicy = 'max-compat';
-  }
-
-  return new window.RTCPeerConnection(config);
-};
-
-
 MediaUtil.createMediaStream = (tracks) => {
   if (!tracks) {
     LoggerProxy.logger.error('Media:util#createMediaStream --> Tracks don\'t exist');