@webex/plugin-meetings 3.8.0-web-workers-keepalive.1 → 3.8.1-next.1

package/src/media/index.ts

@@ -16,11 +16,13 @@ import {
   LocalMicrophoneStream,
 } from '@webex/media-helpers';
 import {RtcMetrics} from '@webex/internal-plugin-metrics';
+import {BrowserInfo} from '@webex/web-capabilities';
 import LoggerProxy from '../common/logs/logger-proxy';
 import {MEDIA_TRACK_CONSTRAINT} from '../constants';
 import Config from '../config';
 import StaticConfig from '../common/config';
 import BrowserDetection from '../common/browser-detection';
+import {TurnServerInfo} from '../roap/types';
 
 const {isBrowser} = BrowserDetection();
 
@@ -138,13 +140,12 @@ Media.createMediaConnection = (
     remoteQualityLevel?: 'LOW' | 'MEDIUM' | 'HIGH';
     enableRtx?: boolean;
     enableExtmap?: boolean;
-    turnServerInfo?: {
-      url: string;
-      username: string;
-      password: string;
-    };
+    turnServerInfo?: TurnServerInfo;
     bundlePolicy?: BundlePolicy;
     iceCandidatesTimeout?: number;
+    disableAudioMainDtx?: boolean;
+    enableAudioTwcc?: boolean;
+    stopIceGatheringAfterFirstRelayCandidate?: boolean;
   }
 ) => {
   const {
@@ -156,28 +157,18 @@ Media.createMediaConnection = (
     turnServerInfo,
     bundlePolicy,
     iceCandidatesTimeout,
+    disableAudioMainDtx,
+    enableAudioTwcc,
+    stopIceGatheringAfterFirstRelayCandidate,
   } = options;
 
   const iceServers = [];
 
-  // we might not have any TURN server if TURN discovery failed or wasn't done or
-  // we might get an empty TURN url if we land on a video mesh node
-  if (turnServerInfo?.url) {
-    if (!isBrowser('firefox')) {
-      let bareTurnServer = turnServerInfo.url;
-      bareTurnServer = bareTurnServer.replace('turns:', 'turn:');
-      bareTurnServer = bareTurnServer.replace('443', '5004');
-
-      iceServers.push({
-        urls: bareTurnServer,
-        username: turnServerInfo.username || '',
-        credential: turnServerInfo.password || '',
-      });
-    }
-
+  // we might not have any TURN server if TURN discovery failed or wasn't done or we land on a video mesh node
+  if (turnServerInfo?.urls.length > 0) {
     // TURN-TLS server
     iceServers.push({
-      urls: turnServerInfo.url,
+      urls: turnServerInfo.urls,
       username: turnServerInfo.username || '',
       credential: turnServerInfo.password || '',
     });
@@ -186,12 +177,23 @@ Media.createMediaConnection = (
   if (isMultistream) {
     const config: MultistreamConnectionConfig = {
       iceServers,
+      disableAudioTwcc: !enableAudioTwcc,
     };
 
     if (bundlePolicy) {
       config.bundlePolicy = bundlePolicy;
     }
 
+    if (disableAudioMainDtx !== undefined) {
+      config.disableAudioMainDtx = disableAudioMainDtx;
+    }
+
+    if (BrowserInfo.isFirefox()) {
+      config.doFullIce = true;
+
+      config.stopIceGatheringAfterFirstRelayCandidate = stopIceGatheringAfterFirstRelayCandidate;
+    }
+
     return new MultistreamRoapMediaConnection(
       config,
       meetingId,

package/src/media/properties.ts

@@ -7,6 +7,8 @@ import {
   RemoteStream,
 } from '@webex/media-helpers';
 
+import {parse} from '@webex/ts-sdp';
+import {ClientEvent} from '@webex/internal-plugin-metrics';
 import {MEETINGS, QUALITY_LEVELS} from '../constants';
 import LoggerProxy from '../common/logs/logger-proxy';
 import MediaConnectionAwaiter from './MediaConnectionAwaiter';
@@ -20,6 +22,8 @@ export type MediaDirection = {
   receiveShare: boolean;
 };
 
+export type IPVersion = ClientEvent['payload']['ipVersion'];
+
 /**
  * @class MediaProperties
  */
@@ -212,6 +216,91 @@ export default class MediaProperties {
     };
   }
 
+  /**
+   * Checks if the given IP address is IPv6
+   * @param {string} ip address to check
+   * @returns {boolean} true if the address is IPv6, false otherwise
+   */
+  private isIPv6(ip: string): boolean {
+    return ip.includes(':');
+  }
+
+  /** Finds out if we connected using IPv4 or IPv6
+   * @param {RTCPeerConnection} webrtcMediaConnection
+   * @param {Array<any>} allStatsReports array of RTC stats reports
+   * @returns {string} IPVersion
+   */
+  private getConnectionIpVersion(
+    webrtcMediaConnection: RTCPeerConnection,
+    allStatsReports: any[]
+  ): IPVersion | undefined {
+    const transports = allStatsReports.filter((report) => report.type === 'transport');
+
+    let selectedCandidatePair;
+
+    if (transports.length > 0 && transports[0].selectedCandidatePairId) {
+      selectedCandidatePair = allStatsReports.find(
+        (report) =>
+          report.type === 'candidate-pair' && report.id === transports[0].selectedCandidatePairId
+      );
+    } else {
+      // Firefox doesn't have selectedCandidatePairId, but has selected property on the candidate pair
+      selectedCandidatePair = allStatsReports.find(
+        (report) => report.type === 'candidate-pair' && report.selected
+      );
+    }
+
+    if (selectedCandidatePair) {
+      const localCandidate = allStatsReports.find(
+        (report) =>
+          report.type === 'local-candidate' && report.id === selectedCandidatePair.localCandidateId
+      );
+
+      if (localCandidate) {
+        if (localCandidate.address) {
+          return this.isIPv6(localCandidate.address) ? 'IPv6' : 'IPv4';
+        }
+
+        try {
+          // safari doesn't have address field on the candidate, so we have to use the port to look up the candidate in the SDP
+          const localSdp = webrtcMediaConnection.localDescription.sdp;
+
+          const parsedSdp = parse(localSdp);
+
+          for (const mediaLine of parsedSdp.avMedia) {
+            const matchingCandidate = mediaLine.iceInfo.candidates.find(
+              (candidate) => candidate.port === localCandidate.port
+            );
+            if (matchingCandidate) {
+              return this.isIPv6(matchingCandidate.connectionAddress) ? 'IPv6' : 'IPv4';
+            }
+          }
+
+          LoggerProxy.logger.warn(
+            `Media:properties#getConnectionIpVersion --> failed to find local candidate in the SDP for port ${localCandidate.port}`
+          );
+        } catch (error) {
+          LoggerProxy.logger.warn(
+            `Media:properties#getConnectionIpVersion --> error while trying to find candidate in local SDP:`,
+            error
+          );
+
+          return undefined;
+        }
+      } else {
+        LoggerProxy.logger.warn(
+          `Media:properties#getConnectionIpVersion --> failed to find local candidate "${selectedCandidatePair.localCandidateId}" in getStats() results`
+        );
+      }
+    } else {
+      LoggerProxy.logger.warn(
+        `Media:properties#getConnectionIpVersion --> failed to find selected candidate pair in getStats() results (transports.length=${transports.length}, selectedCandidatePairId=${transports[0]?.selectedCandidatePairId})`
+      );
+    }
+
+    return undefined;
+  }
+
   /**
    * Returns the type of a connection that has been established
    * It should be 'UDP' | 'TCP' | 'TURN-TLS' | 'TURN-TCP' | 'TURN-UDP' | 'unknown'
@@ -284,6 +373,7 @@ export default class MediaProperties {
    */
   async getCurrentConnectionInfo(): Promise<{
     connectionType: string;
+    ipVersion?: IPVersion;
     selectedCandidatePairChanges: number;
     numTransports: number;
   }> {
@@ -309,10 +399,15 @@ export default class MediaProperties {
       });
 
       const connectionType = this.getConnectionType(allStatsReports);
+      const rtcPeerconnection =
+        this.webrtcMediaConnection.multistreamConnection?.pc.pc ||
+        this.webrtcMediaConnection.mediaConnection?.pc;
+      const ipVersion = this.getConnectionIpVersion(rtcPeerconnection, allStatsReports);
       const {selectedCandidatePairChanges, numTransports} = this.getTransportInfo(allStatsReports);
 
       return {
         connectionType,
+        ipVersion,
         selectedCandidatePairChanges,
         numTransports,
       };
@@ -323,6 +418,7 @@ export default class MediaProperties {
 
       return {
         connectionType: 'unknown',
+        ipVersion: undefined,
         selectedCandidatePairChanges: -1,
         numTransports: 0,
       };

package/src/meeting/brbState.ts

@@ -95,6 +95,13 @@ export class BrbState {
     return this.sendLocalBrbStateToServer(sendSlotManager)
       .then(() => {
         this.state.syncToServerInProgress = false;
+
+        // This is a workaround for the fact that the server does not send the brb state
+        // in the locus update when a user joins from multiple devices but not all devices are requested brb.
+        // In the future, this could be improved with a new brb locus update handler
+        // https://jira-eng-gpk2.cisco.com/jira/browse/SPARK-655626
+        this.handleServerBrbUpdate(this.state.client.enabled);
+
         LoggerProxy.logger.info(
           `Meeting:brbState#applyClientStateToServer: sync with server completed`
         );
@@ -102,9 +109,11 @@ export class BrbState {
         // need to check if a new sync is required, because this.state.client may have changed while we were doing the current sync
         this.applyClientStateToServer(sendSlotManager);
       })
-      .catch((e) => {
+      .catch((error) => {
         this.state.syncToServerInProgress = false;
-        LoggerProxy.logger.warn(`Meeting:brbState#applyClientStateToServer: error: ${e}`);
+        LoggerProxy.logger.warn(`Meeting:brbState#applyClientStateToServer: Error: ${error}`);
+
+        return Promise.reject(error);
       });
   }
 

package/src/meeting/in-meeting-actions.ts

@@ -81,6 +81,8 @@ interface IInMeetingActions {
   canShareDesktop?: boolean;
   canShareContent?: boolean;
   canTransferFile?: boolean;
+  canRealtimeCloseCaption?: boolean;
+  canRealtimeCloseCaptionManual?: boolean;
   canChat?: boolean;
   canDoVideo?: boolean;
   canAnnotate?: boolean;
@@ -99,6 +101,12 @@ interface IInMeetingActions {
   isPracticeSessionOff?: boolean;
   canStartPracticeSession?: boolean;
   canStopPracticeSession?: boolean;
+  requiresPostMeetingDataConsentPrompt?: boolean;
+  canEnableAnnotation?: boolean;
+  canDisableAnnotation?: boolean;
+  canEnableRemoteDesktopControl?: boolean;
+  canDisableRemoteDesktopControl?: boolean;
+  canMoveToLobby?: boolean;
 }
 
 /**
@@ -249,6 +257,10 @@ export default class InMeetingActions implements IInMeetingActions {
 
   canTransferFile = null;
 
+  canRealtimeCloseCaption = null;
+
+  canRealtimeCloseCaptionManual = null;
+
   canChat = null;
 
   canDoVideo = null;
@@ -285,6 +297,18 @@ export default class InMeetingActions implements IInMeetingActions {
 
   canStopPracticeSession = null;
 
+  requiresPostMeetingDataConsentPrompt = null;
+
+  canEnableAnnotation = null;
+
+  canDisableAnnotation = null;
+
+  canEnableRemoteDesktopControl = null;
+
+  canDisableRemoteDesktopControl = null;
+
+  canMoveToLobby = null;
+
   /**
    * Returns all meeting action options
    * @returns {Object}
@@ -361,6 +385,8 @@ export default class InMeetingActions implements IInMeetingActions {
     canShareDesktop: this.canShareDesktop,
     canShareContent: this.canShareContent,
     canTransferFile: this.canTransferFile,
+    canRealtimeCloseCaption: this.canRealtimeCloseCaption,
+    canRealtimeCloseCaptionManual: this.canRealtimeCloseCaptionManual,
     canChat: this.canChat,
     canDoVideo: this.canDoVideo,
     canAnnotate: this.canAnnotate,
@@ -379,6 +405,12 @@ export default class InMeetingActions implements IInMeetingActions {
     isPracticeSessionOff: this.isPracticeSessionOff,
     canStartPracticeSession: this.canStartPracticeSession,
     canStopPracticeSession: this.canStopPracticeSession,
+    requiresPostMeetingDataConsentPrompt: this.requiresPostMeetingDataConsentPrompt,
+    canEnableAnnotation: this.canEnableAnnotation,
+    canDisableAnnotation: this.canDisableAnnotation,
+    canEnableRemoteDesktopControl: this.canEnableRemoteDesktopControl,
+    canDisableRemoteDesktopControl: this.canDisableRemoteDesktopControl,
+    canMoveToLobby: this.canMoveToLobby,
   });
 
   /**