@webex/plugin-meetings 3.9.0-webinar5k.1 → 3.10.0

package/src/members/util.ts

@@ -14,6 +14,7 @@ import {
 } from '../constants';
 
 import {RoleAssignmentOptions, RoleAssignmentRequest, ServerRoleShape} from './types';
+import {Invitee} from '../meeting/type';
 
 const MembersUtil = {
   /**
@@ -105,7 +106,7 @@ const MembersUtil = {
     return requestParams;
   },
 
-  isInvalidInvitee: (invitee) => {
+  isInvalidInvitee: (invitee: Invitee) => {
     if (!(invitee && (invitee.email || invitee.emailAddress || invitee.phoneNumber))) {
       return true;
     }
@@ -189,13 +190,21 @@ const MembersUtil = {
    * @param {String} requestingParticipantId id of the participant who is sending request (optional)
    * @param {String} alias alias name
    * @param {String} locusUrl url
+   * @param {String} suffix optional suffix
    * @returns {Object} consists of {memberID: string, requestingParticipantId: string, alias: string, locusUrl: string}
    */
-  generateEditDisplayNameMemberOptions: (memberId, requestingParticipantId, alias, locusUrl) => ({
+  generateEditDisplayNameMemberOptions: (
     memberId,
     requestingParticipantId,
     alias,
     locusUrl,
+    suffix
+  ) => ({
+    memberId,
+    requestingParticipantId,
+    alias,
+    locusUrl,
+    suffix,
   }),
 
   getMuteMemberRequestParams: (options) => {
@@ -300,10 +309,18 @@ const MembersUtil = {
    * @returns {Object} request parameters (method, uri, body) needed to make a editDisplayName request
    */
   editDisplayNameMemberRequestParams: (options) => {
-    const body = {
+    const body: {
+      aliasValue: string;
+      requestingParticipantId: string;
+      suffixValue?: string;
+    } = {
       aliasValue: options.alias,
       requestingParticipantId: options.requestingParticipantId,
     };
+
+    if (options.suffix !== undefined) {
+      body.suffixValue = options.suffix;
+    }
     const uri = `${options.locusUrl}/${PARTICIPANT}/${options.memberId}/${ALIAS}`;
 
     return {

package/src/metrics/constants.ts

@@ -86,6 +86,7 @@ const BEHAVIORAL_METRICS = {
   VERIFY_REGISTRATION_ID_SUCCESS: 'js_sdk_verify_registrationId_success',
   VERIFY_REGISTRATION_ID_ERROR: 'js_sdk_verify_registrationId_error',
   JOIN_FORBIDDEN_ERROR: 'js_sdk_join_forbidden_error',
+  MEDIA_ISSUE_DETECTED: 'js_sdk_media_issue_detected',
 };
 
 export {BEHAVIORAL_METRICS as default};

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/reachability/index.ts

@@ -923,10 +923,10 @@ export default class Reachability extends EventsScope {
 
       // update expected results counters to include this cluster
       this.expectedResultsCount[cluster.isVideoMesh ? 'videoMesh' : 'public'].udp +=
-        cluster.udp.length;
+        cluster.udp.length > 0 ? 1 : 0;
       if (!cluster.isVideoMesh) {
-        this.expectedResultsCount.public.tcp += cluster.tcp.length;
-        this.expectedResultsCount.public.xtls += cluster.xtls.length;
+        this.expectedResultsCount.public.tcp += cluster.tcp.length > 0 ? 1 : 0;
+        this.expectedResultsCount.public.xtls += cluster.xtls.length > 0 ? 1 : 0;
       }
     });
 

package/test/unit/spec/common/browser-detection.js

@@ -18,16 +18,6 @@ const USER_AGENT_SAFARI_MAC =
 const USER_AGENT_FIREFOX_MAC =
   'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:87.0) ' + 'Gecko/20100101 Firefox/87.0';
 
-const mockDetectionObject = {
-  /* eslint-disable global-require */
-  getOSName: () => require('os').platform(),
-  getOSVersion: () => require('os').release(),
-  /* eslint-enable global-require */
-  getBrowserName: () => '',
-  getBrowserVersion: () => '',
-  isBrowser: () => false,
-};
-
 describe('common/browser-detection', () => {
   it('returns the correct browser name.', () => {
     assert.equal(
@@ -102,18 +92,4 @@ describe('common/browser-detection', () => {
       'This browser is NOT Firefox'
     );
   });
-
-  it('returns the mock object when there is no userAgent', () => {
-    Object.defineProperty(global.window.navigator, 'userAgent', {
-      get: () => undefined,
-      configurable: true,
-    });
-
-    const {getBrowserName, getBrowserVersion, getOSName, getOSVersion} = BrowserDetection(null);
-
-    assert.equal(getBrowserName(), mockDetectionObject.getBrowserName());
-    assert.equal(getBrowserVersion(), mockDetectionObject.getBrowserVersion());
-    assert.equal(getOSName(), mockDetectionObject.getOSName());
-    assert.equal(getOSVersion(), mockDetectionObject.getOSVersion());
-  });
 });

package/test/unit/spec/controls-options-manager/index.js

@@ -133,6 +133,7 @@ describe('plugin-meetings', () => {
 
                 manager.set({
                   locusUrl: 'test/id',
+                  mainLocusUrl: '',
                   displayHints: [],
                 });
               });
@@ -201,6 +202,38 @@ describe('plugin-meetings', () => {
                     Util.canUpdate = restorable;
                   });
               });
+
+              it('should call request with mainLocusUrl and locusUrl as authorizingLocusUrl if mainLocusUrl is exist and not same with locusUrl', () => {
+                const restorable = Util.canUpdate;
+                Util.canUpdate = sinon.stub().returns(true);
+                manager.mainLocusUrl = 'test/main';
+
+                const audio = {scope: 'audio', properties: {a: 1, b: 2}};
+                const reactions = {scope: 'reactions', properties: {c: 3, d: 4}};
+
+                return manager.update(audio, reactions)
+                  .then(() => {
+                    assert.calledWith(request.request, {
+                      uri: 'test/main/controls',
+                      body: {
+                        audio: audio.properties,
+                        authorizingLocusUrl: 'test/id'
+                      },
+                      method: HTTP_VERBS.PATCH,
+                    });
+
+                    assert.calledWith(request.request, {
+                      uri: 'test/main/controls',
+                      body: {
+                        reactions: reactions.properties,
+                        authorizingLocusUrl: 'test/id'
+                      },
+                      method: HTTP_VERBS.PATCH,
+                    });
+
+                    Util.canUpdate = restorable;
+                  });
+              });
             });
 
             describe('Mute/Unmute All', () => {
@@ -214,6 +247,7 @@ describe('plugin-meetings', () => {
 
                 manager.set({
                   locusUrl: 'test/id',
+                  mainLocusUrl: '',
                   displayHints: [],
                 })
               });
@@ -305,6 +339,19 @@ describe('plugin-meetings', () => {
 
                 assert.deepEqual(result, request.request.firstCall.returnValue);
               });
+
+              it('request with mainLocusUrl and make locusUrl as authorizingLocusUrl if mainLocusUrl is exist and not same with locusUrl', () => {
+                manager.setDisplayHints(['MUTE_ALL', 'DISABLE_HARD_MUTE', 'DISABLE_MUTE_ON_ENTRY']);
+                manager.mainLocusUrl = `test/main`;
+
+                const result = manager.setMuteAll(true, true, true, ['attendee']);
+
+                assert.calledWith(request.request, {  uri: 'test/main/controls',
+                  body: { audio: { muted: true, disallowUnmute: true, muteOnEntry: true, roles: ['attendee'] }, authorizingLocusUrl: 'test/id' },
+                  method: HTTP_VERBS.PATCH});
+
+                assert.deepEqual(result, request.request.firstCall.returnValue);
+              });
             });
           });
     });

package/test/unit/spec/fixture/locus.js

@@ -36,6 +36,7 @@ export default {
         'LOCK_STATUS_UNLOCKED',
         'ROSTER_IN_MEETING',
         'SHARE_WHITEBOARD',
+        'SHOW_AUTO_END_MEETING_WARNING',
         'SHARE_WHITEBOARD_POLICY',
         'WEBEX_ASSISTANT_STATUS_INACTIVE',
         'CAPTION_START',

package/test/unit/spec/interceptors/locusRouteToken.ts

@@ -0,0 +1,87 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+
+/* eslint-disable camelcase */
+import 'jsdom-global/register';
+import {assert} from '@webex/test-helper-chai';
+import MockWebex from '@webex/test-helper-mock-webex';
+import {LocusRouteTokenInterceptor} from '@webex/plugin-meetings/src/interceptors';
+import Meetings from '@webex/plugin-meetings';
+
+const X_CISCO_PART_ROUTE_TOKEN = 'X-Cisco-Part-Route-Token';
+
+describe('LocusRouteTokenInterceptor', () => {
+  let interceptor, webex;
+  const TEST_LOCUS_ID = '0f1eba56-91e2-2a11-9b2b-1e2da077f066';
+  beforeEach(() => {
+    webex = new MockWebex({
+      children: {
+        meetings: Meetings,
+      },
+    });
+    interceptor = Reflect.apply(LocusRouteTokenInterceptor.create, webex, []);
+  });
+
+  it('getLocusIdByRequestUrl should return locusId from url', () => {
+    const url = `https://locus-test.webex.com/locus/api/v1/loci/${TEST_LOCUS_ID}/foo`;
+    assert.equal(interceptor.getLocusIdByRequestUrl(url), TEST_LOCUS_ID);
+  });
+
+  it('getLocusIdByRequestUrl should return undefined when no locusId in url', () => {
+    const url = 'https://locus-test.webex.com/locus/api/v1/foo';
+    assert.isUndefined(interceptor.getLocusIdByRequestUrl(url));
+  });
+
+  it('getLocusIdByRequestUrl should return undefined when url is undefined', () => {
+    assert.isUndefined(interceptor.getLocusIdByRequestUrl(undefined));
+  });
+
+  it('onResponse should store route token when header exists', async () => {
+    const response = {
+      headers: {
+        [X_CISCO_PART_ROUTE_TOKEN]: 'test-token',
+      },
+    };
+
+    const result = await interceptor.onResponse(
+      {
+        uri: `https://locus-test.webex.com/locus/api/v1/loci/${TEST_LOCUS_ID}/foo`,
+      },
+      response
+    );
+    assert.equal(result, response);
+    assert.equal(interceptor.getToken(TEST_LOCUS_ID), 'test-token');
+  });
+
+  it('onResponse should not store token when header missing', async () => {
+    interceptor.updateToken(TEST_LOCUS_ID);
+    const response = {headers: {}};
+
+    await interceptor.onResponse({}, response);
+    assert.isUndefined(interceptor.getToken(TEST_LOCUS_ID));
+  });
+
+  it('onRequest should attach token to headers when token exists', async () => {
+    interceptor.updateToken(TEST_LOCUS_ID, 'abc123');
+
+    const options = {
+      headers: {},
+      uri: `https://locus-test.webex.com/locus/api/v1/loci/${TEST_LOCUS_ID}/foo`,
+    };
+    const result = await interceptor.onRequest(options);
+    assert.equal(result.headers[X_CISCO_PART_ROUTE_TOKEN], 'abc123');
+  });
+
+  it('onRequest should not attach token if none is stored', async () => {
+    interceptor.updateToken(TEST_LOCUS_ID);
+    const options = {headers: {}};
+    const result = await interceptor.onRequest(options);
+    assert.isUndefined(result.headers[X_CISCO_PART_ROUTE_TOKEN]);
+  });
+
+  it('updateToken & getToken should work as pair', () => {
+    interceptor.updateToken(TEST_LOCUS_ID, 'abc456');
+    assert.equal(interceptor.getToken(TEST_LOCUS_ID), 'abc456');
+  });
+});