@webex/plugin-meetings 3.0.0-stream-classes.5 → 3.0.0

package/src/meeting/index.ts

@@ -1,12 +1,14 @@
 import uuid from 'uuid';
 import {cloneDeep, isEqual, isEmpty} from 'lodash';
-import jwt from 'jsonwebtoken';
+import jwtDecode from 'jwt-decode';
 // @ts-ignore - Fix this
 import {StatelessWebexPlugin} from '@webex/webex-core';
+// @ts-ignore - Types not available for @webex/common
+import {Defer} from '@webex/common';
 import {
   ClientEvent,
   ClientEventLeaveReason,
-  CALL_DIAGNOSTIC_CONFIG,
+  CallDiagnosticUtils,
 } from '@webex/internal-plugin-metrics';
 import {
   ConnectionState,
@@ -16,6 +18,7 @@ import {
   MediaContent,
   MediaType,
   RemoteTrackType,
+  RoapMessage,
 } from '@webex/internal-media-core';
 
 import {
@@ -30,12 +33,20 @@ import {
   RemoteStream,
 } from '@webex/media-helpers';
 
+import {
+  EVENT_TRIGGERS as VOICEAEVENTS,
+  TURN_ON_CAPTION_STATUS,
+} from '@webex/internal-plugin-voicea';
+import {processNewCaptions} from './voicea-meeting';
+
 import {
   MeetingNotActiveError,
   UserInLobbyError,
   NoMediaEstablishedYetError,
   UserNotJoinedError,
+  AddMediaFailed,
 } from '../common/errors/webex-errors';
+
 import {StatsAnalyzer, EVENTS as StatsAnalyzerEvents} from '../statsAnalyzer';
 import NetworkQualityMonitor from '../networkQualityMonitor';
 import LoggerProxy from '../common/logs/logger-proxy';
@@ -51,19 +62,20 @@ import ReconnectionManager from '../reconnection-manager';
 import MeetingRequest from './request';
 import Members from '../members/index';
 import MeetingUtil from './util';
+import MeetingsUtil from '../meetings/util';
 import RecordingUtil from '../recording-controller/util';
 import ControlsOptionsUtil from '../controls-options-manager/util';
 import MediaUtil from '../media/util';
-import Transcription from '../transcription';
 import {Reactions, SkinTones} from '../reactions/reactions';
 import PasswordError from '../common/errors/password-error';
 import CaptchaError from '../common/errors/captcha-error';
 import ReconnectionError from '../common/errors/reconnection';
 import ReconnectInProgress from '../common/errors/reconnection-in-progress';
 import {
-  _CALL_,
+  _CONVERSATION_URL_,
   _INCOMING_,
   _JOIN_,
+  _MEETING_LINK_,
   AUDIO,
   CONTENT,
   DISPLAY_HINTS,
@@ -91,10 +103,14 @@ import {
   SHARE_STATUS,
   SHARE_STOPPED_REASON,
   VIDEO,
-  HTTP_VERBS,
   SELF_ROLES,
   INTERPRETATION,
   SELF_POLICY,
+  MEETING_PERMISSION_TOKEN_REFRESH_THRESHOLD_IN_SEC,
+  MEETING_PERMISSION_TOKEN_REFRESH_REASON,
+  ROAP_OFFER_ANSWER_EXCHANGE_TIMEOUT,
+  RECONNECTION,
+  LANGUAGE_ENGLISH,
 } from '../constants';
 import BEHAVIORAL_METRICS from '../metrics/constants';
 import ParameterError from '../common/errors/parameter';
@@ -122,6 +138,7 @@ import {
 import Breakouts from '../breakouts';
 import SimultaneousInterpretation from '../interpretation';
 import Annotation from '../annotation';
+import Webinar from '../webinar';
 
 import InMeetingActions from './in-meeting-actions';
 import {REACTION_RELAY_TYPES} from '../reactions/constants';
@@ -147,6 +164,36 @@ const logRequest = (request: any, {logText = ''}) => {
     });
 };
 
+export type CaptionData = {
+  id: string;
+  isFinal: boolean;
+  translations: Array<string>;
+  text: string;
+  currentCaptionLanguage: string;
+  timestamp: string;
+  speaker: string;
+};
+
+export type Transcription = {
+  languageOptions: {
+    captionLanguages?: string; // list of supported caption languages from backend
+    maxLanguages?: number;
+    spokenLanguages?: Array<string>; // list of supported spoken languages from backend
+    currentCaptionLanguage?: string; // current caption language - default is english
+    requestedCaptionLanguage?: string; // requested caption language
+    currentSpokenLanguage?: string; // current spoken language - default is english
+  };
+  status: string;
+  isListening: boolean;
+  commandText: string;
+  captions: Array<CaptionData>;
+  showCaptionBox: boolean;
+  transcribingRequestStatus: string;
+  isCaptioning: boolean;
+  speakerProxy: Map<string, any>;
+  interimCaptions: Map<string, CaptionData>;
+};
+
 export type LocalStreams = {
   microphone?: LocalMicrophoneStream;
   camera?: LocalCameraStream;
@@ -167,6 +214,12 @@ export type AddMediaOptions = {
   allowMediaInLobby?: boolean; // allows adding media when in the lobby
 };
 
+export type CallStateForMetrics = {
+  correlationId?: string;
+  joinTrigger?: string;
+  loginType?: string;
+};
+
 export const MEDIA_UPDATE_TYPE = {
   TRANSCODED_MEDIA_CONNECTION: 'TRANSCODED_MEDIA_CONNECTION',
   SHARE_FLOOR_REQUEST: 'SHARE_FLOOR_REQUEST',
@@ -179,6 +232,13 @@ export enum ScreenShareFloorStatus {
   RELEASED = 'floor_released',
 }
 
+type FetchMeetingInfoParams = {
+  password?: string;
+  captchaCode?: string;
+  extraParams?: Record<string, any>;
+  sendCAevents?: boolean;
+};
+
 /**
  * MediaDirection
  * @typedef {Object} MediaDirection
@@ -457,8 +517,9 @@ export default class Meeting extends StatelessWebexPlugin {
   breakouts: any;
   simultaneousInterpretation: any;
   annotation: any;
+  webinar: any;
   conversationUrl: string;
-  correlationId: string;
+  callStateForMetrics: CallStateForMetrics;
   destination: string;
   destinationType: string;
   deviceUrl: string;
@@ -514,8 +575,9 @@ export default class Meeting extends StatelessWebexPlugin {
 
   meetingInfoFailureReason: string;
   meetingInfoFailureCode?: number;
+  meetingInfoExtraParams?: Record<string, any>;
   networkQualityMonitor: NetworkQualityMonitor;
-  networkStatus: string;
+  networkStatus?: NETWORK_STATUS;
   passwordStatus: string;
   queuedMediaUpdates: any[];
   recording: any;
@@ -525,6 +587,7 @@ export default class Meeting extends StatelessWebexPlugin {
   requiredCaptcha: any;
   receiveSlotManager: ReceiveSlotManager;
   selfUserPolicies: any;
+  enforceVBGImagesURL: string;
   shareStatus: string;
   screenShareFloorState: ScreenShareFloorStatus;
   statsAnalyzer: StatsAnalyzer;
@@ -546,6 +609,7 @@ export default class Meeting extends StatelessWebexPlugin {
   meetingState: any;
   permissionToken: string;
   permissionTokenPayload: any;
+  permissionTokenReceivedLocalTime: number;
   resourceId: any;
   resourceUrl: string;
   selfId: string;
@@ -557,7 +621,55 @@ export default class Meeting extends StatelessWebexPlugin {
   environment: string;
   namespace = MEETINGS;
   allowMediaInLobby: boolean;
+  localShareInstanceId: string;
+  remoteShareInstanceId: string;
+  turnDiscoverySkippedReason: string;
+  turnServerUsed: boolean;
+  areVoiceaEventsSetup = false;
+  voiceaListenerCallbacks: object = {
+    [VOICEAEVENTS.VOICEA_ANNOUNCEMENT]: (payload: Transcription['languageOptions']) => {
+      this.transcription.languageOptions = payload;
+      Trigger.trigger(
+        this,
+        {
+          file: 'meeting/index',
+          function: 'setUpVoiceaListeners',
+        },
+        EVENT_TRIGGERS.MEETING_STARTED_RECEIVING_TRANSCRIPTION,
+        payload
+      );
+    },
+    [VOICEAEVENTS.CAPTIONS_TURNED_ON]: () => {
+      this.transcription.status = TURN_ON_CAPTION_STATUS.ENABLED;
+    },
+    [VOICEAEVENTS.EVA_COMMAND]: (payload) => {
+      const {data} = payload;
+
+      this.transcription.isListening = !!data.isListening;
+      this.transcription.commandText = data.text ?? '';
+    },
+    [VOICEAEVENTS.NEW_CAPTION]: (data) => {
+      processNewCaptions({data, meeting: this});
+      Trigger.trigger(
+        this,
+        {
+          file: 'meeting/index',
+          function: 'setUpVoiceaListeners',
+        },
+        EVENT_TRIGGERS.MEETING_CAPTION_RECEIVED,
+        {
+          captions: this.transcription.captions,
+          interimCaptions: this.transcription.interimCaptions,
+        }
+      );
+    },
+  };
+
+  private retriedWithTurnServer: boolean;
   private sendSlotManager: SendSlotManager = new SendSlotManager(LoggerProxy);
+  private deferSDPAnswer?: Defer; // used for waiting for a response
+  private sdpResponseTimer?: ReturnType<typeof setTimeout>;
+  private hasMediaConnectionConnectedAtLeastOnce: boolean;
 
   /**
    * @param {Object} attrs
@@ -592,20 +704,22 @@ export default class Meeting extends StatelessWebexPlugin {
      */
     this.id = uuid.v4();
     /**
-     * Correlation ID used for network tracking of meeting
+     * Call state used for metrics
      * @instance
-     * @type {String}
+     * @type {CallStateForMetrics}
      * @readonly
      * @public
      * @memberof Meeting
      */
-    if (attrs.correlationId) {
+    this.callStateForMetrics = attrs.callStateForMetrics || {};
+    const correlationId = attrs.correlationId || attrs.callStateForMetrics?.correlationId;
+    if (correlationId) {
       LoggerProxy.logger.log(
-        `Meetings:index#constructor --> Initializing the meeting object with correlation id from app ${this.correlationId}`
+        `Meetings:index#constructor --> Initializing the meeting object with correlation id from app ${correlationId}`
       );
-      this.correlationId = attrs.correlationId;
+      this.callStateForMetrics.correlationId = correlationId;
     } else {
-      this.correlationId = this.id;
+      this.callStateForMetrics.correlationId = this.id;
     }
     /**
      * @instance
@@ -673,6 +787,14 @@ export default class Meeting extends StatelessWebexPlugin {
      */
     // @ts-ignore
     this.annotation = new Annotation({parent: this.webex});
+    /**
+     * @instance
+     * @type {Webinar}
+     * @public
+     * @memberof Meeting
+     */
+    // @ts-ignore
+    this.webinar = new Webinar({}, {parent: this.webex});
     /**
      * helper class for managing receive slots (for multistream media connections)
      */
@@ -1069,13 +1191,14 @@ export default class Meeting extends StatelessWebexPlugin {
      */
     this.networkQualityMonitor = null;
     /**
+     * Indicates network status of the webrtc media connection
      * @instance
      * @type {String}
      * @readonly
      * @public
      * @memberof Meeting
      */
-    this.networkStatus = null;
+    this.networkStatus = undefined;
     /**
      * Passing only info as we send basic info for meeting added event
      * @instance
@@ -1140,7 +1263,17 @@ export default class Meeting extends StatelessWebexPlugin {
      * @private
      * @memberof Meeting
      */
-    this.transcription = undefined;
+    this.transcription = {
+      captions: [],
+      isListening: false,
+      commandText: '',
+      languageOptions: {},
+      showCaptionBox: false,
+      transcribingRequestStatus: 'INACTIVE',
+      isCaptioning: false,
+      interimCaptions: {} as Map<string, CaptionData>,
+      speakerProxy: {} as Map<string, any>,
+    } as Transcription;
 
     /**
      * Password status. If it's PASSWORD_STATUS.REQUIRED then verifyPassword() needs to be called
@@ -1194,6 +1327,24 @@ export default class Meeting extends StatelessWebexPlugin {
      */
     this.keepAliveTimerId = null;
 
+    /**
+     * id for tracking Local Share instances in Call Analyzer
+     * @instance
+     * @type {String}
+     * @private
+     * @memberof Meeting
+     */
+    this.localShareInstanceId = null;
+
+    /**
+     * id for tracking Remote Share instances in Call Analyzer
+     * @instance
+     * @type {String}
+     * @private
+     * @memberof Meeting
+     */
+    this.remoteShareInstanceId = null;
+
     /**
      * The class that helps to control recording functions: start, stop, pause, resume, etc
      * @instance
@@ -1246,6 +1397,60 @@ export default class Meeting extends StatelessWebexPlugin {
         this.updateTranscodedMediaConnection();
       }
     };
+
+    /**
+     * Promise that exists if SDP offer has been generated, and resolves once sdp answer is received.
+     * @instance
+     * @type {Defer}
+     * @private
+     * @memberof Meeting
+     */
+    this.deferSDPAnswer = undefined;
+
+    /**
+     * Timer for waiting for sdp answer.
+     * @instance
+     * @type {ReturnType<typeof setTimeout>}
+     * @private
+     * @memberof Meeting
+     */
+    this.sdpResponseTimer = undefined;
+
+    /**
+     * Reason why TURN discovery is skipped.
+     * @instance
+     * @type {string}
+     * @public
+     * @memberof Meeting
+     */
+    this.turnDiscoverySkippedReason = undefined;
+
+    /**
+     * Whether TURN discovery is used or not.
+     * @instance
+     * @type {boolean}
+     * @public
+     * @memberof Meeting
+     */
+    this.turnServerUsed = false;
+
+    /**
+     * Whether retry was done using TURN Discovery.
+     * @instance
+     * @type {boolean}
+     * @private
+     * @memberof Meeting
+     */
+    this.retriedWithTurnServer = false;
+
+    /**
+     * Whether or not the media connection has ever successfully connected.
+     * @instance
+     * @type {boolean}
+     * @private
+     * @memberof Meeting
+     */
+    this.hasMediaConnectionConnectedAtLeastOnce = false;
   }
 
   /**
@@ -1279,23 +1484,87 @@ export default class Meeting extends StatelessWebexPlugin {
   }
 
   /**
-   * Fetches meeting information.
-   * @param {Object} options
-   * @param {String} [options.password] optional
-   * @param {String} [options.captchaCode] optional
-   * @public
-   * @memberof Meeting
-   * @returns {Promise}
+   * Getter - Returns callStateForMetrics.correlationId
+   * @returns {string}
    */
-  public async fetchMeetingInfo({
-    password = null,
-    captchaCode = null,
-    extraParams = {},
-  }: {
-    password?: string;
-    captchaCode?: string;
-    extraParams?: Record<string, any>;
-  }) {
+  get correlationId() {
+    return this.callStateForMetrics.correlationId;
+  }
+
+  /**
+   * Setter - sets callStateForMetrics.correlationId
+   * @param {string} correlationId
+   */
+  set correlationId(correlationId: string) {
+    this.callStateForMetrics.correlationId = correlationId;
+  }
+
+  /**
+   * Set meeting info and trigger `MEETING_INFO_AVAILABLE` event
+   * @param {any} info
+   * @param {string} [meetingLookupUrl] Lookup url, defined when the meeting info fetched
+   * @returns {void}
+   */
+  private setMeetingInfo(info, meetingLookupUrl) {
+    this.meetingInfo = info ? {...info, meetingLookupUrl} : null;
+    this.meetingInfoFailureReason = MEETING_INFO_FAILURE_REASON.NONE;
+
+    this.requiredCaptcha = null;
+    if (
+      this.passwordStatus === PASSWORD_STATUS.REQUIRED ||
+      this.passwordStatus === PASSWORD_STATUS.VERIFIED
+    ) {
+      this.passwordStatus = PASSWORD_STATUS.VERIFIED;
+    } else {
+      this.passwordStatus = PASSWORD_STATUS.NOT_REQUIRED;
+    }
+
+    Trigger.trigger(
+      this,
+      {
+        file: 'meetings',
+        function: 'fetchMeetingInfo',
+      },
+      EVENT_TRIGGERS.MEETING_INFO_AVAILABLE
+    );
+
+    this.updateMeetingActions();
+  }
+
+  /**
+   * Add pre-fetched meeting info
+   *
+   * The passed meeting info should be be complete, e.g.: fetched after password or captcha provided
+   *
+   * @param {Object} meetingInfo - Complete meeting info
+   * @param {FetchMeetingInfoParams} fetchParams - Fetch parameters for validation
+   * @param {String|undefined} meetingLookupUrl - Lookup url, defined when the meeting info fetched
+   * @returns {Promise<void>}
+   */
+  public async injectMeetingInfo(
+    meetingInfo: any,
+    fetchParams: FetchMeetingInfoParams,
+    meetingLookupUrl: string | undefined
+  ): Promise<void> {
+    await this.prepForFetchMeetingInfo(fetchParams, 'injectMeetingInfo');
+
+    this.parseMeetingInfo(meetingInfo, this.destination);
+    this.setMeetingInfo(meetingInfo, meetingLookupUrl);
+  }
+
+  /**
+   * Validate fetch parameters and clear the fetchMeetingInfoTimeout timeout
+   *
+   * @param {FetchMeetingInfoParams} fetchParams - fetch parameters for validation
+   * @param {String} caller - Name of the caller for logging
+   *
+   * @returns {Promise<void>}
+   * @private
+   */
+  private prepForFetchMeetingInfo(
+    {password = null, captchaCode = null, extraParams = {}}: FetchMeetingInfoParams,
+    caller: string
+  ): Promise<void> {
     // when fetch meeting info is called directly by the client, we want to clear out the random timer for sdk to do it
     if (this.fetchMeetingInfoTimeoutId) {
       clearTimeout(this.fetchMeetingInfoTimeoutId);
@@ -1303,7 +1572,7 @@ export default class Meeting extends StatelessWebexPlugin {
     }
     if (captchaCode && !this.requiredCaptcha) {
       return Promise.reject(
-        new Error('fetchMeetingInfo() called with captchaCode when captcha was not required')
+        new Error(`${caller}() called with captchaCode when captcha was not required`)
       );
     }
     if (
@@ -1312,50 +1581,47 @@ export default class Meeting extends StatelessWebexPlugin {
       this.passwordStatus !== PASSWORD_STATUS.UNKNOWN
     ) {
       return Promise.reject(
-        new Error('fetchMeetingInfo() called with password when password was not required')
+        new Error(`${caller}() called with password when password was not required`)
       );
     }
 
+    this.meetingInfoExtraParams = cloneDeep(extraParams);
+
+    return Promise.resolve();
+  }
+
+  /**
+   * Internal method for fetching meeting info
+   *
+   * @returns {Promise}
+   */
+  private async fetchMeetingInfoInternal({
+    destination,
+    destinationType,
+    password = null,
+    captchaCode = null,
+    extraParams = {},
+    sendCAevents = false,
+  }): Promise<void> {
     try {
       const captchaInfo = captchaCode
         ? {code: captchaCode, id: this.requiredCaptcha.captchaId}
         : null;
 
       const info = await this.attrs.meetingInfoProvider.fetchMeetingInfo(
-        this.destination,
-        this.destinationType,
+        destination,
+        destinationType,
         password,
         captchaInfo,
         // @ts-ignore - config coming from registerPlugin
         this.config.installedOrgID,
         this.locusId,
         extraParams,
-        {meetingId: this.id}
-      );
-
-      this.parseMeetingInfo(info, this.destination);
-      this.meetingInfo = info ? {...info.body, meetingLookupUrl: info?.url} : null;
-      this.meetingInfoFailureReason = MEETING_INFO_FAILURE_REASON.NONE;
-      this.requiredCaptcha = null;
-      if (
-        this.passwordStatus === PASSWORD_STATUS.REQUIRED ||
-        this.passwordStatus === PASSWORD_STATUS.VERIFIED
-      ) {
-        this.passwordStatus = PASSWORD_STATUS.VERIFIED;
-      } else {
-        this.passwordStatus = PASSWORD_STATUS.NOT_REQUIRED;
-      }
-
-      Trigger.trigger(
-        this,
-        {
-          file: 'meetings',
-          function: 'fetchMeetingInfo',
-        },
-        EVENT_TRIGGERS.MEETING_INFO_AVAILABLE
+        {meetingId: this.id, sendCAevents}
       );
 
-      this.updateMeetingActions();
+      this.parseMeetingInfo(info?.body, this.destination, info?.errors);
+      this.setMeetingInfo(info?.body, info?.url);
 
       return Promise.resolve();
     } catch (err) {
@@ -1417,19 +1683,113 @@ export default class Meeting extends StatelessWebexPlugin {
     }
   }
 
+  /**
+   * Refreshes the meeting info permission token (it's required for joining meetings)
+   *
+   * @param {string} [reason] used for metrics and logging purposes (optional)
+   * @returns {Promise}
+   */
+  public async refreshPermissionToken(reason?: string): Promise<void> {
+    if (!this.meetingInfo?.permissionToken) {
+      LoggerProxy.logger.info(
+        `Meeting:index#refreshPermissionToken --> cannot refresh the permission token, because we don't have it (reason=${reason})`
+      );
+
+      return;
+    }
+
+    const isStartingSpaceInstantV2Meeting =
+      this.destinationType === _CONVERSATION_URL_ &&
+      // @ts-ignore - config coming from registerPlugin
+      this.config.experimental.enableAdhocMeetings &&
+      // @ts-ignore
+      this.webex.meetings.preferredWebexSite;
+
+    const destination = isStartingSpaceInstantV2Meeting
+      ? this.meetingInfo.meetingJoinUrl
+      : this.destination;
+    const destinationType = isStartingSpaceInstantV2Meeting ? _MEETING_LINK_ : this.destinationType;
+
+    const permissionTokenExpiryInfo = this.getPermissionTokenExpiryInfo();
+
+    const timeLeft = permissionTokenExpiryInfo?.timeLeft;
+    const expiryTime = permissionTokenExpiryInfo?.expiryTime;
+    const currentTime = permissionTokenExpiryInfo?.currentTime;
+
+    LoggerProxy.logger.info(
+      `Meeting:index#refreshPermissionToken --> refreshing permission token, destinationType=${destinationType}, timeLeft=${timeLeft}, permissionTokenExpiry=${expiryTime}, currentTimestamp=${currentTime},reason=${reason}`
+    );
+
+    Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.PERMISSION_TOKEN_REFRESH, {
+      correlationId: this.correlationId,
+      timeLeft,
+      expiryTime,
+      currentTime,
+      reason,
+      destinationType,
+    });
+
+    try {
+      await this.fetchMeetingInfoInternal({
+        destination,
+        destinationType,
+        extraParams: {
+          ...this.meetingInfoExtraParams,
+          permissionToken: this.meetingInfo.permissionToken,
+        },
+        sendCAevents: true, // because if we're refreshing the permissionToken, it means that user is intending to join that meeting, so we want CA events
+      });
+    } catch (error) {
+      LoggerProxy.logger.info(
+        'Meeting:index#refreshPermissionToken --> failed to refresh the permission token:',
+        error
+      );
+
+      Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.PERMISSION_TOKEN_REFRESH_ERROR, {
+        correlationId: this.correlationId,
+        reason: error.message,
+        stack: error.stack,
+      });
+
+      throw error;
+    }
+  }
+
+  /**
+   * Fetches meeting information.
+   * @param {Object} options
+   * @param {String} [options.password] optional
+   * @param {String} [options.captchaCode] optional
+   * @param {Boolean} [options.sendCAevents] optional - Whether to submit Call Analyzer events or not. Default: false.
+   * @public
+   * @memberof Meeting
+   * @returns {Promise}
+   */
+  public async fetchMeetingInfo(options: FetchMeetingInfoParams) {
+    await this.prepForFetchMeetingInfo(options, 'fetchMeetingInfo');
+
+    return this.fetchMeetingInfoInternal({
+      destination: this.destination,
+      destinationType: this.destinationType,
+      ...options,
+    });
+  }
+
   /**
    * Checks if the supplied password/host key is correct. It returns a promise with information whether the
    * password and captcha code were correct or not.
    * @param {String} password - this can be either a password or a host key, can be undefined if only captcha was required
    * @param {String} captchaCode - can be undefined if captcha was not required by the server
+   * @param {Boolean} sendCAevents - whether Call Analyzer events should be sent when fetching meeting information
    * @public
    * @memberof Meeting
    * @returns {Promise<{isPasswordValid: boolean, requiredCaptcha: boolean, failureReason: MEETING_INFO_FAILURE_REASON}>}
    */
-  public verifyPassword(password: string, captchaCode: string) {
+  public verifyPassword(password: string, captchaCode: string, sendCAevents = false) {
     return this.fetchMeetingInfo({
       password,
       captchaCode,
+      sendCAevents,
     })
       .then(() => {
         Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.VERIFY_PASSWORD_SUCCESS);
@@ -1629,6 +1989,7 @@ export default class Meeting extends StatelessWebexPlugin {
    * @memberof Meeting
    */
   private setUpInterpretationListener() {
+    // TODO: check if its getting used or not
     this.simultaneousInterpretation.on(INTERPRETATION.EVENTS.SUPPORT_LANGUAGES_UPDATE, () => {
       Trigger.trigger(
         this,
@@ -1639,7 +2000,7 @@ export default class Meeting extends StatelessWebexPlugin {
         EVENT_TRIGGERS.MEETING_INTERPRETATION_SUPPORT_LANGUAGES_UPDATE
       );
     });
-
+    // TODO: check if its getting used or not
     this.simultaneousInterpretation.on(
       INTERPRETATION.EVENTS.HANDOFF_REQUESTS_ARRIVED,
       (payload) => {
@@ -1656,6 +2017,43 @@ export default class Meeting extends StatelessWebexPlugin {
     );
   }
 
+  /**
+   * Set up the listeners for captions
+   * @returns {undefined}
+   * @private
+   * @memberof Meeting
+   */
+  private setUpVoiceaListeners() {
+    // @ts-ignore
+    this.webex.internal.voicea.listenToEvents();
+
+    // @ts-ignore
+    this.webex.internal.voicea.on(
+      VOICEAEVENTS.VOICEA_ANNOUNCEMENT,
+      this.voiceaListenerCallbacks[VOICEAEVENTS.VOICEA_ANNOUNCEMENT]
+    );
+
+    // @ts-ignore
+    this.webex.internal.voicea.on(
+      VOICEAEVENTS.CAPTIONS_TURNED_ON,
+      this.voiceaListenerCallbacks[VOICEAEVENTS.CAPTIONS_TURNED_ON]
+    );
+
+    // @ts-ignore
+    this.webex.internal.voicea.on(
+      VOICEAEVENTS.EVA_COMMAND,
+      this.voiceaListenerCallbacks[VOICEAEVENTS.EVA_COMMAND]
+    );
+
+    // @ts-ignore
+    this.webex.internal.voicea.on(
+      VOICEAEVENTS.NEW_CAPTION,
+      this.voiceaListenerCallbacks[VOICEAEVENTS.NEW_CAPTION]
+    );
+
+    this.areVoiceaEventsSetup = true;
+  }
+
   /**
    * Set up the locus info listener for meetings disconnected due to inactivity
    * @returns {undefined}
@@ -1760,12 +2158,12 @@ export default class Meeting extends StatelessWebexPlugin {
 
   /**
    * sets the network status on meeting object
-   * @param {String} networkStatus
+   * @param {NETWORK_STATUS} networkStatus
    * @private
    * @returns {undefined}
    * @memberof Meeting
    */
-  private setNetworkStatus(networkStatus: string) {
+  private setNetworkStatus(networkStatus?: NETWORK_STATUS) {
     if (networkStatus === NETWORK_STATUS.DISCONNECTED) {
       Trigger.trigger(
         this,
@@ -1945,7 +2343,6 @@ export default class Meeting extends StatelessWebexPlugin {
           modifiedBy,
           lastModified,
         };
-
         Trigger.trigger(
           this,
           {
@@ -1976,19 +2373,22 @@ export default class Meeting extends StatelessWebexPlugin {
     this.locusInfo.on(
       LOCUSINFO.EVENTS.CONTROLS_MEETING_TRANSCRIBE_UPDATED,
       ({caption, transcribing}) => {
-        // @ts-ignore - config coming from registerPlugin
-        if (transcribing && this.transcription && this.config.receiveTranscription) {
-          this.receiveTranscription();
-        } else if (!transcribing && this.transcription) {
-          Trigger.trigger(
-            this,
-            {
-              file: 'meeting/index',
-              function: 'setupLocusControlsListener',
-            },
-            EVENT_TRIGGERS.MEETING_STOPPED_RECEIVING_TRANSCRIPTION,
-            {caption, transcribing}
-          );
+        // user need to be joined to start the llm and receive transcription
+        if (this.isJoined()) {
+          // @ts-ignore - config coming from registerPlugin
+          if (transcribing && !this.transcription) {
+            this.startTranscription();
+          } else if (!transcribing && this.transcription) {
+            Trigger.trigger(
+              this,
+              {
+                file: 'meeting/index',
+                function: 'setupLocusControlsListener',
+              },
+              EVENT_TRIGGERS.MEETING_STOPPED_RECEIVING_TRANSCRIPTION,
+              {caption, transcribing}
+            );
+          }
         }
       }
     );
@@ -2020,16 +2420,6 @@ export default class Meeting extends StatelessWebexPlugin {
       }
     );
 
-    this.locusInfo.on(LOCUSINFO.EVENTS.CONTROLS_JOIN_BREAKOUT_FROM_MAIN, ({mainLocusUrl}) => {
-      this.meetingRequest.getLocusStatusByUrl(mainLocusUrl).catch((error) => {
-        // clear main session cache when attendee join into breakout and forbidden to get locus from main locus url,
-        // which means main session is not active for the attendee
-        if (error?.statusCode === 403) {
-          this.locusInfo.clearMainSessionLocusCache();
-        }
-      });
-    });
-
     this.locusInfo.on(LOCUSINFO.EVENTS.CONTROLS_ENTRY_EXIT_TONE_UPDATED, ({entryExitTone}) => {
       Trigger.trigger(
         this,
@@ -2153,6 +2543,7 @@ export default class Meeting extends StatelessWebexPlugin {
       if (
         contentShare.beneficiaryId === previousContentShare?.beneficiaryId &&
         contentShare.disposition === previousContentShare?.disposition &&
+        contentShare.deviceUrlSharing === previousContentShare.deviceUrlSharing &&
         whiteboardShare.beneficiaryId === previousWhiteboardShare?.beneficiaryId &&
         whiteboardShare.disposition === previousWhiteboardShare?.disposition &&
         whiteboardShare.resourceUrl === previousWhiteboardShare?.resourceUrl
@@ -2175,11 +2566,21 @@ export default class Meeting extends StatelessWebexPlugin {
       // LOCAL - check if we started sharing content
       else if (
         this.selfId === contentShare.beneficiaryId &&
-        contentShare.disposition === FLOOR_ACTION.GRANTED
+        contentShare.disposition === FLOOR_ACTION.GRANTED &&
+        contentShare.deviceUrlSharing === this.deviceUrl
       ) {
         // CONTENT - sharing content local
         newShareStatus = SHARE_STATUS.LOCAL_SHARE_ACTIVE;
       }
+      // SAME USER REMOTE - check if same user started sharing content from another client
+      else if (
+        this.selfId === contentShare.beneficiaryId &&
+        contentShare.disposition === FLOOR_ACTION.GRANTED &&
+        contentShare.deviceUrlSharing !== this.deviceUrl
+      ) {
+        // CONTENT - same user sharing content remote
+        newShareStatus = SHARE_STATUS.REMOTE_SHARE_ACTIVE;
+      }
       // If we did not hit the cases above, no one is sharng content, so we check if we are sharing whiteboard
       // There is no concept of local/remote share for whiteboard
       // It does not matter who requested to share the whiteboard, everyone gets the same view
@@ -2253,6 +2654,8 @@ export default class Meeting extends StatelessWebexPlugin {
         switch (newShareStatus) {
           case SHARE_STATUS.REMOTE_SHARE_ACTIVE: {
             const sendStartedSharingRemote = () => {
+              this.remoteShareInstanceId = contentShare.shareInstanceId;
+
               Trigger.trigger(
                 this,
                 {
@@ -2263,7 +2666,7 @@ export default class Meeting extends StatelessWebexPlugin {
                 {
                   memberId: contentShare.beneficiaryId,
                   url: contentShare.url,
-                  shareInstanceId: contentShare.shareInstanceId,
+                  shareInstanceId: this.remoteShareInstanceId,
                   annotationInfo: contentShare.annotation,
                 }
               );
@@ -2300,6 +2703,7 @@ export default class Meeting extends StatelessWebexPlugin {
               name: 'client.share.floor-granted.local',
               payload: {
                 mediaType: 'share',
+                shareInstanceId: this.localShareInstanceId,
               },
               options: {meetingId: this.id},
             });
@@ -2342,6 +2746,8 @@ export default class Meeting extends StatelessWebexPlugin {
       } else if (newShareStatus === SHARE_STATUS.REMOTE_SHARE_ACTIVE) {
         // if we got here, then some remote participant has stolen
         // the presentation from another remote participant
+        this.remoteShareInstanceId = contentShare.shareInstanceId;
+
         Trigger.trigger(
           this,
           {
@@ -2352,7 +2758,7 @@ export default class Meeting extends StatelessWebexPlugin {
           {
             memberId: contentShare.beneficiaryId,
             url: contentShare.url,
-            shareInstanceId: contentShare.shareInstanceId,
+            shareInstanceId: this.remoteShareInstanceId,
             annotationInfo: contentShare.annotation,
           }
         );
@@ -2404,6 +2810,7 @@ export default class Meeting extends StatelessWebexPlugin {
       this.locusId = this.locusUrl?.split('/').pop();
       this.recordingController.setLocusUrl(this.locusUrl);
       this.controlsOptionsManager.setLocusUrl(this.locusUrl);
+      this.webinar.locusUrlUpdate(payload);
 
       Trigger.trigger(
         this,
@@ -2433,6 +2840,10 @@ export default class Meeting extends StatelessWebexPlugin {
       this.breakouts.breakoutServiceUrlUpdate(payload?.services?.breakout?.url);
       this.annotation.approvalUrlUpdate(payload?.services?.approval?.url);
       this.simultaneousInterpretation.approvalUrlUpdate(payload?.services?.approval?.url);
+      this.webinar.webcastUrlUpdate(payload?.services?.webcast?.url);
+      this.webinar.webinarAttendeesSearchingUrlUpdate(
+        payload?.services?.webinarAttendeesSearching?.url
+      );
     });
   }
 
@@ -2473,12 +2884,24 @@ export default class Meeting extends StatelessWebexPlugin {
         );
       }
     });
-    this.locusInfo.on(LOCUSINFO.EVENTS.MEETING_INFO_UPDATED, () => {
+    this.locusInfo.on(LOCUSINFO.EVENTS.MEETING_INFO_UPDATED, ({isInitializing}) => {
       this.updateMeetingActions();
       this.recordingController.setDisplayHints(this.userDisplayHints);
       this.recordingController.setUserPolicy(this.selfUserPolicies);
       this.controlsOptionsManager.setDisplayHints(this.userDisplayHints);
       this.handleDataChannelUrlChange(this.datachannelUrl);
+
+      if (!isInitializing) {
+        // send updated trigger only if locus is not initializing the meeting
+        Trigger.trigger(
+          this,
+          {
+            file: 'meetings',
+            function: 'setUpLocusInfoMeetingInfoListener',
+          },
+          EVENT_TRIGGERS.MEETING_INFO_UPDATED
+        );
+      }
     });
   }
 
@@ -2624,7 +3047,7 @@ export default class Meeting extends StatelessWebexPlugin {
         });
       }
     });
-    this.locusInfo.on(LOCUSINFO.EVENTS.SELF_ADMITTED_GUEST, (payload) => {
+    this.locusInfo.on(LOCUSINFO.EVENTS.SELF_ADMITTED_GUEST, async (payload) => {
       this.stopKeepAlive();
 
       if (payload) {
@@ -2723,6 +3146,7 @@ export default class Meeting extends StatelessWebexPlugin {
       this.simultaneousInterpretation.updateCanManageInterpreters(
         payload.newRoles?.includes(SELF_ROLES.MODERATOR)
       );
+      this.webinar.updateCanManageWebcast(payload.newRoles?.includes(SELF_ROLES.MODERATOR));
       Trigger.trigger(
         this,
         {
@@ -2964,30 +3388,40 @@ export default class Meeting extends StatelessWebexPlugin {
   /**
    * Sets the meeting info on the class instance
    * @param {Object} meetingInfo
-   * @param {Object} meetingInfo.body
-   * @param {String} meetingInfo.body.conversationUrl
-   * @param {String} meetingInfo.body.locusUrl
-   * @param {String} meetingInfo.body.sipUri
-   * @param {Object} meetingInfo.body.owner
+   * @param {String} meetingInfo.conversationUrl
+   * @param {String} meetingInfo.locusUrl
+   * @param {String} meetingInfo.sipUri
+   * @param {String} [meetingInfo.sipUrl]
+   * @param {String} [meetingInfo.sipMeetingUri]
+   * @param {String} [meetingInfo.meetingNumber]
+   * @param {String} [meetingInfo.meetingJoinUrl]
+   * @param {String} [meetingInfo.hostId]
+   * @param {String} [meetingInfo.permissionToken]
+   * @param {String} [meetingInfo.channel]
+   * @param {Object} meetingInfo.owner
    * @param {Object | String} destination locus object with meeting data or destination string (sip url, meeting link, etc)
+   * @param {Object | String} errors Meeting info request error
    * @returns {undefined}
    * @private
    * @memberof Meeting
    */
   parseMeetingInfo(
-    meetingInfo:
-      | {
-          body: {
-            conversationUrl: string;
-            locusUrl: string;
-            sipUri: string;
-            owner: object;
-          };
-        }
-      | any,
-    destination: object | string | null = null
+    meetingInfo: {
+      conversationUrl: string;
+      locusUrl: string;
+      sipUri: string;
+      owner: object;
+      sipUrl?: string;
+      sipMeetingUri?: string;
+      meetingNumber?: string;
+      meetingJoinUrl?: string;
+      hostId?: string;
+      permissionToken?: string;
+      channel?: string;
+    },
+    destination: object | string | null = null,
+    errors: any = undefined
   ) {
-    const webexMeetingInfo = meetingInfo?.body;
     // We try to use as much info from Locus meeting object, stored in destination
 
     let locusMeetingObject;
@@ -2997,40 +3431,31 @@ export default class Meeting extends StatelessWebexPlugin {
     }
 
     // MeetingInfo will be undefined for 1:1 calls
-    if (
-      locusMeetingObject ||
-      (webexMeetingInfo && !(meetingInfo?.errors && meetingInfo?.errors.length > 0))
-    ) {
+    if (locusMeetingObject || (meetingInfo && !(errors?.length > 0))) {
       this.conversationUrl =
-        locusMeetingObject?.conversationUrl ||
-        webexMeetingInfo?.conversationUrl ||
-        this.conversationUrl;
-      this.locusUrl = locusMeetingObject?.url || webexMeetingInfo?.locusUrl || this.locusUrl;
+        locusMeetingObject?.conversationUrl || meetingInfo?.conversationUrl || this.conversationUrl;
+      this.locusUrl = locusMeetingObject?.url || meetingInfo?.locusUrl || this.locusUrl;
       // @ts-ignore - config coming from registerPlugin
       this.setSipUri(
         // @ts-ignore
         this.config.experimental.enableUnifiedMeetings
-          ? locusMeetingObject?.info.sipUri || webexMeetingInfo?.sipUrl
-          : locusMeetingObject?.info.sipUri || webexMeetingInfo?.sipMeetingUri || this.sipUri
+          ? locusMeetingObject?.info.sipUri || meetingInfo?.sipUrl
+          : locusMeetingObject?.info.sipUri || meetingInfo?.sipMeetingUri || this.sipUri
       );
       // @ts-ignore - config coming from registerPlugin
       if (this.config.experimental.enableUnifiedMeetings) {
-        this.meetingNumber =
-          locusMeetingObject?.info.webExMeetingId || webexMeetingInfo?.meetingNumber;
-        this.meetingJoinUrl = webexMeetingInfo?.meetingJoinUrl;
+        this.meetingNumber = locusMeetingObject?.info.webExMeetingId || meetingInfo?.meetingNumber;
+        this.meetingJoinUrl = meetingInfo?.meetingJoinUrl;
       }
       this.owner =
-        locusMeetingObject?.info.owner ||
-        webexMeetingInfo?.owner ||
-        webexMeetingInfo?.hostId ||
-        this.owner;
-      this.permissionToken = webexMeetingInfo?.permissionToken;
-      this.setPermissionTokenPayload(webexMeetingInfo?.permissionToken);
+        locusMeetingObject?.info.owner || meetingInfo?.owner || meetingInfo?.hostId || this.owner;
+      this.permissionToken = meetingInfo?.permissionToken;
+      this.setPermissionTokenPayload(meetingInfo?.permissionToken);
       this.setSelfUserPolicies();
       // Need to populate environment when sending CA event
-      this.environment = locusMeetingObject?.info.channel || webexMeetingInfo?.channel;
+      this.environment = locusMeetingObject?.info.channel || meetingInfo?.channel;
     }
-    MeetingUtil.parseInterpretationInfo(this, webexMeetingInfo);
+    MeetingUtil.parseInterpretationInfo(this, meetingInfo);
   }
 
   /**
@@ -3082,6 +3507,11 @@ export default class Meeting extends StatelessWebexPlugin {
         }) &&
           this.meetingInfo?.video?.supportHDV) ||
         !this.arePolicyRestrictionsSupported(),
+      enforceVirtualBackground:
+        ControlsOptionsUtil.hasPolicies({
+          requiredPolicies: [SELF_POLICY.ENFORCE_VIRTUAL_BACKGROUND],
+          policies: this.selfUserPolicies,
+        }) && this.arePolicyRestrictionsSupported(),
       supportHQV:
         (ControlsOptionsUtil.hasPolicies({
           requiredPolicies: [SELF_POLICY.SUPPORT_HQV],
@@ -3235,6 +3665,10 @@ export default class Meeting extends StatelessWebexPlugin {
             requiredPolicies: [SELF_POLICY.SUPPORT_FILE_TRANSFER],
             policies: this.selfUserPolicies,
           }),
+          canChat: ControlsOptionsUtil.hasPolicies({
+            requiredPolicies: [SELF_POLICY.SUPPORT_CHAT],
+            policies: this.selfUserPolicies,
+          }),
           canShareApplication:
             (ControlsOptionsUtil.hasHints({
               requiredHints: [DISPLAY_HINTS.SHARE_APPLICATION],
@@ -3294,6 +3728,7 @@ export default class Meeting extends StatelessWebexPlugin {
    */
   setSelfUserPolicies() {
     this.selfUserPolicies = this.permissionTokenPayload?.permission?.userPolicies;
+    this.enforceVBGImagesURL = this.permissionTokenPayload?.permission?.enforceVBGImagesURL;
   }
 
   /**
@@ -3303,7 +3738,8 @@ export default class Meeting extends StatelessWebexPlugin {
    * @returns {void}
    */
   public setPermissionTokenPayload(permissionToken: string) {
-    this.permissionTokenPayload = jwt.decode(permissionToken);
+    this.permissionTokenPayload = jwtDecode(permissionToken);
+    this.permissionTokenReceivedLocalTime = new Date().getTime();
   }
 
   /**
@@ -3397,8 +3833,7 @@ export default class Meeting extends StatelessWebexPlugin {
    * @memberof Meeting
    */
   closeRemoteStreams() {
-    const {remoteAudioStream, remoteVideoStream, remoteShareStream, shareAudioStream} =
-      this.mediaProperties;
+    const {remoteAudioStream, remoteVideoStream, remoteShareStream} = this.mediaProperties;
 
     /**
      * Triggers an event to the developer
@@ -3439,7 +3874,6 @@ export default class Meeting extends StatelessWebexPlugin {
       stopStream(remoteAudioStream, EVENT_TYPES.REMOTE_AUDIO),
       stopStream(remoteVideoStream, EVENT_TYPES.REMOTE_VIDEO),
       stopStream(remoteShareStream, EVENT_TYPES.REMOTE_SHARE),
-      stopStream(shareAudioStream, EVENT_TYPES.REMOTE_SHARE_AUDIO),
     ]);
   }
 
@@ -3510,11 +3944,16 @@ export default class Meeting extends StatelessWebexPlugin {
   private async setLocalShareVideoStream(localDisplayStream?: LocalDisplayStream) {
     const oldStream = this.mediaProperties.shareVideoStream;
 
+    oldStream?.off(StreamEventNames.MuteStateChange, this.handleShareVideoStreamMuteStateChange);
     oldStream?.off(StreamEventNames.Ended, this.handleShareVideoStreamEnded);
     oldStream?.off(LocalStreamEventNames.OutputTrackChange, this.localOutputTrackChangeHandler);
 
     this.mediaProperties.setLocalShareVideoStream(localDisplayStream);
 
+    localDisplayStream?.on(
+      StreamEventNames.MuteStateChange,
+      this.handleShareVideoStreamMuteStateChange
+    );
     localDisplayStream?.on(StreamEventNames.Ended, this.handleShareVideoStreamEnded);
     localDisplayStream?.on(
       LocalStreamEventNames.OutputTrackChange,
@@ -3570,7 +4009,7 @@ export default class Meeting extends StatelessWebexPlugin {
     functionName: string;
     isPublished: boolean;
     mediaType: MediaType;
-    stream: MediaStream;
+    stream: LocalStream;
   }) {
     const {functionName, isPublished, mediaType, stream} = options;
     Trigger.trigger(
@@ -3604,12 +4043,16 @@ export default class Meeting extends StatelessWebexPlugin {
     videoStream?.off(StreamEventNames.MuteStateChange, this.localVideoStreamMuteStateHandler);
     videoStream?.off(LocalStreamEventNames.OutputTrackChange, this.localOutputTrackChangeHandler);
 
-    shareAudioStream?.off(StreamEventNames.MuteStateChange, this.handleShareAudioStreamEnded);
+    shareAudioStream?.off(StreamEventNames.Ended, this.handleShareAudioStreamEnded);
     shareAudioStream?.off(
       LocalStreamEventNames.OutputTrackChange,
       this.localOutputTrackChangeHandler
     );
-    shareVideoStream?.off(StreamEventNames.MuteStateChange, this.handleShareVideoStreamEnded);
+    shareVideoStream?.off(
+      StreamEventNames.MuteStateChange,
+      this.handleShareVideoStreamMuteStateChange
+    );
+    shareVideoStream?.off(StreamEventNames.Ended, this.handleShareVideoStreamEnded);
     shareVideoStream?.off(
       LocalStreamEventNames.OutputTrackChange,
       this.localOutputTrackChangeHandler
@@ -3723,6 +4166,7 @@ export default class Meeting extends StatelessWebexPlugin {
       this.receiveSlotManager.reset();
       this.mediaProperties.webrtcMediaConnection.close();
       this.sendSlotManager.reset();
+      this.setNetworkStatus(undefined);
     }
 
     this.audio = null;
@@ -3744,18 +4188,31 @@ export default class Meeting extends StatelessWebexPlugin {
     if (this.config.reconnection.detection) {
       // @ts-ignore
       this.webex.internal.mercury.off(ONLINE);
+      // @ts-ignore
+      this.webex.internal.mercury.off(OFFLINE);
     }
   }
 
   /**
-   * Convenience method to set the correlation id for the Meeting
-   * @param {String} id correlation id to set on the class
+   * Convenience method to set the correlation id for the callStateForMetrics
+   * @param {String} id correlation id to set on the callStateForMetrics
    * @returns {undefined}
-   * @private
+   * @public
+   * @memberof Meeting
+   */
+  public setCorrelationId(id: string) {
+    this.callStateForMetrics.correlationId = id;
+  }
+
+  /**
+   * Update the callStateForMetrics
+   * @param {CallStateForMetrics} callStateForMetrics updated values for callStateForMetrics
+   * @returns {undefined}
+   * @public
    * @memberof Meeting
    */
-  private setCorrelationId(id: string) {
-    this.correlationId = id;
+  public updateCallStateForMetrics(callStateForMetrics: CallStateForMetrics) {
+    this.callStateForMetrics = {...this.callStateForMetrics, ...callStateForMetrics};
   }
 
   /**
@@ -3992,6 +4449,14 @@ export default class Meeting extends StatelessWebexPlugin {
   ) {
     const {mediaOptions, joinOptions} = options;
 
+    if (!mediaOptions?.allowMediaInLobby) {
+      return Promise.reject(
+        new ParameterError('joinWithMedia() can only be used with allowMediaInLobby set to true')
+      );
+    }
+
+    LoggerProxy.logger.info('Meeting:index#joinWithMedia called');
+
     return this.join(joinOptions)
       .then((joinResponse) =>
         this.addMedia(mediaOptions).then((mediaResponse) => ({
@@ -4073,6 +4538,8 @@ export default class Meeting extends StatelessWebexPlugin {
 
     return this.reconnectionManager
       .reconnect(options)
+      .then(() => this.waitForRemoteSDPAnswer())
+      .then(() => this.waitForMediaConnectionConnected())
       .then(() => {
         Trigger.trigger(
           this,
@@ -4083,6 +4550,18 @@ export default class Meeting extends StatelessWebexPlugin {
           EVENT_TRIGGERS.MEETING_RECONNECTION_SUCCESS
         );
         LoggerProxy.logger.log('Meeting:index#reconnect --> Meeting reconnect success');
+
+        // @ts-ignore
+        this.webex.internal.newMetrics.submitClientEvent({
+          name: 'client.media.recovered',
+          payload: {
+            recoveredBy: 'new',
+          },
+          options: {
+            meetingId: this.id,
+          },
+        });
+        this.reconnectionManager.setStatus(RECONNECTION.STATE.COMPLETE);
       })
       .catch((error) => {
         Trigger.trigger(
@@ -4129,7 +4608,7 @@ export default class Meeting extends StatelessWebexPlugin {
     }
 
     LoggerProxy.logger.error(
-      'Meeting:index#isTranscriptionSupported --> Webex Assistant is not supported'
+      'Meeting:index#isTranscriptionSupported --> Webex Assistant is not enabled/supported'
     );
 
     return false;
@@ -4150,109 +4629,139 @@ export default class Meeting extends StatelessWebexPlugin {
   }
 
   /**
-   * Monitor the Low-Latency Mercury (LLM) web socket connection on `onError` and `onClose` states
-   * @private
-   * @returns {void}
+   * sets Caption language for the meeting
+   * @param {string} language
+   * @returns {Promise}
    */
-  private monitorTranscriptionSocketConnection() {
-    this.transcription.onCloseSocket((event) => {
-      LoggerProxy.logger.info(
-        `Meeting:index#onCloseSocket -->
-        unable to continue receiving transcription;
-        low-latency mercury web socket connection is closed now.
-        ${event}`
-      );
+  public setCaptionLanguage(language: string) {
+    return new Promise((resolve, reject) => {
+      if (!this.isTranscriptionSupported()) {
+        LoggerProxy.logger.error(
+          'Meeting:index#setCaptionLanguage --> Webex Assistant is not enabled/supported'
+        );
 
-      this.triggerStopReceivingTranscriptionEvent();
-    });
+        reject(new Error('Webex Assistant is not enabled/supported'));
+      }
 
-    this.transcription.onErrorSocket((event) => {
-      LoggerProxy.logger.error(
-        `Meeting:index#onErrorSocket -->
-         unable to continue receiving transcription;
-         low-latency mercury web socket connection error had occured.
-        ${event}`
-      );
+      try {
+        const voiceaListenerCaptionUpdate = (payload) => {
+          // @ts-ignore
+          this.webex.internal.voicea.off(
+            VOICEAEVENTS.CAPTION_LANGUAGE_UPDATE,
+            voiceaListenerCaptionUpdate
+          );
+          const {statusCode} = payload;
 
-      this.triggerStopReceivingTranscriptionEvent();
+          if (statusCode === 200) {
+            this.transcription.languageOptions = {
+              ...this.transcription.languageOptions,
+              currentCaptionLanguage: language,
+            };
+            resolve(language);
+          } else {
+            reject(payload);
+          }
+        };
+        // @ts-ignore
+        this.webex.internal.voicea.on(
+          VOICEAEVENTS.CAPTION_LANGUAGE_UPDATE,
+          voiceaListenerCaptionUpdate
+        );
+        // @ts-ignore
+        this.webex.internal.voicea.requestLanguage(language);
+      } catch (error) {
+        LoggerProxy.logger.error(`Meeting:index#setCaptionLanguage --> ${error}`);
 
-      Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.RECEIVE_TRANSCRIPTION_FAILURE, {
-        correlation_id: this.correlationId,
-        reason: 'unexpected error: transcription LLM web socket connection error had occured.',
-        event,
-      });
+        reject(error);
+      }
     });
   }
 
   /**
-   * Request for a WebSocket Url, open and monitor the WebSocket connection
-   * @private
-   * @returns {Promise<void>} a promise to open the WebSocket connection
+   * sets Spoken language for the meeting
+   * @param {string} language
+   * @returns {Promise}
    */
-  private async receiveTranscription() {
-    LoggerProxy.logger.info(
-      `Meeting:index#receiveTranscription -->
-      Attempting to generate a web socket url.`
-    );
+  public setSpokenLanguage(language: string) {
+    return new Promise((resolve, reject) => {
+      if (!this.isTranscriptionSupported()) {
+        LoggerProxy.logger.error(
+          'Meeting:index#setCaptionLanguage --> Webex Assistant is not enabled/supported'
+        );
+
+        reject(new Error('Webex Assistant is not enabled/supported'));
+      }
+
+      try {
+        const voiceaListenerLanguageUpdate = (payload) => {
+          // @ts-ignore
+          this.webex.internal.voicea.off(
+            VOICEAEVENTS.SPOKEN_LANGUAGE_UPDATE,
+            voiceaListenerLanguageUpdate
+          );
+          const {languageCode} = payload;
+
+          if (languageCode) {
+            this.transcription.languageOptions = {
+              ...this.transcription.languageOptions,
+              currentSpokenLanguage: languageCode,
+            };
+            resolve(languageCode);
+          } else {
+            reject(payload);
+          }
+        };
 
-    try {
-      const {datachannelUrl} = this.locusInfo.info;
-      // @ts-ignore - fix type
-      const {
-        body: {webSocketUrl},
         // @ts-ignore
-      } = await this.request({
-        method: HTTP_VERBS.POST,
-        uri: datachannelUrl,
-        body: {deviceUrl: this.deviceUrl},
-      });
+        this.webex.internal.voicea.on(
+          VOICEAEVENTS.SPOKEN_LANGUAGE_UPDATE,
+          voiceaListenerLanguageUpdate
+        );
 
-      LoggerProxy.logger.info(
-        `Meeting:index#receiveTranscription -->
-        Generated web socket url succesfully.`
-      );
+        // @ts-ignore
+        this.webex.internal.voicea.setSpokenLanguage(language);
+      } catch (error) {
+        LoggerProxy.logger.error(`Meeting:index#setSpokenLanguage --> ${error}`);
 
-      this.transcription = new Transcription(
-        webSocketUrl,
-        // @ts-ignore - fix type
-        this.webex.sessionId,
-        this.members
-      );
+        reject(error);
+      }
+    });
+  }
 
+  /**
+   * This method will enable the transcription for the current meeting if the meeting has enabled/supports Webex Assistant
+   * @param {Object} options object with spokenlanguage setting
+   * @public
+   * @returns {Promise<void>} a promise to open the WebSocket connection
+   */
+  public async startTranscription(options?: {spokenLanguage?: string}) {
+    if (this.isJoined()) {
       LoggerProxy.logger.info(
-        `Meeting:index#receiveTranscription -->
-        opened LLM web socket connection successfully.`
+        'Meeting:index#startTranscription --> Attempting to enable transcription!'
       );
 
-      if (!this.inMeetingActions.isClosedCaptionActive) {
-        LoggerProxy.logger.error(
-          `Meeting:index#receiveTranscription --> Transcription cannot be started until a licensed user enables it`
-        );
-      }
-
-      // retrieve and pass the payload
-      this.transcription.subscribe((payload) => {
-        Trigger.trigger(
-          this,
-          {
-            file: 'meeting/index',
-            function: 'join',
-          },
-          EVENT_TRIGGERS.MEETING_STARTED_RECEIVING_TRANSCRIPTION,
-          payload
-        );
-      });
+      try {
+        if (!this.areVoiceaEventsSetup) {
+          this.setUpVoiceaListeners();
+        }
 
-      this.monitorTranscriptionSocketConnection();
-      // @ts-ignore - fix type
-      this.transcription.connect(this.webex.credentials.supertoken.access_token);
-    } catch (error) {
-      LoggerProxy.logger.error(`Meeting:index#receiveTranscription --> ${error}`);
-      Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.RECEIVE_TRANSCRIPTION_FAILURE, {
-        correlation_id: this.correlationId,
-        reason: error.message,
-        stack: error.stack,
-      });
+        if (this.getCurUserType() === 'host') {
+          // @ts-ignore
+          await this.webex.internal.voicea.toggleTranscribing(true, options?.spokenLanguage);
+        }
+      } catch (error) {
+        LoggerProxy.logger.error(`Meeting:index#startTranscription --> ${error}`);
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.RECEIVE_TRANSCRIPTION_FAILURE, {
+          correlation_id: this.correlationId,
+          reason: error.message,
+          stack: error.stack,
+        });
+      }
+    } else {
+      LoggerProxy.logger.error(
+        `Meeting:index#startTranscription --> meeting joined : ${this.isJoined()}`
+      );
+      throw new Error('Meeting is not joined');
     }
   }
 
@@ -4295,13 +4804,37 @@ export default class Meeting extends StatelessWebexPlugin {
   };
 
   /**
-   * stop recieving Transcription by closing
-   * the web socket connection properly
+   * This method stops receiving transcription for the current meeting
    * @returns {void}
    */
-  stopReceivingTranscription() {
+  stopTranscription() {
     if (this.transcription) {
-      this.transcription.closeSocket();
+      // @ts-ignore
+      this.webex.internal.voicea.off(
+        VOICEAEVENTS.VOICEA_ANNOUNCEMENT,
+        this.voiceaListenerCallbacks[VOICEAEVENTS.VOICEA_ANNOUNCEMENT]
+      );
+
+      // @ts-ignore
+      this.webex.internal.voicea.off(
+        VOICEAEVENTS.CAPTIONS_TURNED_ON,
+        this.voiceaListenerCallbacks[VOICEAEVENTS.CAPTIONS_TURNED_ON]
+      );
+
+      // @ts-ignore
+      this.webex.internal.voicea.off(
+        VOICEAEVENTS.EVA_COMMAND,
+        this.voiceaListenerCallbacks[VOICEAEVENTS.EVA_COMMAND]
+      );
+
+      // @ts-ignore
+      this.webex.internal.voicea.off(
+        VOICEAEVENTS.NEW_CAPTION,
+        this.voiceaListenerCallbacks[VOICEAEVENTS.NEW_CAPTION]
+      );
+
+      this.areVoiceaEventsSetup = false;
+      this.triggerStopReceivingTranscriptionEvent();
     }
   }
 
@@ -4314,12 +4847,12 @@ export default class Meeting extends StatelessWebexPlugin {
   private triggerStopReceivingTranscriptionEvent() {
     LoggerProxy.logger.info(`
       Meeting:index#stopReceivingTranscription -->
-      closed transcription LLM web socket connection successfully.`);
+      closed voicea event listeners successfully.`);
 
     Trigger.trigger(
       this,
       {
-        file: 'meeting',
+        file: 'meeting/index',
         function: 'triggerStopReceivingTranscriptionEvent',
       },
       EVENT_TRIGGERS.MEETING_STOPPED_RECEIVING_TRANSCRIPTION
@@ -4338,7 +4871,7 @@ export default class Meeting extends StatelessWebexPlugin {
    *             if joining as host on second loop, pass pin and pass moderator if joining as guest on second loop
    * Scenario D: Joining any other way (sip, pstn, conversationUrl, link just need to specify resourceId)
    */
-  public join(options: any = {}) {
+  public async join(options: any = {}) {
     // @ts-ignore - fix type
     if (!this.webex.meetings.registered) {
       const errorMessage = 'Meeting:index#join --> Device not registered';
@@ -4392,27 +4925,14 @@ export default class Meeting extends StatelessWebexPlugin {
     // @ts-ignore
     this.webex.internal.newMetrics.submitClientEvent({
       name: 'client.call.initiated',
-      payload: {trigger: 'user-interaction', isRoapCallEnabled: true},
+      payload: {
+        trigger: this.callStateForMetrics.joinTrigger || 'user-interaction',
+        isRoapCallEnabled: true,
+        pstnAudioType: options?.pstnAudioType,
+      },
       options: {meetingId: this.id},
     });
 
-    if (!isEmpty(this.meetingInfo)) {
-      // @ts-ignore
-      this.webex.internal.newMetrics.submitClientEvent({
-        name: 'client.meetinginfo.request',
-        options: {meetingId: this.id},
-      });
-
-      // @ts-ignore
-      this.webex.internal.newMetrics.submitClientEvent({
-        name: 'client.meetinginfo.response',
-        payload: {
-          identifiers: {meetingLookupUrl: this.meetingInfo?.meetingLookupUrl},
-        },
-        options: {meetingId: this.id},
-      });
-    }
-
     LoggerProxy.logger.log('Meeting:index#join --> Joining a meeting');
 
     if (this.meetingFiniteStateMachine.state === MEETING_STATE_MACHINE.STATES.ENDED) {
@@ -4466,44 +4986,55 @@ export default class Meeting extends StatelessWebexPlugin {
 
     this.isMultistream = !!options.enableMultistream;
 
+    try {
+      // refresh the permission token if its about to expire in 10sec
+      await this.checkAndRefreshPermissionToken(
+        MEETING_PERMISSION_TOKEN_REFRESH_THRESHOLD_IN_SEC,
+        MEETING_PERMISSION_TOKEN_REFRESH_REASON
+      );
+    } catch (error) {
+      LoggerProxy.logger.error('Meeting:index#join --> Failed to refresh permission token:', error);
+
+      if (
+        error instanceof CaptchaError ||
+        error instanceof PasswordError ||
+        error instanceof PermissionError
+      ) {
+        this.meetingFiniteStateMachine.fail(error);
+
+        // Upload logs on refreshpermissionToken refresh Failure
+        Trigger.trigger(
+          this,
+          {
+            file: 'meeting/index',
+            function: 'join',
+          },
+          EVENTS.REQUEST_UPLOAD_LOGS,
+          this
+        );
+
+        joinFailed(error);
+
+        this.deferJoin = undefined;
+
+        // if refresh permission token requires captcha, password or permission, we are throwing the errors
+        // and bubble it up to client
+        return Promise.reject(error);
+      }
+    }
+
     return MeetingUtil.joinMeetingOptions(this, options)
       .then((join) => {
         this.meetingFiniteStateMachine.join();
         LoggerProxy.logger.log('Meeting:index#join --> Success');
 
-        return join;
-      })
-      .then((join) => {
-        joinSuccess(join);
-        this.deferJoin = undefined;
         Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.JOIN_SUCCESS, {
           correlation_id: this.correlationId,
         });
 
-        return join;
-      })
-      .then(async (join) => {
-        // @ts-ignore - config coming from registerPlugin
-        if (this.config.enableAutomaticLLM) {
-          await this.updateLLMConnection();
-        }
+        joinSuccess(join);
 
-        return join;
-      })
-      .then(async (join) => {
-        if (isBrowser) {
-          // @ts-ignore - config coming from registerPlugin
-          if (this.config.receiveTranscription || options.receiveTranscription) {
-            if (this.isTranscriptionSupported()) {
-              await this.receiveTranscription();
-              LoggerProxy.logger.info('Meeting:index#join --> enabled to recieve transcription!');
-            }
-          }
-        } else {
-          LoggerProxy.logger.error(
-            'Meeting:index#join --> Receving transcription is not supported on this platform'
-          );
-        }
+        this.deferJoin = undefined;
 
         return join;
       })
@@ -4539,9 +5070,44 @@ export default class Meeting extends StatelessWebexPlugin {
         );
 
         joinFailed(error);
+
         this.deferJoin = undefined;
 
         return Promise.reject(error);
+      })
+      .then((join) => {
+        // @ts-ignore - config coming from registerPlugin
+        if (this.config.enableAutomaticLLM) {
+          this.updateLLMConnection()
+            .catch((error) => {
+              LoggerProxy.logger.error(
+                'Meeting:index#join --> Transcription Socket Connection Failed',
+                error
+              );
+
+              Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.LLM_CONNECTION_AFTER_JOIN_FAILURE, {
+                correlation_id: this.correlationId,
+                reason: error?.message,
+                stack: error.stack,
+              });
+            })
+            .then(() => {
+              LoggerProxy.logger.info(
+                'Meeting:index#join --> Transcription Socket Connection Success'
+              );
+              Trigger.trigger(
+                this,
+                {
+                  file: 'meeting/index',
+                  function: 'join',
+                },
+                EVENT_TRIGGERS.MEETING_TRANSCRIPTION_CONNECTED,
+                undefined
+              );
+            });
+        }
+
+        return join;
       });
   }
 
@@ -4921,30 +5487,91 @@ export default class Meeting extends StatelessWebexPlugin {
     }
   };
 
-  setupMediaConnectionListeners = () => {
-    this.mediaProperties.webrtcMediaConnection.on(Event.ROAP_STARTED, () => {
-      this.isRoapInProgress = true;
-    });
+  /**
+   * Handles an incoming Roap message
+   * @internal
+   * @param {RoapMessage} roapMessage roap message
+   * @returns {undefined}
+   */
+  public roapMessageReceived = (roapMessage: RoapMessage) => {
+    const mediaServer = MeetingsUtil.getMediaServer(roapMessage.sdp);
 
-    this.mediaProperties.webrtcMediaConnection.on(Event.ROAP_DONE, () => {
-      this.mediaNegotiatedEvent();
-      this.isRoapInProgress = false;
-      this.processNextQueuedMediaUpdate();
-    });
+    this.mediaProperties.webrtcMediaConnection.roapMessageReceived(roapMessage);
 
-    this.mediaProperties.webrtcMediaConnection.on(Event.ROAP_FAILURE, this.handleRoapFailure);
+    if (mediaServer) {
+      this.mediaProperties.webrtcMediaConnection.mediaServer = mediaServer;
+    }
+  };
+
+  /**
+   * This function makes sure we send the right metrics when local and remote SDPs are processed/generated
+   *
+   * @returns {undefined}
+   */
+  setupSdpListeners = () => {
+    this.mediaProperties.webrtcMediaConnection.on(Event.REMOTE_SDP_ANSWER_PROCESSED, () => {
+      // @ts-ignore
+      const cdl = this.webex.internal.newMetrics.callDiagnosticLatencies;
+
+      // @ts-ignore
+      this.webex.internal.newMetrics.submitClientEvent({
+        name: 'client.media-engine.remote-sdp-received',
+        options: {meetingId: this.id},
+      });
+      Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ROAP_OFFER_TO_ANSWER_LATENCY, {
+        correlation_id: this.correlationId,
+        latency: cdl.getLocalSDPGenRemoteSDPRecv(),
+        meetingId: this.id,
+      });
+
+      if (this.deferSDPAnswer) {
+        this.deferSDPAnswer.resolve();
+        clearTimeout(this.sdpResponseTimer);
+        this.sdpResponseTimer = undefined;
+      }
+    });
+
+    this.mediaProperties.webrtcMediaConnection.on(Event.LOCAL_SDP_OFFER_GENERATED, () => {
+      // @ts-ignore
+      this.webex.internal.newMetrics.submitClientEvent({
+        name: 'client.media-engine.local-sdp-generated',
+        options: {meetingId: this.id},
+      });
+
+      // Instantiate Defer so that the SDP offer/answer exchange timeout can start, see waitForRemoteSDPAnswer()
+      this.deferSDPAnswer = new Defer();
+    });
+
+    this.mediaProperties.webrtcMediaConnection.on(Event.LOCAL_SDP_ANSWER_GENERATED, () => {
+      // we are sending "remote-sdp-received" only after we've generated the answer - this indicates that we've fully processed that incoming offer
+      // @ts-ignore
+      this.webex.internal.newMetrics.submitClientEvent({
+        name: 'client.media-engine.remote-sdp-received',
+        options: {meetingId: this.id},
+      });
+    });
+  };
+
+  setupMediaConnectionListeners = () => {
+    this.setupSdpListeners();
+
+    this.mediaProperties.webrtcMediaConnection.on(Event.ROAP_STARTED, () => {
+      this.isRoapInProgress = true;
+    });
+
+    this.mediaProperties.webrtcMediaConnection.on(Event.ROAP_DONE, () => {
+      this.mediaNegotiatedEvent();
+      this.isRoapInProgress = false;
+      this.processNextQueuedMediaUpdate();
+    });
+
+    this.mediaProperties.webrtcMediaConnection.on(Event.ROAP_FAILURE, this.handleRoapFailure);
 
     this.mediaProperties.webrtcMediaConnection.on(Event.ROAP_MESSAGE_TO_SEND, (event) => {
       const LOG_HEADER = `Meeting:index#setupMediaConnectionListeners.ROAP_MESSAGE_TO_SEND --> correlationId=${this.correlationId}`;
 
       switch (event.roapMessage.messageType) {
         case 'OK':
-          // @ts-ignore
-          this.webex.internal.newMetrics.submitClientEvent({
-            name: 'client.media-engine.remote-sdp-received',
-            options: {meetingId: this.id},
-          });
-
           logRequest(
             this.roap.sendRoapOK({
               seq: event.roapMessage.seq,
@@ -4958,33 +5585,32 @@ export default class Meeting extends StatelessWebexPlugin {
           break;
 
         case 'OFFER':
-          // @ts-ignore
-          this.webex.internal.newMetrics.submitClientEvent({
-            name: 'client.media-engine.local-sdp-generated',
-            options: {meetingId: this.id},
-          });
-
           logRequest(
-            this.roap.sendRoapMediaRequest({
-              sdp: event.roapMessage.sdp,
-              seq: event.roapMessage.seq,
-              tieBreaker: event.roapMessage.tieBreaker,
-              meeting: this, // or can pass meeting ID
-              reconnect: this.reconnectionManager.isReconnectInProgress(),
-            }),
+            this.roap
+              .sendRoapMediaRequest({
+                sdp: event.roapMessage.sdp,
+                seq: event.roapMessage.seq,
+                tieBreaker: event.roapMessage.tieBreaker,
+                meeting: this, // or can pass meeting ID
+              })
+              .then(({roapAnswer}) => {
+                if (roapAnswer) {
+                  LoggerProxy.logger.log(`${LOG_HEADER} received Roap ANSWER in http response`);
+
+                  this.roapMessageReceived(roapAnswer);
+                }
+              }),
             {
               logText: `${LOG_HEADER} Roap Offer`,
             }
-          );
+          ).catch(() => {
+            this.deferSDPAnswer.reject();
+            clearTimeout(this.sdpResponseTimer);
+            this.sdpResponseTimer = undefined;
+          });
           break;
 
         case 'ANSWER':
-          // @ts-ignore
-          this.webex.internal.newMetrics.submitClientEvent({
-            name: 'client.media-engine.remote-sdp-received',
-            options: {meetingId: this.id},
-          });
-
           logRequest(
             this.roap.sendRoapAnswer({
               sdp: event.roapMessage.sdp,
@@ -5097,70 +5723,71 @@ export default class Meeting extends StatelessWebexPlugin {
 
     this.mediaProperties.webrtcMediaConnection.on(Event.CONNECTION_STATE_CHANGED, (event) => {
       const connectionFailed = () => {
-        // we know the media connection failed and browser will not attempt to recover it any more
-        // so reset the timer as it's not needed anymore, we want to reconnect immediately
-        this.reconnectionManager.resetReconnectionTimer();
-
-        this.reconnect({networkDisconnect: true});
-        // @ts-ignore
-        this.webex.internal.newMetrics.submitClientEvent({
-          name: 'client.ice.end',
-          payload: {
-            canProceed: false,
-            icePhase: 'IN_MEETING',
-            errors: [
-              // @ts-ignore
-              this.webex.internal.newMetrics.callDiagnosticMetrics.getErrorPayloadForClientErrorCode(
-                {
-                  clientErrorCode: CALL_DIAGNOSTIC_CONFIG.ICE_FAILURE_CLIENT_CODE,
-                }
-              ),
-            ],
-          },
-          options: {
-            meetingId: this.id,
-          },
-        });
-
-        this.uploadLogs({
-          file: 'peer-connection-manager/index',
-          function: 'connectionFailed',
-        });
-
         Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.CONNECTION_FAILURE, {
           correlation_id: this.correlationId,
           locus_id: this.locusId,
+          networkStatus: this.networkStatus,
+          hasMediaConnectionConnectedAtLeastOnce: this.hasMediaConnectionConnectedAtLeastOnce,
         });
+
+        if (this.hasMediaConnectionConnectedAtLeastOnce) {
+          // we know the media connection failed and browser will not attempt to recover it any more
+          // so reset the timer as it's not needed anymore, we want to reconnect immediately
+          this.reconnectionManager.resetReconnectionTimer();
+
+          this.reconnect({networkDisconnect: true});
+
+          this.uploadLogs({
+            file: 'peer-connection-manager/index',
+            function: 'connectionFailed',
+          });
+        }
       };
 
       LoggerProxy.logger.info(
         `Meeting:index#setupMediaConnectionListeners --> correlationId=${this.correlationId} connection state changed to ${event.state}`
       );
+
+      // @ts-ignore
+      const cdl = this.webex.internal.newMetrics.callDiagnosticLatencies;
+
       switch (event.state) {
         case ConnectionState.Connecting:
-          // @ts-ignore
-          this.webex.internal.newMetrics.submitClientEvent({
-            name: 'client.ice.start',
-            options: {
-              meetingId: this.id,
-            },
-          });
+          if (!this.hasMediaConnectionConnectedAtLeastOnce) {
+            // Only send CA event for join flow if we haven't successfully connected media yet
+            // @ts-ignore
+            this.webex.internal.newMetrics.submitClientEvent({
+              name: 'client.ice.start',
+              options: {
+                meetingId: this.id,
+              },
+            });
+          }
           break;
         case ConnectionState.Connected:
-          // @ts-ignore
-          this.webex.internal.newMetrics.submitClientEvent({
-            name: 'client.ice.end',
-            options: {
-              meetingId: this.id,
-            },
-          });
+          if (!this.hasMediaConnectionConnectedAtLeastOnce) {
+            // Only send CA event for join flow if we haven't successfully connected media yet
+            // @ts-ignore
+            this.webex.internal.newMetrics.submitClientEvent({
+              name: 'client.ice.end',
+              payload: {
+                canProceed: true,
+                icePhase: 'JOIN_MEETING_FINAL',
+              },
+              options: {
+                meetingId: this.id,
+              },
+            });
+          }
           Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.CONNECTION_SUCCESS, {
             correlation_id: this.correlationId,
             locus_id: this.locusId,
+            latency: cdl.getICESetupTime(),
           });
           this.setNetworkStatus(NETWORK_STATUS.CONNECTED);
           this.reconnectionManager.iceReconnected();
           this.statsAnalyzer.startAnalyzer(this.mediaProperties.webrtcMediaConnection);
+          this.hasMediaConnectionConnectedAtLeastOnce = true;
           break;
         case ConnectionState.Disconnected:
           this.setNetworkStatus(NETWORK_STATUS.DISCONNECTED);
@@ -5281,7 +5908,10 @@ export default class Meeting extends StatelessWebexPlugin {
       // @ts-ignore
       this.webex.internal.newMetrics.submitClientEvent({
         name: 'client.media.tx.start',
-        payload: {mediaType: data.type},
+        payload: {
+          mediaType: data.type,
+          shareInstanceId: data.type === 'share' ? this.localShareInstanceId : undefined,
+        },
         options: {
           meetingId: this.id,
         },
@@ -5291,7 +5921,10 @@ export default class Meeting extends StatelessWebexPlugin {
       // @ts-ignore
       this.webex.internal.newMetrics.submitClientEvent({
         name: 'client.media.tx.stop',
-        payload: {mediaType: data.type},
+        payload: {
+          mediaType: data.type,
+          shareInstanceId: data.type === 'share' ? this.localShareInstanceId : undefined,
+        },
         options: {
           meetingId: this.id,
         },
@@ -5310,7 +5943,10 @@ export default class Meeting extends StatelessWebexPlugin {
       // @ts-ignore
       this.webex.internal.newMetrics.submitClientEvent({
         name: 'client.media.rx.start',
-        payload: {mediaType: data.type},
+        payload: {
+          mediaType: data.type,
+          shareInstanceId: data.type === 'share' ? this.remoteShareInstanceId : undefined,
+        },
         options: {
           meetingId: this.id,
         },
@@ -5320,7 +5956,10 @@ export default class Meeting extends StatelessWebexPlugin {
       // @ts-ignore
       this.webex.internal.newMetrics.submitClientEvent({
         name: 'client.media.rx.stop',
-        payload: {mediaType: data.type},
+        payload: {
+          mediaType: data.type,
+          shareInstanceId: data.type === 'share' ? this.remoteShareInstanceId : undefined,
+        },
         options: {
           meetingId: this.id,
         },
@@ -5373,8 +6012,8 @@ export default class Meeting extends StatelessWebexPlugin {
           this.mediaProperties.mediaDirection.receiveShare,
       ];
 
-      this.sendSlotManager.createSlot(mc, MediaType.VideoMain, audioEnabled);
-      this.sendSlotManager.createSlot(mc, MediaType.AudioMain, videoEnabled);
+      this.sendSlotManager.createSlot(mc, MediaType.VideoMain, videoEnabled);
+      this.sendSlotManager.createSlot(mc, MediaType.AudioMain, audioEnabled);
       this.sendSlotManager.createSlot(mc, MediaType.VideoSlides, shareEnabled);
       this.sendSlotManager.createSlot(mc, MediaType.AudioSlides, shareEnabled);
     }
@@ -5393,54 +6032,468 @@ export default class Meeting extends StatelessWebexPlugin {
       await this.publishStream(MediaType.AudioSlides, this.mediaProperties.shareAudioStream);
     }
 
-    return mc;
+    return mc;
+  }
+
+  /**
+   * Listens for an event emitted by eventEmitter and emits it from the meeting object
+   *
+   * @private
+   * @param {*} eventEmitter object from which to forward the event
+   * @param {*} eventTypeToForward which event type to listen on and to forward
+   * @param {string} meetingEventType event type to be used in the event emitted from the meeting object
+   * @returns {void}
+   */
+  forwardEvent(eventEmitter, eventTypeToForward, meetingEventType) {
+    eventEmitter.on(eventTypeToForward, (data) =>
+      Trigger.trigger(
+        this,
+        {
+          file: 'meetings',
+          function: 'addMedia',
+        },
+        meetingEventType,
+        data
+      )
+    );
+  }
+
+  /**
+   * Sets up all the references to local streams in this.mediaProperties before creating media connection
+   * and before TURN discovery, so that the correct mute state is sent with TURN discovery roap messages.
+   *
+   * @private
+   * @param {LocalStreams} localStreams
+   * @returns {Promise<void>}
+   */
+  private async setUpLocalStreamReferences(localStreams: LocalStreams) {
+    const setUpStreamPromises = [];
+
+    if (localStreams?.microphone) {
+      setUpStreamPromises.push(this.setLocalAudioStream(localStreams.microphone));
+    }
+    if (localStreams?.camera) {
+      setUpStreamPromises.push(this.setLocalVideoStream(localStreams.camera));
+    }
+    if (localStreams?.screenShare?.video) {
+      setUpStreamPromises.push(this.setLocalShareVideoStream(localStreams.screenShare.video));
+    }
+    if (localStreams?.screenShare?.audio) {
+      setUpStreamPromises.push(this.setLocalShareAudioStream(localStreams.screenShare.audio));
+    }
+
+    try {
+      await Promise.all(setUpStreamPromises);
+    } catch (error) {
+      LoggerProxy.logger.error(
+        `Meeting:index#addMedia():setUpLocalStreamReferences --> Error , `,
+        error
+      );
+
+      throw error;
+    }
+  }
+
+  /**
+   * Calls mediaProperties.waitForMediaConnectionConnected() and sends CA client.ice.end metric on failure
+   *
+   * @private
+   * @returns {Promise<void>}
+   */
+  private async waitForMediaConnectionConnected(): Promise<void> {
+    try {
+      await this.mediaProperties.waitForMediaConnectionConnected();
+    } catch (error) {
+      if (!this.hasMediaConnectionConnectedAtLeastOnce) {
+        // Only send CA event for join flow if we haven't successfully connected media yet
+        // @ts-ignore
+        this.webex.internal.newMetrics.submitClientEvent({
+          name: 'client.ice.end',
+          payload: {
+            canProceed: !this.turnServerUsed, // If we haven't done turn tls retry yet we will proceed with join attempt
+            icePhase: this.turnServerUsed ? 'JOIN_MEETING_FINAL' : 'JOIN_MEETING_RETRY',
+            errors: [
+              // @ts-ignore
+              this.webex.internal.newMetrics.callDiagnosticMetrics.getErrorPayloadForClientErrorCode(
+                {
+                  clientErrorCode: CallDiagnosticUtils.generateClientErrorCodeForIceFailure({
+                    signalingState:
+                      this.mediaProperties.webrtcMediaConnection?.multistreamConnection?.pc?.pc
+                        ?.signalingState ||
+                      this.mediaProperties.webrtcMediaConnection?.mediaConnection?.pc
+                        ?.signalingState ||
+                      'unknown',
+                    iceConnectionState:
+                      this.mediaProperties.webrtcMediaConnection?.multistreamConnection?.pc?.pc
+                        ?.iceConnectionState ||
+                      this.mediaProperties.webrtcMediaConnection?.mediaConnection?.pc
+                        ?.iceConnectionState ||
+                      'unknown',
+                    turnServerUsed: this.turnServerUsed,
+                  }),
+                }
+              ),
+            ],
+          },
+          options: {
+            meetingId: this.id,
+          },
+        });
+      }
+      throw new Error(
+        `Timed out waiting for media connection to be connected, correlationId=${this.correlationId}`
+      );
+    }
+  }
+
+  /**
+   * Enables statsAnalyser if config allows it
+   *
+   * @private
+   * @returns {void}
+   */
+  private createStatsAnalyzer() {
+    // @ts-ignore - config coming from registerPlugin
+    if (this.config.stats.enableStatsAnalyzer) {
+      // @ts-ignore - config coming from registerPlugin
+      this.networkQualityMonitor = new NetworkQualityMonitor(this.config.stats);
+      this.statsAnalyzer = new StatsAnalyzer(
+        // @ts-ignore - config coming from registerPlugin
+        this.config.stats,
+        (ssrc: number) => this.receiveSlotManager.findReceiveSlotBySsrc(ssrc),
+        this.networkQualityMonitor
+      );
+      this.setupStatsAnalyzerEventHandlers();
+      this.networkQualityMonitor.on(
+        EVENT_TRIGGERS.NETWORK_QUALITY,
+        this.sendNetworkQualityEvent.bind(this)
+      );
+    }
+  }
+
+  /**
+   * Handles device logging
+   *
+   * @private
+   * @static
+   * @returns {Promise<void>}
+   */
+  private static async handleDeviceLogging(): Promise<void> {
+    try {
+      const devices = await getDevices();
+
+      MeetingUtil.handleDeviceLogging(devices);
+    } catch {
+      // getDevices may fail if we don't have browser permissions, that's ok, we still can have a media connection
+    }
+  }
+
+  /**
+   * Returns a promise. This promise is created once the local sdp offer has been successfully created and is resolved
+   * once the remote sdp answer has been received.
+   *
+   * @private
+   * @returns {Promise<void>}
+   */
+  private async waitForRemoteSDPAnswer(): Promise<void> {
+    const LOG_HEADER = 'Meeting:index#addMedia():waitForRemoteSDPAnswer -->';
+
+    if (!this.deferSDPAnswer) {
+      LoggerProxy.logger.warn(`${LOG_HEADER} offer not created yet`);
+
+      return Promise.reject(
+        new Error('waitForRemoteSDPAnswer() called before local sdp offer created')
+      );
+    }
+
+    const {deferSDPAnswer} = this;
+
+    this.sdpResponseTimer = setTimeout(() => {
+      LoggerProxy.logger.warn(
+        `${LOG_HEADER} timeout! no REMOTE SDP ANSWER received within ${
+          ROAP_OFFER_ANSWER_EXCHANGE_TIMEOUT / 1000
+        } seconds`
+      );
+      deferSDPAnswer.reject(new Error('Timed out waiting for REMOTE SDP ANSWER'));
+    }, ROAP_OFFER_ANSWER_EXCHANGE_TIMEOUT);
+
+    LoggerProxy.logger.info(`${LOG_HEADER} waiting for REMOTE SDP ANSWER...`);
+
+    return deferSDPAnswer.promise;
+  }
+
+  /**
+   * Calls establishMediaConnection with isForced = true to force turn discovery to happen
+   *
+   * @private
+   * @param {RemoteMediaManagerConfiguration} [remoteMediaManagerConfig]
+   * @param {BundlePolicy} [bundlePolicy]
+   * @returns {Promise<void>}
+   */
+  private async retryEstablishMediaConnectionWithForcedTurnDiscovery(
+    remoteMediaManagerConfig?: RemoteMediaManagerConfiguration,
+    bundlePolicy?: BundlePolicy
+  ): Promise<void> {
+    const LOG_HEADER =
+      'Meeting:index#addMedia():retryEstablishMediaConnectionWithForcedTurnDiscovery -->';
+
+    try {
+      await this.establishMediaConnection(remoteMediaManagerConfig, bundlePolicy, true);
+    } catch (err) {
+      LoggerProxy.logger.error(
+        `${LOG_HEADER} retry with TURN-TLS failed, media connection unable to connect, `,
+        err
+      );
+
+      throw err;
+    }
+  }
+
+  /**
+   * Does relevant clean up before retrying to establish media connection
+   * and performs the retry with forced turn discovery
+   *
+   * @private
+   * @param {RemoteMediaManagerConfiguration} [remoteMediaManagerConfig]
+   * @param {BundlePolicy} [bundlePolicy]
+   * @returns {Promise<void>}
+   */
+  private async retryWithForcedTurnDiscovery(
+    remoteMediaManagerConfig?: RemoteMediaManagerConfiguration,
+    bundlePolicy?: BundlePolicy
+  ): Promise<void> {
+    this.retriedWithTurnServer = true;
+    const LOG_HEADER = 'Meeting:index#addMedia():retryWithForcedTurnDiscovery -->';
+
+    await this.cleanUpBeforeRetryWithTurnServer();
+
+    Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ADD_MEDIA_RETRY, {
+      correlation_id: this.correlationId,
+      state: this.state,
+      meetingState: this.meetingState,
+      reason: 'forcingTurnTls',
+    });
+
+    if (this.state === MEETING_STATE.STATES.LEFT) {
+      LoggerProxy.logger.info(
+        `${LOG_HEADER} meeting state was LEFT after first attempt to establish media connection. Attempting to rejoin. `
+      );
+      await this.join({rejoin: true});
+    }
+
+    await this.retryEstablishMediaConnectionWithForcedTurnDiscovery(
+      remoteMediaManagerConfig,
+      bundlePolicy
+    );
+  }
+
+  /**
+   * If waitForMediaConnectionConnected() fails when we haven't done turn discovery then we
+   * attempt to establish a media connection again, but this time using turn discovery. If we
+   * used turn discovery on the first pass we do not attempt connection again.
+   *
+   * @private
+   * @param {Error} error
+   * @param {RemoteMediaManagerConfiguration} [remoteMediaManagerConfig]
+   * @param {BundlePolicy} [bundlePolicy]
+   * @returns {Promise<void>}
+   */
+  private async handleWaitForMediaConnectionConnectedError(
+    error: Error,
+    remoteMediaManagerConfig?: RemoteMediaManagerConfiguration,
+    bundlePolicy?: BundlePolicy
+  ): Promise<void> {
+    const LOG_HEADER = 'Meeting:index#addMedia():handleWaitForMediaConnectionConnectedError -->';
+
+    // @ts-ignore - config coming from registerPlugin
+    if (!this.turnServerUsed) {
+      LoggerProxy.logger.info(
+        `${LOG_HEADER} error waiting for media to connect on UDP, TCP, retrying using TURN-TLS, `,
+        error
+      );
+
+      await this.retryWithForcedTurnDiscovery(remoteMediaManagerConfig, bundlePolicy);
+    } else {
+      LoggerProxy.logger.error(
+        `${LOG_HEADER} error waiting for media to connect using UDP, TCP and TURN-TLS`,
+        error
+      );
+
+      throw new AddMediaFailed();
+    }
+  }
+
+  /**
+   * Does TURN discovery, SDP offer/answer exhange, establishes ICE connection and DTLS handshake.
+   *
+   * @private
+   * @param {RemoteMediaManagerConfiguration} [remoteMediaManagerConfig]
+   * @param {BundlePolicy} [bundlePolicy]
+   * @param {boolean} [isForced] - let isForced be true to do turn discovery regardless of reachability results
+   * @returns {Promise<void>}
+   */
+  private async establishMediaConnection(
+    remoteMediaManagerConfig?: RemoteMediaManagerConfiguration,
+    bundlePolicy?: BundlePolicy,
+    isForced?: boolean
+  ): Promise<void> {
+    const LOG_HEADER = 'Meeting:index#addMedia():establishMediaConnection -->';
+    // @ts-ignore
+    const cdl = this.webex.internal.newMetrics.callDiagnosticLatencies;
+    const isRetry = this.retriedWithTurnServer;
+
+    try {
+      // @ts-ignore
+      this.webex.internal.newMetrics.submitInternalEvent({
+        name: 'internal.client.add-media.turn-discovery.start',
+      });
+
+      const turnDiscoveryObject = await this.roap.doTurnDiscovery(this, isRetry, isForced);
+
+      this.turnDiscoverySkippedReason = turnDiscoveryObject?.turnDiscoverySkippedReason;
+      this.turnServerUsed = !this.turnDiscoverySkippedReason;
+
+      // @ts-ignore
+      this.webex.internal.newMetrics.submitInternalEvent({
+        name: 'internal.client.add-media.turn-discovery.end',
+      });
+
+      const {turnServerInfo} = turnDiscoveryObject;
+
+      if (this.turnServerUsed && turnServerInfo) {
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.TURN_DISCOVERY_LATENCY, {
+          correlation_id: this.correlationId,
+          latency: cdl.getTurnDiscoveryTime(),
+          turnServerUsed: this.turnServerUsed,
+          retriedWithTurnServer: this.retriedWithTurnServer,
+        });
+      }
+
+      const mc = await this.createMediaConnection(turnServerInfo, bundlePolicy);
+
+      LoggerProxy.logger.info(`${LOG_HEADER} media connection created`);
+
+      if (this.isMultistream) {
+        this.remoteMediaManager = new RemoteMediaManager(
+          this.receiveSlotManager,
+          this.mediaRequestManagers,
+          remoteMediaManagerConfig
+        );
+
+        this.forwardEvent(
+          this.remoteMediaManager,
+          RemoteMediaManagerEvent.AudioCreated,
+          EVENT_TRIGGERS.REMOTE_MEDIA_AUDIO_CREATED
+        );
+        this.forwardEvent(
+          this.remoteMediaManager,
+          RemoteMediaManagerEvent.ScreenShareAudioCreated,
+          EVENT_TRIGGERS.REMOTE_MEDIA_SCREEN_SHARE_AUDIO_CREATED
+        );
+        this.forwardEvent(
+          this.remoteMediaManager,
+          RemoteMediaManagerEvent.VideoLayoutChanged,
+          EVENT_TRIGGERS.REMOTE_MEDIA_VIDEO_LAYOUT_CHANGED
+        );
+
+        await this.remoteMediaManager.start();
+      }
+
+      await mc.initiateOffer();
+
+      await this.waitForRemoteSDPAnswer();
+
+      this.handleMediaLogging(this.mediaProperties);
+    } catch (error) {
+      LoggerProxy.logger.error(`${LOG_HEADER} error establishing media connection, `, error);
+
+      throw error;
+    }
+
+    try {
+      await this.waitForMediaConnectionConnected();
+    } catch (error) {
+      await this.handleWaitForMediaConnectionConnectedError(
+        error,
+        remoteMediaManagerConfig,
+        bundlePolicy
+      );
+    }
+  }
+
+  /**
+   * Cleans up stats analyzer, peer connection, and turns off listeners
+   *
+   * @private
+   * @returns {Promise<void>}
+   */
+  private async cleanUpOnAddMediaFailure(): Promise<void> {
+    if (this.statsAnalyzer) {
+      await this.statsAnalyzer.stopAnalyzer();
+    }
+
+    this.statsAnalyzer = null;
+
+    // when media fails, we want to upload a webrtc dump to see whats going on
+    // this function is async, but returns once the stats have been gathered
+    await this.forceSendStatsReport({callFrom: 'addMedia'});
+
+    if (this.mediaProperties.webrtcMediaConnection) {
+      this.closePeerConnections();
+      this.unsetPeerConnections();
+    }
   }
 
   /**
-   * Listens for an event emitted by eventEmitter and emits it from the meeting object
+   * Sends stats report, closes peer connection and cleans up any media connection
+   * related things before trying to establish media connection again with turn server
    *
    * @private
-   * @param {*} eventEmitter object from which to forward the event
-   * @param {*} eventTypeToForward which event type to listen on and to forward
-   * @param {string} meetingEventType event type to be used in the event emitted from the meeting object
-   * @returns {void}
+   * @returns {Promise<void>}
    */
-  forwardEvent(eventEmitter, eventTypeToForward, meetingEventType) {
-    eventEmitter.on(eventTypeToForward, (data) =>
-      Trigger.trigger(
-        this,
-        {
-          file: 'meetings',
-          function: 'addMedia',
-        },
-        meetingEventType,
-        data
-      )
-    );
+  private async cleanUpBeforeRetryWithTurnServer(): Promise<void> {
+    // when media fails, we want to upload a webrtc dump to see whats going on
+    // this function is async, but returns once the stats have been gathered
+    await this.forceSendStatsReport({callFrom: 'cleanUpBeforeRetryWithTurnServer'});
+
+    if (this.mediaProperties.webrtcMediaConnection) {
+      if (this.remoteMediaManager) {
+        this.remoteMediaManager.stop();
+        this.remoteMediaManager = null;
+      }
+
+      Object.values(this.mediaRequestManagers).forEach((mediaRequestManager) =>
+        mediaRequestManager.reset()
+      );
+
+      this.receiveSlotManager.reset();
+      this.mediaProperties.webrtcMediaConnection.close();
+      this.sendSlotManager.reset();
+
+      this.mediaProperties.unsetPeerConnection();
+    }
   }
 
   /**
    * Creates a media connection to the server. Media connection is required for sending or receiving any audio/video.
    *
    * @param {AddMediaOptions} options
-   * @returns {Promise}
+   * @returns {Promise<void>}
    * @public
    * @memberof Meeting
    */
-  addMedia(options: AddMediaOptions = {}) {
+  async addMedia(options: AddMediaOptions = {}): Promise<void> {
+    this.retriedWithTurnServer = false;
+    this.hasMediaConnectionConnectedAtLeastOnce = false;
     const LOG_HEADER = 'Meeting:index#addMedia -->';
-
-    let turnDiscoverySkippedReason;
-    let turnServerUsed = false;
-
     LoggerProxy.logger.info(`${LOG_HEADER} called with: ${JSON.stringify(options)}`);
 
-    if (this.meetingState !== FULL_STATE.ACTIVE) {
-      return Promise.reject(new MeetingNotActiveError());
+    if (options.allowMediaInLobby !== true && this.meetingState !== FULL_STATE.ACTIVE) {
+      throw new MeetingNotActiveError();
     }
 
     if (MeetingUtil.isUserInLeftState(this.locusInfo)) {
-      return Promise.reject(new UserNotJoinedError());
+      throw new UserNotJoinedError();
     }
 
     const {
@@ -5459,7 +6512,7 @@ export default class Meeting extends StatelessWebexPlugin {
     // If the user is unjoined or guest waiting in lobby dont allow the user to addMedia
     // @ts-ignore - isUserUnadmitted coming from SelfUtil
     if (this.isUserUnadmitted && !this.wirelessShare && !allowMediaInLobby) {
-      return Promise.reject(new UserInLobbyError());
+      throw new UserInLobbyError();
     }
 
     // @ts-ignore
@@ -5519,240 +6572,100 @@ export default class Meeting extends StatelessWebexPlugin {
 
     this.audio = createMuteState(AUDIO, this, audioEnabled);
     this.video = createMuteState(VIDEO, this, videoEnabled);
-    const promises = [];
-
-    // setup all the references to local streams in this.mediaProperties before creating media connection
-    // and before TURN discovery, so that the correct mute state is sent with TURN discovery roap messages
-    if (localStreams?.microphone) {
-      promises.push(this.setLocalAudioStream(localStreams.microphone));
-    }
-    if (localStreams?.camera) {
-      promises.push(this.setLocalVideoStream(localStreams.camera));
-    }
-    if (localStreams?.screenShare?.video) {
-      promises.push(this.setLocalShareVideoStream(localStreams.screenShare.video));
-    }
-    if (localStreams?.screenShare?.audio) {
-      promises.push(this.setLocalShareAudioStream(localStreams.screenShare.audio));
-    }
-
-    return Promise.all(promises)
-      .then(() => this.roap.doTurnDiscovery(this, false))
-      .then(async (turnDiscoveryObject) => {
-        ({turnDiscoverySkippedReason} = turnDiscoveryObject);
-        turnServerUsed = !turnDiscoverySkippedReason;
 
-        const {turnServerInfo} = turnDiscoveryObject;
-
-        const mc = await this.createMediaConnection(turnServerInfo, bundlePolicy);
-
-        if (this.isMultistream) {
-          this.remoteMediaManager = new RemoteMediaManager(
-            this.receiveSlotManager,
-            this.mediaRequestManagers,
-            remoteMediaManagerConfig
-          );
-
-          this.forwardEvent(
-            this.remoteMediaManager,
-            RemoteMediaManagerEvent.AudioCreated,
-            EVENT_TRIGGERS.REMOTE_MEDIA_AUDIO_CREATED
-          );
-          this.forwardEvent(
-            this.remoteMediaManager,
-            RemoteMediaManagerEvent.ScreenShareAudioCreated,
-            EVENT_TRIGGERS.REMOTE_MEDIA_SCREEN_SHARE_AUDIO_CREATED
-          );
-          this.forwardEvent(
-            this.remoteMediaManager,
-            RemoteMediaManagerEvent.VideoLayoutChanged,
-            EVENT_TRIGGERS.REMOTE_MEDIA_VIDEO_LAYOUT_CHANGED
-          );
+    try {
+      await this.setUpLocalStreamReferences(localStreams);
 
-          await this.remoteMediaManager.start();
-        }
+      this.setMercuryListener();
 
-        await mc.initiateOffer();
-      })
-      .then(() => {
-        this.setMercuryListener();
-      })
-      .then(
-        () =>
-          getDevices()
-            .then((devices) => {
-              MeetingUtil.handleDeviceLogging(devices);
-            })
-            .catch(() => {}) // getDevices may fail if we don't have browser permissions, that's ok, we still can have a media connection
-      )
-      .then(() => {
-        this.handleMediaLogging(this.mediaProperties);
-        LoggerProxy.logger.info(`${LOG_HEADER} media connection created`);
+      this.createStatsAnalyzer();
 
-        // @ts-ignore - config coming from registerPlugin
-        if (this.config.stats.enableStatsAnalyzer) {
-          // @ts-ignore - config coming from registerPlugin
-          this.networkQualityMonitor = new NetworkQualityMonitor(this.config.stats);
-          this.statsAnalyzer = new StatsAnalyzer(
-            // @ts-ignore - config coming from registerPlugin
-            this.config.stats,
-            (ssrc: number) => this.receiveSlotManager.findReceiveSlotBySsrc(ssrc),
-            this.networkQualityMonitor
-          );
-          this.setupStatsAnalyzerEventHandlers();
-          this.networkQualityMonitor.on(
-            EVENT_TRIGGERS.NETWORK_QUALITY,
-            this.sendNetworkQualityEvent.bind(this)
-          );
-        }
-      })
-      .catch((error) => {
-        LoggerProxy.logger.error(
-          `${LOG_HEADER} Error adding media , setting up peerconnection, `,
-          error
-        );
+      await this.establishMediaConnection(remoteMediaManagerConfig, bundlePolicy, false);
 
-        throw error;
-      })
-      .then(
-        () =>
-          new Promise<void>((resolve, reject) => {
-            let timerCount = 0;
-
-            // eslint-disable-next-line func-names
-            // eslint-disable-next-line prefer-arrow-callback
-            if (this.type === _CALL_ || this.meetingState === FULL_STATE.ACTIVE) {
-              resolve();
-            }
-            const joiningTimer = setInterval(() => {
-              timerCount += 1;
-              if (this.meetingState === FULL_STATE.ACTIVE) {
-                clearInterval(joiningTimer);
-                resolve();
-              }
+      await Meeting.handleDeviceLogging();
 
-              if (timerCount === 4) {
-                clearInterval(joiningTimer);
-                reject(new Error('Meeting is still not active '));
-              }
-            }, 1000);
-          })
-      )
-      .then(() =>
-        this.mediaProperties.waitForMediaConnectionConnected().catch(() => {
-          // @ts-ignore
-          this.webex.internal.newMetrics.submitClientEvent({
-            name: 'client.ice.end',
-            payload: {
-              canProceed: false,
-              icePhase: 'JOIN_MEETING_FINAL',
-              errors: [
-                // @ts-ignore
-                this.webex.internal.newMetrics.callDiagnosticMetrics.getErrorPayloadForClientErrorCode(
-                  {
-                    clientErrorCode: CALL_DIAGNOSTIC_CONFIG.ICE_FAILURE_CLIENT_CODE,
-                  }
-                ),
-              ],
-            },
-            options: {
-              meetingId: this.id,
-            },
-          });
-          throw new Error(
-            `Timed out waiting for media connection to be connected, correlationId=${this.correlationId}`
-          );
-        })
-      )
-      .then(() => {
-        if (this.mediaProperties.hasLocalShareStream()) {
-          return this.enqueueScreenShareFloorRequest();
-        }
+      if (this.mediaProperties.hasLocalShareStream()) {
+        await this.enqueueScreenShareFloorRequest();
+      }
 
-        return Promise.resolve();
-      })
-      .then(() => this.mediaProperties.getCurrentConnectionType())
-      .then((connectionType) => {
-        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ADD_MEDIA_SUCCESS, {
-          correlation_id: this.correlationId,
-          locus_id: this.locusUrl.split('/').pop(),
-          connectionType,
-          isMultistream: this.isMultistream,
-        });
-        // @ts-ignore
-        this.webex.internal.newMetrics.submitClientEvent({
-          name: 'client.media-engine.ready',
-          options: {
-            meetingId: this.id,
-          },
-        });
-        LoggerProxy.logger.info(
-          `${LOG_HEADER} successfully established media connection, type=${connectionType}`
-        );
+      const connectionType = await this.mediaProperties.getCurrentConnectionType();
+      // @ts-ignore
+      const reachabilityStats = await this.webex.meetings.reachability.getReachabilityMetrics();
 
-        // We can log ReceiveSlot SSRCs only after the SDP exchange, so doing it here:
-        this.remoteMediaManager?.logAllReceiveSlots();
-      })
-      .catch((error) => {
-        LoggerProxy.logger.error(`${LOG_HEADER} failed to establish media connection: `, error);
+      Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ADD_MEDIA_SUCCESS, {
+        correlation_id: this.correlationId,
+        locus_id: this.locusUrl.split('/').pop(),
+        connectionType,
+        isMultistream: this.isMultistream,
+        retriedWithTurnServer: this.retriedWithTurnServer,
+        ...reachabilityStats,
+      });
+      // @ts-ignore
+      this.webex.internal.newMetrics.submitClientEvent({
+        name: 'client.media-engine.ready',
+        options: {
+          meetingId: this.id,
+        },
+      });
+      LoggerProxy.logger.info(
+        `${LOG_HEADER} successfully established media connection, type=${connectionType}`
+      );
 
-        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ADD_MEDIA_FAILURE, {
-          correlation_id: this.correlationId,
-          locus_id: this.locusUrl.split('/').pop(),
-          reason: error.message,
-          stack: error.stack,
-          code: error.code,
-          turnDiscoverySkippedReason,
-          turnServerUsed,
-          isMultistream: this.isMultistream,
-          signalingState:
-            this.mediaProperties.webrtcMediaConnection?.multistreamConnection?.pc?.pc
-              ?.signalingState ||
-            this.mediaProperties.webrtcMediaConnection?.mediaConnection?.pc?.signalingState ||
-            'unknown',
-          connectionState:
-            this.mediaProperties.webrtcMediaConnection?.multistreamConnection?.pc?.pc
-              ?.connectionState ||
-            this.mediaProperties.webrtcMediaConnection?.mediaConnection?.pc?.connectionState ||
-            'unknown',
-          iceConnectionState:
-            this.mediaProperties.webrtcMediaConnection?.multistreamConnection?.pc?.pc
-              ?.iceConnectionState ||
-            this.mediaProperties.webrtcMediaConnection?.mediaConnection?.pc?.iceConnectionState ||
-            'unknown',
-        });
+      // We can log ReceiveSlot SSRCs only after the SDP exchange, so doing it here:
+      this.remoteMediaManager?.logAllReceiveSlots();
+    } catch (error) {
+      LoggerProxy.logger.error(`${LOG_HEADER} failed to establish media connection: `, error);
 
-        // Clean up stats analyzer, peer connection, and turn off listeners
-        const stopStatsAnalyzer = this.statsAnalyzer
-          ? this.statsAnalyzer.stopAnalyzer()
-          : Promise.resolve();
+      // @ts-ignore
+      const reachabilityMetrics = await this.webex.meetings.reachability.getReachabilityMetrics();
 
-        return stopStatsAnalyzer.then(() => {
-          this.statsAnalyzer = null;
+      Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ADD_MEDIA_FAILURE, {
+        correlation_id: this.correlationId,
+        locus_id: this.locusUrl.split('/').pop(),
+        reason: error.message,
+        stack: error.stack,
+        code: error.code,
+        turnDiscoverySkippedReason: this.turnDiscoverySkippedReason,
+        turnServerUsed: this.turnServerUsed,
+        retriedWithTurnServer: this.retriedWithTurnServer,
+        isMultistream: this.isMultistream,
+        signalingState:
+          this.mediaProperties.webrtcMediaConnection?.multistreamConnection?.pc?.pc
+            ?.signalingState ||
+          this.mediaProperties.webrtcMediaConnection?.mediaConnection?.pc?.signalingState ||
+          'unknown',
+        connectionState:
+          this.mediaProperties.webrtcMediaConnection?.multistreamConnection?.pc?.pc
+            ?.connectionState ||
+          this.mediaProperties.webrtcMediaConnection?.mediaConnection?.pc?.connectionState ||
+          'unknown',
+        iceConnectionState:
+          this.mediaProperties.webrtcMediaConnection?.multistreamConnection?.pc?.pc
+            ?.iceConnectionState ||
+          this.mediaProperties.webrtcMediaConnection?.mediaConnection?.pc?.iceConnectionState ||
+          'unknown',
+        ...reachabilityMetrics,
+      });
 
-          if (this.mediaProperties.webrtcMediaConnection) {
-            this.closePeerConnections();
-            this.unsetPeerConnections();
-          }
+      await this.cleanUpOnAddMediaFailure();
 
-          // Upload logs on error while adding media
-          Trigger.trigger(
-            this,
-            {
-              file: 'meeting/index',
-              function: 'addMedia',
-            },
-            EVENTS.REQUEST_UPLOAD_LOGS,
-            this
-          );
+      // Upload logs on error while adding media
+      Trigger.trigger(
+        this,
+        {
+          file: 'meeting/index',
+          function: 'addMedia',
+        },
+        EVENTS.REQUEST_UPLOAD_LOGS,
+        this
+      );
 
-          if (error instanceof Errors.SdpError) {
-            this.leave({reason: MEETING_REMOVED_REASON.MEETING_CONNECTION_FAILED});
-          }
+      if (error instanceof Errors.SdpError) {
+        this.leave({reason: MEETING_REMOVED_REASON.MEETING_CONNECTION_FAILED});
+      }
 
-          throw error;
-        });
-      });
+      throw error;
+    }
   }
 
   /**
@@ -5766,6 +6679,24 @@ export default class Meeting extends StatelessWebexPlugin {
     return !this.isRoapInProgress;
   }
 
+  /**
+   *  media failed, so collect a stats report from webrtc using the wcme connection to grab the rtc stats report
+   * send a webrtc telemetry dump to the configured server using the internal media core check metrics configured callback
+   * @param {String} callFrom - the function calling this function, optional.
+   * @returns {Promise<void>}
+   */
+  private forceSendStatsReport = async ({callFrom}: {callFrom?: string}) => {
+    const LOG_HEADER = `Meeting:index#forceSendStatsReport --> called from ${callFrom} : `;
+    try {
+      await this.mediaProperties?.webrtcMediaConnection?.forceRtcMetricsSend();
+      LoggerProxy.logger.info(
+        `${LOG_HEADER} successfully uploaded available webrtc telemetry statistics`
+      );
+    } catch (e) {
+      LoggerProxy.logger.error(`${LOG_HEADER} failed to upload webrtc telemetry statistics: `, e);
+    }
+  };
+
   /**
    * Enqueues a media update operation.
    * @param {String} mediaUpdateType one of MEDIA_UPDATE_TYPE values
@@ -6231,17 +7162,13 @@ export default class Meeting extends StatelessWebexPlugin {
         .catch((error) => {
           LoggerProxy.logger.error('Meeting:index#stopWhiteboardShare --> Error ', error);
 
-          Metrics.sendBehavioralMetric(
-            // @ts-ignore - check if STOP_WHITEBOARD_SHARE_FAILURE exists
-            BEHAVIORAL_METRICS.STOP_WHITEBOARD_SHARE_FAILURE,
-            {
-              correlation_id: this.correlationId,
-              locus_id: this.locusUrl.split('/').pop(),
-              reason: error.message,
-              stack: error.stack,
-              board: {channelUrl},
-            }
-          );
+          Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.MEETING_STOP_WHITEBOARD_SHARE_FAILURE, {
+            correlation_id: this.correlationId,
+            locus_id: this.locusUrl.split('/').pop(),
+            reason: error.message,
+            stack: error.stack,
+            board: {channelUrl},
+          });
 
           return Promise.reject(error);
         })
@@ -6278,11 +7205,14 @@ export default class Meeting extends StatelessWebexPlugin {
       if (content && this.shareStatus !== SHARE_STATUS.LOCAL_SHARE_ACTIVE) {
         // @ts-ignore
         this.webex.internal.newMetrics.submitClientEvent({
-          name: 'client.share.initiated',
+          name: 'client.share.floor-grant.request',
           payload: {
             mediaType: 'share',
+            shareInstanceId: this.localShareInstanceId,
+          },
+          options: {
+            meetingId: this.id,
           },
-          options: {meetingId: this.id},
         });
 
         return this.meetingRequest
@@ -6292,10 +7222,16 @@ export default class Meeting extends StatelessWebexPlugin {
             deviceUrl: this.deviceUrl,
             uri: content.url,
             resourceUrl: this.resourceUrl,
+            shareInstanceId: this.localShareInstanceId,
           })
           .then(() => {
             this.screenShareFloorState = ScreenShareFloorStatus.GRANTED;
 
+            Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.MEETING_SHARE_SUCCESS, {
+              correlation_id: this.correlationId,
+              locus_id: this.locusUrl.split('/').pop(),
+            });
+
             return Promise.resolve();
           })
           .catch((error) => {
@@ -6308,6 +7244,19 @@ export default class Meeting extends StatelessWebexPlugin {
               stack: error.stack,
             });
 
+            // @ts-ignore
+            this.webex.internal.newMetrics.submitClientEvent({
+              name: 'client.share.floor-granted.local',
+              payload: {
+                mediaType: 'share',
+                errors: MeetingUtil.getChangeMeetingFloorErrorPayload(error.message),
+                shareInstanceId: this.localShareInstanceId,
+              },
+              options: {
+                meetingId: this.id,
+              },
+            });
+
             this.screenShareFloorState = ScreenShareFloorStatus.RELEASED;
 
             return Promise.reject(error);
@@ -6359,6 +7308,7 @@ export default class Meeting extends StatelessWebexPlugin {
         name: 'client.share.stopped',
         payload: {
           mediaType: 'share',
+          shareInstanceId: this.localShareInstanceId,
         },
         options: {meetingId: this.id},
       });
@@ -6375,6 +7325,7 @@ export default class Meeting extends StatelessWebexPlugin {
           deviceUrl: this.deviceUrl,
           uri: content.url,
           resourceUrl: this.resourceUrl,
+          shareInstanceId: this.localShareInstanceId,
         })
         .catch((error) => {
           LoggerProxy.logger.error('Meeting:index#releaseScreenShareFloor --> Error ', error);
@@ -6578,8 +7529,8 @@ export default class Meeting extends StatelessWebexPlugin {
 
     if (layoutType) {
       if (!LAYOUT_TYPES.includes(layoutType)) {
-        this.rejectWithErrorLog(
-          'Meeting:index#changeVideoLayout --> cannot change video layout, invalid layoutType recieved.'
+        return this.rejectWithErrorLog(
+          'Meeting:index#changeVideoLayout --> cannot change video layout, invalid layoutType received.'
         );
       }
 
@@ -6717,6 +7668,23 @@ export default class Meeting extends StatelessWebexPlugin {
     }
   };
 
+  /**
+   * Functionality for when a share video is muted or unmuted.
+   * @private
+   * @memberof Meeting
+   * @param {boolean} muted
+   * @returns {undefined}
+   */
+  private handleShareVideoStreamMuteStateChange = (muted: boolean) => {
+    LoggerProxy.logger.log(
+      `Meeting:index#handleShareVideoStreamMuteStateChange --> Share video stream mute state changed to muted ${muted}`
+    );
+    Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.MEETING_SHARE_VIDEO_MUTE_STATE_CHANGE, {
+      correlationId: this.correlationId,
+      muted,
+    });
+  };
+
   /**
    * Functionality for when a share video is ended.
    * @private
@@ -6817,6 +7785,9 @@ export default class Meeting extends StatelessWebexPlugin {
       if (roles.includes(SELF_ROLES.COHOST)) {
         return 'cohost';
       }
+      if (roles.includes(SELF_ROLES.PRESENTER)) {
+        return 'presenter';
+      }
       if (roles.includes(SELF_ROLES.ATTENDEE)) {
         return 'attendee';
       }
@@ -6907,8 +7878,7 @@ export default class Meeting extends StatelessWebexPlugin {
     this.queuedMediaUpdates = [];
 
     if (this.transcription) {
-      this.transcription.closeSocket();
-      this.triggerStopReceivingTranscriptionEvent();
+      this.stopTranscription();
       this.transcription = undefined;
     }
   };
@@ -7083,10 +8053,12 @@ export default class Meeting extends StatelessWebexPlugin {
       .update({
         // TODO: RoapMediaConnection is not ready to use stream classes yet, so we pass the raw MediaStreamTrack for now
         localTracks: {
-          audio: this.mediaProperties.audioStream?.outputTrack || null,
-          video: this.mediaProperties.videoStream?.outputTrack || null,
-          screenShareVideo: this.mediaProperties.shareVideoStream?.outputTrack || null,
-          screenShareAudio: this.mediaProperties.shareAudioStream?.outputTrack || null,
+          audio: this.mediaProperties.audioStream?.outputStream?.getTracks()[0] || null,
+          video: this.mediaProperties.videoStream?.outputStream?.getTracks()[0] || null,
+          screenShareVideo:
+            this.mediaProperties.shareVideoStream?.outputStream?.getTracks()[0] || null,
+          screenShareAudio:
+            this.mediaProperties.shareAudioStream?.outputStream?.getTracks()[0] || null,
         },
         direction: {
           audio: Media.getDirection(
@@ -7220,6 +8192,23 @@ export default class Meeting extends StatelessWebexPlugin {
     }
 
     if (floorRequestNeeded) {
+      this.localShareInstanceId = uuid.v4();
+
+      // @ts-ignore
+      this.webex.internal.newMetrics.submitClientEvent({
+        name: 'client.share.initiated',
+        payload: {
+          mediaType: 'share',
+          shareInstanceId: this.localShareInstanceId,
+        },
+        options: {meetingId: this.id},
+      });
+
+      this.statsAnalyzer.updateMediaStatus({
+        expected: {
+          sendShare: true,
+        },
+      });
       // we're sending the http request to Locus to request the screen share floor
       // only after the SDP update, because that's how it's always been done for transcoded meetings
       // and also if sharing from the start, we need confluence to have been created
@@ -7268,6 +8257,12 @@ export default class Meeting extends StatelessWebexPlugin {
     if (!this.mediaProperties.hasLocalShareStream()) {
       try {
         this.releaseScreenShareFloor(); // we ignore the returned promise here on purpose
+
+        this.statsAnalyzer.updateMediaStatus({
+          expected: {
+            sendShare: false,
+          },
+        });
       } catch (e) {
         // nothing to do here, error is logged already inside releaseScreenShareFloor()
       }
@@ -7275,24 +8270,51 @@ export default class Meeting extends StatelessWebexPlugin {
   }
 
   /**
-   * Gets the time left in seconds till the permission token expires
+   * Gets permission token expiry information including timeLeft, expiryTime, currentTime
    * (from the time the function has been fired)
    *
-   * @returns {number} time left in seconds
+   * @returns {object} permissionTokenExpiryInfo
+   * @returns {number} permissionTokenExpiryInfo.timeLeft The time left for token to expire
+   * @returns {number} permissionTokenExpiryInfo.expiryTime The expiry time of permission token from the server
+   * @returns {number} permissionTokenExpiryInfo.currentTime The current time of the local machine
    */
-  public getPermissionTokenTimeLeftInSec(): number | undefined {
+  public getPermissionTokenExpiryInfo() {
     if (!this.permissionTokenPayload) {
       return undefined;
     }
 
-    const permissionTokenExpValue = Number(this.permissionTokenPayload.exp);
+    const permissionTokenExpiryFromServer = Number(this.permissionTokenPayload.exp);
+    const permissionTokenIssuedTimeFromServer = Number(this.permissionTokenPayload.iat);
+
+    const shiftInTime = this.permissionTokenReceivedLocalTime - permissionTokenIssuedTimeFromServer;
 
     // using new Date instead of Date.now() to allow for accurate unit testing
     // https://github.com/sinonjs/fake-timers/issues/321
-    const now = new Date().getTime();
+    const currentTime = new Date().getTime();
+
+    // adjusted time is calculated in case your machine time is wrong
+    const adjustedCurrentTime = currentTime - shiftInTime;
+
+    const timeLeft = (permissionTokenExpiryFromServer - adjustedCurrentTime) / 1000;
+
+    return {timeLeft, expiryTime: permissionTokenExpiryFromServer, currentTime};
+  }
 
-    // substract current time from the permissionTokenExp
-    // (permissionTokenExp is a epoch timestamp, not a time to live duration)
-    return (permissionTokenExpValue - now) / 1000;
+  /**
+   * Check if there is enough time left till the permission token expires
+   * If not - refresh the permission token
+   *
+   * @param {number} threshold - time in seconds
+   * @param {string} reason - reason for refreshing the permission token
+   * @returns {Promise<void>}
+   */
+  public checkAndRefreshPermissionToken(threshold: number, reason: string): Promise<void> {
+    const timeLeft = this.getPermissionTokenExpiryInfo()?.timeLeft;
+
+    if (timeLeft !== undefined && timeLeft <= threshold) {
+      return this.refreshPermissionToken(reason);
+    }
+
+    return Promise.resolve();
   }
 }