@webex/plugin-meetings 2.59.8 → 2.60.0-next.10

package/src/reactions/reactions.ts

@@ -1,6 +1,6 @@
-import {Reaction, ReactionType, SkinTone, SkinToneType} from './reactions.type';
+import {Reaction, ReactionServerType, SkinTone, SkinToneType} from './reactions.type';
 
-const Reactions: Record<ReactionType, Reaction> = {
+const Reactions: Record<ReactionServerType, Reaction> = {
   smile: {
     type: 'smile',
     codepoints: '1F642',
@@ -31,12 +31,12 @@ const Reactions: Record<ReactionType, Reaction> = {
     codepoints: '1F44F',
     shortcodes: ':clap:',
   },
-  thumbs_up: {
+  thumb_up: {
     type: 'thumb_up',
     codepoints: '1F44D',
     shortcodes: ':thumbsup:',
   },
-  thumbs_down: {
+  thumb_down: {
     type: 'thumb_down',
     codepoints: '1F44E',
     shortcodes: ':thumbsdown:',

package/src/reactions/reactions.type.ts

@@ -1,3 +1,5 @@
+import {REACTION_RELAY_TYPES} from './constants';
+
 export type EmoticonData = {
   type: string;
   codepoints?: string;
@@ -5,20 +7,21 @@ export type EmoticonData = {
 };
 
 export type SkinTone = EmoticonData;
-// @ts-ignore
+
 export type Reaction = EmoticonData & {
   tone?: SkinTone;
 };
 
-export enum ReactionType {
+// eslint-disable-next-line no-shadow
+export enum ReactionServerType {
   smile = 'smile',
   sad = 'sad',
   wow = 'wow',
   haha = 'haha',
   celebrate = 'celebrate',
   clap = 'clap',
-  thumbs_up = 'thumbs_up',
-  thumbs_down = 'thumbs_down',
+  thumb_up = 'thumb_up',
+  thumb_down = 'thumb_down',
   heart = 'heart',
   fire = 'fire',
   prayer = 'prayer',
@@ -26,6 +29,7 @@ export enum ReactionType {
   slow_down = 'slow_down',
 }
 
+// eslint-disable-next-line no-shadow
 export enum SkinToneType {
   normal = 'normal',
   light = 'light',
@@ -34,3 +38,25 @@ export enum SkinToneType {
   medium_dark = 'medium_dark',
   dark = 'dark',
 }
+
+export type Sender = {
+  participantId: string;
+};
+
+export type ProcessedReaction = {
+  reaction: Reaction;
+  sender: {
+    id: Sender['participantId'];
+    name: string;
+  };
+};
+
+type RelayEventData = {
+  relayType: (typeof REACTION_RELAY_TYPES)['REACTION'];
+  reaction: Reaction;
+  sender: Sender;
+};
+
+export type RelayEvent = {
+  data: RelayEventData;
+};

package/src/reconnection-manager/index.ts

@@ -14,16 +14,14 @@ 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.
@@ -99,7 +97,7 @@ export default class ReconnectionManager {
 
     /**
      * @instance
-     * @type {String}
+     * @type {RECONNECTION_STATE}
      * @private
      * @memberof ReconnectionManager
      */
@@ -141,6 +139,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.
@@ -153,13 +166,7 @@ export default class ReconnectionManager {
     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;
     }
@@ -221,7 +228,53 @@ export default class ReconnectionManager {
    */
   public cleanUp() {
     this.reset();
-    this.meeting = null;
+  }
+
+  /**
+   * 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;
   }
 
   /**
@@ -286,72 +339,65 @@ export default class ReconnectionManager {
       LoggerProxy.logger.info(
         'ReconnectionManager:index#reconnect --> Sending reconnect start metric.'
       );
-      Metrics.postEvent({
-        event: eventType.MEDIA_RECONNECTING,
-        meeting: this.meeting,
+
+      // @ts-ignore
+      this.webex.internal.newMetrics.submitClientEvent({
+        name: 'client.media.reconnecting',
+        options: {
+          meetingId: this.meeting.id,
+        },
       });
     }
 
-    return this.executeReconnection({networkDisconnect})
-      .then(() => {
-        LoggerProxy.logger.info('ReconnectionManager:index#reconnect --> Reconnection successful.');
+    return this.executeReconnection({networkDisconnect}).catch((reconnectError) => {
+      if (reconnectError instanceof NeedsRetryError) {
         LoggerProxy.logger.info(
-          'ReconnectionManager:index#reconnect --> Sending reconnect success metric.'
+          'ReconnectionManager:index#reconnect --> Reconnection not successful, retrying.'
         );
-        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});
-        }
+        // Reset our reconnect status since we are looping back to the beginning
+        this.status = RECONNECTION.STATE.DEFAULT_STATUS;
 
-        // Reconnect has failed
-        LoggerProxy.logger.error(
-          'ReconnectionManager:index#reconnect --> Reconnection failed.',
-          reconnectError.message
-        );
-        LoggerProxy.logger.info(
-          'ReconnectionManager:index#reconnect --> Sending reconnect abort metric.'
-        );
+        // This is a network retry, so we should not log START metrics again
+        return this.reconnect({networkDisconnect: true, networkRetry: true});
+      }
 
-        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);
-          }
-        }
+      // Reconnect has failed
+      LoggerProxy.logger.error(
+        'ReconnectionManager:index#reconnect --> Reconnection failed.',
+        reconnectError.message
+      );
+      LoggerProxy.logger.info(
+        'ReconnectionManager:index#reconnect --> Sending reconnect abort metric.'
+      );
 
-        throw reconnectError;
+      // @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
+
+        if (this.autoRejoinEnabled) {
+          return this.rejoinMeeting(reconnectError.wasSharing);
+        }
+      }
+
+      throw reconnectError;
+    });
   }
 
   /**
@@ -369,6 +415,12 @@ 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();
@@ -385,29 +437,29 @@ export default class ReconnectionManager {
       }
     }
 
-    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);
+    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);
+      }
     }
 
     // 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(
@@ -427,14 +479,13 @@ export default class ReconnectionManager {
       const media = await this.reconnectMedia();
 
       LoggerProxy.logger.log(
-        'ReconnectionManager:index#executeReconnection --> Media reestablished'
+        'ReconnectionManager:index#executeReconnection --> webRTC media connection renewed and local sdp offer sent'
       );
-      this.status = RECONNECTION.STATE.COMPLETE;
 
       return media;
     } catch (error) {
       LoggerProxy.logger.error(
-        'ReconnectionManager:index#executeReconnection --> Media reestablishment failed'
+        'ReconnectionManager:index#executeReconnection --> failed to renew webRTC media connection or initiate offer'
       );
       this.status = RECONNECTION.STATE.FAILURE;
 
@@ -454,32 +505,12 @@ 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) {
-        // 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,
-          }
-        );
+        await this.stopLocalShareStream(SHARE_STOPPED_REASON.MEETING_REJOIN);
       }
     } catch (joinError) {
       this.rejoinAttempts += 1;
@@ -520,33 +551,37 @@ export default class ReconnectionManager {
    * @private
    * @memberof ReconnectionManager
    */
-  reconnectMedia() {
+  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 || '',
+      });
+    }
+
     LoggerProxy.logger.log(
-      'ReconnectionManager:index#reconnectMedia --> Begin reestablishment of media'
+      'ReconnectionManager:index#reconnectMedia --> renew webRTC media connection and send local sdp offer'
     );
 
-    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'
-        );
+    await this.meeting.mediaProperties.webrtcMediaConnection.reconnect(iceServers);
 
-        return this.meeting.roap.sendRoapMediaRequest({
-          sdp: this.meeting.mediaProperties.peerConnection.sdp,
-          roapSeq: this.meeting.roapSeq,
-          meeting: this.meeting,
-          reconnect: true,
-        });
-      });
+    // resend media requests
+    if (this.meeting.isMultistream) {
+      Object.values(this.meeting.mediaRequestManagers).forEach(
+        (mediaRequestManager: MediaRequestManager) => {
+          mediaRequestManager.clearPreviousRequests();
+          mediaRequestManager.commit();
+        }
+      );
+    }
   }
 
   /**
@@ -596,27 +631,4 @@ 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} from '../constants';
+import {CONTROLS, HTTP_VERBS, SELF_POLICY} from '../constants';
 import MeetingRequest from '../meeting/request';
 import RecordingAction from './enums';
 import Util from './util';
@@ -28,6 +28,14 @@ export default class RecordingController {
    */
   private displayHints: Array<string> = [];
 
+  /**
+   * @instance
+   * @type {Object}
+   * @private
+   * @memberof RecordingInfo
+   */
+  private selfUserPolicies: Record<SELF_POLICY, boolean>;
+
   /**
    * @instance
    * @type {string}
@@ -81,7 +89,6 @@ export default class RecordingController {
 
   /**
    * @param {MeetingRequest} request
-   * @param {LocusInfo} info
    * @returns {void}
    * @private
    * @memberof RecordingController
@@ -126,6 +133,16 @@ 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}
@@ -264,7 +281,7 @@ export default class RecordingController {
     );
 
     // assumes action is proper cased (i.e., Example)
-    if (Util?.[`canUser${action}`](this.displayHints)) {
+    if (Util?.[`canUser${action}`](this.displayHints, this.selfUserPolicies)) {
       if (this.serviceUrl) {
         return this.recordingService(action);
       }

package/src/recording-controller/util.ts

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