@webex/plugin-meetings 3.6.0 → 3.7.0-ipv6-multi-turn-urls.2

package/src/meeting/util.ts

@@ -89,8 +89,12 @@ const MeetingUtil = {
   getIpVersion(webex: any): IP_VERSION | undefined {
     const {supportsIpV4, supportsIpV6} = webex.internal.device.ipNetworkDetector;
 
-    if (BrowserDetection().isBrowser('firefox')) {
-      // our ipv6 solution relies on FQDN ICE candidates, but Firefox doesn't support them,
+    if (
+      !webex.config.meetings.backendIpv6NativeSupport &&
+      BrowserDetection().isBrowser('firefox')
+    ) {
+      // when backend doesn't support native ipv6,
+      // then our NAT64/DNS64 based solution relies on FQDN ICE candidates, but Firefox doesn't support them,
       // see https://bugzilla.mozilla.org/show_bug.cgi?id=1713128
       // so for Firefox we don't want the backend to activate the "ipv6 feature"
       return undefined;
@@ -111,7 +115,7 @@ const MeetingUtil = {
     return IP_VERSION.unknown;
   },
 
-  joinMeeting: (meeting, options) => {
+  joinMeeting: async (meeting, options) => {
     if (!meeting) {
       return Promise.reject(new ParameterError('You need a meeting object.'));
     }
@@ -123,6 +127,27 @@ const MeetingUtil = {
       options: {meetingId: meeting.id},
     });
 
+    let reachability;
+    let clientMediaPreferences = {
+      // bare minimum fallback value that should allow us to join
+      ipver: IP_VERSION.unknown,
+      joinCookie: undefined,
+      preferTranscoding: !meeting.isMultistream,
+    };
+
+    try {
+      clientMediaPreferences = await webex.meetings.reachability.getClientMediaPreferences(
+        meeting.isMultistream,
+        MeetingUtil.getIpVersion(webex)
+      );
+      reachability = await webex.meetings.reachability.getReachabilityReportToAttachToRoap();
+    } catch (e) {
+      LoggerProxy.logger.error(
+        'Meeting:util#joinMeeting --> Error getting reachability or clientMediaPreferences:',
+        e
+      );
+    }
+
     // eslint-disable-next-line no-warning-comments
     // TODO: check if the meeting is in JOINING state
     // if Joining state termintate the request as user might click multiple times
@@ -134,20 +159,19 @@ const MeetingUtil = {
         locusUrl: meeting.locusUrl,
         locusClusterUrl: meeting.meetingInfo?.locusClusterUrl,
         correlationId: meeting.correlationId,
-        reachability: options.reachability,
+        reachability,
         roapMessage: options.roapMessage,
         permissionToken: meeting.permissionToken,
         resourceId: options.resourceId || null,
         moderator: options.moderator,
         pin: options.pin,
         moveToResource: options.moveToResource,
-        preferTranscoding: !meeting.isMultistream,
         asResourceOccupant: options.asResourceOccupant,
         breakoutsSupported: options.breakoutsSupported,
         locale: options.locale,
         deviceCapabilities: options.deviceCapabilities,
         liveAnnotationSupported: options.liveAnnotationSupported,
-        ipVersion: MeetingUtil.getIpVersion(meeting.getWebexObject()),
+        clientMediaPreferences,
       })
       .then((res) => {
         const parsed = MeetingUtil.parseLocusJoin(res);
@@ -173,6 +197,7 @@ const MeetingUtil = {
 
   cleanUp: (meeting) => {
     meeting.getWebexObject().internal.device.meetingEnded();
+    meeting.stopPeriodicLogUpload();
 
     meeting.breakouts.cleanUp();
     meeting.simultaneousInterpretation.cleanUp();

package/src/meeting-info/meeting-info-v2.ts

@@ -18,6 +18,19 @@ const ADHOC_MEETING_DEFAULT_ERROR =
   'Failed starting the adhoc meeting, Please contact support team ';
 const CAPTCHA_ERROR_REQUIRES_PASSWORD_CODES = [423005, 423006];
 const POLICY_ERROR_CODES = [403049, 403104, 403103, 403048, 403102, 403101];
+/**
+ * 403021 - Meeting registration is required
+ * 403022 - Meeting registration is still pending
+ * 403024 - Meeting registration have been rejected
+ * 403137 - Registration ID verified failure
+ * 423007 - Registration ID input too many time,please input captcha code
+ * 403026 - Need to join meeting via webcast
+ * 403037 - Meeting join required registration ID
+ * 403137 - Registration ID verified failure
+ *
+ */
+const JOIN_WEBINAR_ERROR_CODES = [403021, 403022, 403024, 403137, 423007, 403026, 403037, 403137];
+
 /**
  * Error to indicate that wbxappapi requires a password
  */
@@ -124,6 +137,31 @@ export class MeetingInfoV2CaptchaError extends Error {
   }
 }
 
+/**
+ * Error preventing join because of a webinar have some error
+ */
+export class MeetingInfoV2JoinWebinarError extends Error {
+  meetingInfo: any;
+  sdkMessage: any;
+  wbxAppApiCode: any;
+  body: any;
+  /**
+   *
+   * @constructor
+   * @param {Number} [wbxAppApiErrorCode]
+   * @param {Object} [meetingInfo]
+   * @param {String} [message]
+   */
+  constructor(wbxAppApiErrorCode?: number, meetingInfo?: object, message?: string) {
+    super(`${message}, code=${wbxAppApiErrorCode}`);
+    this.name = 'MeetingInfoV2JoinWebinarError';
+    this.sdkMessage = message;
+    this.stack = new Error().stack;
+    this.wbxAppApiCode = wbxAppApiErrorCode;
+    this.meetingInfo = meetingInfo;
+  }
+}
+
 /**
  * @class MeetingInfo
  */
@@ -177,6 +215,29 @@ export default class MeetingInfoV2 {
     }
   };
 
+  /**
+   * Raises a handleJoinWebinarError for join webinar error codes
+   * @param {any} err the error from the request
+   * @returns {void}
+   */
+  handleJoinWebinarError = (err) => {
+    if (!err.body) {
+      return;
+    }
+
+    if (JOIN_WEBINAR_ERROR_CODES.includes(err.body?.code)) {
+      Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.JOIN_WEBINAR_ERROR, {
+        code: err.body?.code,
+      });
+
+      throw new MeetingInfoV2JoinWebinarError(
+        err.body?.code,
+        err.body?.data?.meetingInfo,
+        err.body?.message
+      );
+    }
+  };
+
   /**
    * Creates adhoc space meetings for a space by fetching the conversation infomation
    * @param {String} conversationUrl conversationUrl to start adhoc meeting on
@@ -237,6 +298,7 @@ export default class MeetingInfoV2 {
       })
       .catch((err) => {
         this.handlePolicyError(err);
+        this.handleJoinWebinarError(err);
 
         Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ADHOC_MEETING_FAILURE, {
           reason: err.message,
@@ -391,6 +453,7 @@ export default class MeetingInfoV2 {
 
         if (err?.statusCode === 403) {
           this.handlePolicyError(err);
+          this.handleJoinWebinarError(err);
 
           Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.VERIFY_PASSWORD_ERROR, {
             reason: err.message,

package/src/meetings/index.ts

@@ -56,6 +56,7 @@ import MeetingCollection from './collection';
 import {MEETING_KEY, INoiseReductionEffect, IVirtualBackgroundEffect} from './meetings.types';
 import MeetingsUtil from './util';
 import PermissionError from '../common/errors/permission';
+import JoinWebinarError from '../common/errors/join-webinar-error';
 import {SpaceIDDeprecatedError} from '../common/errors/webex-errors';
 import NoMeetingInfoError from '../common/errors/no-meeting-info';
 
@@ -154,6 +155,9 @@ export type BasicMeetingInformation = {
   };
   meetingInfo: any;
   sessionCorrelationId: string;
+  roles: string[];
+  getCurUserType: () => string | null;
+  callStateForMetrics: CallStateForMetrics;
 };
 
 /**
@@ -762,6 +766,25 @@ export default class Meetings extends WebexPlugin {
     }
   }
 
+  /**
+   * API to toggle backend ipv6 native support config, needs to be called before webex.meetings.register()
+   *
+   * @param {Boolean} newValue
+   * @private
+   * @memberof Meetings
+   * @returns {undefined}
+   */
+  private _toggleIpv6BackendNativeSupport(newValue: boolean) {
+    if (typeof newValue !== 'boolean') {
+      return;
+    }
+    // @ts-ignore
+    if (this.config.backendIpv6NativeSupport !== newValue) {
+      // @ts-ignore
+      this.config.backendIpv6NativeSupport = newValue;
+    }
+  }
+
   /**
    * Explicitly sets up the meetings plugin by registering
    * the device, connecting to mercury, and listening for locus events.
@@ -1024,48 +1047,55 @@ export default class Meetings extends WebexPlugin {
    */
   fetchUserPreferredWebexSite() {
     // @ts-ignore
-    return this.webex.people._getMe().then((me) => {
-      const isGuestUser = me.type === 'appuser';
-      if (!isGuestUser) {
-        return this.request.getMeetingPreferences().then((res) => {
-          if (res) {
-            const preferredWebexSite = MeetingsUtil.parseDefaultSiteFromMeetingPreferences(res);
-            this.preferredWebexSite = preferredWebexSite;
-            // @ts-ignore
-            this.webex.internal.services._getCatalog().addAllowedDomains([preferredWebexSite]);
-          }
+    return this.webex.people
+      ._getMe()
+      .then((me) => {
+        const isGuestUser = me.type === 'appuser';
+        if (!isGuestUser) {
+          return this.request.getMeetingPreferences().then((res) => {
+            if (res) {
+              const preferredWebexSite = MeetingsUtil.parseDefaultSiteFromMeetingPreferences(res);
+              this.preferredWebexSite = preferredWebexSite;
+              // @ts-ignore
+              this.webex.internal.services._getCatalog().addAllowedDomains([preferredWebexSite]);
+            }
 
-          // fall back to getting the preferred site from the user information
-          if (!this.preferredWebexSite) {
-            // @ts-ignore
-            return this.webex.internal.user
-              .get()
-              .then((user) => {
-                const preferredWebexSite =
-                  user?.userPreferences?.userPreferencesItems?.preferredWebExSite;
-                if (preferredWebexSite) {
-                  this.preferredWebexSite = preferredWebexSite;
-                  // @ts-ignore
-                  this.webex.internal.services
-                    ._getCatalog()
-                    .addAllowedDomains([preferredWebexSite]);
-                } else {
-                  throw new Error('site not found');
-                }
-              })
-              .catch(() => {
-                LoggerProxy.logger.error(
-                  'Failed to fetch preferred site from user - no site will be set'
-                );
-              });
-          }
+            // fall back to getting the preferred site from the user information
+            if (!this.preferredWebexSite) {
+              // @ts-ignore
+              return this.webex.internal.user
+                .get()
+                .then((user) => {
+                  const preferredWebexSite =
+                    user?.userPreferences?.userPreferencesItems?.preferredWebExSite;
+                  if (preferredWebexSite) {
+                    this.preferredWebexSite = preferredWebexSite;
+                    // @ts-ignore
+                    this.webex.internal.services
+                      ._getCatalog()
+                      .addAllowedDomains([preferredWebexSite]);
+                  } else {
+                    throw new Error('site not found');
+                  }
+                })
+                .catch(() => {
+                  LoggerProxy.logger.error(
+                    'Failed to fetch preferred site from user - no site will be set'
+                  );
+                });
+            }
 
-          return Promise.resolve();
-        });
-      }
+            return Promise.resolve();
+          });
+        }
 
-      return Promise.resolve();
-    });
+        return Promise.resolve();
+      })
+      .catch(() => {
+        LoggerProxy.logger.error(
+          'Failed to retrieve user information. No preferredWebexSite will be set'
+        );
+      });
   }
 
   /**
@@ -1116,6 +1146,9 @@ export default class Meetings extends WebexPlugin {
           sessionId: meeting.locusInfo?.fullState?.sessionId,
         },
       },
+      roles: meeting.roles,
+      callStateForMetrics: meeting.callStateForMetrics,
+      getCurUserType: meeting.getCurUserType,
     });
     this.meetingCollection.delete(meeting.id);
     Trigger.trigger(
@@ -1378,7 +1411,8 @@ export default class Meetings extends WebexPlugin {
       if (
         !(err instanceof CaptchaError) &&
         !(err instanceof PasswordError) &&
-        !(err instanceof PermissionError)
+        !(err instanceof PermissionError) &&
+        !(err instanceof JoinWebinarError)
       ) {
         LoggerProxy.logger.info(
           `Meetings:index#createMeeting --> Info Unable to fetch meeting info for ${destination}.`

package/src/members/index.ts

@@ -915,11 +915,12 @@ export default class Members extends StatelessWebexPlugin {
   /**
    * Lower all hands of members in a meeting
    * @param {String} requestingMemberId - id of the participant which requested the lower all hands
+   * @param {array} roles which should be lowered
    * @returns {Promise}
    * @public
    * @memberof Members
    */
-  public lowerAllHands(requestingMemberId: string) {
+  public lowerAllHands(requestingMemberId: string, roles: Array<string>) {
     if (!this.locusUrl) {
       return Promise.reject(
         new ParameterError(
@@ -936,7 +937,8 @@ export default class Members extends StatelessWebexPlugin {
     }
     const options = MembersUtil.generateLowerAllHandsMemberOptions(
       requestingMemberId,
-      this.locusUrl
+      this.locusUrl,
+      roles
     );
 
     return this.membersRequest.lowerAllHandsMember(options);

package/src/members/util.ts

@@ -46,6 +46,7 @@ const MembersUtil = {
       {
         address:
           options.invitee.emailAddress || options.invitee.email || options.invitee.phoneNumber,
+        ...(options.invitee.roles ? {roles: options.invitee.roles} : {}),
       },
     ],
     alertIfActive: options.alertIfActive,
@@ -166,9 +167,10 @@ const MembersUtil = {
     locusUrl,
   }),
 
-  generateLowerAllHandsMemberOptions: (requestingParticipantId, locusUrl) => ({
+  generateLowerAllHandsMemberOptions: (requestingParticipantId, locusUrl, roles) => ({
     requestingParticipantId,
     locusUrl,
+    ...(roles !== undefined && {roles}),
   }),
 
   /**
@@ -253,6 +255,7 @@ const MembersUtil = {
     const body = {
       hand: {
         raised: false,
+        ...(options.roles !== undefined && {roles: options.roles}),
       },
       requestingParticipantId: options.requestingParticipantId,
     };

package/src/metrics/constants.ts

@@ -70,6 +70,9 @@ const BEHAVIORAL_METRICS = {
   ROAP_HTTP_RESPONSE_MISSING: 'js_sdk_roap_http_response_missing',
   TURN_DISCOVERY_REQUIRES_OK: 'js_sdk_turn_discovery_requires_ok',
   REACHABILITY_COMPLETED: 'js_sdk_reachability_completed',
+  JOIN_WEBINAR_ERROR: 'js_sdk_join_webinar_error',
+  GUEST_ENTERED_LOBBY: 'js_sdk_guest_entered_lobby',
+  GUEST_EXITED_LOBBY: 'js_sdk_guest_exited_lobby',
 };
 
 export {BEHAVIORAL_METRICS as default};

package/src/multistream/remoteMedia.ts

@@ -19,6 +19,14 @@ export type RemoteVideoResolution =
   | 'large' // 1080p or less
   | 'best'; // highest possible resolution
 
+const MAX_FS_VALUES = {
+  '90p': 60,
+  '180p': 240,
+  '360p': 920,
+  '720p': 3600,
+  '1080p': 8192,
+};
+
 /**
  * Converts pane size into h264 maxFs
  * @param {PaneSize} paneSize
@@ -29,28 +37,28 @@ export function getMaxFs(paneSize: RemoteVideoResolution): number {
 
   switch (paneSize) {
     case 'thumbnail':
-      maxFs = 60;
+      maxFs = MAX_FS_VALUES['90p'];
       break;
     case 'very small':
-      maxFs = 240;
+      maxFs = MAX_FS_VALUES['180p'];
       break;
     case 'small':
-      maxFs = 920;
+      maxFs = MAX_FS_VALUES['360p'];
       break;
     case 'medium':
-      maxFs = 3600;
+      maxFs = MAX_FS_VALUES['720p'];
       break;
     case 'large':
-      maxFs = 8192;
+      maxFs = MAX_FS_VALUES['1080p'];
       break;
     case 'best':
-      maxFs = 8192; // for now 'best' is 1080p, so same as 'large'
+      maxFs = MAX_FS_VALUES['1080p']; // for now 'best' is 1080p, so same as 'large'
       break;
     default:
       LoggerProxy.logger.warn(
         `RemoteMedia#getMaxFs --> unsupported paneSize: ${paneSize}, using "medium" instead`
       );
-      maxFs = 3600;
+      maxFs = MAX_FS_VALUES['720p'];
   }
 
   return maxFs;
@@ -107,21 +115,31 @@ export class RemoteMedia extends EventsScope {
    * to restrict the requested resolution to this size
    * @param width width of the video element
    * @param height height of the video element
+   * @note width/height of 0 will be ignored
    */
   public setSizeHint(width, height) {
     // only base on height for now
     let fs: number;
 
-    if (height < 135) {
-      fs = 60;
-    } else if (height < 270) {
-      fs = 240;
-    } else if (height < 540) {
-      fs = 920;
+    if (width === 0 || height === 0) {
+      return;
+    }
+
+    // we switch to the next resolution level when the height is 10% more than the current resolution height
+    // except for 1080p - we switch to it immediately when the height is more than 720p
+    const threshold = 1.1;
+    const getThresholdHeight = (h: number) => Math.round(h * threshold);
+
+    if (height < getThresholdHeight(90)) {
+      fs = MAX_FS_VALUES['90p'];
+    } else if (height < getThresholdHeight(180)) {
+      fs = MAX_FS_VALUES['180p'];
+    } else if (height < getThresholdHeight(360)) {
+      fs = MAX_FS_VALUES['360p'];
     } else if (height <= 720) {
-      fs = 3600;
+      fs = MAX_FS_VALUES['720p'];
     } else {
-      fs = 8192;
+      fs = MAX_FS_VALUES['1080p'];
     }
 
     this.receiveSlot?.setMaxFs(fs);

package/src/reachability/clusterReachability.ts

@@ -6,20 +6,7 @@ import {convertStunUrlToTurn, convertStunUrlToTurnTls} from './util';
 import EventsScope from '../common/events/events-scope';
 
 import {CONNECTION_STATE, Enum, ICE_GATHERING_STATE} from '../constants';
-
-// result for a specific transport protocol (like udp or tcp)
-export type TransportResult = {
-  result: 'reachable' | 'unreachable' | 'untested';
-  latencyInMilliseconds?: number; // amount of time it took to get the first ICE candidate
-  clientMediaIPs?: string[];
-};
-
-// reachability result for a specific media cluster
-export type ClusterReachabilityResult = {
-  udp: TransportResult;
-  tcp: TransportResult;
-  xtls: TransportResult;
-};
+import {ClusterReachabilityResult} from './reachability.types';
 
 // data for the Events.resultReady event
 export type ResultEventData = {
@@ -370,11 +357,14 @@ export class ClusterReachability extends EventsScope {
 
       this.startTimestamp = performance.now();
 
+      // Set up the state change listeners before triggering the ICE gathering
+      const gatherIceCandidatePromise = this.gatherIceCandidates();
+
       // not awaiting the next call on purpose, because we're not sending the offer anywhere and there won't be any answer
       // we just need to make this call to trigger the ICE gathering process
       this.pc.setLocalDescription(offer);
 
-      await this.gatherIceCandidates();
+      await gatherIceCandidatePromise;
     } catch (error) {
       LoggerProxy.logger.warn(`Reachability:ClusterReachability#start --> Error: `, error);
     }