@webex/plugin-meetings 3.8.1-web-workers-keepalive.1 → 3.9.0-next.1

package/src/members/index.ts

@@ -30,6 +30,7 @@ import MembersUtil from './util';
 import {ReceiveSlotManager} from '../multistream/receiveSlotManager';
 import {MediaRequestManager} from '../multistream/mediaRequestManager';
 import {ServerRoleShape} from './types';
+import {Invitee} from '../meeting/type';
 
 /**
  * Members Update Event
@@ -800,18 +801,18 @@ export default class Members extends StatelessWebexPlugin {
 
   /**
    * Adds a guest Member to the associated meeting
-   * @param {String} invitee
+   * @param {Invitee} invitee
    * @param {Boolean} [alertIfActive]
    * @returns {Promise}
    * @memberof Members
    */
-  addMember(invitee: any, alertIfActive?: boolean) {
+  addMember(invitee: Invitee, alertIfActive?: boolean) {
     if (!this.locusUrl) {
       return Promise.reject(
         new ParameterError('The associated locus url for this meeting object must be defined.')
       );
     }
-    if (MembersUtil.isInvalidInvitee(invitee)) {
+    if (invitee?.skipEmailValidation !== true && MembersUtil.isInvalidInvitee(invitee)) {
       return Promise.reject(
         new ParameterError(
           'The invitee must be defined with either a valid email, emailAddress or phoneNumber property.'
@@ -825,11 +826,11 @@ export default class Members extends StatelessWebexPlugin {
 
   /**
    * Cancels an outgoing PSTN call to the associated meeting
-   * @param {String} invitee
+   * @param {Invitee} invitee
    * @returns {Promise}
    * @memberof Members
    */
-  cancelPhoneInvite(invitee: any) {
+  cancelPhoneInvite(invitee: Invitee) {
     if (!this.locusUrl) {
       return Promise.reject(
         new ParameterError('The associated locus url for this meeting object must be defined.')
@@ -846,12 +847,14 @@ export default class Members extends StatelessWebexPlugin {
   }
 
   /**
-   * Cancels an SIP call to the associated meeting
-   * @param {String} invitee
+   * Cancels an SIP/phone call to the associated meeting
+   * @param {Invitee} invitee
+   * @param {String} invitee.memberId - The memberId of the invitee
+   * @param {Boolean} [invitee.isInternalNumber] - When cancel phone invitation, if the number is internal
    * @returns {Promise}
    * @memberof Members
    */
-  cancelSIPInvite(invitee: any) {
+  cancelInviteByMemberId(invitee: Invitee) {
     if (!this.locusUrl) {
       return Promise.reject(
         new ParameterError('The associated locus url for this meeting object must be defined.')
@@ -862,9 +865,9 @@ export default class Members extends StatelessWebexPlugin {
         new ParameterError('The invitee must be defined with a memberId property.')
       );
     }
-    const options = MembersUtil.cancelSIPInviteOptions(invitee, this.locusUrl);
+    const options = MembersUtil.cancelInviteByMemberIdOptions(invitee, this.locusUrl);
 
-    return this.membersRequest.cancelSIPInvite(options);
+    return this.membersRequest.cancelInviteByMemberId(options);
   }
 
   /**

package/src/members/request.ts

@@ -285,14 +285,14 @@ export default class MembersRequest extends StatelessWebexPlugin {
    * @throws {Error} if the options are not valid and complete, must have invitee with memberId AND locusUrl
    * @memberof MembersRequest
    */
-  cancelSIPInvite(options: any) {
+  cancelInviteByMemberId(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);
+    const requestParams = MembersUtil.generateCancelInviteByMemberIdRequestParams(options);
 
     return this.locusDeltaRequest(requestParams);
   }

package/src/members/util.ts

@@ -1,4 +1,5 @@
 import uuid from 'uuid';
+import {has} from 'lodash';
 import {
   HTTP_VERBS,
   CONTROLS,
@@ -13,6 +14,7 @@ import {
 } from '../constants';
 
 import {RoleAssignmentOptions, RoleAssignmentRequest, ServerRoleShape} from './types';
+import {Invitee} from '../meeting/type';
 
 const MembersUtil = {
   /**
@@ -47,6 +49,9 @@ const MembersUtil = {
         address:
           options.invitee.emailAddress || options.invitee.email || options.invitee.phoneNumber,
         ...(options.invitee.roles ? {roles: options.invitee.roles} : {}),
+        ...(has(options.invitee, 'isInternalNumber')
+          ? {isInternalNumber: options.invitee.isInternalNumber}
+          : {}),
       },
     ],
     alertIfActive: options.alertIfActive,
@@ -101,12 +106,16 @@ const MembersUtil = {
     return requestParams;
   },
 
-  isInvalidInvitee: (invitee) => {
+  isInvalidInvitee: (invitee: Invitee) => {
     if (!(invitee && (invitee.email || invitee.emailAddress || invitee.phoneNumber))) {
       return true;
     }
 
     if (invitee.phoneNumber) {
+      if (invitee.isInternalNumber) {
+        return !DIALER_REGEX.INTERNAL_NUMBER.test(invitee.phoneNumber);
+      }
+
       return !DIALER_REGEX.E164_FORMAT.test(invitee.phoneNumber);
     }
 
@@ -371,17 +380,20 @@ const MembersUtil = {
     return requestParams;
   },
 
-  cancelSIPInviteOptions: (invitee, locusUrl) => ({
+  cancelInviteByMemberIdOptions: (invitee, locusUrl) => ({
     invitee,
     locusUrl,
   }),
 
-  generateCancelSIPInviteRequestParams: (options) => {
+  generateCancelInviteByMemberIdRequestParams: (options) => {
+    const {memberId, isInternalNumber} = options.invitee;
+    const hasIsInternalNumberProp = has(options.invitee, 'isInternalNumber');
     const body = {
       actionType: _REMOVE_,
       invitees: [
         {
-          address: options.invitee.memberId,
+          address: memberId,
+          ...(hasIsInternalNumberProp ? {isInternalNumber} : {}),
         },
       ],
     };

package/src/multistream/mediaRequestManager.ts

@@ -15,7 +15,7 @@ import {cloneDeepWith, debounce, isEmpty} from 'lodash';
 import LoggerProxy from '../common/logs/logger-proxy';
 
 import {ReceiveSlot, ReceiveSlotEvents} from './receiveSlot';
-import {getMaxFs} from './remoteMedia';
+import {MAX_FS_VALUES} from './remoteMedia';
 
 export interface ActiveSpeakerPolicyInfo {
   policy: 'active-speaker';
@@ -123,12 +123,12 @@ export class MediaRequestManager {
 
   private getDegradedClientRequests(clientRequests: ClientRequestsMap) {
     const maxFsLimits = [
-      getMaxFs('best'),
-      getMaxFs('large'),
-      getMaxFs('medium'),
-      getMaxFs('small'),
-      getMaxFs('very small'),
-      getMaxFs('thumbnail'),
+      MAX_FS_VALUES['1080p'],
+      MAX_FS_VALUES['720p'],
+      MAX_FS_VALUES['540p'],
+      MAX_FS_VALUES['360p'],
+      MAX_FS_VALUES['180p'],
+      MAX_FS_VALUES['90p'],
     ];
 
     // reduce max-fs until total macroblocks is below limit

package/src/multistream/remoteMedia.ts

@@ -19,17 +19,18 @@ export type RemoteVideoResolution =
   | 'large' // 1080p or less
   | 'best'; // highest possible resolution
 
-const MAX_FS_VALUES = {
+export const MAX_FS_VALUES = {
   '90p': 60,
   '180p': 240,
   '360p': 920,
+  '540p': 2040,
   '720p': 3600,
   '1080p': 8192,
 };
 
 /**
  * Converts pane size into h264 maxFs
- * @param {PaneSize} paneSize
+ * @param {RemoteVideoResolution} paneSize
  * @returns {number}
  */
 export function getMaxFs(paneSize: RemoteVideoResolution): number {
@@ -89,6 +90,13 @@ export class RemoteMedia extends EventsScope {
 
   public readonly id: RemoteMediaId;
 
+  /**
+   * The max frame size of the media request, used for logging and media requests.
+   * Set by setSizeHint() based on video element dimensions.
+   * When > 0, this value takes precedence over options.resolution in sendMediaRequest().
+   */
+  private maxFrameSize = 0;
+
   /**
    * Constructs RemoteMedia instance
    *
@@ -136,15 +144,34 @@ export class RemoteMedia extends EventsScope {
       fs = MAX_FS_VALUES['180p'];
     } else if (height < getThresholdHeight(360)) {
       fs = MAX_FS_VALUES['360p'];
+    } else if (height < getThresholdHeight(540)) {
+      fs = MAX_FS_VALUES['540p'];
     } else if (height <= 720) {
       fs = MAX_FS_VALUES['720p'];
     } else {
       fs = MAX_FS_VALUES['1080p'];
     }
 
+    this.maxFrameSize = fs;
     this.receiveSlot?.setMaxFs(fs);
   }
 
+  /**
+   * Get the current effective maxFs value that would be used in media requests
+   * @returns {number | undefined} The maxFs value, or undefined if no constraints
+   */
+  public getEffectiveMaxFs(): number | undefined {
+    if (this.maxFrameSize > 0) {
+      return this.maxFrameSize;
+    }
+
+    if (this.options.resolution) {
+      return getMaxFs(this.options.resolution);
+    }
+
+    return undefined;
+  }
+
   /**
    * Invalidates the remote media by clearing the reference to a receive slot and
    * cancelling the media request.
@@ -185,6 +212,9 @@ export class RemoteMedia extends EventsScope {
       throw new Error('sendMediaRequest() called on an invalidated RemoteMedia instance');
     }
 
+    // Use maxFrameSize from setSizeHint if available, otherwise fallback to options.resolution
+    const maxFs = this.getEffectiveMaxFs();
+
     this.mediaRequestId = this.mediaRequestManager.addRequest(
       {
         policyInfo: {
@@ -192,9 +222,9 @@ export class RemoteMedia extends EventsScope {
           csi,
         },
         receiveSlots: [this.receiveSlot],
-        codecInfo: this.options.resolution && {
+        codecInfo: maxFs && {
           codec: 'h264',
-          maxFs: getMaxFs(this.options.resolution),
+          maxFs,
         },
       },
       commit

package/src/multistream/remoteMediaGroup.ts

@@ -215,6 +215,9 @@ export class RemoteMediaGroup {
   private sendActiveSpeakerMediaRequest(commit: boolean) {
     this.cancelActiveSpeakerMediaRequest(false);
 
+    // Calculate the effective maxFs based on all unpinned RemoteMedia instances
+    const effectiveMaxFs = this.getEffectiveMaxFsForActiveSpeaker();
+
     this.mediaRequestId = this.mediaRequestManager.addRequest(
       {
         policyInfo: {
@@ -230,9 +233,9 @@ export class RemoteMediaGroup {
         receiveSlots: this.unpinnedRemoteMedia.map((remoteMedia) =>
           remoteMedia.getUnderlyingReceiveSlot()
         ) as ReceiveSlot[],
-        codecInfo: this.options.resolution && {
+        codecInfo: effectiveMaxFs && {
           codec: 'h264',
-          maxFs: getMaxFs(this.options.resolution),
+          maxFs: effectiveMaxFs,
         },
       },
       commit
@@ -300,4 +303,36 @@ export class RemoteMediaGroup {
       this.unpinnedRemoteMedia.includes(remoteMedia) || this.pinnedRemoteMedia.includes(remoteMedia)
     );
   }
+
+  /**
+   * Calculate the effective maxFs for the active speaker media request based on unpinned RemoteMedia instances
+   * @returns {number | undefined} The calculated maxFs value, or undefined if no constraints
+   * @private
+   */
+  private getEffectiveMaxFsForActiveSpeaker(): number | undefined {
+    // Get all effective maxFs values from unpinned RemoteMedia instances
+    const maxFsValues = this.unpinnedRemoteMedia
+      .map((remoteMedia) => remoteMedia.getEffectiveMaxFs())
+      .filter((maxFs) => maxFs !== undefined);
+
+    // Use the highest maxFs value to ensure we don't under-request resolution for any instance
+    if (maxFsValues.length > 0) {
+      return Math.max(...maxFsValues);
+    }
+
+    // Fall back to group's resolution option
+    if (this.options.resolution) {
+      return getMaxFs(this.options.resolution);
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Get the current effective maxFs that would be used for the active speaker media request
+   * @returns {number | undefined} The effective maxFs value
+   */
+  public getEffectiveMaxFs(): number | undefined {
+    return this.getEffectiveMaxFsForActiveSpeaker();
+  }
 }

package/src/multistream/sendSlotManager.ts

@@ -7,10 +7,20 @@ import {
   StreamState,
 } from '@webex/internal-media-core';
 
+/**
+ * This class is used to manage the sendSlots for the given media types.
+ */
 export default class SendSlotManager {
   private readonly slots: Map<MediaType, SendSlot> = new Map();
   private readonly LoggerProxy: any;
+  private readonly sourceStateOverrides: Map<MediaType, StreamState> = new Map();
 
+  /**
+   * Constructor for SendSlotManager
+   *
+   * @param {any} LoggerProxy is used to log the messages
+   * @constructor
+   */
   constructor(LoggerProxy: any) {
     this.LoggerProxy = LoggerProxy;
   }
@@ -93,7 +103,7 @@ export default class SendSlotManager {
   public setSourceStateOverride(mediaType: MediaType, state: StreamState | null) {
     if (mediaType !== MediaType.VideoMain) {
       throw new Error(
-        `sendSlotManager cannot set source state override which media type is ${mediaType}`
+        `Invalid media type '${mediaType}'. Source state overrides are only applicable to ${MediaType.VideoMain}.`
       );
     }
 
@@ -103,17 +113,39 @@ export default class SendSlotManager {
       throw new Error(`Slot for ${mediaType} does not exist`);
     }
 
+    const currentStateOverride = this.getSourceStateOverride(mediaType);
+    if (currentStateOverride === state) {
+      return;
+    }
+
     if (state) {
       slot.setSourceStateOverride(state);
+      this.sourceStateOverrides.set(mediaType, state);
     } else {
       slot.clearSourceStateOverride();
+      this.sourceStateOverrides.delete(mediaType);
     }
 
     this.LoggerProxy.logger.info(
-      `SendSlotsManager->setSourceStateOverride#set source state override for ${mediaType} to ${state}`
+      `SendSlotManager->setSourceStateOverride#set source state override for ${mediaType} to ${state}`
     );
   }
 
+  /**
+   * Gets the source state override for the given media type.
+   * @param {MediaType} mediaType - The type of media to get the source state override for.
+   * @returns {StreamState | null} - The current source state override or null if not set.
+   */
+  private getSourceStateOverride(mediaType: MediaType): StreamState | null {
+    if (mediaType !== MediaType.VideoMain) {
+      throw new Error(
+        `Invalid media type '${mediaType}'. Source state overrides are only applicable to ${MediaType.VideoMain}.`
+      );
+    }
+
+    return this.sourceStateOverrides.get(mediaType) || null;
+  }
+
   /**
    * This method publishes the given stream to the sendSlot for the given mediaType
    * @param {MediaType} mediaType MediaType of the sendSlot to which a stream needs to be published (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)