@webex/plugin-meetings 3.8.0 → 3.8.1-next.10

package/src/members/collection.ts

@@ -1,10 +1,11 @@
 import {MEETINGS} from '../constants';
+import Member from '../member';
 
 /**
  * @class MembersCollection
  */
 export default class MembersCollection {
-  members: any;
+  members: Record<string, Member>;
   namespace = MEETINGS;
   /**
    * @param {Object} locus
@@ -14,11 +15,11 @@ export default class MembersCollection {
     this.members = {};
   }
 
-  set(id, member) {
+  set(id: string, member: Member) {
     this.members[id] = member;
   }
 
-  setAll(members) {
+  setAll(members: Record<string, Member>) {
     this.members = members;
   }
 

package/src/members/index.ts

@@ -1,7 +1,7 @@
 /*!
  * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
  */
-import {isEmpty} from 'lodash';
+import {get, isEmpty, set} from 'lodash';
 // @ts-ignore
 import {StatelessWebexPlugin} from '@webex/webex-core';
 
@@ -73,6 +73,7 @@ import {ServerRoleShape} from './types';
  * @memberof Members
  */
 
+type UpdatedMembers = {added: Array<Member>; updated: Array<Member>};
 /**
  * @class Members
  */
@@ -81,7 +82,7 @@ export default class Members extends StatelessWebexPlugin {
   locusUrl: any;
   mediaShareContentId: any;
   mediaShareWhiteboardId: any;
-  membersCollection: any;
+  membersCollection: MembersCollection;
   membersRequest: any;
   receiveSlotManager: ReceiveSlotManager;
   mediaRequestManagers: {
@@ -321,6 +322,63 @@ export default class Members extends StatelessWebexPlugin {
     );
   }
 
+  /**
+   * Updates properties on members that rely on information from other members.
+   * This function MUST be called only after the membersCollection has been fully updated
+   * @param {UpdatedMembers} membersUpdate
+   * @returns {Object} membersCollection
+   * @private
+   * @memberof Members
+   */
+  private updateRelationsBetweenMembers(membersUpdate: UpdatedMembers) {
+    const updatePairedMembers = (membersList: Member[]) => {
+      membersList.forEach((member) => {
+        if (!member.pairedWith.participantUrl) {
+          // if we don't have a participantUrl set, it may be that we had it in the past and not anymore, so cleanup the rest of the data
+          if (member.pairedWith.memberId) {
+            const pairedMember = this.membersCollection.get(member.pairedWith.memberId);
+
+            if (pairedMember) {
+              // remove member from pairedMember's associatedUsers array
+              pairedMember.associatedUsers.delete(member.id);
+
+              if (pairedMember.associatedUser === member.id) {
+                pairedMember.associatedUser = null;
+              }
+
+              // reset all the props that we set on pairedMember
+              pairedMember.isPairedWithSelf = false;
+              pairedMember.isHost = false;
+            }
+          }
+          member.pairedWith.memberId = undefined;
+        } else if (member.pairedWith.memberId === undefined) {
+          // we have participantUrl set but not memberId, so find the member and set it
+          const pairedMember = Object.values(this.membersCollection.getAll()).find(
+            (m) => m.participant?.url === member.pairedWith.participantUrl
+          );
+
+          if (pairedMember) {
+            member.pairedWith.memberId = pairedMember.id;
+            pairedMember.associatedUsers.add(member.id);
+
+            if (pairedMember.associatedUsers.size === 1) {
+              // associatedUser is deprecated, because it's broken - device can have multiple associated users,
+              // so for backwards compatibility we set it to the first associated user
+              pairedMember.associatedUser = member.id;
+            }
+
+            pairedMember.isPairedWithSelf = member.isSelf;
+            pairedMember.isHost = member.isHost;
+          }
+        }
+      });
+    };
+
+    updatePairedMembers(membersUpdate.updated);
+    updatePairedMembers(membersUpdate.added);
+  }
+
   /**
    * when new participant updates come in, both delta and full participants, update them in members collection
    * delta object in the event will have {updated, added} and full will be the full membersCollection
@@ -338,6 +396,8 @@ export default class Members extends StatelessWebexPlugin {
       const delta = this.handleLocusInfoUpdatedParticipants(payload);
       const full = this.handleMembersUpdate(delta); // SDK should propagate the full list for both delta and non delta updates
 
+      this.updateRelationsBetweenMembers(delta);
+
       this.receiveSlotManager?.updateMemberIds();
 
       Trigger.trigger(
@@ -478,20 +538,14 @@ export default class Members extends StatelessWebexPlugin {
 
   /**
    * sets values in the members collection for updated and added properties from delta
-   * @param {Object} membersUpdate {updated: [], added: []}
+   * @param {UpdatedMembers} membersUpdate
    * @returns {Object} membersCollection
    * @private
    * @memberof Members
    */
-  private handleMembersUpdate(membersUpdate: any) {
-    if (membersUpdate) {
-      if (membersUpdate.updated) {
-        this.constructMembers(membersUpdate.updated);
-      }
-      if (membersUpdate.added) {
-        this.constructMembers(membersUpdate.added);
-      }
-    }
+  private handleMembersUpdate(membersUpdate: UpdatedMembers) {
+    this.constructMembers(membersUpdate.updated, true);
+    this.constructMembers(membersUpdate.added, false);
 
     return this.membersCollection.getAll();
   }
@@ -499,12 +553,30 @@ export default class Members extends StatelessWebexPlugin {
   /**
    * set members to the member collection from each updated/added lists as passed in
    * @param {Array} list
+   * @param {boolean} isUpdate
    * @returns {undefined}
    * @private
    * @memberof Members
    */
-  private constructMembers(list: Array<any>) {
+  private constructMembers(list: Array<any>, isUpdate: boolean) {
     list.forEach((member) => {
+      if (isUpdate) {
+        // some member props are generated by SDK and need to be preserved on update,
+        // because they depend on relationships with other members so they need to be handled
+        // at the end, once all members are updated - this is done in updateRelationsBetweenMembers()
+        const propsToKeepOnUpdate = ['pairedWith.memberId'];
+
+        const existingMember = this.membersCollection.get(member.id);
+        if (existingMember) {
+          propsToKeepOnUpdate.forEach((prop) => {
+            const existingValue = get(existingMember, prop);
+
+            if (existingValue !== undefined) {
+              set(member, prop, existingValue);
+            }
+          });
+        }
+      }
       this.membersCollection.set(member.id, member);
     });
   }
@@ -512,11 +584,11 @@ export default class Members extends StatelessWebexPlugin {
   /**
    * Internal update the participants value
    * @param {Object} payload
-   * @returns {Object}
+   * @returns {UpdatedMembers}
    * @private
    * @memberof Members
    */
-  private handleLocusInfoUpdatedParticipants(payload: any) {
+  private handleLocusInfoUpdatedParticipants(payload: any): UpdatedMembers {
     this.hostId = payload.hostId || this.hostId;
     this.selfId = payload.selfId || this.selfId;
     this.recordingId = payload.recordingId;
@@ -681,12 +753,12 @@ export default class Members extends StatelessWebexPlugin {
    * Removed/left members will end up in updates
    * Each array contains only members
    * @param {Array} participants the locus participants
-   * @returns {Object} {added: {Array}, updated: {Array}}
+   * @returns {UpdatedMembers} {added: {Array}, updated: {Array}}
    * @private
    * @memberof Members
    */
-  private update(participants: Array<any>) {
-    const membersUpdate = {added: [], updated: []};
+  private update(participants: Array<any>): UpdatedMembers {
+    const membersUpdate: UpdatedMembers = {added: [], updated: []};
 
     if (participants) {
       participants.forEach((participant) => {
@@ -773,6 +845,28 @@ export default class Members extends StatelessWebexPlugin {
     return this.membersRequest.cancelPhoneInvite(options);
   }
 
+  /**
+   * Cancels an SIP call to the associated meeting
+   * @param {String} invitee
+   * @returns {Promise}
+   * @memberof Members
+   */
+  cancelSIPInvite(invitee: any) {
+    if (!this.locusUrl) {
+      return Promise.reject(
+        new ParameterError('The associated locus url for this meeting object must be defined.')
+      );
+    }
+    if (!invitee?.memberId) {
+      return Promise.reject(
+        new ParameterError('The invitee must be defined with a memberId property.')
+      );
+    }
+    const options = MembersUtil.cancelSIPInviteOptions(invitee, this.locusUrl);
+
+    return this.membersRequest.cancelSIPInvite(options);
+  }
+
   /**
    * Admits waiting members (invited guests to meeting)
    * @param {Array} memberIds
@@ -886,6 +980,31 @@ export default class Members extends StatelessWebexPlugin {
     });
   }
 
+  /**
+   * Moves a meeting member into the lobby.
+   * @param {String} memberId -- The ID of the member to move.
+   * @returns {Promise} -- Resolves with the lobby‐move response.
+   * @public
+   * @memberof Members
+   */
+  public moveToLobby(memberId: string) {
+    if (!this.locusUrl) {
+      return Promise.reject(
+        new ParameterError(
+          'The associated locus url for this meetings members object must be defined.'
+        )
+      );
+    }
+    if (!memberId) {
+      return Promise.reject(
+        new ParameterError('The member id must be defined to move the member to lobby.')
+      );
+    }
+    const body = MembersUtil.getMoveMemberToLobbyRequestBody(memberId);
+
+    return this.membersRequest.moveToLobbyMember({locusUrl: this.locusUrl, memberId}, body);
+  }
+
   /**
    * Raise or lower the hand of a member in a meeting
    * @param {String} memberId

package/src/members/request.ts

@@ -129,6 +129,32 @@ export default class MembersRequest extends StatelessWebexPlugin {
     return this.locusDeltaRequest(requestParams);
   }
 
+  /**
+   * Sends a request to move a meeting member into the lobby.
+   * *
+   * @param {Object} options - Request options.
+   * @param {string} options.locusUrl - The locus URL for the meeting.
+   * @param {string} options.memberId - The ID of the member to move.
+   * @param {Object} body - The request payload.
+   * @param {Object} body.moveToLobby - Container for move‐to‐lobby data.
+   * @param {string[]} body.moveToLobby.participantIds - Array of participant IDs to move.
+   * @returns {Promise} - Resolves with the locus‐delta response.
+   */
+  moveToLobbyMember(
+    options: {locusUrl: string; memberId: string},
+    body: {moveToLobby: {participantIds: string[]}}
+  ) {
+    if (!options || !options.locusUrl || !options.memberId) {
+      throw new ParameterError(
+        'memberId must be defined, and the associated locus url for this meeting object must be defined.'
+      );
+    }
+
+    const requestParams = MembersUtil.getMoveMemberToLobbyRequestParams(options, body);
+
+    return this.locusDeltaRequest(requestParams);
+  }
+
   /**
    * Sends a request to raise or lower a member's hand
    * @param {Object} options
@@ -252,4 +278,22 @@ export default class MembersRequest extends StatelessWebexPlugin {
 
     return this.locusDeltaRequest(requestParams);
   }
+
+  /**
+   * @param {Object} options with format of {invitee: object, locusUrl: string}
+   * @returns {Promise}
+   * @throws {Error} if the options are not valid and complete, must have invitee with memberId AND locusUrl
+   * @memberof MembersRequest
+   */
+  cancelSIPInvite(options: any) {
+    if (!options?.invitee?.memberId || !options?.locusUrl) {
+      throw new ParameterError(
+        'invitee must be passed and the associated locus url for this meeting object must be defined.'
+      );
+    }
+
+    const requestParams = MembersUtil.generateCancelSIPInviteRequestParams(options);
+
+    return this.locusDeltaRequest(requestParams);
+  }
 }

package/src/members/util.ts

@@ -110,7 +110,10 @@ const MembersUtil = {
       return !DIALER_REGEX.E164_FORMAT.test(invitee.phoneNumber);
     }
 
-    return !VALID_EMAIL_ADDRESS.test(invitee.email || invitee.emailAddress);
+    return !(
+      VALID_EMAIL_ADDRESS.test(invitee.email || invitee.emailAddress) ||
+      DIALER_REGEX.SIP_ADDRESS.test(invitee.email || invitee.emailAddress)
+    );
   },
 
   getRemoveMemberRequestParams: (options) => {
@@ -203,6 +206,22 @@ const MembersUtil = {
     };
   },
 
+  getMoveMemberToLobbyRequestBody: (memberId: string) => ({
+    moveToLobby: {
+      participantIds: [memberId],
+    },
+  }),
+
+  getMoveMemberToLobbyRequestParams: (options: {memberId: string; locusUrl: string}, body) => {
+    const uri = `${options.locusUrl}/${PARTICIPANT}/${options.memberId}/${CONTROLS}`;
+
+    return {
+      method: HTTP_VERBS.PATCH,
+      uri,
+      body,
+    };
+  },
+
   /**
    * @param {ServerRoleShape} role
    * @returns {ServerRoleShape} the role shape to be added to the body
@@ -351,6 +370,29 @@ const MembersUtil = {
 
     return requestParams;
   },
+
+  cancelSIPInviteOptions: (invitee, locusUrl) => ({
+    invitee,
+    locusUrl,
+  }),
+
+  generateCancelSIPInviteRequestParams: (options) => {
+    const body = {
+      actionType: _REMOVE_,
+      invitees: [
+        {
+          address: options.invitee.memberId,
+        },
+      ],
+    };
+    const requestParams = {
+      method: HTTP_VERBS.PUT,
+      uri: options.locusUrl,
+      body,
+    };
+
+    return requestParams;
+  },
 };
 
 export default MembersUtil;

package/src/metrics/constants.ts

@@ -48,10 +48,19 @@ const BEHAVIORAL_METRICS = {
   UPLOAD_LOGS_FAILURE: 'js_sdk_upload_logs_failure',
   UPLOAD_LOGS_SUCCESS: 'js_sdk_upload_logs_success',
   RECEIVE_TRANSCRIPTION_FAILURE: 'js_sdk_receive_transcription_failure',
+  MEETING_IS_IN_PROGRESS_ERROR: 'js_sdk_meeting_is_in_progress_error',
+  STATIC_MEETING_LINK_ALREADY_EXISTS_ERROR: 'js_sdk_static_meeting_link_already_exists_error',
   FETCH_MEETING_INFO_V1_SUCCESS: 'js_sdk_fetch_meeting_info_v1_success',
   FETCH_MEETING_INFO_V1_FAILURE: 'js_sdk_fetch_meeting_info_v1_failure',
+  ENABLE_STATIC_METTING_LINK_SUCCESS: 'js_sdk_enable_static_meeting_link_success',
+  ENABLE_STATIC_METTING_LINK_FAILURE: 'js_sdk_enable_static_meeting_link_failure',
+  DISABLE_STATIC_MEETING_LINK_SUCCESS: 'js_sdk_disable_static_meeting_link_success',
+  DISABLE_STATIC_MEETING_LINK_FAILURE: 'js_sdk_disable_static_meeting_link_failure',
   ADHOC_MEETING_SUCCESS: 'js_sdk_adhoc_meeting_success',
   ADHOC_MEETING_FAILURE: 'js_sdk_adhoc_meeting_failure',
+  FETCH_STATIC_MEETING_LINK_SUCCESS: 'js_sdk_fetch_static_meeting_link_success',
+  FETCH_STATIC_MEETING_LINK_FAILURE: 'js_sdk_fetch_static_meeting_link_failure',
+  MEETING_LINK_DOES_NOT_EXIST_ERROR: 'js_sdk_meeting_link_does_not_exist_error',
   VERIFY_PASSWORD_SUCCESS: 'js_sdk_verify_password_success',
   VERIFY_PASSWORD_ERROR: 'js_sdk_verify_password_error',
   VERIFY_CAPTCHA_ERROR: 'js_sdk_verify_captcha_error',
@@ -63,6 +72,7 @@ const BEHAVIORAL_METRICS = {
   MEETING_INFO_POLICY_ERROR: 'js_sdk_meeting_info_policy_error',
   LOCUS_DELTA_SYNC_FAILED: 'js_sdk_locus_delta_sync_failed',
   LOCUS_DELTA_OUT_OF_ORDER: 'js_sdk_locus_delta_ooo',
+  LOCUS_SYNC_HANDLING_FAILED: 'js_sdk_locus_sync_handling_failed',
   PERMISSION_TOKEN_REFRESH: 'js_sdk_permission_token_refresh',
   PERMISSION_TOKEN_REFRESH_ERROR: 'js_sdk_permission_token_refresh_error',
   TURN_DISCOVERY_LATENCY: 'js_sdk_turn_discovery_latency',

package/src/multistream/remoteMediaManager.ts

@@ -1054,22 +1054,44 @@ export class RemoteMediaManager extends EventsScope {
     );
   }
 
+  /**
+   * Set multiple remote video CSIs at once
+   * @param remoteMediaCsis The remote medias and CSIs to set them to
+   * @returns {void}
+   */
+  public setRemoteVideoCsis(remoteMediaCsis: {remoteMedia: RemoteMedia; csi?: CSI | null}[]) {
+    if (!remoteMediaCsis.length) {
+      return;
+    }
+
+    // Check all remote medias are known
+    remoteMediaCsis.forEach(({remoteMedia}) => {
+      if (!Object.values(this.media.video.memberPanes).includes(remoteMedia)) {
+        throw new Error(`remoteMedia ${remoteMedia.id} not found`);
+      }
+    });
+
+    // Set remote video CSIs
+    remoteMediaCsis.forEach(({remoteMedia, csi}) => {
+      if (csi) {
+        remoteMedia.sendMediaRequest(csi, false);
+      } else {
+        remoteMedia.cancelMediaRequest(false);
+      }
+    });
+
+    // Commit the changes
+    this.mediaRequestManagers.video.commit();
+  }
+
   /**
    * Sets a new CSI on a given remote media object
    *
    * @param {RemoteMedia} remoteMedia remote Media object to modify
    * @param {CSI} csi new CSI value, can be null if we want to stop receiving media
    */
-  public setRemoteVideoCsi(remoteMedia: RemoteMedia, csi: CSI | null) {
-    if (!Object.values(this.media.video.memberPanes).includes(remoteMedia)) {
-      throw new Error('remoteMedia not found');
-    }
-
-    if (csi) {
-      remoteMedia.sendMediaRequest(csi, true);
-    } else {
-      remoteMedia.cancelMediaRequest(true);
-    }
+  public setRemoteVideoCsi(remoteMedia: RemoteMedia, csi?: CSI | null) {
+    this.setRemoteVideoCsis([{remoteMedia, csi}]);
   }
 
   /**

package/src/reachability/clusterReachability.ts

@@ -6,7 +6,7 @@ import {convertStunUrlToTurn, convertStunUrlToTurnTls} from './util';
 import EventsScope from '../common/events/events-scope';
 
 import {CONNECTION_STATE, Enum, ICE_GATHERING_STATE} from '../constants';
-import {ClusterReachabilityResult} from './reachability.types';
+import {ClusterReachabilityResult, NatType} from './reachability.types';
 
 // data for the Events.resultReady event
 export type ResultEventData = {
@@ -22,9 +22,14 @@ export type ClientMediaIpsUpdatedEventData = {
   clientMediaIPs: string[];
 };
 
+export type NatTypeUpdatedEventData = {
+  natType: NatType;
+};
+
 export const Events = {
   resultReady: 'resultReady', // emitted when a cluster is reached successfully using specific protocol
   clientMediaIpsUpdated: 'clientMediaIpsUpdated', // emitted when more public IPs are found after resultReady was already sent for a given protocol
+  natTypeUpdated: 'natTypeUpdated', // emitted when NAT type is determined
 } as const;
 
 export type Events = Enum<typeof Events>;
@@ -41,8 +46,10 @@ export class ClusterReachability extends EventsScope {
   private pc?: RTCPeerConnection;
   private defer: Defer; // this defer is resolved once reachability checks for this cluster are completed
   private startTimestamp: number;
+  private srflxIceCandidates: RTCIceCandidate[] = [];
   public readonly isVideoMesh: boolean;
   public readonly name;
+  public readonly reachedSubnets: Set<string> = new Set();
 
   /**
    * Constructor for ClusterReachability
@@ -228,27 +235,13 @@ export class ClusterReachability extends EventsScope {
    */
   private registerIceGatheringStateChangeListener() {
     this.pc.onicegatheringstatechange = () => {
-      const {COMPLETE} = ICE_GATHERING_STATE;
-
-      if (this.pc.iceConnectionState === COMPLETE) {
+      if (this.pc.iceGatheringState === ICE_GATHERING_STATE.COMPLETE) {
         this.closePeerConnection();
         this.finishReachabilityCheck();
       }
     };
   }
 
-  /**
-   * Checks if we have the results for all the protocols (UDP and TCP)
-   *
-   * @returns {boolean} true if we have all results, false otherwise
-   */
-  private haveWeGotAllResults(): boolean {
-    return ['udp', 'tcp', 'xtls'].every(
-      (protocol) =>
-        this.result[protocol].result === 'reachable' || this.result[protocol].result === 'untested'
-    );
-  }
-
   /**
    * Saves the latency in the result for the given protocol and marks it as reachable,
    * emits the "resultReady" event if this is the first result for that protocol,
@@ -258,9 +251,15 @@ export class ClusterReachability extends EventsScope {
    * @param {string} protocol
    * @param {number} latency
    * @param {string|null} [publicIp]
+   * @param {string|null} [serverIp]
    * @returns {void}
    */
-  private saveResult(protocol: 'udp' | 'tcp' | 'xtls', latency: number, publicIp?: string | null) {
+  private saveResult(
+    protocol: 'udp' | 'tcp' | 'xtls',
+    latency: number,
+    publicIp?: string | null,
+    serverIp?: string | null
+  ) {
     const result = this.result[protocol];
 
     if (result.latencyInMilliseconds === undefined) {
@@ -288,6 +287,48 @@ export class ClusterReachability extends EventsScope {
     } else {
       this.addPublicIP(protocol, publicIp);
     }
+
+    if (serverIp) {
+      this.reachedSubnets.add(serverIp);
+    }
+  }
+
+  /**
+   * Determines NAT Type.
+   *
+   * @param {RTCIceCandidate} candidate
+   * @returns {void}
+   */
+  private determineNatType(candidate: RTCIceCandidate) {
+    this.srflxIceCandidates.push(candidate);
+
+    if (this.srflxIceCandidates.length > 1) {
+      const portsFound: Record<string, Set<number>> = {};
+
+      this.srflxIceCandidates.forEach((c) => {
+        const key = `${c.address}:${c.relatedPort}`;
+        if (!portsFound[key]) {
+          portsFound[key] = new Set();
+        }
+        portsFound[key].add(c.port);
+      });
+
+      Object.entries(portsFound).forEach(([, ports]) => {
+        if (ports.size > 1) {
+          // Found candidates with the same address and relatedPort, but different ports
+          this.emit(
+            {
+              file: 'clusterReachability',
+              function: 'determineNatType',
+            },
+            Events.natTypeUpdated,
+            {
+              natType: NatType.SymmetricNat,
+            }
+          );
+        }
+      });
+    }
   }
 
   /**
@@ -307,19 +348,25 @@ export class ClusterReachability extends EventsScope {
 
       if (e.candidate) {
         if (e.candidate.type === CANDIDATE_TYPES.SERVER_REFLEXIVE) {
-          this.saveResult('udp', latencyInMilliseconds, e.candidate.address);
+          let serverIp = null;
+          if ('url' in e.candidate) {
+            const stunServerUrlRegex = /stun:([\d.]+):\d+/;
+
+            const match = (e.candidate as any).url.match(stunServerUrlRegex);
+            if (match) {
+              // eslint-disable-next-line prefer-destructuring
+              serverIp = match[1];
+            }
+          }
+
+          this.saveResult('udp', latencyInMilliseconds, e.candidate.address, serverIp);
+
+          this.determineNatType(e.candidate);
         }
 
         if (e.candidate.type === CANDIDATE_TYPES.RELAY) {
           const protocol = e.candidate.port === TURN_TLS_PORT ? 'xtls' : 'tcp';
-          this.saveResult(protocol, latencyInMilliseconds);
-          // we don't add public IP for TCP, because in the case of relay candidates
-          // e.candidate.address is the TURN server address, not the client's public IP
-        }
-
-        if (this.haveWeGotAllResults()) {
-          this.closePeerConnection();
-          this.finishReachabilityCheck();
+          this.saveResult(protocol, latencyInMilliseconds, null, e.candidate.address);
         }
       }
     };