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

package/src/reconnection-manager/index.ts

@@ -14,14 +14,16 @@ import {
   _CALL_,
   _LEFT_,
   _ID_,
-  RECONNECTION_STATE,
 } from '../constants';
 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';
-import {MediaRequestManager} from '../multistream/mediaRequestManager';
-import ReconnectionError from '../common/errors/reconnection';
 
 /**
  * Used to indicate that the reconnect logic needs to be retried.
@@ -97,7 +99,7 @@ export default class ReconnectionManager {
 
     /**
      * @instance
-     * @type {RECONNECTION_STATE}
+     * @type {String}
      * @private
      * @memberof ReconnectionManager
      */
@@ -139,21 +141,6 @@ 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.
@@ -166,7 +153,13 @@ export default class ReconnectionManager {
     if (this.iceState.disconnected) {
       LoggerProxy.logger.log('ReconnectionManager:index#iceReconnected --> ice has reconnected');
 
-      this.resetReconnectionTimer();
+      this.iceState.resolve();
+      this.iceState.resolve = () => {};
+
+      if (this.iceState.timer) {
+        clearTimeout(this.iceState.timer);
+        delete this.iceState.timer;
+      }
 
       this.iceState.disconnected = false;
     }
@@ -228,53 +221,7 @@ export default class ReconnectionManager {
    */
   public cleanUp() {
     this.reset();
-  }
-
-  /**
-   * Stop the local share stream.
-   *
-   * @param {string} reason a {@link SHARE_STOPPED_REASON}
-   * @returns {undefined}
-   * @private
-   * @memberof ReconnectionManager
-   */
-  private async stopLocalShareStream(reason: string) {
-    await this.meeting.unpublishStreams([
-      this.meeting.mediaProperties.shareVideoStream,
-      this.meeting.mediaProperties.shareAudioStream,
-    ]);
-    Trigger.trigger(
-      this.meeting,
-      {
-        file: 'reconnection-manager/index',
-        function: 'stopLocalShareStream',
-      },
-      EVENT_TRIGGERS.MEETING_STOPPED_SHARING_LOCAL,
-      {
-        reason,
-      }
-    );
-  }
-
-  /**
-   * @public
-   * @memberof ReconnectionManager
-   * @returns {Boolean} true if reconnection operation is in progress
-   */
-  isReconnectInProgress() {
-    return this.status === RECONNECTION.STATE.IN_PROGRESS;
-  }
-
-  /**
-   * Sets the reconnection status
-   *
-   * @public
-   * @param {RECONNECTION_STATE} status
-   * @memberof ReconnectionManager
-   * @returns {undefined}
-   */
-  public setStatus(status: RECONNECTION_STATE) {
-    this.status = status;
+    this.meeting = null;
   }
 
   /**
@@ -339,65 +286,72 @@ export default class ReconnectionManager {
       LoggerProxy.logger.info(
         'ReconnectionManager:index#reconnect --> Sending reconnect start metric.'
       );
-
-      // @ts-ignore
-      this.webex.internal.newMetrics.submitClientEvent({
-        name: 'client.media.reconnecting',
-        options: {
-          meetingId: this.meeting.id,
-        },
+      Metrics.postEvent({
+        event: eventType.MEDIA_RECONNECTING,
+        meeting: this.meeting,
       });
     }
 
-    return this.executeReconnection({networkDisconnect}).catch((reconnectError) => {
-      if (reconnectError instanceof NeedsRetryError) {
+    return this.executeReconnection({networkDisconnect})
+      .then(() => {
+        LoggerProxy.logger.info('ReconnectionManager:index#reconnect --> Reconnection successful.');
         LoggerProxy.logger.info(
-          'ReconnectionManager:index#reconnect --> Reconnection not successful, retrying.'
+          'ReconnectionManager:index#reconnect --> Sending reconnect success metric.'
         );
-        // Reset our reconnect status since we are looping back to the beginning
-        this.status = RECONNECTION.STATE.DEFAULT_STATUS;
-
-        // This is a network retry, so we should not log START metrics again
-        return this.reconnect({networkDisconnect: true, networkRetry: true});
-      }
-
-      // Reconnect has failed
-      LoggerProxy.logger.error(
-        'ReconnectionManager:index#reconnect --> Reconnection failed.',
-        reconnectError.message
-      );
-      LoggerProxy.logger.info(
-        'ReconnectionManager:index#reconnect --> Sending reconnect abort metric.'
-      );
+        Metrics.postEvent({
+          event: eventType.MEDIA_RECOVERED,
+          meeting: this.meeting,
+          data: {recoveredBy: reconnection.RECOVERED_BY_NEW},
+        });
+      })
+      .catch((reconnectError) => {
+        if (reconnectError instanceof NeedsRetryError) {
+          LoggerProxy.logger.info(
+            'ReconnectionManager:index#reconnect --> Reconnection not successful, retrying.'
+          );
+          // Reset our reconnect status since we are looping back to the beginning
+          this.status = RECONNECTION.STATE.DEFAULT_STATUS;
+
+          // This is a network retry, so we should not log START metrics again
+          return this.reconnect({networkDisconnect: true, networkRetry: true});
+        }
 
-      // @ts-ignore
-      this.webex.internal.newMetrics.submitClientEvent({
-        name: 'client.call.aborted',
-        payload: {
-          errors: [
-            {
-              category: 'expected',
-              errorCode: 2008,
-              fatal: true,
-              name: 'media-engine',
-              shownToUser: false,
-            },
-          ],
-        },
-        options: {
-          meetingId: this.meeting.id,
-        },
-      });
-      if (reconnectError instanceof NeedsRejoinError) {
-        // send call aborded event with catogery as expected as we are trying to rejoin
+        // Reconnect has failed
+        LoggerProxy.logger.error(
+          'ReconnectionManager:index#reconnect --> Reconnection failed.',
+          reconnectError.message
+        );
+        LoggerProxy.logger.info(
+          'ReconnectionManager:index#reconnect --> Sending reconnect abort metric.'
+        );
 
-        if (this.autoRejoinEnabled) {
-          return this.rejoinMeeting(reconnectError.wasSharing);
+        const reconnectMetric = {
+          event: eventType.CALL_ABORTED,
+          meeting: this.meeting,
+          data: {
+            errors: [
+              {
+                category: errorObjects.category.expected,
+                errorCode: 2008,
+                fatal: true,
+                name: errorObjects.name.mediaEngine,
+                shownToUser: false,
+              },
+            ],
+          },
+        };
+
+        Metrics.postEvent(reconnectMetric);
+        if (reconnectError instanceof NeedsRejoinError) {
+          // send call aborded event with catogery as expected as we are trying to rejoin
+
+          if (this.autoRejoinEnabled) {
+            return this.rejoinMeeting(reconnectError.wasSharing);
+          }
         }
-      }
 
-      throw reconnectError;
-    });
+        throw reconnectError;
+      });
   }
 
   /**
@@ -415,12 +369,6 @@ export default class ReconnectionManager {
       'ReconnectionManager:index#executeReconnection --> Attempting to reconnect to meeting.'
     );
 
-    const wasSharing = this.meeting.shareStatus === SHARE_STATUS.LOCAL_SHARE_ACTIVE;
-
-    if (wasSharing) {
-      await this.stopLocalShareStream(SHARE_STOPPED_REASON.MEDIA_RECONNECTION);
-    }
-
     if (networkDisconnect) {
       try {
         await this.reconnectMercuryWebSocket();
@@ -437,29 +385,29 @@ export default class ReconnectionManager {
       }
     }
 
-    if (!this.webex.credentials.isUnverifiedGuest) {
-      try {
-        LoggerProxy.logger.info(
-          'ReconnectionManager:index#executeReconnection --> Updating meeting data from server.'
-        );
-        await this.webex.meetings.syncMeetings();
-      } catch (syncError) {
-        LoggerProxy.logger.info(
-          'ReconnectionManager:index#executeReconnection --> Unable to sync meetings, reconnecting.',
-          syncError
-        );
-        throw new NeedsRetryError(syncError);
-      }
+    const wasSharing = this.meeting.shareStatus === SHARE_STATUS.LOCAL_SHARE_ACTIVE;
+
+    try {
+      LoggerProxy.logger.info(
+        'ReconnectionManager:index#executeReconnection --> Updating meeting data from server.'
+      );
+      await this.webex.meetings.syncMeetings();
+    } catch (syncError) {
+      LoggerProxy.logger.info(
+        'ReconnectionManager:index#executeReconnection --> Unable to sync meetings, reconnecting.',
+        syncError
+      );
+      throw new NeedsRetryError(syncError);
     }
 
     // TODO: try to improve this logic as the reconnection manager saves the instance of deleted meeting object
     // So that on rejoin it known what parametrs it was using
     if (!this.meeting || !this.webex.meetings.getMeetingByType(_ID_, this.meeting.id)) {
       LoggerProxy.logger.info(
-        'ReconnectionManager:index#executeReconnection --> Meeting got deleted due to inactivity or ended remotely.'
+        'ReconnectionManager:index#executeReconnection --> Meeting got deleted due to inactivity or ended remotely '
       );
 
-      throw new Error('Unable to rejoin a meeting already ended or inactive.');
+      throw new Error('Unable to rejoin a meeting already ended or inactive .');
     }
 
     LoggerProxy.logger.info(
@@ -479,13 +427,14 @@ export default class ReconnectionManager {
       const media = await this.reconnectMedia();
 
       LoggerProxy.logger.log(
-        'ReconnectionManager:index#executeReconnection --> webRTC media connection renewed and local sdp offer sent'
+        'ReconnectionManager:index#executeReconnection --> Media reestablished'
       );
+      this.status = RECONNECTION.STATE.COMPLETE;
 
       return media;
     } catch (error) {
       LoggerProxy.logger.error(
-        'ReconnectionManager:index#executeReconnection --> failed to renew webRTC media connection or initiate offer'
+        'ReconnectionManager:index#executeReconnection --> Media reestablishment failed'
       );
       this.status = RECONNECTION.STATE.FAILURE;
 
@@ -505,12 +454,32 @@ export default class ReconnectionManager {
       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) {
-        await this.stopLocalShareStream(SHARE_STOPPED_REASON.MEETING_REJOIN);
+        // Stop the share streams if user tried to rejoin
+        Media.stopTracks(this.meeting.mediaProperties.shareTrack);
+        this.meeting.isSharing = false;
+        if (this.shareStatus === SHARE_STATUS.LOCAL_SHARE_ACTIVE) {
+          this.meeting.shareStatus = SHARE_STATUS.NO_SHARE;
+        }
+        this.meeting.mediaProperties.mediaDirection.sendShare = false;
+        Trigger.trigger(
+          this.meeting,
+          {
+            file: 'reconnection-manager/index',
+            function: 'rejoinMeeting',
+          },
+          EVENT_TRIGGERS.MEETING_STOPPED_SHARING_LOCAL,
+          {
+            reason: SHARE_STOPPED_REASON.MEETING_REJOIN,
+          }
+        );
       }
     } catch (joinError) {
       this.rejoinAttempts += 1;
@@ -551,37 +520,33 @@ export default class ReconnectionManager {
    * @private
    * @memberof ReconnectionManager
    */
-  async reconnectMedia() {
-    LoggerProxy.logger.log('ReconnectionManager:index#reconnectMedia --> do turn discovery');
-
-    // do the TURN server discovery again and ignore reachability results since the TURN server might change
-    const turnServerResult = await this.meeting.roap.doTurnDiscovery(this.meeting, true, true);
-
-    const iceServers = [];
-
-    if (turnServerResult.turnServerInfo) {
-      iceServers.push({
-        urls: turnServerResult.turnServerInfo.url,
-        username: turnServerResult.turnServerInfo.username || '',
-        credential: turnServerResult.turnServerInfo.password || '',
-      });
-    }
-
+  reconnectMedia() {
     LoggerProxy.logger.log(
-      'ReconnectionManager:index#reconnectMedia --> renew webRTC media connection and send local sdp offer'
+      'ReconnectionManager:index#reconnectMedia --> Begin reestablishment of media'
     );
 
-    await this.meeting.mediaProperties.webrtcMediaConnection.reconnect(iceServers);
+    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'
+        );
 
-    // resend media requests
-    if (this.meeting.isMultistream) {
-      Object.values(this.meeting.mediaRequestManagers).forEach(
-        (mediaRequestManager: MediaRequestManager) => {
-          mediaRequestManager.clearPreviousRequests();
-          mediaRequestManager.commit();
-        }
-      );
-    }
+        return this.meeting.roap.sendRoapMediaRequest({
+          sdp: this.meeting.mediaProperties.peerConnection.sdp,
+          roapSeq: this.meeting.roapSeq,
+          meeting: this.meeting,
+          reconnect: true,
+        });
+      });
   }
 
   /**
@@ -631,4 +596,27 @@ export default class ReconnectionManager {
       throw connectError;
     }
   }
+
+  /**
+   * @param {Meeting} meeting
+   * @returns {undefined}
+   * @private
+   * @memberof ReconnectionManager
+   */
+  private static async setupPeerConnection(meeting: 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 turnServerResult = await meeting.roap.doTurnDiscovery(meeting, true);
+
+    meeting.mediaProperties.reInitiatePeerconnection(turnServerResult.turnServerInfo);
+    PeerConnectionManager.setPeerConnectionEvents(meeting);
+
+    // update the peerconnection in the stats manager when ever we reconnect
+    meeting.statsAnalyzer.updatePeerconnection(meeting.mediaProperties.peerConnection);
+  }
 }

package/src/recording-controller/index.ts

@@ -1,5 +1,5 @@
 import PermissionError from '../common/errors/permission';
-import {CONTROLS, HTTP_VERBS, SELF_POLICY} from '../constants';
+import {CONTROLS, HTTP_VERBS} from '../constants';
 import MeetingRequest from '../meeting/request';
 import RecordingAction from './enums';
 import Util from './util';
@@ -28,14 +28,6 @@ export default class RecordingController {
    */
   private displayHints: Array<string> = [];
 
-  /**
-   * @instance
-   * @type {Object}
-   * @private
-   * @memberof RecordingInfo
-   */
-  private selfUserPolicies: Record<SELF_POLICY, boolean>;
-
   /**
    * @instance
    * @type {string}
@@ -89,6 +81,7 @@ export default class RecordingController {
 
   /**
    * @param {MeetingRequest} request
+   * @param {LocusInfo} info
    * @returns {void}
    * @private
    * @memberof RecordingController
@@ -133,16 +126,6 @@ export default class RecordingController {
     this.displayHints = hints;
   }
 
-  /**
-   * @param {Object} selfUserPolicies
-   * @returns {void}
-   * @public
-   * @memberof RecordingController
-   */
-  public setUserPolicy(selfUserPolicies: Record<SELF_POLICY, boolean>) {
-    this.selfUserPolicies = selfUserPolicies;
-  }
-
   /**
    * @param {string} id
    * @returns {void}
@@ -281,7 +264,7 @@ export default class RecordingController {
     );
 
     // assumes action is proper cased (i.e., Example)
-    if (Util?.[`canUser${action}`](this.displayHints, this.selfUserPolicies)) {
+    if (Util?.[`canUser${action}`](this.displayHints)) {
       if (this.serviceUrl) {
         return this.recordingService(action);
       }

package/src/recording-controller/util.ts

@@ -1,34 +1,17 @@
-import {DISPLAY_HINTS, SELF_POLICY} from '../constants';
+import {DISPLAY_HINTS} from '../constants';
 import RecordingAction from './enums';
-import MeetingUtil from '../meeting/util';
 
-const canUserStart = (
-  displayHints: Array<string>,
-  userPolicies: Record<SELF_POLICY, boolean>
-): boolean =>
-  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_START) &&
-  MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
+const canUserStart = (displayHints: Array<string>): boolean =>
+  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_START);
 
-const canUserPause = (
-  displayHints: Array<string>,
-  userPolicies: Record<SELF_POLICY, boolean>
-): boolean =>
-  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_PAUSE) &&
-  MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
+const canUserPause = (displayHints: Array<string>): boolean =>
+  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_PAUSE);
 
-const canUserResume = (
-  displayHints: Array<string>,
-  userPolicies: Record<SELF_POLICY, boolean>
-): boolean =>
-  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_RESUME) &&
-  MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
+const canUserResume = (displayHints: Array<string>): boolean =>
+  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_RESUME);
 
-const canUserStop = (
-  displayHints: Array<string>,
-  userPolicies: Record<SELF_POLICY, boolean>
-): boolean =>
-  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_STOP) &&
-  MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
+const canUserStop = (displayHints: Array<string>): boolean =>
+  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_STOP);
 
 const extractLocusId = (url: string) => {
   return url?.split('/').pop();

package/src/roap/collection.ts

@@ -0,0 +1,62 @@
+import RoapStateMachine from './state';
+
+/* eslint-disable */
+const RoapCollection = {
+  sessions: {},
+
+  getSession(id) {
+    if (!this.sessions[id]) {
+      this.sessions[id] = {
+        activeSequences: 0,
+      };
+    }
+    return this.sessions[id];
+  },
+
+  deleteSession(id) {
+    if (this.getSession(id)) {
+      delete this.sessions[id];
+    }
+  },
+
+  getSessionSequence(id, seqId) {
+    const session = this.getSession(id);
+    if (!session[seqId]) {
+      session[seqId] = {
+        state: RoapStateMachine.createState(),
+        finished: false,
+      };
+      session.activeSequences += 1;
+    }
+    return session[seqId];
+  },
+
+  deleteSessionSequence(id, seqId) {
+    const seq = this.getSessionSequence(id, seqId);
+    if (seq) {
+      if (!seq.finished) {
+        // @ts-ignore
+        session.activeSequences -= 1;
+      }
+      delete this.sessions[id][seqId];
+    }
+  },
+
+  isBusy(id) {
+    const session = this.getSession(id);
+    if (!session) return false;
+
+    return session.activeSequences > 0;
+  },
+
+  onSessionSequenceFinish(id, seqId) {
+    const session = this.getSession(id);
+    const seq = session[seqId];
+    if (seq && !seq.finished) {
+      seq.finished = true;
+      session.activeSequences -= 1;
+    }
+  },
+};
+
+export default RoapCollection;