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

package/src/reconnection-manager/{index.js → index.ts}

@@ -18,11 +18,10 @@ import {
 import BEHAVIORAL_METRICS from '../metrics/constants';
 import ReconnectionError from '../common/errors/reconnection';
 import ReconnectInProgress from '../common/errors/reconnection-in-progress';
-import PeerConnectionManager from '../peer-connection-manager';
 import {eventType, reconnection, errorObjects} from '../metrics/config';
 import Media from '../media';
 import Metrics from '../metrics';
-import RoapCollection from '../roap/collection';
+import Meeting from '../meeting';
 
 /**
  * Used to indicate that the reconnect logic needs to be retried.
@@ -39,6 +38,8 @@ class NeedsRetryError extends Error {}
  * @extends {Error}
  */
 class NeedsRejoinError extends Error {
+  wasSharing: any;
+
   /**
    * Creates an instance of NeedsRejoinError.
    * @param {Object} params
@@ -46,7 +47,14 @@ class NeedsRejoinError extends Error {
    * @param {Error} params.error
    * @memberof NeedsRejoinError
    */
-  constructor({wasSharing, error = new Error('Meeting needs to be rejoined')}) {
+  constructor({
+    wasSharing,
+    error = new Error('Meeting needs to be rejoined'),
+  }: {
+    wasSharing?: boolean;
+    error?: Error;
+  }) {
+    // @ts-ignore
     super(error);
 
     this.wasSharing = wasSharing;
@@ -58,10 +66,19 @@ class NeedsRejoinError extends Error {
  * @class ReconnectionManager
 */
 export default class ReconnectionManager {
+  autoRejoinEnabled: any;
+  iceState: any;
+  maxRejoinAttempts: any;
+  meeting: any;
+  rejoinAttempts: any;
+  shareStatus: any;
+  status: any;
+  tryCount: any;
+  webex: any;
   /**
    * @param {Meeting} meeting
    */
-  constructor(meeting) {
+  constructor(meeting: Meeting) {
     /**
      * Stores ICE reconnection state data.
      *
@@ -74,6 +91,7 @@ export default class ReconnectionManager {
       disconnected: false,
       resolve: () => {},
       timer: undefined,
+      // @ts-ignore
       timeoutDuration: meeting.config.reconnection.iceReconnectionTimeout
     };
 
@@ -99,6 +117,7 @@ export default class ReconnectionManager {
     */
     // TODO : change this logic to not save the meeting instance
     // It gets complicated when meeting ends on remote side , We have a old meeting instance which is not up to date
+    // @ts-ignore
     this.webex = meeting.webex;
     /**
      * @instance
@@ -110,8 +129,10 @@ export default class ReconnectionManager {
     // try moving this to meetings collection
     this.meeting = meeting;
 
+    // @ts-ignore
     this.maxRejoinAttempts = meeting.config.reconnection.maxRejoinAttempts;
     this.rejoinAttempts = RECONNECTION.STATE.DEFAULT_TRY_COUNT;
+    // @ts-ignore
     this.autoRejoinEnabled = meeting.config.reconnection.autoRejoin;
 
 
@@ -119,6 +140,21 @@ export default class ReconnectionManager {
     this.reset();
   }
 
+  /**
+   * @public
+   * @memberof ReconnectionManager
+   * @returns {void}
+   */
+  resetReconnectionTimer() {
+    this.iceState.resolve();
+    this.iceState.resolve = () => {};
+
+    if (this.iceState.timer) {
+      clearTimeout(this.iceState.timer);
+      delete this.iceState.timer;
+    }
+  }
+
   /**
    * Sets the iceState to connected and clears any disconnect timeouts and
    * related timeout data within the iceState.
@@ -127,17 +163,11 @@ export default class ReconnectionManager {
    * @public
    * @memberof ReconnectionManager
    */
-  iceReconnected() {
+  public iceReconnected() {
     if (this.iceState.disconnected) {
       LoggerProxy.logger.log('ReconnectionManager:index#iceReconnected --> ice has reconnected');
 
-      this.iceState.resolve();
-      this.iceState.resolve = () => {};
-
-      if (this.iceState.timer) {
-        clearTimeout(this.iceState.timer);
-        delete this.iceState.timer;
-      }
+      this.resetReconnectionTimer();
 
       this.iceState.disconnected = false;
     }
@@ -153,13 +183,13 @@ export default class ReconnectionManager {
    * @public
    * @memberof ReconnectionManager
    */
-  waitForIceReconnect() {
+  public waitForIceReconnect() {
     if (!this.iceState.disconnected) {
       LoggerProxy.logger.log('ReconnectionManager:index#waitForIceReconnect --> waiting for ice reconnect');
 
       this.iceState.disconnected = true;
 
-      return new Promise((resolve, reject) => {
+      return new Promise<void>((resolve, reject) => {
         this.iceState.timer = setTimeout(() => {
           if (this.iceState.disconnected === false) {
             resolve();
@@ -183,7 +213,7 @@ export default class ReconnectionManager {
    * @public
    * @memberof ReconnectionManager
    */
-  reset() {
+  public reset() {
     this.status = RECONNECTION.STATE.DEFAULT_STATUS;
     this.tryCount = RECONNECTION.STATE.DEFAULT_TRY_COUNT;
     this.rejoinAttempts = RECONNECTION.STATE.DEFAULT_TRY_COUNT;
@@ -194,18 +224,28 @@ export default class ReconnectionManager {
    * @public
    * @memberof ReconnectionManager
    */
-  cleanUp() {
+  public cleanUp() {
     this.reset();
     this.meeting = null;
   }
 
+
+  /**
+   * @public
+   * @memberof ReconnectionManager
+   * @returns {Boolean} true if reconnection operation is in progress
+   */
+  isReconnectInProgress() {
+    return (this.status === RECONNECTION.STATE.IN_PROGRESS);
+  }
+
   /**
    * @returns {Boolean}
    * @throws {ReconnectionError}
    * @private
    * @memberof ReconnectionManager
    */
-  validate() {
+  private validate() {
     if (this.meeting.config.reconnection.enabled) {
       if (
         this.status === RECONNECTION.STATE.DEFAULT_STATUS ||
@@ -233,7 +273,13 @@ export default class ReconnectionManager {
    * @public
    * @memberof ReconnectionManager
    */
-  async reconnect({networkDisconnect = false, networkRetry = false} = {}) {
+  public async reconnect({
+    networkDisconnect = false,
+    networkRetry = false,
+  }: {
+    networkDisconnect?: boolean;
+    networkRetry?: boolean;
+  } = {}) {
     LoggerProxy.logger.info(`ReconnectionManager:index#reconnect --> Reconnection start for meeting ${this.meeting.id}.`);
     // First, validate that we can reconnect, if not, it will throw an error
     try {
@@ -315,7 +361,7 @@ export default class ReconnectionManager {
    * @private
    * @memberof ReconnectionManager
    */
-  async executeReconnection({networkDisconnect = false}) {
+  private async executeReconnection({ networkDisconnect = false }: { networkDisconnect?: boolean }) {
     this.status = RECONNECTION.STATE.IN_PROGRESS;
 
     LoggerProxy.logger.info('ReconnectionManager:index#executeReconnection --> Attempting to reconnect to meeting.');
@@ -385,16 +431,13 @@ export default class ReconnectionManager {
    * @param {boolean} wasSharing
    * @returns {Promise}
    */
-  async rejoinMeeting(wasSharing = false) {
+  async rejoinMeeting(wasSharing: boolean = false) {
     try {
       LoggerProxy.logger.info('ReconnectionManager:index#rejoinMeeting --> attemping meeting rejoin');
-      const previousCorrelationId = this.meeting.correlationId;
 
       await this.meeting.join({rejoin: true});
       LoggerProxy.logger.info('ReconnectionManager:index#rejoinMeeting --> meeting rejoined');
 
-      RoapCollection.deleteSession(previousCorrelationId);
-
       if (wasSharing) {
         // Stop the share streams if user tried to rejoin
         Media.stopTracks(this.meeting.mediaProperties.shareTrack);
@@ -451,28 +494,22 @@ export default class ReconnectionManager {
    * @private
    * @memberof ReconnectionManager
    */
-  reconnectMedia() {
+  async reconnectMedia() {
     LoggerProxy.logger.log('ReconnectionManager:index#reconnectMedia --> Begin reestablishment of media');
 
-    return ReconnectionManager.setupPeerConnection(this.meeting)
-      .then(() => Media.attachMedia(this.meeting.mediaProperties, {
-        meetingId: this.meeting.id,
-        remoteQualityLevel: this.meeting.mediaProperties.remoteQualityLevel,
-        enableRtx: this.meeting.config.enableRtx,
-        enableExtmap: this.meeting.config.enableExtmap
-      }))
-      .then((peerConnection) => this.meeting.setRemoteStream(peerConnection))
-      .then(() => {
-        LoggerProxy.logger.log('ReconnectionManager:index#reconnectMedia --> Sending ROAP media request');
-
-        return this.meeting.roap
-          .sendRoapMediaRequest({
-            sdp: this.meeting.mediaProperties.peerConnection.sdp,
-            roapSeq: this.meeting.roapSeq,
-            meeting: this.meeting,
-            reconnect: true
-          });
-      });
+    // we are not simply calling this.meeting.mediaProperties.webrtcMediaConnection.reconnect(),
+    // but instead manually closing and creating new media connection, because we need to do the TURN discovery again
+
+    await this.meeting.closePeerConnections();
+    this.meeting.mediaProperties.unsetPeerConnection();
+
+    const turnServerResult = await this.meeting.roap.doTurnDiscovery(this.meeting, true);
+
+    const mc = this.meeting.createMediaConnection(turnServerResult.turnServerInfo);
+
+    this.meeting.statsAnalyzer.updateMediaConnection(mc);
+
+    return mc.initiateOffer();
   }
 
   /**
@@ -481,7 +518,7 @@ export default class ReconnectionManager {
    * @private
    * @memberof ReconnectionManager
    */
-  async reconnectMercuryWebSocket() {
+  private async reconnectMercuryWebSocket() {
     LoggerProxy.logger.info('ReconnectionManager:index#reconnectMercuryWebSocket --> Reconnecting websocket.');
     // First, attempt to disconnect if we think we are already connected.
     if (this.webex.internal.mercury.connected) {
@@ -508,25 +545,4 @@ export default class ReconnectionManager {
       throw (connectError);
     }
   }
-
-  /**
-   * @param {Meeting} meeting
-   * @returns {undefined}
-   * @private
-   * @memberof ReconnectionManager
-   */
-  static async setupPeerConnection(meeting) {
-    LoggerProxy.logger.log('ReconnectionManager:index#setupPeerConnection --> Begin resetting peer connection');
-    // close pcs, unset to null and create a new one with out closing any streams
-    PeerConnectionManager.close(meeting.mediaProperties.peerConnection);
-    meeting.mediaProperties.unsetPeerConnection();
-
-    const turnInfo = await meeting.roap.doTurnDiscovery(meeting, true);
-
-    meeting.mediaProperties.reInitiatePeerconnection(turnInfo);
-    PeerConnectionManager.setPeerConnectionEvents(meeting);
-
-    // update the peerconnection in the stats manager when ever we reconnect
-    meeting.statsAnalyzer.updatePeerconnection(meeting.mediaProperties.peerConnection);
-  }
 }

package/src/roap/index.ts

@@ -0,0 +1,229 @@
+// @ts-ignore
+import {StatelessWebexPlugin} from '@webex/webex-core';
+
+import {ROAP} from '../constants';
+import LoggerProxy from '../common/logs/logger-proxy';
+
+import RoapRequest from './request';
+import TurnDiscovery from './turnDiscovery';
+import Meeting from '../meeting';
+
+/**
+ * Roap options
+ * @typedef {Object} RoapOptions
+ * @property {String} sdp
+ * @property {Meeting} meeting
+ * @property {Number} seq
+ * @property {Number} tieBreaker
+ *  @property {Boolean} reconnect
+ */
+
+/**
+  * @typedef {Object} SeqOptions
+  * @property {String} correlationId
+  * @property {String} mediaId
+  * @property {Number} seq
+  */
+
+/**
+ * @class Roap
+ * @export
+ * @private
+ */
+export default class Roap extends StatelessWebexPlugin {
+  attrs: any;
+  lastRoapOffer: any;
+  options: any;
+  roapHandler: any;
+  roapRequest: any;
+  turnDiscovery: any;
+
+  /**
+   *
+   * @param {Object} attrs
+   * @param {Object} options
+   */
+  constructor(attrs: any, options: any) {
+    super({}, options);
+    /**
+     * @instance
+     * @type {Object}
+     * @private
+     * @memberof Roap
+     */
+    this.attrs = attrs;
+    /**
+     * @instance
+     * @type {Object}
+     * @private
+     * @memberof Roap
+     */
+    this.options = options;
+    /**
+     * The Roap Request Server Proxy Object
+     * @instance
+     * @type {RoapRequest}
+     * @private
+     * @memberof Roap
+     */
+    // @ts-ignore
+    this.roapRequest = new RoapRequest({}, options);
+
+    this.turnDiscovery = new TurnDiscovery(this.roapRequest);
+  }
+
+  /**
+   *
+   * @param {SeqOptions} options
+   * @returns {null}
+   * @memberof Roap
+   */
+  public sendRoapOK(options: any) {
+    return Promise.resolve().then(() => {
+      // @ts-ignore
+      const meeting = this.webex.meetings.meetingCollection.getByKey('correlationId', options.correlationId);
+      const roapMessage = {
+        messageType: ROAP.ROAP_TYPES.OK,
+        version: ROAP.ROAP_VERSION,
+        seq: options.seq
+      };
+
+      LoggerProxy.logger.log(`Roap:index#sendRoapOK --> ROAP OK sending with seq ${options.seq}`);
+
+      return this.roapRequest
+        .sendRoap({
+          roapMessage,
+          locusSelfUrl: meeting.selfUrl,
+          mediaId: options.mediaId,
+          correlationId: options.correlationId,
+          audioMuted: meeting.isAudioMuted(),
+          videoMuted: meeting.isVideoMuted(),
+          meetingId: meeting.id,
+          preferTranscoding: !meeting.isMultistream,
+        })
+        .then(() => {
+          LoggerProxy.logger.log(`Roap:index#sendRoapOK --> ROAP OK sent with seq ${options.seq}`);
+        });
+    });
+  }
+
+  /**
+   * Sends a ROAP answer...
+   * @param {SeqOptions} options
+   * @param {Boolean} options.audioMuted
+   * @param {Boolean} options.videoMuted
+   * @returns {Promise}
+   * @memberof Roap
+   */
+  public sendRoapAnswer(options: any) {
+    // @ts-ignore
+    const meeting = this.webex.meetings.meetingCollection.getByKey('correlationId', options.correlationId);
+    const roapMessage = {
+      messageType: ROAP.ROAP_TYPES.ANSWER,
+      sdps: [options.sdp],
+      version: ROAP.ROAP_VERSION,
+      seq: options.seq
+    };
+
+    return this.roapRequest
+      .sendRoap({
+        roapMessage,
+        locusSelfUrl: meeting.selfUrl,
+        mediaId: options.mediaId,
+        correlationId: options.correlationId,
+        audioMuted: meeting.isAudioMuted(),
+        videoMuted: meeting.isVideoMuted(),
+        meetingId: meeting.id,
+        preferTranscoding: !meeting.isMultistream,
+      });
+  }
+
+  /**
+   * Sends a ROAP error...
+   * @param {Object} options
+   * @returns {Promise}
+   * @memberof Roap
+   */
+  sendRoapError(options) {
+    // @ts-ignore
+    const meeting = this.webex.meetings.meetingCollection.getByKey('correlationId', options.correlationId);
+    const roapMessage = {
+      messageType: ROAP.ROAP_TYPES.ERROR,
+      version: ROAP.ROAP_VERSION,
+      errorType: options.errorType,
+      seq: options.seq
+
+    };
+
+    return this.roapRequest.sendRoap({
+      roapMessage,
+      locusSelfUrl: meeting.selfUrl,
+      mediaId: options.mediaId,
+      correlationId: options.correlationId,
+      audioMuted: meeting.isAudioMuted(),
+      videoMuted: meeting.isVideoMuted(),
+      meetingId: meeting.id,
+      preferTranscoding: !meeting.isMultistream,
+    })
+      .then(() => {
+        LoggerProxy.logger.log(`Roap:index#sendRoapError --> ROAP ERROR sent with seq ${options.seq}`);
+      });
+  }
+
+  /**
+   * sends a roap media request
+   * @param {RoapOptions} options
+   * @returns {Promise}
+   * @memberof Roap
+   */
+  sendRoapMediaRequest(options: any) {
+    const {
+      meeting, seq, sdp, reconnect, tieBreaker
+    } = options;
+    const roapMessage = {
+      messageType: ROAP.ROAP_TYPES.OFFER,
+      sdps: [sdp],
+      version: ROAP.ROAP_VERSION,
+      seq,
+      tieBreaker
+    };
+
+    // When reconnecting, it's important that the first roap message being sent out has empty media id.
+    // Normally this is the roap offer, but when TURN discovery is enabled,
+    // then this is the TURN discovery request message
+    const sendEmptyMediaId = reconnect && !meeting.config.experimental.enableTurnDiscovery;
+
+    return this.roapRequest
+      .sendRoap({
+        roapMessage,
+        correlationId: meeting.correlationId,
+        locusSelfUrl: meeting.selfUrl,
+        mediaId: sendEmptyMediaId ? '' : meeting.mediaId,
+        audioMuted: meeting.isAudioMuted(),
+        videoMuted: meeting.isVideoMuted(),
+        meetingId: meeting.id,
+        preferTranscoding: !meeting.isMultistream,
+      })
+      .then(({locus, mediaConnections}) => {
+        if (mediaConnections) {
+          meeting.updateMediaConnections(mediaConnections);
+        }
+
+        return locus;
+      });
+  }
+
+  /**
+   * Performs a TURN server discovery procedure, which involves exchanging
+   * some roap messages with the server. This exchange has to be done before
+   * any other roap messages are sent
+   *
+   * @param {Meeting} meeting
+   * @param {Boolean} isReconnecting should be set to true if this is a new
+   *                                 media connection just after a reconnection
+   * @returns {Promise}
+   */
+  doTurnDiscovery(meeting: Meeting, isReconnecting: boolean) {
+    return this.turnDiscovery.doTurnDiscovery(meeting, isReconnecting);
+  }
+}

package/src/roap/{request.js → request.ts}

@@ -1,19 +1,16 @@
-
 /* global window */
+// @ts-ignore
 import {StatelessWebexPlugin} from '@webex/webex-core';
 
 import LoggerProxy from '../common/logs/logger-proxy';
 import {
-  PARTICIPANT,
-  LOCI,
-  CALL,
   MEDIA,
   HTTP_VERBS,
   REACHABILITY
 } from '../constants';
 import Metrics from '../metrics';
 import {eventType} from '../metrics/config';
-import ParameterError from '../common/errors/parameter';
+
 /**
  * @class RoapRequest
  */
@@ -45,74 +42,6 @@ export default class RoapRequest extends StatelessWebexPlugin {
     return localSdp;
   }
 
-  joinMeetingWithRoap(options) {
-    LoggerProxy.logger.info('Roap:request#joinMeetingWithRoap --> Join locus with roap');
-    LoggerProxy.logger.info(`Roap:request#joinMeetingWithRoap --> Local SDP: ${options.roapMessage}`);
-
-    return Promise.resolve().then(async () => {
-      const deviceUrl = this.webex.internal.device.url;
-      let url = '';
-
-      const body = {
-        deviceUrl,
-        usingResource: options.resourceId || null,
-        correlationId: options.correlationId,
-        localMedias: [
-          {
-            localSdp: JSON.stringify(this.attachRechabilityData({
-              roapMessage: options.roapMessage,
-              audioMuted: false,
-              videoMuted: false
-            }))
-          }
-        ],
-        clientMediaPreferences: {
-          preferTranscoding: options.preferTranscoding ?? true
-        }
-      };
-
-      if (options.locusUrl) {
-        url = `${options.locusUrl}/${PARTICIPANT}`;
-      }
-      else if (options.sipUrl) {
-        try {
-          await this.webex.internal.services.waitForCatalog('postauth');
-          url = `${this.webex.internal.services.get('locus')}/${LOCI}/${CALL}`;
-          body.invitee = {
-            address: options.sipTarget
-          };
-        }
-        catch (e) {
-          LoggerProxy.logger.error(`Roap:request#joinMeetingWithRoap --> ${e}`);
-          throw (e);
-        }
-      }
-      else {
-        throw new ParameterError('Must provide a locusUrl or sipTarget');
-      }
-
-      return this.webex
-        .request({
-          method: HTTP_VERBS.POST,
-          uri: url,
-          body
-        })
-        .then((res) => {
-          const {locus} = res.body;
-
-          locus.roapSeq = options.roapMessage.seq;
-          locus.id = locus.url.split('/').pop();
-          LoggerProxy.logger.info(`Roap:request#joinMeetingWithRoap --> Joined locus [${locus.id}][${locus.fullState.lastActive}]`);
-
-          return locus;
-        })
-        .catch((err) => {
-          LoggerProxy.logger.error(`Roap:request#joinMeetingWithRoap --> failed with error: ${err}`);
-          throw err;
-        });
-    });
-  }
-
   /**
    * Sends a ROAP message
    * @param {Object} options
@@ -125,7 +54,16 @@ export default class RoapRequest extends StatelessWebexPlugin {
    * @param {String} options.meetingId
    * @returns {Promise} returns the response/failure of the request
    */
-  sendRoap(options) {
+  sendRoap(options: {
+    roapMessage: any;
+    locusSelfUrl: string;
+    mediaId: string;
+    correlationId: string;
+    audioMuted: boolean;
+    videoMuted: boolean;
+    meetingId: string;
+    preferTranscoding?: boolean;
+  }) {
     const {
       roapMessage, locusSelfUrl, mediaId, correlationId, meetingId
     } = options;
@@ -135,12 +73,14 @@ export default class RoapRequest extends StatelessWebexPlugin {
     }
 
     const mediaUrl = `${locusSelfUrl}/${MEDIA}`;
+    // @ts-ignore
     const deviceUrl = this.webex.internal.device.url;
 
     LoggerProxy.logger.info(`Roap:request#sendRoap --> ${mediaUrl} \n ${roapMessage.messageType} \n seq:${roapMessage.seq}`);
 
     Metrics.postEvent({event: eventType.MEDIA_REQUEST, meetingId});
 
+    // @ts-ignore
     return this.webex
       .request({
         uri: mediaUrl,
@@ -148,6 +88,7 @@ export default class RoapRequest extends StatelessWebexPlugin {
         body: {
           device: {
             url: deviceUrl,
+            // @ts-ignore
             deviceType: this.config.meetings.deviceType
           },
           correlationId,