@webex/plugin-meetings 2.60.1-next.9 → 2.60.2

package/src/media/properties.ts

@@ -1,65 +1,41 @@
-import {ConnectionState, Event} from '@webex/internal-media-core';
-
-import {
-  LocalCameraStream,
-  LocalMicrophoneStream,
-  LocalDisplayStream,
-  LocalSystemAudioStream,
-  RemoteStream,
-} from '@webex/media-helpers';
-
-import {MEETINGS, ICE_AND_DTLS_CONNECTION_TIMEOUT, QUALITY_LEVELS} from '../constants';
+import {ICE_STATE, MEETINGS, PC_BAIL_TIMEOUT, QUALITY_LEVELS} from '../constants';
 import LoggerProxy from '../common/logs/logger-proxy';
 
-export type MediaDirection = {
-  sendAudio: boolean;
-  sendVideo: boolean;
-  sendShare: boolean;
-  receiveAudio: boolean;
-  receiveVideo: boolean;
-  receiveShare: boolean;
-};
+import MediaUtil from './util';
 
 /**
  * @class MediaProperties
  */
 export default class MediaProperties {
-  audioStream?: LocalMicrophoneStream;
-  mediaDirection: MediaDirection;
+  audioTrack: any;
+  localQualityLevel: any;
+  mediaDirection: any;
   mediaSettings: any;
-  webrtcMediaConnection: any;
-  remoteAudioStream: RemoteStream;
+  peerConnection: any;
+  remoteAudioTrack: any;
   remoteQualityLevel: any;
-  remoteShareStream: RemoteStream;
-  remoteVideoStream: RemoteStream;
-  shareVideoStream?: LocalDisplayStream;
-  shareAudioStream?: LocalSystemAudioStream;
+  remoteShare: any;
+  remoteVideoTrack: any;
+  shareTrack: any;
   videoDeviceId: any;
-  videoStream?: LocalCameraStream;
+  videoTrack: any;
   namespace = MEETINGS;
 
   /**
    * @param {Object} [options] -- to auto construct
    * @returns {MediaProperties}
    */
-  constructor() {
-    this.webrtcMediaConnection = null;
-    this.mediaDirection = {
-      receiveAudio: false,
-      receiveVideo: false,
-      receiveShare: false,
-      sendAudio: false,
-      sendVideo: false,
-      sendShare: false,
-    };
-    this.videoStream = null;
-    this.audioStream = null;
-    this.shareVideoStream = null;
-    this.shareAudioStream = null;
-    this.remoteShareStream = undefined;
-    this.remoteAudioStream = undefined;
-    this.remoteVideoStream = undefined;
-    this.remoteQualityLevel = QUALITY_LEVELS.HIGH;
+  constructor(options: any = {}) {
+    this.peerConnection = MediaUtil.createPeerConnection();
+    this.mediaDirection = options.mediaDirection;
+    this.videoTrack = options.videoTrack;
+    this.audioTrack = options.audioTrack;
+    this.shareTrack = options.shareTrack;
+    this.remoteShare = options.remoteShare;
+    this.remoteAudioTrack = options.remoteAudioTrack;
+    this.remoteVideoTrack = options.remoteVideoTrack;
+    this.localQualityLevel = options.localQualityLevel || QUALITY_LEVELS['720p'];
+    this.remoteQualityLevel = options.remoteQualityLevel || QUALITY_LEVELS.HIGH;
     this.mediaSettings = {};
     this.videoDeviceId = null;
   }
@@ -80,50 +56,50 @@ export default class MediaProperties {
     this.mediaSettings[type] = values;
   }
 
-  setMediaPeerConnection(mediaPeerConnection) {
-    this.webrtcMediaConnection = mediaPeerConnection;
+  setMediaPeerConnection(peerConnection) {
+    this.peerConnection = peerConnection;
   }
 
-  setLocalVideoStream(videoStream?: LocalCameraStream) {
-    this.videoStream = videoStream;
+  setLocalVideoTrack(videoTrack) {
+    this.videoTrack = videoTrack;
   }
 
-  setLocalAudioStream(audioStream?: LocalMicrophoneStream) {
-    this.audioStream = audioStream;
+  setLocalAudioTrack(audioTrack) {
+    this.audioTrack = audioTrack;
   }
 
-  setLocalShareVideoStream(shareVideoStream?: LocalDisplayStream) {
-    this.shareVideoStream = shareVideoStream;
+  setLocalQualityLevel(localQualityLevel) {
+    this.localQualityLevel = localQualityLevel;
   }
 
-  setLocalShareAudioStream(shareAudioStream?: LocalSystemAudioStream) {
-    this.shareAudioStream = shareAudioStream;
+  setLocalShareTrack(shareTrack) {
+    this.shareTrack = shareTrack;
   }
 
   setRemoteQualityLevel(remoteQualityLevel) {
     this.remoteQualityLevel = remoteQualityLevel;
   }
 
-  setRemoteShareStream(remoteShareStream: RemoteStream) {
-    this.remoteShareStream = remoteShareStream;
+  setRemoteShare(remoteShare) {
+    this.remoteShare = remoteShare;
   }
 
   /**
-   * Sets the remote audio stream
-   * @param {RemoteStream} remoteAudioStream RemoteStream to save
+   * Sets the remote audio track
+   * @param {MediaTrack} remoteAudioTrack MediaTrack to save
    * @returns {void}
    */
-  setRemoteAudioStream(remoteAudioStream: RemoteStream) {
-    this.remoteAudioStream = remoteAudioStream;
+  setRemoteAudioTrack(remoteAudioTrack: any) {
+    this.remoteAudioTrack = remoteAudioTrack;
   }
 
   /**
-   * Sets the remote video stream
-   * @param {RemoteStream} remoteVideoStream RemoteStream to save
+   * Sets the remote video track
+   * @param {MediaTrack} remoteVideoTrack MediaTrack to save
    * @returns {void}
    */
-  setRemoteVideoStream(remoteVideoStream: RemoteStream) {
-    this.remoteVideoStream = remoteVideoStream;
+  setRemoteVideoTrack(remoteVideoTrack: any) {
+    this.remoteVideoTrack = remoteVideoTrack;
   }
 
   /**
@@ -136,7 +112,36 @@ export default class MediaProperties {
   }
 
   unsetPeerConnection() {
-    this.webrtcMediaConnection = null;
+    this.peerConnection = null;
+  }
+
+  reInitiatePeerconnection(turnServerInfo) {
+    this.peerConnection = MediaUtil.createPeerConnection(turnServerInfo);
+  }
+
+  unsetLocalVideoTrack() {
+    this.videoTrack = null;
+  }
+
+  unsetLocalShareTrack() {
+    this.shareTrack = null;
+  }
+
+  unsetLocalAudioTrack() {
+    this.audioTrack = null;
+  }
+
+  /**
+   * Removes remote stream from class instance
+   * @deprecated after v1.89.3
+   * @returns {void}
+   */
+  unsetRemoteStream() {
+    LoggerProxy.logger.warn(
+      'Media:properties#unsetRemoteStream --> [DEPRECATION WARNING]: unsetRemoteStream has been deprecated after v1.89.3 (use unsetRemoteTracks instead)'
+    );
+    // unsets audio and video only
+    this.unsetRemoteMedia();
   }
 
   /**
@@ -144,65 +149,103 @@ export default class MediaProperties {
    * @returns {void}
    */
   unsetRemoteMedia() {
-    this.remoteAudioStream = null;
-    this.remoteVideoStream = null;
+    this.remoteAudioTrack = null;
+    this.remoteVideoTrack = null;
   }
 
-  unsetRemoteShareStream() {
-    this.remoteShareStream = null;
+  unsetRemoteShare() {
+    this.remoteShare = null;
+  }
+
+  unsetLocalVideoTracks() {
+    this.unsetLocalVideoTrack();
+    this.unsetLocalShareTrack();
   }
 
   /**
-   * Unsets all remote streams
+   * Removes remote stream and remote share from class instance
+   * @deprecated after v1.89.3
    * @returns {void}
    */
   unsetRemoteStreams() {
+    LoggerProxy.logger.warn(
+      'Media:properties#unsetRemoteStreams --> [DEPRECATION WARNING]: unsetRemoteStreams has been deprecated after v1.89.3 (use unsetRemoteTracks instead)'
+    );
+    this.unsetRemoteStream();
+    this.unsetRemoteShare();
+  }
+
+  /**
+   * Unsets all remote tracks
+   * @returns {void}
+   */
+  unsetRemoteTracks() {
     this.unsetRemoteMedia();
-    this.unsetRemoteShareStream();
+    this.unsetRemoteShare();
+  }
+
+  unsetShareStreams() {
+    this.unsetLocalShareTrack();
+    this.unsetRemoteShare();
   }
 
   /**
-   * Returns if we have at least one local share stream or not.
-   * @returns {Boolean}
+   * Removes both local and remote video stream from class instance
+   * @deprecated after v1.89.3
+   * @returns {void}
    */
-  hasLocalShareStream() {
-    return !!(this.shareAudioStream || this.shareVideoStream);
+  unsetMediaStreams() {
+    LoggerProxy.logger.warn(
+      'Media:properties#unsetMediaStreams --> [DEPRECATION WARNING]: unsetMediaStreams has been deprecated after v1.89.3 (use unsetMediaTracks instead)'
+    );
+    this.unsetLocalVideoTrack();
+    this.unsetRemoteStream();
   }
 
   /**
-   * Waits for the webrtc media connection to be connected.
+   * Removes both local and remote video stream from class instance
+   * @returns {void}
+   */
+  unsetMediaTracks() {
+    this.unsetLocalVideoTrack();
+    this.unsetRemoteMedia();
+  }
+
+  /**
+   * Waits until ice connection is established
    *
    * @returns {Promise<void>}
    */
-  waitForMediaConnectionConnected(): Promise<void> {
-    const isConnected = () =>
-      this.webrtcMediaConnection.getConnectionState() === ConnectionState.Connected;
+  waitForIceConnectedState() {
+    const isIceConnected = () =>
+      this.peerConnection.iceConnectionState === ICE_STATE.CONNECTED ||
+      this.peerConnection.iceConnectionState === ICE_STATE.COMPLETED;
 
-    if (isConnected()) {
+    if (isIceConnected()) {
       return Promise.resolve();
     }
 
     return new Promise<void>((resolve, reject) => {
       let timer;
 
-      const connectionStateListener = () => {
+      const iceListener = () => {
         LoggerProxy.logger.log(
-          `Media:properties#waitForMediaConnectionConnected --> connection state: ${this.webrtcMediaConnection.getConnectionState()}`
+          `Media:properties#waitForIceConnectedState --> ice state: ${this.peerConnection.iceConnectionState}, conn state: ${this.peerConnection.connectionState}`
         );
 
-        if (isConnected()) {
+        if (isIceConnected()) {
           clearTimeout(timer);
-          this.webrtcMediaConnection.off(Event.CONNECTION_STATE_CHANGED, connectionStateListener);
+          this.peerConnection.removeEventListener('iceconnectionstatechange', iceListener);
           resolve();
         }
       };
 
       timer = setTimeout(() => {
-        this.webrtcMediaConnection.off(Event.CONNECTION_STATE_CHANGED, connectionStateListener);
+        this.peerConnection.removeEventListener('iceconnectionstatechange', iceListener);
         reject();
-      }, ICE_AND_DTLS_CONNECTION_TIMEOUT);
+      }, PC_BAIL_TIMEOUT);
 
-      this.webrtcMediaConnection.on(Event.CONNECTION_STATE_CHANGED, connectionStateListener);
+      this.peerConnection.addEventListener('iceconnectionstatechange', iceListener);
     });
   }
 
@@ -213,12 +256,14 @@ export default class MediaProperties {
    */
   async getCurrentConnectionType() {
     // we can only get the connection type after ICE connection has been established
-    await this.waitForMediaConnectionConnected();
+    await this.waitForIceConnectedState();
 
     const allStatsReports = [];
 
     try {
-      const statsResult = await this.webrtcMediaConnection.getStats();
+      // eslint-disable-next-line no-await-in-loop
+      const statsResult = await this.peerConnection.getStats();
+
       statsResult.forEach((report) => allStatsReports.push(report));
     } catch (error) {
       LoggerProxy.logger.warn(
@@ -259,25 +304,10 @@ export default class MediaProperties {
 
         return true;
       }
-      LoggerProxy.logger.warn(
-        `Media:properties#getCurrentConnectionType --> missing localCandidate.protocol, candidateType=${localCandidate.candidateType}`
-      );
 
       return false;
     });
 
-    if (foundConnectionType === 'unknown') {
-      const candidatePairStates = allStatsReports
-        .filter((report) => report.type === 'candidate-pair')
-        .map((report) => report.state);
-
-      LoggerProxy.logger.warn(
-        `Media:properties#getCurrentConnectionType --> all candidate pair states: ${JSON.stringify(
-          candidatePairStates
-        )}`
-      );
-    }
-
     return foundConnectionType;
   }
 }

package/src/media/util.ts

@@ -1,9 +1,30 @@
 /* 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: any = {};
 
+MediaUtil.createPeerConnection = (turnServerInfo) => {
+  const config: any = {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");