@webex/plugin-meetings 3.12.0-next.9 → 3.12.0-task-refactor.1

package/src/meetings/util.ts

@@ -117,16 +117,15 @@ MeetingsUtil.getMediaServerIp = (sdp) => {
   return mediaServerIp;
 };
 
-/**
- * Finds correlationId of a device from locus self devices array
- * that matches the given deviceUrl
- * @param {string} deviceUrl
- * @param {object} locusSelf
- * @returns {string|false} correlationId or false if not found
- */
-MeetingsUtil.getCorrelationIdForDevice = (deviceUrl: string, locusSelf: any) => {
-  if (locusSelf?.devices) {
-    const foundDevice = locusSelf?.devices.find((device) => device.url === deviceUrl);
+MeetingsUtil.checkForCorrelationId = (deviceUrl, locus) => {
+  let devices = [];
+
+  if (locus) {
+    if (locus && locus.self && locus.self.devices) {
+      devices = locus.self.devices;
+    }
+
+    const foundDevice = devices.find((device) => device.url === deviceUrl);
 
     if (foundDevice && foundDevice.correlationId) {
       return foundDevice.correlationId;

package/src/member/index.ts

@@ -13,7 +13,6 @@ export type MemberId = string;
 export default class Member {
   associatedUser: MemberId | null; // deprecated, use associatedUsers instead
   associatedUsers: Set<MemberId>; // users associated with this device, empty if this member is not a device
-  canApproveAIEnablement: boolean;
   canReclaimHost: boolean;
   id: MemberId;
   isAudioMuted: any;
@@ -292,14 +291,6 @@ export default class Member {
      */
     this.isPresenterAssignmentProhibited = null;
 
-    /**
-     * @instance
-     * @type {Boolean}
-     * @public
-     * @memberof Member
-     */
-    this.canApproveAIEnablement = null;
-
     /**
      * @instance
      * @type {Boolean}
@@ -369,7 +360,6 @@ export default class Member {
         MemberUtil.isModeratorAssignmentProhibited(participant);
       this.isPresenterAssignmentProhibited =
         MemberUtil.isPresenterAssignmentProhibited(participant);
-      this.canApproveAIEnablement = MemberUtil.canApproveAIEnablement(participant);
       this.processStatus(participant);
       this.processRoles(participant);
       // must be done last

package/src/member/util.ts

@@ -42,18 +42,6 @@ const MemberUtil = {
     return participant.canReclaimHostRole || false;
   },
 
-  /**
-   * @param {Object} participant - The locus participant object.
-   * @returns {Boolean}
-   */
-  canApproveAIEnablement: (participant) => {
-    if (!participant) {
-      return false;
-    }
-
-    return !participant.attendeeRequestAiAssistantNotAllowed;
-  },
-
   /**
    * @param {Object} participant - The locus participant object.
    * @returns {[ServerRoleShape]}

package/src/metrics/constants.ts

@@ -21,7 +21,6 @@ const BEHAVIORAL_METRICS = {
   GET_DISPLAY_MEDIA_FAILURE: 'js_sdk_get_display_media_failures',
   JOIN_WITH_MEDIA_FAILURE: 'js_sdk_join_with_media_failures',
   LLM_CONNECTION_AFTER_JOIN_FAILURE: 'js_sdk_llm_connection_after_join_failure',
-  LLM_HEALTHCHECK_FAILURE: 'js_sdk_llm_healthcheck_failure',
   RECEIVE_TRANSCRIPTION_AFTER_JOIN_FAILURE: 'js_sdk_receive_transcription_after_join_failure',
 
   DISCONNECT_DUE_TO_INACTIVITY: 'js_sdk_disconnect_due_to_inactivity',
@@ -90,12 +89,6 @@ const BEHAVIORAL_METRICS = {
   MEDIA_ISSUE_DETECTED: 'js_sdk_media_issue_detected',
   LOCUS_CLASSIC_VS_HASH_TREE_MISMATCH: 'js_sdk_locus_classic_vs_hash_tree_mismatch',
   LOCUS_HASH_TREE_UNSUPPORTED_OPERATION: 'js_sdk_locus_hash_tree_unsupported_operation',
-  MEDIA_STILL_NOT_CONNECTED: 'js_sdk_media_still_not_connected',
-  DEPRECATED_SET_CODEC_PARAMETERS_USED: 'js_sdk_deprecated_set_codec_parameters_used',
-  DEPRECATED_DELETE_CODEC_PARAMETERS_USED: 'js_sdk_deprecated_delete_codec_parameters_used',
-  SET_CUSTOM_CODEC_PARAMETERS_USED: 'js_sdk_set_custom_codec_parameters_used',
-  MARK_CUSTOM_CODEC_PARAMETERS_FOR_DELETION_USED:
-    'js_sdk_mark_custom_codec_parameters_for_deletion_used',
 };
 
 export {BEHAVIORAL_METRICS as default};

package/src/multistream/mediaRequestManager.ts

@@ -10,7 +10,7 @@ import {
   RecommendedOpusBitrates,
   NamedMediaGroup,
 } from '@webex/internal-media-core';
-import {cloneDeepWith, debounce} from 'lodash';
+import {cloneDeepWith, debounce, isEmpty} from 'lodash';
 
 import LoggerProxy from '../common/logs/logger-proxy';
 
@@ -94,6 +94,8 @@ export class MediaRequestManager {
 
   private debouncedSourceUpdateListener: () => void;
 
+  private previousStreamRequests: Array<StreamRequest> = [];
+
   private trimRequestsToNumOfSources: boolean;
   private numTotalSources: number;
   private numLiveSources: number;
@@ -159,6 +161,36 @@ export class MediaRequestManager {
     }
   }
 
+  /**
+   * Returns true if two stream requests are the same, false otherwise.
+   *
+   * @param {StreamRequest} streamRequestA - Stream request A for comparison.
+   * @param {StreamRequest} streamRequestB - Stream request B for comparison.
+   * @returns {boolean} - Whether they are equal.
+   */
+  // eslint-disable-next-line class-methods-use-this
+  public isEqual(streamRequestA: StreamRequest, streamRequestB: StreamRequest) {
+    return (
+      JSON.stringify(streamRequestA._toJmpStreamRequest()) ===
+      JSON.stringify(streamRequestB._toJmpStreamRequest())
+    );
+  }
+
+  /**
+   * Compares new stream requests to previous ones and determines
+   * if they are the same.
+   *
+   * @param {StreamRequest[]} newRequests - Array with new requests.
+   * @returns {boolean} - True if they are equal, false otherwise.
+   */
+  private checkIsNewRequestsEqualToPrev(newRequests: StreamRequest[]) {
+    return (
+      !isEmpty(this.previousStreamRequests) &&
+      this.previousStreamRequests.length === newRequests.length &&
+      this.previousStreamRequests.every((req, idx) => this.isEqual(req, newRequests[idx]))
+    );
+  }
+
   /**
    * Returns the maxPayloadBitsPerSecond per Stream
    *
@@ -198,6 +230,15 @@ export class MediaRequestManager {
     return (mediaRequest.codecInfo.maxFs * maxFps) / 100;
   }
 
+  /**
+   * Clears the previous stream requests.
+   *
+   * @returns {void}
+   */
+  public clearPreviousRequests(): void {
+    this.previousStreamRequests = [];
+  }
+
   /** Modifies the passed in clientRequests and makes sure that in total they don't ask
    *  for more streams than there are available.
    *
@@ -315,7 +356,7 @@ export class MediaRequestManager {
             mr.receiveSlots.map((receiveSlot) => receiveSlot.wcmeReceiveSlot),
             this.getMaxPayloadBitsPerSecond(mr),
             mr.codecInfo && [
-              WcmeCodecInfo.fromH264(
+              new WcmeCodecInfo(
                 0x80,
                 new H264Codec(
                   mr.codecInfo.maxFs,
@@ -331,8 +372,17 @@ export class MediaRequestManager {
       }
     });
 
-    this.sendMediaRequestsCallback(streamRequests);
-    LoggerProxy.logger.info(`multistream:sendRequests --> media requests sent. `);
+    //! IMPORTANT: this is only a temporary fix. This will soon be done in the jmp layer (@webex/json-multistream)
+    // https://jira-eng-gpk2.cisco.com/jira/browse/WEBEX-326713
+    if (!this.checkIsNewRequestsEqualToPrev(streamRequests)) {
+      this.sendMediaRequestsCallback(streamRequests);
+      this.previousStreamRequests = streamRequests;
+      LoggerProxy.logger.info(`multistream:sendRequests --> media requests sent. `);
+    } else {
+      LoggerProxy.logger.info(
+        `multistream:sendRequests --> detected duplicate WCME requests, skipping them... `
+      );
+    }
   }
 
   public addRequest(mediaRequest: MediaRequest, commit = true): MediaRequestId {

package/src/multistream/remoteMediaManager.ts

@@ -67,18 +67,6 @@ const AllEqualLayout: VideoLayout = {
   ],
 };
 
-// An "all equal" grid, with size up to 5 x 5 = 25:
-const AllEqual25Layout: VideoLayout = {
-  activeSpeakerVideoPaneGroups: [
-    {
-      id: 'main',
-      numPanes: 25,
-      size: 'best',
-      priority: 255,
-    },
-  ],
-};
-
 // A layout with just a single remote active speaker video pane:
 const SingleLayout: VideoLayout = {
   activeSpeakerVideoPaneGroups: [
@@ -176,7 +164,6 @@ export const DefaultConfiguration: Configuration = {
 
     layouts: {
       AllEqual: AllEqualLayout,
-      AllEqual25: AllEqual25Layout,
       OnePlusFive: OnePlusFiveLayout,
       Single: SingleLayout,
       Stage: Stage2x2With6ThumbnailsLayout,

package/src/multistream/sendSlotManager.ts

@@ -5,11 +5,7 @@ import {
   MultistreamRoapMediaConnection,
   NamedMediaGroup,
   StreamState,
-  MediaCodecMimeType,
-  CodecParameters,
 } from '@webex/internal-media-core';
-import Metrics from '../metrics';
-import BEHAVIORAL_METRICS from '../metrics/constants';
 
 /**
  * This class is used to manage the sendSlots for the given media types.
@@ -210,8 +206,6 @@ export default class SendSlotManager {
   }
 
   /**
-   * @deprecated Use {@link setCustomCodecParameters} instead, which requires specifying the codec MIME type.
-   *
    * This method is used to set the codec parameters for the sendSlot of the given mediaType
    * @param {MediaType} mediaType MediaType of the sendSlot for which the codec parameters needs to be set (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)
    * @param {Object} codecParameters
@@ -232,19 +226,12 @@ export default class SendSlotManager {
 
     await slot.setCodecParameters(codecParameters);
 
-    this.LoggerProxy.logger.warn(
-      'SendSlotsManager->setCodecParameters --> [DEPRECATION WARNING]: setCodecParameters has been deprecated, use setCustomCodecParameters instead'
+    this.LoggerProxy.logger.info(
+      `SendSlotsManager->setCodecParameters#Set codec parameters for ${mediaType} to ${codecParameters}`
     );
-
-    Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.DEPRECATED_SET_CODEC_PARAMETERS_USED, {
-      mediaType,
-      codecParameters,
-    });
   }
 
   /**
-   * @deprecated Use {@link markCustomCodecParametersForDeletion} instead, which requires specifying the codec MIME type.
-   *
    * This method is used to delete the codec parameters for the sendSlot of the given mediaType
    * @param {MediaType} mediaType MediaType of the sendSlot for which the codec parameters needs to be deleted (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)
    * @param {Array<String>} parameters Array of keys of the codec parameters to be deleted
@@ -259,89 +246,8 @@ export default class SendSlotManager {
 
     await slot.deleteCodecParameters(parameters);
 
-    this.LoggerProxy.logger.warn(
-      'SendSlotsManager->deleteCodecParameters --> [DEPRECATION WARNING]: deleteCodecParameters has been deprecated, use markCustomCodecParametersForDeletion instead'
-    );
-
-    Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.DEPRECATED_DELETE_CODEC_PARAMETERS_USED, {
-      mediaType,
-      parameters,
-    });
-  }
-
-  /**
-   * Sets custom codec parameters for the sendSlot of the given mediaType, scoped to a specific codec MIME type.
-   * Delegates to WCME's setCustomCodecParameters API.
-   * @param {MediaType} mediaType MediaType of the sendSlot
-   * @param {MediaCodecMimeType} codecMimeType The codec MIME type to apply parameters to (e.g. OPUS, H264, AV1)
-   * @param {CodecParameters} parameters Key-value pairs of codec parameters to set
-   * @returns {Promise<void>}
-   */
-  public async setCustomCodecParameters(
-    mediaType: MediaType,
-    codecMimeType: MediaCodecMimeType,
-    parameters: CodecParameters
-  ): Promise<void> {
-    const slot = this.slots.get(mediaType);
-
-    if (!slot) {
-      throw new Error(`Slot for ${mediaType} does not exist`);
-    }
-
-    try {
-      await slot.setCustomCodecParameters(codecMimeType, parameters);
-
-      this.LoggerProxy.logger.info(
-        `SendSlotsManager->setCustomCodecParameters#Set custom codec parameters for ${mediaType} (codec: ${codecMimeType}) to ${JSON.stringify(
-          parameters
-        )}`
-      );
-    } catch (error) {
-      this.LoggerProxy.logger.error(
-        `SendSlotsManager->setCustomCodecParameters#Failed to set custom codec parameters for ${mediaType} (codec: ${codecMimeType}): ${error}`
-      );
-      throw error;
-    } finally {
-      Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.SET_CUSTOM_CODEC_PARAMETERS_USED, {
-        mediaType,
-        codecMimeType,
-        parameters,
-      });
-    }
-  }
-
-  /**
-   * Marks custom codec parameters for deletion on the sendSlot of the given mediaType, scoped to a specific codec MIME type.
-   * Delegates to WCME's markCustomCodecParametersForDeletion API.
-   * @param {MediaType} mediaType MediaType of the sendSlot
-   * @param {MediaCodecMimeType} codecMimeType The codec MIME type whose parameters should be deleted (e.g. OPUS, H264, AV1)
-   * @param {string[]} parameters Array of parameter keys to delete
-   * @returns {Promise<void>}
-   */
-  public async markCustomCodecParametersForDeletion(
-    mediaType: MediaType,
-    codecMimeType: MediaCodecMimeType,
-    parameters: string[]
-  ): Promise<void> {
-    const slot = this.slots.get(mediaType);
-
-    if (!slot) {
-      throw new Error(`Slot for ${mediaType} does not exist`);
-    }
-
-    await slot.markCustomCodecParametersForDeletion(codecMimeType, parameters);
-
     this.LoggerProxy.logger.info(
-      `SendSlotsManager->markCustomCodecParametersForDeletion#Marked codec parameters for deletion -> ${parameters} for ${mediaType} (codec: ${codecMimeType})`
-    );
-
-    Metrics.sendBehavioralMetric(
-      BEHAVIORAL_METRICS.MARK_CUSTOM_CODEC_PARAMETERS_FOR_DELETION_USED,
-      {
-        mediaType,
-        codecMimeType,
-        parameters,
-      }
+      `SendSlotsManager->deleteCodecParameters#Deleted the following codec parameters -> ${parameters} for ${mediaType}`
     );
   }
 

package/src/reachability/clusterReachability.ts

@@ -1,6 +1,5 @@
 import {ClusterNode} from './request';
 import EventsScope from '../common/events/events-scope';
-import LoggerProxy from '../common/logs/logger-proxy';
 
 import {Enum} from '../constants';
 import {
@@ -38,117 +37,36 @@ export type Events = Enum<typeof Events>;
 
 /**
  * A class that handles reachability checks for a single cluster.
- * Creates and orchestrates ReachabilityPeerConnection instance(s).
+ * Creates and orchestrates a ReachabilityPeerConnection instance.
  * Listens to events and emits them to consumers.
- *
- * When enablePerUdpUrlReachability is true:
- *   - Creates one ReachabilityPeerConnection for each UDP URL
- *   - Creates one ReachabilityPeerConnection for all TCP and TLS URLs together
- * Otherwise:
- *   - Creates a single ReachabilityPeerConnection for all URLs
  */
 export class ClusterReachability extends EventsScope {
-  private reachabilityPeerConnection: ReachabilityPeerConnection | null = null;
-  private reachabilityPeerConnectionsForUdp: ReachabilityPeerConnection[] = [];
-
+  private reachabilityPeerConnection: ReachabilityPeerConnection;
   public readonly isVideoMesh: boolean;
   public readonly name;
   public readonly reachedSubnets: Set<string> = new Set();
 
-  private enablePerUdpUrlReachability: boolean;
-  private udpResultEmitted = false;
-
   /**
    * Constructor for ClusterReachability
    * @param {string} name cluster name
    * @param {ClusterNode} clusterInfo information about the media cluster
-   * @param {boolean} enablePerUdpUrlReachability whether to create separate peer connections per UDP URL
    */
-  constructor(name: string, clusterInfo: ClusterNode, enablePerUdpUrlReachability = false) {
+  constructor(name: string, clusterInfo: ClusterNode) {
     super();
     this.name = name;
     this.isVideoMesh = clusterInfo.isVideoMesh;
-    this.enablePerUdpUrlReachability = enablePerUdpUrlReachability;
 
-    if (this.enablePerUdpUrlReachability) {
-      this.initializePerUdpUrlReachabilityCheck(clusterInfo);
-    } else {
-      this.initializeSingleReachabilityPeerConnection(clusterInfo);
-    }
-  }
+    this.reachabilityPeerConnection = new ReachabilityPeerConnection(name, clusterInfo);
 
-  /**
-   * Initializes a single ReachabilityPeerConnection for all protocols
-   * @param {ClusterNode} clusterInfo information about the media cluster
-   * @returns {void}
-   */
-  private initializeSingleReachabilityPeerConnection(clusterInfo: ClusterNode) {
-    this.reachabilityPeerConnection = new ReachabilityPeerConnection(this.name, clusterInfo);
-    this.setupReachabilityPeerConnectionEventListeners(this.reachabilityPeerConnection);
+    this.setupReachabilityPeerConnectionEventListeners();
   }
 
   /**
-   * Initializes per-URL UDP reachability checks:
-   * - One ReachabilityPeerConnection per UDP URL
-   * - One ReachabilityPeerConnection for all TCP and TLS URLs together
-   * @param {ClusterNode} clusterInfo information about the media cluster
+   * Sets up event listeners for the ReachabilityPeerConnection instance
    * @returns {void}
    */
-  private initializePerUdpUrlReachabilityCheck(clusterInfo: ClusterNode) {
-    LoggerProxy.logger.log(
-      `ClusterReachability#initializePerUdpUrlReachabilityCheck --> cluster: ${this.name}, performing per-URL UDP reachability for ${clusterInfo.udp.length} URLs`
-    );
-
-    // Create one ReachabilityPeerConnection for each UDP URL
-    clusterInfo.udp.forEach((udpUrl) => {
-      const singleUdpClusterInfo: ClusterNode = {
-        isVideoMesh: clusterInfo.isVideoMesh,
-        udp: [udpUrl],
-        tcp: [],
-        xtls: [],
-      };
-      const rpc = new ReachabilityPeerConnection(this.name, singleUdpClusterInfo);
-      this.setupReachabilityPeerConnectionEventListeners(rpc, true);
-      this.reachabilityPeerConnectionsForUdp.push(rpc);
-    });
-
-    // Create one ReachabilityPeerConnection for all TCP and TLS URLs together
-    if (clusterInfo.tcp.length > 0 || clusterInfo.xtls.length > 0) {
-      const tcpTlsClusterInfo: ClusterNode = {
-        isVideoMesh: clusterInfo.isVideoMesh,
-        udp: [],
-        tcp: clusterInfo.tcp,
-        xtls: clusterInfo.xtls,
-      };
-      this.reachabilityPeerConnection = new ReachabilityPeerConnection(
-        this.name,
-        tcpTlsClusterInfo
-      );
-      this.setupReachabilityPeerConnectionEventListeners(this.reachabilityPeerConnection);
-    }
-  }
-
-  /**
-   * Sets up event listeners for a ReachabilityPeerConnection instance
-   * @param {ReachabilityPeerConnection} rpc the ReachabilityPeerConnection instance
-   * @param {boolean} isUdpPerUrl whether this is a per-URL UDP instance
-   * @returns {void}
-   */
-  private setupReachabilityPeerConnectionEventListeners(
-    rpc: ReachabilityPeerConnection,
-    isUdpPerUrl = false
-  ) {
-    rpc.on(ReachabilityPeerConnectionEvents.resultReady, (data) => {
-      // For per-URL UDP checks, only emit the first successful UDP result
-      if (isUdpPerUrl && data.protocol === 'udp') {
-        if (this.udpResultEmitted) {
-          return;
-        }
-        if (data.result === 'reachable') {
-          this.udpResultEmitted = true;
-        }
-      }
-
+  private setupReachabilityPeerConnectionEventListeners() {
+    this.reachabilityPeerConnection.on(ReachabilityPeerConnectionEvents.resultReady, (data) => {
       this.emit(
         {
           file: 'clusterReachability',
@@ -159,18 +77,21 @@ export class ClusterReachability extends EventsScope {
       );
     });
 
-    rpc.on(ReachabilityPeerConnectionEvents.clientMediaIpsUpdated, (data) => {
-      this.emit(
-        {
-          file: 'clusterReachability',
-          function: 'setupReachabilityPeerConnectionEventListeners',
-        },
-        Events.clientMediaIpsUpdated,
-        data
-      );
-    });
+    this.reachabilityPeerConnection.on(
+      ReachabilityPeerConnectionEvents.clientMediaIpsUpdated,
+      (data) => {
+        this.emit(
+          {
+            file: 'clusterReachability',
+            function: 'setupReachabilityPeerConnectionEventListeners',
+          },
+          Events.clientMediaIpsUpdated,
+          data
+        );
+      }
+    );
 
-    rpc.on(ReachabilityPeerConnectionEvents.natTypeUpdated, (data) => {
+    this.reachabilityPeerConnection.on(ReachabilityPeerConnectionEvents.natTypeUpdated, (data) => {
       this.emit(
         {
           file: 'clusterReachability',
@@ -181,54 +102,18 @@ export class ClusterReachability extends EventsScope {
       );
     });
 
-    rpc.on(ReachabilityPeerConnectionEvents.reachedSubnets, (data) => {
-      data.subnets.forEach((subnet: string) => {
+    this.reachabilityPeerConnection.on(ReachabilityPeerConnectionEvents.reachedSubnets, (data) => {
+      data.subnets.forEach((subnet) => {
         this.reachedSubnets.add(subnet);
       });
     });
   }
 
   /**
-   * Gets the aggregated reachability result for this cluster.
    * @returns {ClusterReachabilityResult} reachability result for this cluster
    */
   getResult(): ClusterReachabilityResult {
-    if (!this.enablePerUdpUrlReachability) {
-      return (
-        this.reachabilityPeerConnection?.getResult() ?? {
-          udp: {result: 'untested'},
-          tcp: {result: 'untested'},
-          xtls: {result: 'untested'},
-        }
-      );
-    }
-
-    const result: ClusterReachabilityResult = {
-      udp: {result: 'untested'},
-      tcp: {result: 'untested'},
-      xtls: {result: 'untested'},
-    };
-
-    // Get the first reachable UDP result from per-URL instances
-    for (const rpc of this.reachabilityPeerConnectionsForUdp) {
-      const rpcResult = rpc.getResult();
-      if (rpcResult.udp.result === 'reachable') {
-        result.udp = rpcResult.udp;
-        break;
-      }
-      if (rpcResult.udp.result === 'unreachable' && result.udp.result === 'untested') {
-        result.udp = rpcResult.udp;
-      }
-    }
-
-    // Get TCP and TLS results from the main peer connection
-    if (this.reachabilityPeerConnection) {
-      const mainResult = this.reachabilityPeerConnection.getResult();
-      result.tcp = mainResult.tcp;
-      result.xtls = mainResult.xtls;
-    }
-
-    return result;
+    return this.reachabilityPeerConnection.getResult();
   }
 
   /**
@@ -236,17 +121,7 @@ export class ClusterReachability extends EventsScope {
    * @returns {Promise<ClusterReachabilityResult>}
    */
   async start(): Promise<ClusterReachabilityResult> {
-    const startPromises: Promise<ClusterReachabilityResult>[] = [];
-
-    this.reachabilityPeerConnectionsForUdp.forEach((rpc) => {
-      startPromises.push(rpc.start());
-    });
-
-    if (this.reachabilityPeerConnection) {
-      startPromises.push(this.reachabilityPeerConnection.start());
-    }
-
-    await Promise.all(startPromises);
+    await this.reachabilityPeerConnection.start();
 
     return this.getResult();
   }
@@ -256,7 +131,6 @@ export class ClusterReachability extends EventsScope {
    * @returns {void}
    */
   public abort() {
-    this.reachabilityPeerConnectionsForUdp.forEach((rpc) => rpc.abort());
-    this.reachabilityPeerConnection?.abort();
+    this.reachabilityPeerConnection.abort();
   }
 }

package/src/reachability/index.ts

@@ -6,7 +6,6 @@
 import {isEqual, mapValues, mean} from 'lodash';
 
 import {Defer} from '@webex/common';
-import {CapabilityState, WebCapabilities} from '@webex/web-capabilities';
 import LoggerProxy from '../common/logs/logger-proxy';
 import MeetingUtil from '../meeting/util';
 
@@ -197,14 +196,6 @@ export default class Reachability extends EventsScope {
     if (!this.webex.config.meetings.enableReachabilityChecks) {
       throw new Error('enableReachabilityChecks is disabled in config');
     }
-
-    if (WebCapabilities.supportsRTCPeerConnection() !== CapabilityState.CAPABLE) {
-      LoggerProxy.logger.warn(
-        'Reachability:index#gatherReachability --> WebRTC API is not available, skipping reachability checks'
-      );
-
-      return {};
-    }
     // Fetch clusters and measure latency
     try {
       this.lastTrigger = trigger;
@@ -970,12 +961,7 @@ export default class Reachability extends EventsScope {
     Object.keys(clusterList).forEach((key) => {
       const cluster = clusterList[key];
 
-      this.clusterReachability[key] = new ClusterReachability(
-        key,
-        cluster,
-        // @ts-ignore
-        this.webex.config.meetings.enablePerUdpUrlReachability
-      );
+      this.clusterReachability[key] = new ClusterReachability(key, cluster);
       this.clusterReachability[key].on(Events.resultReady, async (data: ResultEventData) => {
         const {protocol, result, clientMediaIPs, latencyInMilliseconds} = data;
 

package/src/reachability/reachabilityPeerConnection.ts

@@ -243,9 +243,7 @@ export class ReachabilityPeerConnection extends EventsScope {
     if (result.latencyInMilliseconds === undefined) {
       LoggerProxy.logger.log(
         // @ts-ignore
-        `Reachability:ReachabilityPeerConnection#saveResult --> Successfully reached ${
-          this.clusterName
-        } over ${protocol}: ${latency}ms, serverIp=${serverIp || 'unknown'}`
+        `Reachability:ReachabilityPeerConnection#saveResult --> Successfully reached ${this.clusterName} over ${protocol}: ${latency}ms`
       );
       result.latencyInMilliseconds = latency;
       result.result = 'reachable';

package/src/reactions/reactions.type.ts

@@ -40,7 +40,6 @@ export enum SkinToneType {
 }
 
 export type Sender = {
-  displayName: string;
   participantId: string;
 };
 

package/src/reconnection-manager/index.ts

@@ -609,6 +609,7 @@ export default class ReconnectionManager {
     if (this.meeting.isMultistream) {
       Object.values(this.meeting.mediaRequestManagers).forEach(
         (mediaRequestManager: MediaRequestManager) => {
+          mediaRequestManager.clearPreviousRequests();
           mediaRequestManager.commit();
         }
       );