@webex/plugin-meetings 3.1.0 → 3.2.0

package/src/reachability/index.ts

@@ -296,6 +296,63 @@ export default class Reachability {
     return reachable;
   }
 
+  /**
+   * Returns true only if ALL protocols (UDP, TCP and TLS) have been tested and none
+   * of the media clusters where reachable with any of the protocols. This is done
+   * irrespective of the config, so for example:
+   * if config.meetings.experimental.enableTlsReachability === false,
+   * it will return false, because TLS reachability won't be tested,
+   * so we can't say for sure that media backend is unreachable over TLS.
+   *
+   * @returns {boolean}
+   */
+  async isWebexMediaBackendUnreachable() {
+    let unreachable = false;
+
+    // @ts-ignore
+    const reachabilityData = await this.webex.boundedStorage
+      .get(this.namespace, REACHABILITY.localStorageResult)
+      .catch(() => {});
+
+    if (reachabilityData) {
+      try {
+        const reachabilityResults: ReachabilityResults = JSON.parse(reachabilityData);
+
+        const protocols = {
+          udp: {tested: false, reachable: undefined},
+          tcp: {tested: false, reachable: undefined},
+          xtls: {tested: false, reachable: undefined},
+        };
+
+        Object.values(reachabilityResults).forEach((result) => {
+          Object.keys(protocols).forEach((protocol) => {
+            if (
+              result[protocol]?.result === 'reachable' ||
+              result[protocol]?.result === 'unreachable'
+            ) {
+              protocols[protocol].tested = true;
+
+              // we need at least 1 'reachable' result to mark the whole protocol as reachable
+              if (result[protocol].result === 'reachable') {
+                protocols[protocol].reachable = true;
+              }
+            }
+          });
+        });
+
+        unreachable = Object.values(protocols).every(
+          (protocol) => protocol.tested && !protocol.reachable
+        );
+      } catch (e) {
+        LoggerProxy.logger.error(
+          `Roap:request#attachReachabilityData --> Error in parsing reachability data: ${e}`
+        );
+      }
+    }
+
+    return unreachable;
+  }
+
   /**
    * Get list of all unreachable clusters
    * @returns {array} Unreachable clusters
@@ -314,6 +371,9 @@ export default class Reachability {
       if (result.tcp.result === 'unreachable') {
         unreachableList.push({name: key, protocol: 'tcp'});
       }
+      if (result.xtls.result === 'unreachable') {
+        unreachableList.push({name: key, protocol: 'xtls'});
+      }
     });
 
     return unreachableList;

package/src/reconnection-manager/index.ts

@@ -17,11 +17,11 @@ import {
   RECONNECTION_STATE,
 } from '../constants';
 import BEHAVIORAL_METRICS from '../metrics/constants';
-import ReconnectInProgress from '../common/errors/reconnection-in-progress';
+import ReconnectionError from '../common/errors/reconnection';
+import ReconnectionNotStartedError from '../common/errors/reconnection-not-started';
 import Metrics from '../metrics';
 import Meeting from '../meeting';
 import {MediaRequestManager} from '../multistream/mediaRequestManager';
-import ReconnectionError from '../common/errors/reconnection';
 
 /**
  * Used to indicate that the reconnect logic needs to be retried.
@@ -73,7 +73,6 @@ export default class ReconnectionManager {
   rejoinAttempts: any;
   shareStatus: any;
   status: any;
-  tryCount: any;
   webex: any;
   /**
    * @param {Meeting} meeting
@@ -102,13 +101,6 @@ export default class ReconnectionManager {
      * @memberof ReconnectionManager
      */
     this.status = RECONNECTION.STATE.DEFAULT_STATUS;
-    /**
-     * @instance
-     * @type {Number}
-     * @private
-     * @memberof ReconnectionManager
-     */
-    this.tryCount = RECONNECTION.STATE.DEFAULT_TRY_COUNT;
     /**
      * @instance
      * @type {Object}
@@ -131,7 +123,7 @@ export default class ReconnectionManager {
 
     // @ts-ignore
     this.maxRejoinAttempts = meeting.config.reconnection.maxRejoinAttempts;
-    this.rejoinAttempts = RECONNECTION.STATE.DEFAULT_TRY_COUNT;
+    this.rejoinAttempts = 0;
     // @ts-ignore
     this.autoRejoinEnabled = meeting.config.reconnection.autoRejoin;
 
@@ -217,8 +209,7 @@ export default class ReconnectionManager {
    */
   public reset() {
     this.status = RECONNECTION.STATE.DEFAULT_STATUS;
-    this.tryCount = RECONNECTION.STATE.DEFAULT_TRY_COUNT;
-    this.rejoinAttempts = RECONNECTION.STATE.DEFAULT_TRY_COUNT;
+    this.rejoinAttempts = 0;
   }
 
   /**
@@ -265,43 +256,30 @@ export default class ReconnectionManager {
     return this.status === RECONNECTION.STATE.IN_PROGRESS;
   }
 
-  /**
-   * Sets the reconnection status
-   *
-   * @public
-   * @param {RECONNECTION_STATE} status
-   * @memberof ReconnectionManager
-   * @returns {undefined}
-   */
-  public setStatus(status: RECONNECTION_STATE) {
-    this.status = status;
-  }
-
   /**
    * @returns {Boolean}
-   * @throws {ReconnectionError}
+   * @throws {ReconnectInProgress, ReconnectionDisabled}
    * @private
    * @memberof ReconnectionManager
    */
-  private validate() {
+  private canStartReconnection() {
     if (this.meeting.config.reconnection.enabled) {
-      if (
-        this.status === RECONNECTION.STATE.DEFAULT_STATUS ||
-        this.status === RECONNECTION.STATE.COMPLETE
-      ) {
+      if (this.status === RECONNECTION.STATE.DEFAULT_STATUS) {
         return true;
       }
 
       LoggerProxy.logger.info(
-        'ReconnectionManager:index#validate --> Reconnection already in progress.'
+        'ReconnectionManager:index#canStartReconnection --> Reconnection already in progress.'
       );
 
-      throw new ReconnectInProgress('Reconnection already in progress.');
+      return false;
     }
 
-    LoggerProxy.logger.info('ReconnectionManager:index#validate --> Reconnection is not enabled.');
+    LoggerProxy.logger.info(
+      'ReconnectionManager:index#canStartReconnection --> Reconnection is not enabled.'
+    );
 
-    throw new ReconnectionError('Reconnection is not enabled.');
+    return false;
   }
 
   /**
@@ -309,105 +287,152 @@ export default class ReconnectionManager {
    * @param {Object} reconnectOptions
    * @param {boolean} [reconnectOptions.networkDisconnect=false] indicates if a network disconnect event happened
    * @param {boolean} [reconnectOptions.networkRetry=false] indicates if we are retrying the reconnect
+   * @param {Function} [completionCallback] callback that gets called when reconnection is started successfully
    * @returns {Promise}
    * @public
    * @memberof ReconnectionManager
    */
-  public async reconnect({
-    networkDisconnect = false,
-    networkRetry = false,
-  }: {
-    networkDisconnect?: boolean;
-    networkRetry?: boolean;
-  } = {}) {
+  public async reconnect(
+    {
+      networkDisconnect = false,
+      networkRetry = false,
+    }: {
+      networkDisconnect?: boolean;
+      networkRetry?: boolean;
+    } = {},
+    completionCallback: (() => Promise<void>) | undefined = undefined
+  ) {
     LoggerProxy.logger.info(
       `ReconnectionManager:index#reconnect --> Reconnection start for meeting ${this.meeting.id}.`
     );
-    // First, validate that we can reconnect, if not, it will throw an error
-    try {
-      this.validate();
-    } catch (error) {
-      LoggerProxy.logger.info(
-        'ReconnectionManager:index#reconnect --> Reconnection unable to begin.',
-        error
-      );
-      throw error;
-    }
 
-    if (!networkRetry) {
-      // Only log START metrics on the initial reconnect
-      LoggerProxy.logger.info(
-        'ReconnectionManager:index#reconnect --> Sending reconnect start metric.'
+    const triggerEvent = (event, payload = undefined) =>
+      Trigger.trigger(
+        this.meeting,
+        {
+          file: 'reconnection-manager/index',
+          function: 'reconnect',
+        },
+        event,
+        payload
       );
 
-      // @ts-ignore
-      this.webex.internal.newMetrics.submitClientEvent({
-        name: 'client.media.reconnecting',
-        options: {
-          meetingId: this.meeting.id,
-        },
-      });
+    if (!this.canStartReconnection()) {
+      throw new ReconnectionNotStartedError();
     }
 
     try {
-      await this.webex.meetings.startReachability();
-    } catch (err) {
-      LoggerProxy.logger.info(
-        'ReconnectionManager:index#reconnect --> Reachability failed, continuing with reconnection attempt, err: ',
-        err
-      );
-    }
+      this.status = RECONNECTION.STATE.IN_PROGRESS;
 
-    try {
-      const media = await this.executeReconnection({networkDisconnect});
+      triggerEvent(EVENT_TRIGGERS.MEETING_RECONNECTION_STARTING);
 
-      return media;
-    } catch (reconnectError) {
-      if (reconnectError instanceof NeedsRetryError) {
+      if (!networkRetry) {
+        // Only log START metrics on the initial reconnect
         LoggerProxy.logger.info(
-          'ReconnectionManager:index#reconnect --> Reconnection not successful, retrying.'
+          'ReconnectionManager:index#reconnect --> Sending reconnect start metric.'
         );
-        // Reset our reconnect status since we are looping back to the beginning
-        this.status = RECONNECTION.STATE.DEFAULT_STATUS;
 
-        // This is a network retry, so we should not log START metrics again
-        return this.reconnect({networkDisconnect: true, networkRetry: true});
+        // @ts-ignore
+        this.webex.internal.newMetrics.submitClientEvent({
+          name: 'client.media.reconnecting',
+          options: {
+            meetingId: this.meeting.id,
+          },
+        });
       }
 
-      // Reconnect has failed
-      LoggerProxy.logger.error(
-        'ReconnectionManager:index#reconnect --> Reconnection failed.',
-        reconnectError.message
-      );
-      LoggerProxy.logger.info(
-        'ReconnectionManager:index#reconnect --> Sending reconnect abort metric.'
-      );
+      try {
+        await this.webex.meetings.startReachability();
+      } catch (err) {
+        LoggerProxy.logger.info(
+          'ReconnectionManager:index#reconnect --> Reachability failed, continuing with reconnection attempt, err: ',
+          err
+        );
+      }
+
+      try {
+        await this.executeReconnection({networkDisconnect});
+      } catch (reconnectError) {
+        if (reconnectError instanceof NeedsRetryError) {
+          LoggerProxy.logger.info(
+            'ReconnectionManager:index#reconnect --> Reconnection not successful, retrying.'
+          );
+          // Reset our reconnect status since we are looping back to the beginning
+          this.status = RECONNECTION.STATE.DEFAULT_STATUS;
+
+          // This is a network retry, so we should not log START metrics again
+          await this.reconnect({networkDisconnect: true, networkRetry: true}, completionCallback);
+
+          return;
+        }
+
+        // Reconnect has failed
+        LoggerProxy.logger.error(
+          'ReconnectionManager:index#reconnect --> Reconnection failed.',
+          reconnectError.message
+        );
+
+        // send call aborted event with category as expected as we are trying to rejoin
+        // @ts-ignore
+        this.webex.internal.newMetrics.submitClientEvent({
+          name: 'client.call.aborted',
+          payload: {
+            errors: [
+              {
+                category: 'expected',
+                errorCode: 2008,
+                fatal: true,
+                name: 'media-engine',
+                shownToUser: false,
+              },
+            ],
+          },
+          options: {
+            meetingId: this.meeting.id,
+          },
+        });
+
+        if (reconnectError instanceof NeedsRejoinError && this.autoRejoinEnabled) {
+          await this.rejoinMeeting(reconnectError.wasSharing);
+
+          return;
+        }
+
+        throw reconnectError;
+      }
+
+      // finalize the reconnection process by calling the completionCallback
+      if (completionCallback) {
+        await completionCallback();
+      }
+
+      triggerEvent(EVENT_TRIGGERS.MEETING_RECONNECTION_SUCCESS);
 
-      // send call aborted event with catogery as expected as we are trying to rejoin
       // @ts-ignore
       this.webex.internal.newMetrics.submitClientEvent({
-        name: 'client.call.aborted',
+        name: 'client.media.recovered',
         payload: {
-          errors: [
-            {
-              category: 'expected',
-              errorCode: 2008,
-              fatal: true,
-              name: 'media-engine',
-              shownToUser: false,
-            },
-          ],
+          recoveredBy: 'new',
         },
         options: {
           meetingId: this.meeting.id,
         },
       });
+    } catch (error) {
+      triggerEvent(EVENT_TRIGGERS.MEETING_RECONNECTION_FAILURE, {
+        error: new ReconnectionError('Reconnection failure event', error),
+      });
 
-      if (reconnectError instanceof NeedsRejoinError && this.autoRejoinEnabled) {
-        return this.rejoinMeeting(reconnectError.wasSharing);
-      }
+      Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.MEETING_RECONNECT_FAILURE, {
+        correlation_id: this.meeting.correlationId,
+        locus_id: this.meeting.locusUrl.split('/').pop(),
+        reason: error.message,
+        stack: error.stack,
+      });
 
-      throw reconnectError;
+      throw new ReconnectionError('Reconnection failure event', error);
+    } finally {
+      this.reset();
     }
   }
 
@@ -420,8 +445,6 @@ export default class ReconnectionManager {
    * @memberof ReconnectionManager
    */
   private async executeReconnection({networkDisconnect = false}: {networkDisconnect?: boolean}) {
-    this.status = RECONNECTION.STATE.IN_PROGRESS;
-
     LoggerProxy.logger.info(
       'ReconnectionManager:index#executeReconnection --> Attempting to reconnect to meeting.'
     );

package/src/roap/request.ts

@@ -61,7 +61,7 @@ export default class RoapRequest extends StatelessWebexPlugin {
     ipVersion?: IP_VERSION;
     locusMediaRequest?: LocusMediaRequest;
   }) {
-    const {roapMessage, locusSelfUrl, mediaId, meetingId, locusMediaRequest, ipVersion} = options;
+    const {roapMessage, locusSelfUrl, mediaId, locusMediaRequest, ipVersion} = options;
 
     if (!mediaId) {
       LoggerProxy.logger.info('Roap:request#sendRoap --> sending empty mediaID');
@@ -82,14 +82,6 @@ export default class RoapRequest extends StatelessWebexPlugin {
       `Roap:request#sendRoap --> ${locusSelfUrl} \n ${roapMessage.messageType} \n seq:${roapMessage.seq}`
     );
 
-    // @ts-ignore
-    this.webex.internal.newMetrics.submitClientEvent({
-      name: 'client.locus.media.request',
-      options: {
-        meetingId,
-      },
-    });
-
     return locusMediaRequest
       .send({
         type: 'RoapMessage',
@@ -101,13 +93,6 @@ export default class RoapRequest extends StatelessWebexPlugin {
         ipVersion,
       })
       .then((res) => {
-        // @ts-ignore
-        this.webex.internal.newMetrics.submitClientEvent({
-          name: 'client.locus.media.response',
-          options: {
-            meetingId,
-          },
-        });
         // always it will be the first mediaConnection Object
         const mediaConnections =
           res.body.mediaConnections &&
@@ -131,14 +116,6 @@ export default class RoapRequest extends StatelessWebexPlugin {
         };
       })
       .catch((err) => {
-        // @ts-ignore
-        this.webex.internal.newMetrics.submitClientEvent({
-          name: 'client.locus.media.response',
-          options: {
-            meetingId,
-            rawError: err,
-          },
-        });
         LoggerProxy.logger.error(`Roap:request#sendRoap --> Error:`, err);
         LoggerProxy.logger.error(
           `Roap:request#sendRoapRequest --> roapMessage that caused error:${JSON.stringify(

package/src/statsAnalyzer/index.ts

@@ -998,12 +998,13 @@ export class StatsAnalyzer extends EventsScope {
         result.qualityLimitationReason;
       this.statsResults[mediaType][sendrecvType].qualityLimitationResolutionChanges =
         result.qualityLimitationResolutionChanges;
-      this.statsResults[mediaType][sendrecvType].retransmittedPacketsSent =
+      this.statsResults[mediaType][sendrecvType].totalRtxPacketsSent =
         result.retransmittedPacketsSent;
+      this.statsResults[mediaType][sendrecvType].totalRtxBytesSent = result.retransmittedBytesSent;
       this.statsResults[mediaType][sendrecvType].totalBytesSent = result.bytesSent;
       this.statsResults[mediaType][sendrecvType].headerBytesSent = result.headerBytesSent;
-      this.statsResults[mediaType][sendrecvType].retransmittedBytesSent =
-        result.retransmittedBytesSent;
+      this.statsResults[mediaType][sendrecvType].requestedBitrate = result.requestedBitrate;
+      this.statsResults[mediaType][sendrecvType].requestedFrameSize = result.requestedFrameSize;
     }
   }
 
@@ -1116,6 +1117,8 @@ export class StatsAnalyzer extends EventsScope {
 
       this.statsResults[mediaType][sendrecvType].lastPacketReceivedTimestamp =
         result.lastPacketReceivedTimestamp;
+      this.statsResults[mediaType][sendrecvType].requestedBitrate = result.requestedBitrate;
+      this.statsResults[mediaType][sendrecvType].requestedFrameSize = result.requestedFrameSize;
 
       // From Thin
       this.statsResults[mediaType][sendrecvType].totalNackCount = result.nackCount;
@@ -1132,6 +1135,10 @@ export class StatsAnalyzer extends EventsScope {
       this.statsResults[mediaType][sendrecvType].fecPacketsReceived = result.fecPacketsReceived;
       this.statsResults[mediaType][sendrecvType].totalBytesReceived = result.bytesReceived;
       this.statsResults[mediaType][sendrecvType].headerBytesReceived = result.headerBytesReceived;
+      this.statsResults[mediaType][sendrecvType].totalRtxPacketsReceived =
+        result.retransmittedPacketsReceived;
+      this.statsResults[mediaType][sendrecvType].totalRtxBytesReceived =
+        result.retransmittedBytesReceived;
 
       this.statsResults[mediaType][sendrecvType].meanRtpJitter.push(result.jitter);
 

package/src/statsAnalyzer/mqaUtil.ts

@@ -216,6 +216,8 @@ export const getAudioSenderStreamMqa = ({
     statsResults[mediaType][sendrecvType].totalKeyFramesEncoded - lastFramesEncoded || 0;
   audioSenderStream.requestedKeyFrames =
     statsResults[mediaType][sendrecvType].totalFirCount - lastFirCount || 0;
+
+  audioSenderStream.requestedBitrate = statsResults[mediaType][sendrecvType].requestedBitrate || 0;
 };
 
 export const getVideoReceiverMqa = ({
@@ -235,10 +237,16 @@ export const getVideoReceiverMqa = ({
   const lastPacketsLost = getLastTotalValue('totalPacketsLost');
   const lastBytesReceived = getLastTotalValue('totalBytesReceived');
 
+  const lastRtxPacketsReceived = getLastTotalValue('totalRtxPacketsReceived');
+  const lastRtxBytesReceived = getLastTotalValue('totalRtxBytesReceived');
+
   const packetsLost = getTotalValue('totalPacketsLost');
   const totalPacketsReceived = getTotalValue('totalPacketsReceived');
   const totalBytesReceived = getTotalValue('totalBytesReceived');
 
+  const totalRtxPacketsReceived = getTotalValue('totalRtxPacketsReceived');
+  const totalRtxBytesReceived = getTotalValue('totalRtxBytesReceived');
+
   const meanRemoteJitter = Object.keys(statsResults)
     .filter((mt) => mt.includes(baseMediaType))
     .reduce((acc, mt) => acc.concat(statsResults[mt][sendrecvType].meanRemoteJitter), []);
@@ -264,10 +272,15 @@ export const getVideoReceiverMqa = ({
 
   // Calculate the outgoing bitrate
   const totalBytesReceivedInaMin = totalBytesReceived - lastBytesReceived;
+  const totalRtxBytesReceivedInaMin = totalRtxBytesReceived - lastRtxBytesReceived;
 
   videoReceiver.common.rtpBitrate = totalBytesReceivedInaMin
     ? (totalBytesReceivedInaMin * 8) / 60
     : 0;
+  videoReceiver.common.rtxPackets = totalRtxPacketsReceived - lastRtxPacketsReceived;
+  videoReceiver.common.rtxBitrate = totalRtxBytesReceivedInaMin
+    ? (totalRtxBytesReceivedInaMin * 8) / 60
+    : 0;
 };
 
 export const getVideoReceiverStreamMqa = ({
@@ -347,11 +360,15 @@ export const getVideoSenderMqa = ({videoSender, statsResults, lastMqaDataSent, b
   const lastPacketsSent = getLastTotalValue('totalPacketsSent');
   const lastBytesSent = getLastTotalValue('totalBytesSent');
   const lastPacketsLostTotal = getLastTotalValue('totalPacketsLostOnReceiver');
+  const lastRtxPacketsSent = getLastTotalValue('totalRtxPacketsSent');
+  const lastRtxBytesSent = getLastTotalValue('totalRtxBytesSent');
 
   const totalPacketsLostOnReceiver = getTotalValue('totalPacketsLostOnReceiver');
   const totalPacketsSent = getTotalValue('totalPacketsSent');
   const totalBytesSent = getTotalValue('totalBytesSent');
   const availableOutgoingBitrate = getTotalValue('availableOutgoingBitrate');
+  const totalRtxPacketsSent = getTotalValue('totalRtxPacketsSent');
+  const totalRtxBytesSent = getTotalValue('totalRtxBytesSent');
 
   videoSender.common.common.direction =
     statsResults[Object.keys(statsResults).find((mediaType) => mediaType.includes(baseMediaType))]
@@ -387,8 +404,11 @@ export const getVideoSenderMqa = ({videoSender, statsResults, lastMqaDataSent, b
 
   // Calculate the outgoing bitrate
   const totalBytesSentInaMin = totalBytesSent - lastBytesSent;
+  const totalRtxBytesSentInaMin = totalRtxBytesSent - lastRtxBytesSent;
 
   videoSender.common.rtpBitrate = totalBytesSentInaMin ? (totalBytesSentInaMin * 8) / 60 : 0;
+  videoSender.common.rtxPackets = totalRtxPacketsSent - lastRtxPacketsSent;
+  videoSender.common.rtxBitrate = totalRtxBytesSentInaMin ? (totalRtxBytesSentInaMin * 8) / 60 : 0;
 };
 
 export const getVideoSenderStreamMqa = ({
@@ -437,4 +457,7 @@ export const getVideoSenderStreamMqa = ({
   videoSenderStream.transmittedWidth = statsResults[mediaType][sendrecvType].width || 0;
   videoSenderStream.transmittedFrameSize =
     (videoSenderStream.transmittedHeight * videoSenderStream.transmittedWidth) / 256;
+  videoSenderStream.requestedBitrate = statsResults[mediaType][sendrecvType].requestedBitrate || 0;
+  videoSenderStream.requestedFrameSize =
+    statsResults[mediaType][sendrecvType].requestedFrameSize || 0;
 };

package/test/unit/spec/locus-info/controlsUtils.js

@@ -269,6 +269,26 @@ describe('plugin-meetings', () => {
         assert.equal(updates.hasInterpretationChanged, false);
       });
 
+      it('returns hasManualCaptionChanged = true when it has changed', () => {
+        const newControls = {
+          manualCaptionControl: {enabled: false},
+        };
+
+        const {updates} = ControlsUtils.getControls({manualCaptionControl: {enabled: true}}, newControls);
+
+        assert.equal(updates.hasManualCaptionChanged, true);
+      });
+
+      it('returns hasManualCaptionChanged = false when it has not changed', () => {
+        const newControls = {
+          manualCaptionControl: {enabled: true},
+        };
+
+        const {updates} = ControlsUtils.getControls({manualCaptionControl: {enabled: true}}, newControls);
+
+        assert.equal(updates.hasManualCaptionChanged, false);
+      });
+
       describe('videoEnabled', () => {
         const testVideoEnabled = (oldControls, newControls, updatedProperty) => {
           const result = ControlsUtils.getControls(oldControls, newControls);

package/test/unit/spec/locus-info/index.js

@@ -467,6 +467,27 @@ describe('plugin-meetings', () => {
         );
       });
 
+      it('should update the manual caption state', () => {
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.controls = {
+          manualCaptionControl: {enabled: false},
+        };
+
+        locusInfo.updateControls({manualCaptionControl: { enabled: true, }});
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {
+            file: 'locus-info',
+            function: 'updateControls',
+          },
+          LOCUSINFO.EVENTS.CONTROLS_MEETING_MANUAL_CAPTION_UPDATED,
+          {
+            enabled: true,
+          }
+        );
+      });
+
       it('should update the meetingContainerURL from null', () => {
         locusInfo.controls = {
           meetingContainer: {meetingContainerUrl: null},