@webex/plugin-meetings 3.0.0-stream-classes.4 → 3.0.0-test.1

package/src/config.ts

@@ -88,7 +88,7 @@ export default {
       enableMediaNegotiatedEvent: false,
       enableUnifiedMeetings: true,
       enableAdhocMeetings: true,
-      enableTurnDiscovery: true,
+      enableTcpReachability: false,
     },
     degradationPreferences: {
       maxMacroblocksLimit: 8192,

package/src/constants.ts

@@ -1,6 +1,8 @@
 // @ts-ignore
 import {hydraTypes} from '@webex/common';
 
+type Enum<T extends Record<string, unknown>> = T[keyof T];
+
 // *********** LOWERCASE / CAMELCASE STRINGS ************
 
 export const AUDIO = 'audio';
@@ -190,7 +192,8 @@ export const ICE_FAIL_TIMEOUT = 3000;
 
 export const RETRY_TIMEOUT = 3000;
 
-export const PC_BAIL_TIMEOUT = 15000;
+export const ICE_AND_DTLS_CONNECTION_TIMEOUT = 10000;
+export const ROAP_OFFER_ANSWER_EXCHANGE_TIMEOUT = 35000;
 
 // ******************** REGEX **********************
 // Please alphabetize
@@ -236,6 +239,13 @@ export const CALENDAR_EVENTS = {
   DELETE: 'event:calendar.meeting.delete',
 };
 
+export const ASSIGN_ROLES_ERROR_CODES = {
+  ReclaimHostNotSupportedErrorCode: 2400127,
+  ReclaimHostNotAllowedErrorCode: 2403135,
+  ReclaimHostEmptyWrongKeyErrorCode: 2403136,
+  ReclaimHostIsHostAlreadyErrorCode: 2409150,
+};
+
 export const DEFAULT_GET_STATS_FILTER = {
   types: [
     'track',
@@ -331,6 +341,7 @@ export const EVENT_TRIGGERS = {
   MEETING_UNLOCKED: 'meeting:unlocked',
   MEETING_LOCKED: 'meeting:locked',
   MEETING_INFO_AVAILABLE: 'meeting:meetingInfoAvailable',
+  MEETING_INFO_UPDATED: 'meeting:meetingInfoUpdated',
   MEETING_LOG_UPLOAD_SUCCESS: 'meeting:logUpload:success',
   MEETING_LOG_UPLOAD_FAILURE: 'meeting:logUpload:failure',
   MEETING_ACTIONS_UPDATE: 'meeting:actionsUpdate',
@@ -348,6 +359,7 @@ export const EVENT_TRIGGERS = {
   REMOTE_VIDEO_SOURCE_COUNT_CHANGED: 'media:remoteVideoSourceCountChanged',
   REMOTE_AUDIO_SOURCE_COUNT_CHANGED: 'media:remoteAudioSourceCountChanged',
   REMOTE_MEDIA_AUDIO_CREATED: 'media:remoteAudio:created',
+  REMOTE_MEDIA_INTERPRETATION_AUDIO_CREATED: 'media:remoteInterpretationAudio:created',
   REMOTE_MEDIA_SCREEN_SHARE_AUDIO_CREATED: 'media:remoteScreenShareAudio:created',
   REMOTE_MEDIA_VIDEO_LAYOUT_CHANGED: 'media:remoteVideo:layoutChanged',
   // Controls
@@ -388,6 +400,8 @@ export const MEETING_REMOVED_REASON = {
   USER_ENDED_SHARE_STREAMS: 'USER_ENDED_SHARE_STREAMS', // user triggered stop share
   NO_MEETINGS_TO_SYNC: 'NO_MEETINGS_TO_SYNC', // After the syncMeeting no meeting exists
   MEETING_CONNECTION_FAILED: 'MEETING_CONNECTION_FAILED', // meeting failed to connect due to ice failures or firewall issue
+  LOCUS_DTO_SYNC_FAILED: 'LOCUS_DTO_SYNC_FAILED', // failed to get any Locus DTO for that meeting
+  MISSING_MEETING_INFO: 'MISSING_MEETING_INFO', // meeting info failed to be fetched
 };
 
 // One one one calls ends for the following reasons
@@ -484,6 +498,35 @@ export const ERROR_DICTIONARY = {
     MESSAGE: 'Edit lock token mismatch',
     CODE: 9,
   },
+  NO_MEETING_INFO: {
+    NAME: 'NoMeetingInfo',
+    MESSAGE: 'No meeting info found for the meeting',
+    CODE: 10,
+  },
+  RECLAIM_HOST_ROLE_NOT_SUPPORTED: {
+    NAME: 'ReclaimHostRoleNotSupported',
+    MESSAGE:
+      'Non converged meetings, PSTN or SIP users in converged meetings are not supported currently.',
+    CODE: 11,
+  },
+  RECLAIM_HOST_ROLE_NOT_ALLOWED: {
+    NAME: 'ReclaimHostRoleNotAllowed',
+    MESSAGE:
+      'Reclaim Host Role Not Allowed For Other Participants. Participants cannot claim host role in PMR meeting, space instant meeting or escalated instant meeting. However, the original host still can reclaim host role when it manually makes another participant to be the host.',
+    CODE: 12,
+  },
+  RECLAIM_HOST_ROLE_EMPTY_OR_WRONG_KEY: {
+    NAME: 'ReclaimHostRoleEmptyOrWrongKey',
+    MESSAGE:
+      'Host Key Not Specified Or Matched. The original host can reclaim the host role without entering the host key. However, any other person who claims the host role must enter the host key to get it.',
+    CODE: 13,
+  },
+  RECLAIM_HOST_ROLE_IS_ALREADY_HOST: {
+    NAME: 'ReclaimHostRoleIsAlreadyHost',
+    MESSAGE:
+      'Participant Having Host Role Already. Participant who sends request to reclaim host role has already a host role.',
+    CODE: 14,
+  },
 };
 
 export const FLOOR_ACTION = {
@@ -539,6 +582,8 @@ export const LOCUS = {
     INACTIVE: 'INACTIVE',
     ENDED: 'ENDED',
     INITIALIZING: 'INITIALIZING',
+    ACTIVE: 'ACTIVE',
+    TERMINATING: 'TERMINATING',
   },
   SEQUENCE: {
     UN_DEF: 'undef',
@@ -622,7 +667,6 @@ export const LOCUSINFO = {
     CONTROLS_MEETING_CONTAINER_UPDATED: 'CONTROLS_MEETING_CONTAINER_UPDATED',
     CONTROLS_MEETING_INTERPRETATION_UPDATED: 'CONTROLS_MEETING_INTERPRETATION_UPDATED',
     CONTROLS_ENTRY_EXIT_TONE_UPDATED: 'CONTROLS_ENTRY_EXIT_TONE_UPDATED',
-    CONTROLS_JOIN_BREAKOUT_FROM_MAIN: 'CONTROLS_JOIN_BREAKOUT_FROM_MAIN',
     CONTROLS_MUTE_ON_ENTRY_CHANGED: 'CONTROLS_MUTE_ON_ENTRY_CHANGED',
     CONTROLS_SHARE_CONTROL_CHANGED: 'CONTROLS_SHARE_CONTROL_CHANGED',
     CONTROLS_DISALLOW_UNMUTE_CHANGED: 'CONTROLS_DISALLOW_UNMUTE_CHANGED',
@@ -995,7 +1039,9 @@ export const RECONNECTION = {
     DEFAULT_TRY_COUNT: 0,
     DEFAULT_STATUS: '',
   },
-};
+} as const;
+
+export type RECONNECTION_STATE = Enum<typeof RECONNECTION.STATE>;
 
 export const RESOURCE = {
   CLUSTERS: 'clusters',
@@ -1031,7 +1077,9 @@ export const NETWORK_STATUS = {
   DISCONNECTED: 'DISCONNECTED',
   RECONNECTING: 'RECONNECTING',
   CONNECTED: 'CONNECTED',
-};
+} as const;
+
+export type NETWORK_STATUS = Enum<typeof NETWORK_STATUS>;
 
 export const NETWORK_TYPE = {
   VPN: 'vpn',
@@ -1190,7 +1238,7 @@ export const AVAILABLE_RESOLUTIONS = {
  *  mqa Interval for sending stats metrics
  */
 
-export const MQA_INTEVAL = 60000; // mqa analyzer interval its fixed to 60000
+export const MQA_INTERVAL = 60000; // mqa analyzer interval its fixed to 60000
 
 export const MEDIA_DEVICES = {
   MICROPHONE: 'microphone',
@@ -1247,4 +1295,21 @@ export const IP_VERSION = {
   ipv4_and_ipv6: 1,
 } as const;
 
-export type IP_VERSION = (typeof IP_VERSION)[keyof typeof IP_VERSION];
+export const LOCAL_SHARE_ERRORS = {
+  DEVICE_NOT_JOINED: 'Floor requested but device not yet joined',
+  UNDEFINED: 'undefined PUT',
+  NO_MEDIA_FOR_DEVICE: 'No media session found for device',
+  NO_CONFLUENCE_ID: 'Failed to request floor: 404 (null) could not find confluence id',
+  CONTENT_SHARING_DISABLED: 'Content share policies are disabled',
+  LOCUS_PARTICIPANT_DNE: 'does not exist in Locus',
+  CONTENT_REQUEST_WHILE_PENDING_WHITEBOARD:
+    'Content share request is not allowed while whiteboard floor request is pending',
+};
+export type IP_VERSION = Enum<typeof IP_VERSION>;
+
+// constant for if the permissionToken is about to expire in the next 30 seconds, refresh it
+export const MEETING_PERMISSION_TOKEN_REFRESH_THRESHOLD_IN_SEC = 30;
+export const MEETING_PERMISSION_TOKEN_REFRESH_REASON = 'ttl-join';
+
+// constant for named media group type
+export const NAMED_MEDIA_GROUP_TYPE_AUDIO = 1;

package/src/index.ts

@@ -3,9 +3,13 @@ import {registerPlugin} from '@webex/webex-core';
 
 import Meetings from './meetings';
 import config from './config';
+import {LocusRetryStatusInterceptor} from './interceptors';
 
 registerPlugin('meetings', Meetings, {
   config,
+  interceptors: {
+    LocusRetryStatusInterceptor: LocusRetryStatusInterceptor.create,
+  },
 });
 
 export {
@@ -15,6 +19,7 @@ export {
   LocalSystemAudioStream,
   LocalStreamEventNames,
   StreamEventNames,
+  RemoteStreamEventNames,
   type ServerMuteReason,
   LocalMicrophoneStreamEventNames,
   LocalCameraStreamEventNames,

package/src/interceptors/index.ts

@@ -0,0 +1,3 @@
+import LocusRetryStatusInterceptor from './locusRetry';
+
+export {LocusRetryStatusInterceptor};

package/src/interceptors/locusRetry.ts

@@ -0,0 +1,67 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+
+import {Interceptor} from '@webex/http-core';
+
+const rateLimitExpiryTime = new WeakMap();
+/**
+ * @class
+ */
+export default class LocusRetryStatusInterceptor extends Interceptor {
+  /**
+   * @returns {LocusRetryStatusInterceptor}
+   */
+  static create() {
+    // @ts-ignore
+    return new LocusRetryStatusInterceptor({webex: this});
+  }
+
+  /**
+   * Handle response errors
+   * @param {Object} options
+   * @param {WebexHttpError} reason
+   * @returns {Promise<WebexHttpError>}
+   */
+  onResponseError(options, reason) {
+    if ((reason.statusCode === 503 || reason.statusCode === 429) && options.uri.includes('locus')) {
+      const hasRetriedLocusRequest = rateLimitExpiryTime.get(this);
+      const retryAfterTime = options.headers['retry-after'] || 2000;
+
+      if (hasRetriedLocusRequest) {
+        rateLimitExpiryTime.set(this, false);
+
+        return Promise.reject(options);
+      }
+      rateLimitExpiryTime.set(this, true);
+
+      return this.handleRetryRequestLocusServiceError(options, retryAfterTime);
+    }
+
+    return Promise.reject(reason);
+  }
+
+  /**
+   * Handle retries for locus service unavailable errors
+   * @param {Object} options associated with the request
+   * @param {number} retryAfterTime retry after time in milliseconds
+   * @returns {Promise}
+   */
+  handleRetryRequestLocusServiceError(options, retryAfterTime) {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        clearTimeout(timeout);
+
+        // @ts-ignore
+        this.webex
+          .request({
+            method: options.method,
+            uri: options.uri,
+            body: options.body,
+          })
+          .then(resolve)
+          .catch(reject);
+      }, retryAfterTime);
+    });
+  }
+}

package/src/interpretation/index.ts

@@ -121,14 +121,31 @@ const SimultaneousInterpretation = WebexPlugin.extend({
    * Update self's interpretation information (self is interpreter)
    * @param {Object} interpretation
    * @param {String} selfParticipantId
-   * @returns {void}
+   * @returns {bool} is target language changed
    */
   updateSelfInterpretation({interpretation, selfParticipantId}) {
+    this.set('selfIsInterpreter', true);
+    const preTargetLanguage = this.targetLanguage;
     const {originalLanguage, sourceLanguage, order, isActive, targetLanguage, receiveLanguage} =
       interpretation || {};
     this.set({originalLanguage, sourceLanguage, order, isActive, targetLanguage, receiveLanguage});
     this.set('selfParticipantId', selfParticipantId);
+
+    return !!(targetLanguage && preTargetLanguage !== targetLanguage);
   },
+
+  /**
+   * Get the language code of the interpreter target language
+   * @returns {number}
+   */
+  getTargetLanguageCode() {
+    if (this.selfIsInterpreter) {
+      return this.siLanguages.get(this.targetLanguage)?.languageCode;
+    }
+
+    return 0;
+  },
+
   /**
    * query interpretation languages
    * @returns {Promise}

package/src/locus-info/index.ts

@@ -25,6 +25,8 @@ import ControlsUtils from './controlsUtils';
 import EmbeddedAppsUtils from './embeddedAppsUtils';
 import MediaSharesUtils from './mediaSharesUtils';
 import LocusDeltaParser from './parser';
+import Metrics from '../metrics';
+import BEHAVIORAL_METRICS from '../metrics/constants';
 
 /**
  * @description LocusInfo extends ChildEmitter to convert locusInfo info a private emitter to parent object
@@ -110,6 +112,37 @@ export default class LocusInfo extends EventsScope {
     // return value ignored on purpose
     meeting.meetingRequest
       .getLocusDTO({url})
+      .catch((e) => {
+        if (isDelta) {
+          LoggerProxy.logger.info(
+            'Locus-info:index#doLocusSync --> delta sync failed, falling back to full sync'
+          );
+
+          Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.LOCUS_DELTA_SYNC_FAILED, {
+            correlationId: meeting.correlationId,
+            url,
+            reason: e.message,
+            errorName: e.name,
+            stack: e.stack,
+            code: e.code,
+          });
+
+          isDelta = false;
+
+          return meeting.meetingRequest.getLocusDTO({url: meeting.locusUrl}).catch((err) => {
+            LoggerProxy.logger.info(
+              'Locus-info:index#doLocusSync --> fallback full sync failed, destroying the meeting'
+            );
+            this.webex.meetings.destroy(meeting, MEETING_REMOVED_REASON.LOCUS_DTO_SYNC_FAILED);
+            throw err;
+          });
+        }
+        LoggerProxy.logger.info(
+          'Locus-info:index#doLocusSync --> fallback full sync failed, destroying the meeting'
+        );
+        this.webex.meetings.destroy(meeting, MEETING_REMOVED_REASON.LOCUS_DTO_SYNC_FAILED);
+        throw e;
+      })
       .then((res) => {
         if (isDelta) {
           if (!isEmpty(res.body)) {
@@ -122,8 +155,6 @@ export default class LocusInfo extends EventsScope {
         } else {
           meeting.locusInfo.onFullLocus(res.body);
         }
-      })
-      .finally(() => {
         // Notify parser to resume processing delta events.
         // Any deltas in the queue that have now been superseded by this sync will simply be ignored
         this.locusParser.resume();
@@ -138,7 +169,7 @@ export default class LocusInfo extends EventsScope {
    * @returns {undefined}
    */
   applyLocusDeltaData(action: string, locus: any, meeting: any) {
-    const {DESYNC, USE_CURRENT, USE_INCOMING, WAIT} = LocusDeltaParser.loci;
+    const {DESYNC, USE_CURRENT, USE_INCOMING, WAIT, LOCUS_URL_CHANGED} = LocusDeltaParser.loci;
 
     switch (action) {
       case USE_INCOMING:
@@ -149,6 +180,7 @@ export default class LocusInfo extends EventsScope {
         // do nothing
         break;
       case DESYNC:
+      case LOCUS_URL_CHANGED:
         this.doLocusSync(meeting);
         break;
       default:
@@ -1137,7 +1169,10 @@ export default class LocusInfo extends EventsScope {
           file: 'locus-info',
           function: 'updateMeetingInfo',
         },
-        LOCUSINFO.EVENTS.MEETING_INFO_UPDATED
+        LOCUSINFO.EVENTS.MEETING_INFO_UPDATED,
+        {
+          isInitializing: !self, // if self is undefined, then the update is caused by locus init
+        }
       );
     }
     this.roles = roles;
@@ -1572,7 +1607,7 @@ export default class LocusInfo extends EventsScope {
 
   /**
    * if return from breakout to main session, need to use cached main session DTO since locus won't send the full locus (participants)
-   * if join breakout from main session, need to query main locus url (if response with 403 means no privilege, need to clear the cache)
+   * if join breakout from main session, main session is not active for the attendee and remove main session locus cache
    * @param {Object} newLocus
    * @returns {Object}
    * @memberof LocusInfo
@@ -1582,17 +1617,18 @@ export default class LocusInfo extends EventsScope {
     if (switchStatus.isReturnToMain && this.mainSessionLocusCache) {
       return cloneDeep(this.mainSessionLocusCache);
     }
-    if (switchStatus.isJoinToBreakout) {
-      this.emitScoped(
-        {
-          file: 'locus-info',
-          function: 'updateControls',
-        },
-        LOCUSINFO.EVENTS.CONTROLS_JOIN_BREAKOUT_FROM_MAIN,
-        {
-          mainLocusUrl: this.url,
-        }
-      );
+    const isMainSessionDTO =
+      this.mainSessionLocusCache && ControlsUtils.isMainSessionDTO(this.mainSessionLocusCache);
+
+    if (isMainSessionDTO) {
+      const isActive =
+        [LOCUS.STATE.ACTIVE, LOCUS.STATE.INITIALIZING, LOCUS.STATE.TERMINATING].includes(
+          this.fullState?.state
+        ) && !this.mainSessionLocusCache?.self?.removed;
+
+      if (!isActive) {
+        this.clearMainSessionLocusCache();
+      }
     }
 
     return newLocus;

package/src/locus-info/mediaSharesUtils.ts

@@ -16,6 +16,7 @@ MediaSharesUtils.parse = (mediaShares: object) => {
         annotation: MediaSharesUtils.getContentAnnotation(mediaShares),
         url: MediaSharesUtils.getContentUrl(mediaShares),
         shareInstanceId: MediaSharesUtils.getShareInstanceId(mediaShares),
+        deviceUrlSharing: MediaSharesUtils.getContentBeneficiaryDeviceUrl(mediaShares),
       },
       whiteboard: {
         beneficiaryId: MediaSharesUtils.getWhiteboardBeneficiaryId(mediaShares),
@@ -188,6 +189,21 @@ MediaSharesUtils.getShareInstanceId = (mediaShares: object) => {
   return extractContent.floor.shareInstanceId;
 };
 
+/**
+ * get deviceUrl that is requesting the floor for media shares (content)
+ * @param {Object} mediaShares
+ * @returns {Object}
+ */
+MediaSharesUtils.getContentBeneficiaryDeviceUrl = (mediaShares: object) => {
+  const contentFloor = MediaSharesUtils.extractContentFloor(mediaShares);
+
+  if (!contentFloor || !contentFloor.beneficiary || !contentFloor.beneficiary.deviceUrl) {
+    return null;
+  }
+
+  return contentFloor.beneficiary.deviceUrl;
+};
+
 /**
  * get who is sharing from media shares (whiteboard)
  * @param {Object} mediaShares

package/src/locus-info/parser.ts

@@ -3,11 +3,15 @@ import {difference} from 'lodash';
 import SortedQueue from '../common/queue';
 import LoggerProxy from '../common/logs/logger-proxy';
 
+import Metrics from '../metrics';
+import BEHAVIORAL_METRICS from '../metrics/constants';
+
 const MAX_OOO_DELTA_COUNT = 5; // when we receive an out-of-order delta and the queue builds up to MAX_OOO_DELTA_COUNT, we do a sync with Locus
 const OOO_DELTA_WAIT_TIME = 10000; // [ms] minimum wait time before we do a sync if we get out-of-order deltas
 const OOO_DELTA_WAIT_TIME_RANDOM_DELAY = 5000; // [ms] max random delay added to OOO_DELTA_WAIT_TIME
 
 type LocusDeltaDto = {
+  url: string;
   baseSequence: {
     rangeStart: number;
     rangeEnd: number;
@@ -44,11 +48,12 @@ export default class Parser {
     USE_CURRENT: 'USE_CURRENT',
     WAIT: 'WAIT',
     ERROR: 'ERROR',
+    LOCUS_URL_CHANGED: 'LOCUS_URL_CHANGED',
   };
 
   queue: SortedQueue<LocusDeltaDto>;
   workingCopy: any;
-  syncTimer: null | number | NodeJS.Timeout;
+  syncTimer?: ReturnType<typeof setTimeout>;
 
   /**
    * @constructs Parser
@@ -80,7 +85,7 @@ export default class Parser {
     this.status = 'IDLE';
     this.onDeltaAction = null;
     this.workingCopy = null;
-    this.syncTimer = null;
+    this.syncTimer = undefined;
   }
 
   /**
@@ -264,7 +269,7 @@ export default class Parser {
    * @returns {string} loci comparison state
    */
   private static compareDelta(current, incoming) {
-    const {LT, GT, EQ, DESYNC, USE_INCOMING, WAIT} = Parser.loci;
+    const {LT, GT, EQ, DESYNC, USE_INCOMING, WAIT, LOCUS_URL_CHANGED} = Parser.loci;
 
     const {extractComparisonState: extract} = Parser;
     const {packComparisonResult: pack} = Parser;
@@ -276,6 +281,13 @@ export default class Parser {
       return pack(Parser.compareToAction(comparison), result);
     }
 
+    if (incoming.url !== current.url) {
+      // when moving to/from a breakout session, the locus URL will change and also
+      // the baseSequence, making incoming and current incomparable, so use a
+      // unique comparison state
+      return pack(LOCUS_URL_CHANGED, result);
+    }
+
     comparison = Parser.compareSequence(current.sequence, incoming.baseSequence);
 
     switch (extract(comparison)) {
@@ -293,6 +305,10 @@ export default class Parser {
           // the incoming locus has baseSequence from the future, so it is out-of-order,
           // we are missing 1 or more locus that should be in front of it, we need to wait for it
           comparison = WAIT;
+
+          Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.LOCUS_DELTA_OUT_OF_ORDER, {
+            stack: new Error().stack,
+          });
         }
         break;
       default:
@@ -657,11 +673,11 @@ export default class Parser {
    * @returns {undefined}
    */
   private startSyncTimer() {
-    if (this.syncTimer === null) {
+    if (this.syncTimer === undefined) {
       const timeout = OOO_DELTA_WAIT_TIME + Math.random() * OOO_DELTA_WAIT_TIME_RANDOM_DELAY;
 
       this.syncTimer = setTimeout(() => {
-        this.syncTimer = null;
+        this.syncTimer = undefined;
         this.triggerSync('timer expired, blocked on out-of-order delta');
       }, timeout);
     }
@@ -673,9 +689,9 @@ export default class Parser {
    * @returns {undefined}
    */
   private stopSyncTimer() {
-    if (this.syncTimer !== null) {
+    if (this.syncTimer !== undefined) {
       clearTimeout(this.syncTimer);
-      this.syncTimer = null;
+      this.syncTimer = undefined;
     }
   }
 
@@ -686,7 +702,7 @@ export default class Parser {
    * @returns {undefined}
    */
   processDeltaEvent() {
-    const {DESYNC, USE_INCOMING, WAIT} = Parser.loci;
+    const {DESYNC, USE_INCOMING, WAIT, LOCUS_URL_CHANGED} = Parser.loci;
     const {extractComparisonState: extract} = Parser;
     const newLoci = this.queue.dequeue();
 
@@ -705,19 +721,29 @@ export default class Parser {
 
     let needToWait = false;
 
-    if (lociComparison === DESYNC) {
-      // wait for desync response
-      this.pause();
-    } else if (lociComparison === USE_INCOMING) {
-      // update working copy for future comparisons.
-      // Note: The working copy of parser gets updated in .onFullLocus()
-      // and here when USE_INCOMING locus.
-      this.workingCopy = newLoci;
-    } else if (lociComparison === WAIT) {
-      // we've taken newLoci from the front of the queue, so put it back there as we have to wait
-      // for the one that should be in front of it, before we can process it
-      this.queue.enqueue(newLoci);
-      needToWait = true;
+    switch (lociComparison) {
+      case DESYNC:
+        // wait for desync response
+        this.pause();
+        break;
+
+      case USE_INCOMING:
+      case LOCUS_URL_CHANGED:
+        // update working copy for future comparisons.
+        // Note: The working copy of parser gets updated in .onFullLocus()
+        // and here when USE_INCOMING or LOCUS_URL_CHANGED locus.
+        this.workingCopy = newLoci;
+        break;
+
+      case WAIT:
+        // we've taken newLoci from the front of the queue, so put it back there as we have to wait
+        // for the one that should be in front of it, before we can process it
+        this.queue.enqueue(newLoci);
+        needToWait = true;
+        break;
+
+      default:
+        break;
     }
 
     if (needToWait) {

package/src/media/index.ts

@@ -182,8 +182,10 @@ Media.createMediaConnection = (
     return new MultistreamRoapMediaConnection(
       config,
       meetingId,
+      /* the rtc metrics objects callbacks */
       (data) => rtcMetrics.addMetrics(data),
-      () => rtcMetrics.closeMetrics()
+      () => rtcMetrics.closeMetrics(),
+      () => rtcMetrics.sendMetricsInQueue()
     );
   }
 
@@ -215,10 +217,10 @@ Media.createMediaConnection = (
     {
       // TODO: RoapMediaConnection is not ready to use stream classes yet, so we pass the raw MediaStreamTrack for now SPARK-460530
       localTracks: {
-        audio: audioStream?.outputTrack,
-        video: videoStream?.outputTrack,
-        screenShareVideo: shareVideoStream?.outputTrack,
-        screenShareAudio: shareAudioStream?.outputTrack, // TODO: add type for screenShareAudio in internal-media-core SPARK-446923
+        audio: audioStream?.outputStream?.getTracks()[0],
+        video: videoStream?.outputStream?.getTracks()[0],
+        screenShareVideo: shareVideoStream?.outputStream?.getTracks()[0],
+        screenShareAudio: shareAudioStream?.outputStream?.getTracks()[0], // TODO: add type for screenShareAudio in internal-media-core SPARK-446923
       } as unknown,
       direction: {
         audio: Media.getDirection(true, mediaDirection.receiveAudio, mediaDirection.sendAudio),
@@ -397,7 +399,7 @@ Media.stopStream = (stream: LocalStream) => {
       stream.stop();
     } catch (e) {
       LoggerProxy.logger.error(
-        `Media:index#stopStream --> Unable to stop the stream with ready state of the output track => ${stream.outputTrack.readyState} & input track => ${stream.inputTrack.readyState}, error: ${e}`
+        `Media:index#stopStream --> Unable to stop the stream with ready state => ${stream.readyState}, error: ${e}`
       );
     }
   });

package/src/media/properties.ts

@@ -8,7 +8,7 @@ import {
   RemoteStream,
 } from '@webex/media-helpers';
 
-import {MEETINGS, PC_BAIL_TIMEOUT, QUALITY_LEVELS} from '../constants';
+import {MEETINGS, ICE_AND_DTLS_CONNECTION_TIMEOUT, QUALITY_LEVELS} from '../constants';
 import LoggerProxy from '../common/logs/logger-proxy';
 
 export type MediaDirection = {
@@ -200,7 +200,7 @@ export default class MediaProperties {
       timer = setTimeout(() => {
         this.webrtcMediaConnection.off(Event.CONNECTION_STATE_CHANGED, connectionStateListener);
         reject();
-      }, PC_BAIL_TIMEOUT);
+      }, ICE_AND_DTLS_CONNECTION_TIMEOUT);
 
       this.webrtcMediaConnection.on(Event.CONNECTION_STATE_CHANGED, connectionStateListener);
     });
@@ -259,10 +259,25 @@ export default class MediaProperties {
 
         return true;
       }
+      LoggerProxy.logger.warn(
+        `Media:properties#getCurrentConnectionType --> missing localCandidate.protocol, candidateType=${localCandidate.candidateType}`
+      );
 
       return false;
     });
 
+    if (foundConnectionType === 'unknown') {
+      const candidatePairStates = allStatsReports
+        .filter((report) => report.type === 'candidate-pair')
+        .map((report) => report.state);
+
+      LoggerProxy.logger.warn(
+        `Media:properties#getCurrentConnectionType --> all candidate pair states: ${JSON.stringify(
+          candidatePairStates
+        )}`
+      );
+    }
+
     return foundConnectionType;
   }
 }