@webex/plugin-meetings 3.0.0-beta.17 → 3.0.0-beta.171

package/src/locus-info/mediaSharesUtils.ts

@@ -13,6 +13,9 @@ MediaSharesUtils.parse = (mediaShares: object) => {
       content: {
         beneficiaryId: MediaSharesUtils.getContentBeneficiaryId(mediaShares),
         disposition: MediaSharesUtils.getContentDisposition(mediaShares),
+        annotation: MediaSharesUtils.getContentAnnotation(mediaShares),
+        url: MediaSharesUtils.getContentUrl(mediaShares),
+        shareInstanceId: MediaSharesUtils.getShareInstanceId(mediaShares),
       },
       whiteboard: {
         beneficiaryId: MediaSharesUtils.getWhiteboardBeneficiaryId(mediaShares),
@@ -140,6 +143,51 @@ MediaSharesUtils.getContentBeneficiaryId = (mediaShares: object) => {
   return contentFloor.beneficiary.id;
 };
 
+/**
+ * get live annotation is sharing from media shares (content)
+ * @param {Object} mediaShares
+ * @returns {Object}
+ */
+MediaSharesUtils.getContentAnnotation = (mediaShares: object) => {
+  const extractContent = MediaSharesUtils.extractContent(mediaShares);
+
+  if (!extractContent || !extractContent.annotation) {
+    return undefined;
+  }
+
+  return extractContent.annotation;
+};
+
+/**
+ * get url is sharing from media shares (content)
+ * @param {Object} mediaShares
+ * @returns {Object}
+ */
+MediaSharesUtils.getContentUrl = (mediaShares: object) => {
+  const extractContent = MediaSharesUtils.extractContent(mediaShares);
+
+  if (!extractContent || !extractContent.url) {
+    return undefined;
+  }
+
+  return extractContent.url;
+};
+
+/**
+ * get shareInstanceId is sharing from media shares (content)
+ * @param {Object} mediaShares
+ * @returns {Object}
+ */
+MediaSharesUtils.getShareInstanceId = (mediaShares: object) => {
+  const extractContent = MediaSharesUtils.extractContent(mediaShares);
+
+  if (!extractContent || !extractContent.floor || !extractContent.floor.shareInstanceId) {
+    return undefined;
+  }
+
+  return extractContent.floor.shareInstanceId;
+};
+
 /**
  * get who is sharing from media shares (whiteboard)
  * @param {Object} mediaShares

package/src/locus-info/parser.ts

@@ -397,6 +397,7 @@ export default class Parser {
     const {isLoci} = Parser;
     // @ts-ignore
     const setStatus = (status) => {
+      // @ts-ignore
       this.status = status;
     };
 
@@ -477,7 +478,7 @@ export default class Parser {
    * @param {Types~Locus} locus Locus delta
    * @returns {undefined}
    */
-  // eslint-disable-next-line no-unused-vars
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   onDeltaAction(action: string, locus) {}
 
   /**

package/src/locus-info/selfUtils.ts

@@ -1,5 +1,6 @@
 /* eslint-disable default-param-last */
 
+import {isEqual} from 'lodash';
 import {
   _IDLE_,
   _JOINED_,
@@ -31,9 +32,11 @@ SelfUtils.parse = (self: any, deviceId: string) => {
     const pstnDevices = self.devices.filter((device) => PSTN_DEVICE_TYPE === device.deviceType);
 
     return {
+      remoteVideoMuted: SelfUtils.getRemoteVideoMuted(self),
       remoteMuted: SelfUtils.getRemoteMuted(self),
       unmuteAllowed: SelfUtils.getUnmuteAllowed(self),
       localAudioUnmuteRequested: SelfUtils.getLocalAudioUnmuteRequested(self),
+      localAudioUnmuteRequestedTimeStamp: SelfUtils.getLocalAudioUnmuteRequestedTimeStamp(self),
       localAudioUnmuteRequired: SelfUtils.getLocalAudioUnmuteRequired(self),
       lastModified: SelfUtils.getLastModified(self),
       modifiedBy: SelfUtils.getModifiedBy(self),
@@ -60,12 +63,19 @@ SelfUtils.parse = (self: any, deviceId: string) => {
       layout: SelfUtils.getLayout(self),
       canNotViewTheParticipantList: SelfUtils.canNotViewTheParticipantList(self),
       isSharingBlocked: SelfUtils.isSharingBlocked(self),
+      breakoutSessions: SelfUtils.getBreakoutSessions(self),
+      breakout: SelfUtils.getBreakout(self),
+      interpretation: SelfUtils.getInterpretation(self),
     };
   }
 
   return null;
 };
 
+SelfUtils.getBreakoutSessions = (self) => self?.controls?.breakout?.sessions;
+SelfUtils.getBreakout = (self) => self?.controls?.breakout;
+SelfUtils.getInterpretation = (self) => self?.controls?.interpretation;
+
 SelfUtils.getLayout = (self) =>
   Array.isArray(self?.controls?.layouts) ? self.controls.layouts[0].type : undefined;
 
@@ -89,6 +99,7 @@ SelfUtils.getSelves = (oldSelf, newSelf, deviceId) => {
 
   updates.isUserUnadmitted = SelfUtils.isUserUnadmitted(current);
   updates.isUserAdmitted = SelfUtils.isUserAdmitted(previous, current);
+  updates.isVideoMutedByOthersChanged = SelfUtils.videoMutedByOthersChanged(previous, current);
   updates.isMutedByOthersChanged = SelfUtils.mutedByOthersChanged(previous, current);
   updates.localAudioUnmuteRequestedByServer = SelfUtils.localAudioUnmuteRequestedByServer(
     previous,
@@ -99,6 +110,7 @@ SelfUtils.getSelves = (oldSelf, newSelf, deviceId) => {
     current
   );
   updates.moderatorChanged = SelfUtils.moderatorChanged(previous, current);
+  updates.isRolesChanged = SelfUtils.isRolesChanged(previous, current);
   updates.isMediaInactiveOrReleased = SelfUtils.wasMediaInactiveOrReleased(previous, current);
   updates.isUserObserving = SelfUtils.isDeviceObserving(previous, current);
   updates.layoutChanged = SelfUtils.layoutChanged(previous, current);
@@ -114,6 +126,8 @@ SelfUtils.getSelves = (oldSelf, newSelf, deviceId) => {
   updates.canNotViewTheParticipantListChanged =
     previous?.canNotViewTheParticipantList !== current.canNotViewTheParticipantList;
   updates.isSharingBlockedChanged = previous?.isSharingBlocked !== current.isSharingBlocked;
+  updates.breakoutsChanged = SelfUtils.breakoutsChanged(previous, current);
+  updates.interpretationChanged = SelfUtils.interpretationChanged(previous, current);
 
   return {
     previous,
@@ -134,11 +148,17 @@ SelfUtils.isJoined = (self: any) => self?.state === _JOINED_;
  *
  * @param {Self} previous - Previous self state
  * @param {Self} current - Current self state [per event]
- * @returns {boolean} - If the MEeting Layout Controls Layout has changed.
+ * @returns {boolean} - If the Meeting Layout Controls Layout has changed.
  */
 SelfUtils.layoutChanged = (previous: any, current: any) =>
   current?.layout && previous?.layout !== current?.layout;
 
+SelfUtils.breakoutsChanged = (previous, current) =>
+  !isEqual(previous?.breakoutSessions, current?.breakoutSessions) && !!current?.breakout;
+
+SelfUtils.interpretationChanged = (previous, current) =>
+  !isEqual(previous?.interpretation, current?.interpretation) && !!current?.interpretation;
+
 SelfUtils.isMediaInactive = (previous, current) => {
   if (
     previous &&
@@ -228,6 +248,19 @@ SelfUtils.getSelfIdentity = (self: any) => {
   return self.person.id;
 };
 
+/**
+ * get the "remote video mute" property from the self object
+ * @param {Object} self
+ * @returns {Boolean}
+ */
+SelfUtils.getRemoteVideoMuted = (self: any) => {
+  if (!self || !self.controls || !self.controls.video) {
+    return null;
+  }
+
+  return self.controls.video.muted;
+};
+
 /**
  * get the "remote mute" property from the self object
  * @param {Object} self
@@ -243,6 +276,10 @@ SelfUtils.getRemoteMuted = (self: any) => {
 
 SelfUtils.getLocalAudioUnmuteRequested = (self) => !!self?.controls?.audio?.requestedToUnmute;
 
+// requestedToUnmute timestamp
+SelfUtils.getLocalAudioUnmuteRequestedTimeStamp = (self) =>
+  Date.parse(self?.controls?.audio?.lastModifiedRequestedToUnmute) || 0;
+
 SelfUtils.getUnmuteAllowed = (self) => {
   if (!self || !self.controls || !self.controls.audio) {
     return null;
@@ -267,6 +304,7 @@ SelfUtils.getStatus = (status) => ({
 SelfUtils.wasMediaInactiveOrReleased = (oldSelf: any = {}, changedSelf: any) =>
   oldSelf.joinedWith &&
   oldSelf.joinedWith.state === _JOINED_ &&
+  changedSelf.joinedWith &&
   changedSelf.joinedWith.state === _LEFT_ &&
   (changedSelf.joinedWith.reason === MEETING_END_REASON.INACTIVE ||
     changedSelf.joinedWith.reason === MEETING_END_REASON.MEDIA_RELEASED);
@@ -311,6 +349,20 @@ SelfUtils.moderatorChanged = (oldSelf, changedSelf) => {
   return oldSelf.moderator !== changedSelf.moderator;
 };
 
+/**
+ * determine whether the roles of self is changed or not
+ * @param {Object} oldSelf
+ * @param {Object} changedSelf
+ * @returns {Boolean}
+ */
+SelfUtils.isRolesChanged = (oldSelf, changedSelf) => {
+  if (!changedSelf) {
+    // no new self means no change
+    return false;
+  }
+
+  return !isEqual(oldSelf?.roles, changedSelf?.roles);
+};
 /**
  * @param {Object} oldSelf
  * @param {Object} changedSelf
@@ -343,6 +395,25 @@ SelfUtils.isUserAdmitted = (oldSelf: object, changedSelf: object) => {
   return SelfUtils.isLocusUserUnadmitted(oldSelf) && SelfUtils.isLocusUserAdmitted(changedSelf);
 };
 
+SelfUtils.videoMutedByOthersChanged = (oldSelf, changedSelf) => {
+  if (!changedSelf) {
+    throw new ParameterError(
+      'New self must be defined to determine if self was video muted by others.'
+    );
+  }
+
+  if (!oldSelf || oldSelf.remoteVideoMuted === null) {
+    if (changedSelf.remoteVideoMuted) {
+      return true; // this happens when host disables "Allow start video"
+    }
+
+    // we don't want to be sending the 'meeting:self:videoUnmutedByOthers' notification on meeting join
+    return false;
+  }
+
+  return oldSelf.remoteVideoMuted !== changedSelf.remoteVideoMuted;
+};
+
 SelfUtils.mutedByOthersChanged = (oldSelf, changedSelf) => {
   if (!changedSelf) {
     throw new ParameterError('New self must be defined to determine if self was muted by others.');
@@ -371,7 +442,10 @@ SelfUtils.localAudioUnmuteRequestedByServer = (oldSelf: any = {}, changedSelf: a
     );
   }
 
-  return changedSelf.localAudioUnmuteRequested && !oldSelf.localAudioUnmuteRequested;
+  return (
+    changedSelf.localAudioUnmuteRequested &&
+    changedSelf.localAudioUnmuteRequestedTimeStamp > oldSelf.localAudioUnmuteRequestedTimeStamp
+  );
 };
 
 SelfUtils.localAudioUnmuteRequiredByServer = (oldSelf: any = {}, changedSelf: any) => {
@@ -424,4 +498,14 @@ SelfUtils.getMediaStatus = (mediaSessions = []) => {
   return mediaStatus;
 };
 
+SelfUtils.getReplacedBreakoutMoveId = (self: any, deviceId: string) => {
+  if (self && Array.isArray(self.devices)) {
+    const joinedDevice = self.devices.find((device) => deviceId === device.url);
+    if (Array.isArray(joinedDevice?.replaces)) {
+      return joinedDevice.replaces[0]?.breakoutMoveId;
+    }
+  }
+
+  return null;
+};
 export default SelfUtils;

package/src/media/index.ts

@@ -3,17 +3,27 @@
  */
 /* globals navigator */
 
+import {RoapMediaConnection, MultistreamRoapMediaConnection} from '@webex/internal-media-core';
+import {
+  LocalCameraTrack,
+  LocalDisplayTrack,
+  LocalSystemAudioTrack,
+  LocalMicrophoneTrack,
+} from '@webex/media-helpers';
 import LoggerProxy from '../common/logs/logger-proxy';
-import {AUDIO_INPUT, VIDEO_INPUT, MEDIA_TRACK_CONSTRAINT} from '../constants';
+import {MEDIA_TRACK_CONSTRAINT} from '../constants';
 import Config from '../config';
 import StaticConfig from '../common/config';
-import MediaError from '../common/errors/media';
 import BrowserDetection from '../common/browser-detection';
 
-import {RoapMediaConnection, MultistreamRoapMediaConnection} from './internal-media-core-wrapper';
-
 const {isBrowser} = BrowserDetection();
 
+type MultistreamConnectionConfig = ConstructorParameters<typeof MultistreamRoapMediaConnection>[0];
+
+export type BundlePolicy = ConstructorParameters<
+  typeof MultistreamRoapMediaConnection
+>[0]['bundlePolicy'];
+
 /**
  * MediaDirection
  * @typedef {Object} MediaDirection
@@ -44,45 +54,6 @@ const {isBrowser} = BrowserDetection();
  */
 const Media: any = {};
 
-/**
- * @param {boolean} enabled
- * @param {MediaStreamTrack} track
- * @returns {Boolean}
- * @public
- */
-Media.setLocalTrack = (enabled: boolean, track: MediaStreamTrack) => {
-  if (track) {
-    track.enabled = enabled;
-
-    return true;
-  }
-
-  return false;
-};
-
-/**
- * format the media array for send
- * @param {String} mediaId
- * @param {Boolean} audioMuted
- * @param {Boolean} videoMuted
- * @returns {Array} medias
- */
-Media.generateLocalMedias = (mediaId: string, audioMuted: boolean, videoMuted: boolean) => {
-  if (mediaId) {
-    return [
-      {
-        localSdp: JSON.stringify({
-          audioMuted,
-          videoMuted,
-        }),
-        mediaId,
-      },
-    ];
-  }
-
-  return [];
-};
-
 /**
  * make a browser call to get the media
  * @param {SendOptions} options
@@ -110,33 +81,54 @@ Media.getLocalMedia = (options: any, config: object) => {
   return Promise.resolve(undefined);
 };
 
+Media.getDirection = (forceSendRecv: boolean, receive: boolean, send: boolean) => {
+  if (!receive && !send) {
+    return 'inactive';
+  }
+
+  if (forceSendRecv || (receive && send)) {
+    return 'sendrecv';
+  }
+
+  if (receive) {
+    return 'recvonly';
+  }
+
+  return 'sendonly';
+};
+
 /**
  * creates a webrtc media connection with provided tracks and mediaDirection configuration
  *
  * @param {boolean} isMultistream
  * @param {string} debugId string useful for debugging (will appear in media connection logs)
  * @param {Object} options
- * @param {Object} [options.mediaProperties] only applicable to non-multistream connections, contains mediaDirection and local tracks:
- *                                 audioTrack, videoTrack and shareTrack
+ * @param {Object} [options.mediaProperties] contains mediaDirection and local tracks:
+ *                                 audioTrack, videoTrack, shareVideoTrack, and shareAudioTrack
  * @param {string} [options.remoteQualityLevel] LOW|MEDIUM|HIGH applicable only to non-multistream connections
  * @param {boolean} [options.enableRtx] applicable only to non-multistream connections
  * @param {boolean} [options.enableExtmap] applicable only to non-multistream connections
  * @param {Object} [options.turnServerInfo]
- * @returns {RoapMediaConnection}
+ * @param {BundlePolicy} [options.bundlePolicy]
+ * @returns {RoapMediaConnection | MultistreamRoapMediaConnection}
  */
 Media.createMediaConnection = (
   isMultistream: boolean,
   debugId: string,
   options: {
-    mediaProperties?: {
+    mediaProperties: {
       mediaDirection?: {
         receiveAudio: boolean;
         receiveVideo: boolean;
         receiveShare: boolean;
+        sendAudio: boolean;
+        sendVideo: boolean;
+        sendShare: boolean;
       };
-      audioTrack?: MediaStreamTrack;
-      videoTrack?: MediaStreamTrack;
-      shareTrack?: MediaStreamTrack;
+      audioTrack?: LocalMicrophoneTrack;
+      videoTrack?: LocalCameraTrack;
+      shareVideoTrack?: LocalDisplayTrack;
+      shareAudioTrack?: LocalSystemAudioTrack;
     };
     remoteQualityLevel?: 'LOW' | 'MEDIUM' | 'HIGH';
     enableRtx?: boolean;
@@ -146,9 +138,17 @@ Media.createMediaConnection = (
       username: string;
       password: string;
     };
+    bundlePolicy?: BundlePolicy;
   }
 ) => {
-  const {mediaProperties, remoteQualityLevel, enableRtx, enableExtmap, turnServerInfo} = options;
+  const {
+    mediaProperties,
+    remoteQualityLevel,
+    enableRtx,
+    enableExtmap,
+    turnServerInfo,
+    bundlePolicy,
+  } = options;
 
   const iceServers = [];
 
@@ -161,19 +161,26 @@ Media.createMediaConnection = (
   }
 
   if (isMultistream) {
-    return new MultistreamRoapMediaConnection(
-      {
-        iceServers,
-      },
-      debugId
-    );
+    const config: MultistreamConnectionConfig = {
+      iceServers,
+      enableMainAudio:
+        mediaProperties.mediaDirection?.sendAudio || mediaProperties.mediaDirection?.receiveAudio,
+      enableMainVideo:
+        mediaProperties.mediaDirection?.sendVideo || mediaProperties.mediaDirection?.receiveVideo,
+    };
+
+    if (bundlePolicy) {
+      config.bundlePolicy = bundlePolicy;
+    }
+
+    return new MultistreamRoapMediaConnection(config, debugId);
   }
 
   if (!mediaProperties) {
     throw new Error('mediaProperties have to be provided for non-multistream media connections');
   }
 
-  const {mediaDirection, audioTrack, videoTrack, shareTrack} = mediaProperties;
+  const {mediaDirection, audioTrack, videoTrack, shareVideoTrack} = mediaProperties;
 
   return new RoapMediaConnection(
     {
@@ -194,17 +201,21 @@ Media.createMediaConnection = (
       },
     },
     {
-      send: {
-        audio: audioTrack,
-        video: videoTrack,
-        screenShareVideo: shareTrack,
+      localTracks: {
+        audio: audioTrack?.underlyingTrack,
+        video: videoTrack?.underlyingTrack,
+        screenShareVideo: shareVideoTrack?.underlyingTrack,
       },
-      receive: {
-        audio: mediaDirection.receiveAudio,
-        video: mediaDirection.receiveVideo,
-        screenShareVideo: mediaDirection.receiveShare,
-        remoteQualityLevel,
+      direction: {
+        audio: Media.getDirection(true, mediaDirection.receiveAudio, mediaDirection.sendAudio),
+        video: Media.getDirection(true, mediaDirection.receiveVideo, mediaDirection.sendVideo),
+        screenShareVideo: Media.getDirection(
+          false,
+          mediaDirection.receiveShare,
+          mediaDirection.sendShare
+        ),
       },
+      remoteQualityLevel,
     },
     debugId
   );
@@ -349,52 +360,6 @@ Media.getMedia = (audio: any | boolean, video: any | boolean, config: any) => {
   });
 };
 
-/**
- * Checks if the machine has at least one audio or video device (Dont use this for screen share)
- * @param {object} [options]
- * {
- *    sendAudio: true/false,
- *    sendVideo: true/false
- * }
- * @returns {Object} {
- *    sendAudio: true/false,
- *    sendVideo: true/false
- *}
- */
-Media.getSupportedDevice = ({sendAudio, sendVideo}: {sendAudio: boolean; sendVideo: boolean}) =>
-  Promise.resolve().then(() => {
-    if (!navigator.mediaDevices || navigator.mediaDevices.enumerateDevices === undefined) {
-      return {
-        sendAudio: false,
-        sendVideo: false,
-      };
-    }
-
-    return navigator.mediaDevices.enumerateDevices().then((devices) => {
-      const supported = {
-        audio: devices.filter((device) => device.kind === AUDIO_INPUT).length > 0,
-        video: devices.filter((device) => device.kind === VIDEO_INPUT).length > 0,
-      };
-
-      return {
-        sendAudio: supported.audio && sendAudio,
-        sendVideo: supported.video && sendVideo,
-      };
-    });
-  });
-
-/**
- * proxy to browser navigator.mediaDevices.enumerateDevices()
- * @returns {Promise}
- */
-Media.getDevices = () => {
-  if (navigator && navigator.mediaDevices && navigator.mediaDevices.enumerateDevices) {
-    return navigator.mediaDevices.enumerateDevices();
-  }
-
-  return Promise.reject(new MediaError('enumerateDevices not supported.'));
-};
-
 /**
  *
  * Toggle a specific stream
@@ -426,37 +391,6 @@ Media.stopTracks = (track: any) => {
   });
 };
 
-/**
- *
- * Stop input stream
- * @param {Stream} stream A media stream
- * @returns {null}
- * @deprecated after v1.89.3
- */
-Media.stopStream = (stream: any) => {
-  LoggerProxy.logger.warn(
-    'Media:index#stopStream --> [DEPRECATION WARNING]: stopStream has been deprecated after v1.89.3'
-  );
-  if (!stream) {
-    return Promise.resolve();
-  }
-
-  /*
-   * To release local media
-   * 1) Chrome requires all tracks to be stopped (stream.stop got deprecated)
-   * 2) Firefox requires the stream to be stopped
-   */
-  return Promise.resolve().then(() => {
-    if (stream.getTracks) {
-      stream.getTracks().forEach((track) => {
-        track.stop();
-      });
-    } else if (stream.stop) {
-      stream.stop();
-    }
-  });
-};
-
 /**
  * generates streams for audio video and share
  * @param {object} mediaSetting parameter