@webex/plugin-meetings 3.0.0-beta.17 → 3.0.0-beta.170

package/src/reachability/index.ts

@@ -14,11 +14,13 @@ import ReachabilityRequest from './request';
 const DEFAULT_TIMEOUT = 3000;
 const VIDEO_MESH_TIMEOUT = 1000;
 
+export type ICECandidateResult = {clusterId: string; elapsed?: string | null; publicIPs?: string[]};
 /**
  * @class Reachability
  * @export
  */
 export default class Reachability {
+  namespace = REACHABILITY.namespace;
   webex: object;
   reachabilityRequest: any;
   clusterLatencyResults: any;
@@ -61,24 +63,30 @@ export default class Reachability {
     this.setup();
 
     // Remove stored reachability results to ensure no stale data
-    if (window?.localStorage?.removeItem) {
-      window.localStorage.removeItem(REACHABILITY.localStorage);
-    } else {
-      LoggerProxy.logger.error(
-        'Reachability:index#gatherReachability --> Error in accessing LocalStorage.'
-      );
-
-      return {};
-    }
+    // @ts-ignore
+    await this.webex.boundedStorage.del(this.namespace, REACHABILITY.localStorageResult);
+    // @ts-ignore
+    await this.webex.boundedStorage.del(this.namespace, REACHABILITY.localStorageJoinCookie);
 
     // Fetch clusters and measure latency
     try {
-      const clusters = await this.reachabilityRequest.getClusters();
+      const {clusters, joinCookie} = await this.reachabilityRequest.getClusters();
 
       // Perform Reachability Check
       const results = await this.performReachabilityCheck(clusters);
 
-      window.localStorage.setItem(REACHABILITY.localStorage, JSON.stringify(results));
+      // @ts-ignore
+      await this.webex.boundedStorage.put(
+        this.namespace,
+        REACHABILITY.localStorageResult,
+        JSON.stringify(results)
+      );
+      // @ts-ignore
+      await this.webex.boundedStorage.put(
+        this.namespace,
+        REACHABILITY.localStorageJoinCookie,
+        JSON.stringify(joinCookie)
+      );
 
       LoggerProxy.logger.log(
         'Reachability:index#gatherReachability --> Reachability checks completed'
@@ -100,9 +108,12 @@ export default class Reachability {
    * @public
    * @memberof Reachability
    */
-  isAnyClusterReachable() {
+  async isAnyClusterReachable() {
     let reachable = false;
-    const reachabilityData = window.localStorage.getItem(REACHABILITY.localStorage);
+    // @ts-ignore
+    const reachabilityData = await this.webex.boundedStorage
+      .get(this.namespace, REACHABILITY.localStorageResult)
+      .catch(() => {});
 
     if (reachabilityData) {
       try {
@@ -261,6 +272,7 @@ export default class Reachability {
 
         // @ts-ignore
         LoggerProxy.logger.log(
+          // @ts-ignore
           `Reachability:index#onIceGatheringStateChange --> Successfully pinged ${peerConnection.key}:`,
           elapsed
         );
@@ -284,11 +296,13 @@ export default class Reachability {
       if (e.candidate && String(e.candidate.type).toLowerCase() === SERVER_REFLEXIVE) {
         const elapsed = this.getElapsedTime(peerConnection);
 
-        // @ts-ignore
         LoggerProxy.logger.log(
+          // @ts-ignore
           `Reachability:index#onIceCandidate --> Successfully pinged ${peerConnection.key}:`,
           elapsed
         );
+        // order is important
+        this.addPublicIP(peerConnection, e.candidate.address);
         this.setLatencyAndClose(peerConnection, elapsed);
       }
     };
@@ -306,8 +320,9 @@ export default class Reachability {
   private iceGatheringState(peerConnection: RTCPeerConnection, timeout: number) {
     const ELAPSED = 'elapsed';
 
-    return new Promise((resolve) => {
+    return new Promise<ICECandidateResult>((resolve) => {
       const peerConnectionProxy = new window.Proxy(peerConnection, {
+        // eslint-disable-next-line require-jsdoc
         get(target, property) {
           const targetMember = target[property];
 
@@ -321,7 +336,7 @@ export default class Reachability {
           // only intercept elapsed property
           if (property === ELAPSED) {
             // @ts-ignore
-            resolve({clusterId: peerConnection.key, elapsed: value});
+            resolve({clusterId: peerConnection.key, publicIPs: target.publicIPs, elapsed: value});
 
             return true;
           }
@@ -342,6 +357,8 @@ export default class Reachability {
 
         // Close any open peerConnections
         if (peerConnectionProxy.connectionState !== CLOSED) {
+          // order is important
+          this.addPublicIP(peerConnectionProxy, null);
           this.setLatencyAndClose(peerConnectionProxy, null);
         }
       }, timeout);
@@ -366,24 +383,30 @@ export default class Reachability {
 
   /**
    * Calculates time to establish connection
-   * @param {array} iceResults iceResults
+   * @param {Array<ICECandidateResult>} iceResults iceResults
    * @returns {object} reachabilityMap
-   * @private
+   * @protected
    * @memberof Reachability
    */
-  private parseIceResultsToReachabilityResults(iceResults: Array<any>) {
+  protected parseIceResultsToReachabilityResults(iceResults: Array<ICECandidateResult>) {
     const reachabilityMap = {};
 
-    iceResults.forEach(({clusterId, elapsed}) => {
-      let latencyResult;
+    iceResults.forEach(({clusterId, elapsed, publicIPs}) => {
+      const latencyResult = {};
 
-      if (elapsed === null) {
-        latencyResult = {reachable: 'false'};
+      if (!elapsed) {
+        Object.assign(latencyResult, {reachable: 'false'});
       } else {
-        latencyResult = {
+        Object.assign(latencyResult, {
           reachable: 'true',
           latencyInMilliseconds: elapsed.toString(),
-        };
+        });
+      }
+
+      if (publicIPs) {
+        Object.assign(latencyResult, {
+          clientMediaIPs: publicIPs,
+        });
       }
 
       reachabilityMap[clusterId] = {
@@ -429,6 +452,33 @@ export default class Reachability {
     });
   }
 
+  /**
+   * Adds public IP (client media IPs)
+   * @param {RTCPeerConnection} peerConnection
+   * @param {string} publicIP
+   * @returns {void}
+   */
+  protected addPublicIP(peerConnection: RTCPeerConnection, publicIP?: string | null) {
+    const modifiedPeerConnection: RTCPeerConnection & {publicIPs?: string[]} = peerConnection;
+    const {CLOSED} = CONNECTION_STATE;
+
+    if (modifiedPeerConnection.connectionState === CLOSED) {
+      LoggerProxy.logger.log(
+        `Reachability:index#addPublicIP --> Attempting to set publicIP of ${publicIP} on closed peerConnection.`
+      );
+    }
+
+    if (publicIP) {
+      if (modifiedPeerConnection.publicIPs) {
+        modifiedPeerConnection.publicIPs.push(publicIP);
+      } else {
+        modifiedPeerConnection.publicIPs = [publicIP];
+      }
+    } else {
+      modifiedPeerConnection.publicIPs = null;
+    }
+  }
+
   /**
    * Records latency and closes the peerConnection
    * @param {RTCPeerConnection} peerConnection

package/src/reachability/request.ts

@@ -28,21 +28,23 @@ class ReachabilityRequest {
   }
 
   /**
-   * gets the cluster information
+   * Gets the cluster information
    *
-   * @param {boolean} includeVideoMesh whether to include the video mesh clusters in the result or not
    * @returns {Promise}
    */
-  getClusters = (): Promise<ClusterList> =>
+  getClusters = (): Promise<{clusters: ClusterList; joinCookie: any}> =>
     this.webex
       .request({
         method: HTTP_VERBS.GET,
         shouldRefreshAccessToken: false,
         api: API.CALLIOPEDISCOVERY,
         resource: RESOURCE.CLUSTERS,
+        qs: {
+          JCSupport: 1,
+        },
       })
       .then((res) => {
-        const {clusters} = res.body;
+        const {clusters, joinCookie} = res.body;
 
         Object.keys(clusters).forEach((key) => {
           clusters[key].isVideoMesh = res.body.clusterClasses?.hybridMedia?.includes(key);
@@ -52,7 +54,10 @@ class ReachabilityRequest {
           `Reachability:request#getClusters --> get clusters successful:${JSON.stringify(clusters)}`
         );
 
-        return clusters;
+        return {
+          clusters,
+          joinCookie,
+        };
       });
 
   /**

package/src/reactions/constants.ts

@@ -0,0 +1,4 @@
+// eslint-disable-next-line import/prefer-default-export
+export const REACTION_RELAY_TYPES = {
+  REACTION: 'react',
+} as const;

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;
+
 export type Reaction = EmoticonData & {
   tone?: SkinTone;
 };
 
 // eslint-disable-next-line no-shadow
-export enum ReactionType {
+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',
@@ -35,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

@@ -18,10 +18,9 @@ import {
 import BEHAVIORAL_METRICS from '../metrics/constants';
 import ReconnectionError from '../common/errors/reconnection';
 import ReconnectInProgress from '../common/errors/reconnection-in-progress';
-import {eventType, reconnection, errorObjects} from '../metrics/config';
-import Media from '../media';
 import Metrics from '../metrics';
 import Meeting from '../meeting';
+import {MediaRequestManager} from '../multistream/mediaRequestManager';
 
 /**
  * Used to indicate that the reconnect logic needs to be retried.
@@ -231,6 +230,29 @@ export default class ReconnectionManager {
     this.meeting = null;
   }
 
+  /**
+   * Stop the local share track.
+   *
+   * @param {string} reason a {@link SHARE_STOPPED_REASON}
+   * @returns {undefined}
+   * @private
+   * @memberof ReconnectionManager
+   */
+  private async stopLocalShareTrack(reason: string) {
+    await this.meeting.unpublishTracks([this.meeting.mediaProperties.shareTrack]); // todo screen share audio SPARK-399690
+    Trigger.trigger(
+      this.meeting,
+      {
+        file: 'reconnection-manager/index',
+        function: 'stopLocalShareTrack',
+      },
+      EVENT_TRIGGERS.MEETING_STOPPED_SHARING_LOCAL,
+      {
+        reason,
+      }
+    );
+  }
+
   /**
    * @public
    * @memberof ReconnectionManager
@@ -302,9 +324,13 @@ 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,
+        },
       });
     }
 
@@ -314,10 +340,16 @@ export default class ReconnectionManager {
         LoggerProxy.logger.info(
           'ReconnectionManager:index#reconnect --> Sending reconnect success metric.'
         );
-        Metrics.postEvent({
-          event: eventType.MEDIA_RECOVERED,
-          meeting: this.meeting,
-          data: {recoveredBy: reconnection.RECOVERED_BY_NEW},
+
+        // @ts-ignore
+        this.webex.internal.newMetrics.submitClientEvent({
+          name: 'client.media.recovered',
+          payload: {
+            recoveredBy: 'new',
+          },
+          options: {
+            meetingId: this.meeting.id,
+          },
         });
       })
       .catch((reconnectError) => {
@@ -341,23 +373,24 @@ export default class ReconnectionManager {
           'ReconnectionManager:index#reconnect --> Sending reconnect abort metric.'
         );
 
-        const reconnectMetric = {
-          event: eventType.CALL_ABORTED,
-          meeting: this.meeting,
-          data: {
+        // @ts-ignore
+        this.webex.internal.newMetrics.submitClientEvent({
+          name: 'client.call.aborted',
+          payload: {
             errors: [
               {
-                category: errorObjects.category.expected,
+                category: 'expected',
                 errorCode: 2008,
                 fatal: true,
-                name: errorObjects.name.mediaEngine,
+                name: 'media-engine',
                 shownToUser: false,
               },
             ],
           },
-        };
-
-        Metrics.postEvent(reconnectMetric);
+          options: {
+            meetingId: this.meeting.id,
+          },
+        });
         if (reconnectError instanceof NeedsRejoinError) {
           // send call aborded event with catogery as expected as we are trying to rejoin
 
@@ -385,6 +418,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.stopLocalShareTrack(SHARE_STOPPED_REASON.MEDIA_RECONNECTION);
+    }
+
     if (networkDisconnect) {
       try {
         await this.reconnectMercuryWebSocket();
@@ -401,8 +440,6 @@ 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.'
@@ -420,10 +457,10 @@ export default class ReconnectionManager {
     // 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(
@@ -475,24 +512,7 @@ export default class ReconnectionManager {
       LoggerProxy.logger.info('ReconnectionManager:index#rejoinMeeting --> meeting rejoined');
 
       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.stopLocalShareTrack(SHARE_STOPPED_REASON.MEETING_REJOIN);
       }
     } catch (joinError) {
       this.rejoinAttempts += 1;
@@ -538,19 +558,30 @@ export default class ReconnectionManager {
       'ReconnectionManager:index#reconnectMedia --> Begin reestablishment of media'
     );
 
-    // 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();
-
+    // do the TURN server discovery again since the TURN server might change
     const turnServerResult = await this.meeting.roap.doTurnDiscovery(this.meeting, true);
 
-    const mc = this.meeting.createMediaConnection(turnServerResult.turnServerInfo);
+    const iceServers = [];
 
-    this.meeting.statsAnalyzer.updateMediaConnection(mc);
+    if (turnServerResult.turnServerInfo) {
+      iceServers.push({
+        urls: turnServerResult.turnServerInfo.url,
+        username: turnServerResult.turnServerInfo.username || '',
+        credential: turnServerResult.turnServerInfo.password || '',
+      });
+    }
 
-    return mc.initiateOffer();
+    await this.meeting.mediaProperties.webrtcMediaConnection.reconnect(iceServers);
+
+    // resend media requests
+    if (this.meeting.isMultistream) {
+      Object.values(this.meeting.mediaRequestManagers).forEach(
+        (mediaRequestManager: MediaRequestManager) => {
+          mediaRequestManager.clearPreviousRequests();
+          mediaRequestManager.commit();
+        }
+      );
+    }
   }
 
   /**

package/src/recording-controller/enums.ts

@@ -0,0 +1,8 @@
+enum RecordingAction {
+  Start = 'Start',
+  Stop = 'Stop',
+  Pause = 'Pause',
+  Resume = 'Resume',
+}
+
+export default RecordingAction;