@webex/plugin-meetings 3.1.0 → 3.2.0

package/dist/types/multistream/remoteMediaManager.d.ts

@@ -0,0 +1,300 @@
+import { EventMap } from 'typed-emitter';
+import { MediaType, NamedMediaGroup } from '@webex/internal-media-core';
+import EventsScope from '../common/events/events-scope';
+import { RemoteMedia, RemoteVideoResolution } from './remoteMedia';
+import { CSI } from './receiveSlot';
+import { ReceiveSlotManager } from './receiveSlotManager';
+import { RemoteMediaGroup } from './remoteMediaGroup';
+import { MediaRequestManager } from './mediaRequestManager';
+export type PaneSize = RemoteVideoResolution;
+export type LayoutId = string;
+export type PaneId = string;
+export type PaneGroupId = string;
+export interface ActiveSpeakerVideoPaneGroup {
+    id: PaneGroupId;
+    numPanes: number;
+    size: PaneSize;
+    priority: number;
+}
+export interface MemberVideoPane {
+    id: PaneId;
+    size: PaneSize;
+    csi?: CSI;
+}
+export interface VideoLayout {
+    screenShareVideo?: {
+        size: PaneSize;
+    };
+    activeSpeakerVideoPaneGroups?: ActiveSpeakerVideoPaneGroup[];
+    memberVideoPanes?: MemberVideoPane[];
+}
+export interface Configuration {
+    audio: {
+        numOfActiveSpeakerStreams: number;
+        numOfScreenShareStreams: number;
+    };
+    video: {
+        preferLiveVideo: boolean;
+        initialLayoutId: LayoutId;
+        layouts: {
+            [key: LayoutId]: VideoLayout;
+        };
+    };
+    namedMediaGroup?: NamedMediaGroup;
+}
+/**
+ * Default configuration:
+ * - uses 3 audio streams
+ * - prefers active speakers with live video (e.g. are not audio only or video muted) over active speakers without live video
+ * - has a few layouts defined, including 1 that contains remote screen share (ScreenShareView)
+ */
+export declare const DefaultConfiguration: Configuration;
+export declare enum Event {
+    AudioCreated = "AudioCreated",
+    InterpretationAudioCreated = "InterpretationAudioCreated",
+    ScreenShareAudioCreated = "ScreenShareAudioCreated",
+    VideoLayoutChanged = "VideoLayoutChanged"
+}
+export interface VideoLayoutChangedEventData {
+    layoutId: LayoutId;
+    activeSpeakerVideoPanes: {
+        [key: PaneGroupId]: RemoteMediaGroup;
+    };
+    memberVideoPanes: {
+        [key: PaneId]: RemoteMedia;
+    };
+    screenShareVideo?: RemoteMedia;
+}
+export interface Events extends EventMap {
+    [Event.AudioCreated]: (audio: RemoteMediaGroup) => void;
+    [Event.ScreenShareAudioCreated]: (screenShareAudio: RemoteMediaGroup) => void;
+    [Event.VideoLayoutChanged]: (data: VideoLayoutChangedEventData) => void;
+}
+/**
+ * A helper class that manages all remote audio/video streams in order to achieve a predefined set of layouts.
+ * It also creates a fixed number of audio streams and these don't change during the meeting.
+ *
+ * Things that RemoteMediaManager does:
+ * - owns the receive slots (creates them when needed, and re-uses them when switching layouts)
+ * - constructs appropriate RemoteMedia and RemoteMediaGroup objects and sends appropriate mediaRequests
+ */
+export declare class RemoteMediaManager extends EventsScope {
+    private config;
+    private started;
+    private receiveSlotManager;
+    private mediaRequestManagers;
+    private currentLayout?;
+    private slots;
+    private media;
+    private receiveSlotAllocations;
+    private currentLayoutId?;
+    /**
+     * Constructor
+     *
+     * @param {ReceiveSlotManager} receiveSlotManager
+     * @param {{audio: MediaRequestManager, video: mediaRequestManagers}} mediaRequestManagers
+     * @param {Configuration} config Configuration describing what video layouts to use during the meeting
+     */
+    constructor(receiveSlotManager: ReceiveSlotManager, mediaRequestManagers: {
+        audio: MediaRequestManager;
+        video: MediaRequestManager;
+        screenShareAudio: MediaRequestManager;
+        screenShareVideo: MediaRequestManager;
+    }, config?: Configuration);
+    /**
+     * Checks if configuration is valid, throws an error if it's not
+     */
+    private checkConfigValidity;
+    /**
+     * Starts the RemoteMediaManager.
+     *
+     * @returns {Promise}
+     */
+    start(): Promise<void>;
+    /**
+     * Releases all the used resources (like allocated receive slots). This function needs
+     * to be called when we leave the meeting, etc.
+     */
+    stop(): void;
+    /**
+     * Returns the total number of main video panes required for a given layout
+     *
+     * @param {VideoLayout} layout
+     * @returns {number}
+     */
+    private getRequiredNumVideoSlotsForLayout;
+    /**
+     * Allocates the maximum number of panes that any of the configured layouts will require.
+     * We do this at the beginning, because it's more efficient (much faster) then allocating receive slots
+     * later, after the SDP exchange was done.
+     */
+    private preallocateVideoReceiveSlots;
+    /**
+     * Changes the layout (triggers Event.VideoLayoutChanged)
+     *
+     * @param {LayoutId} layoutId new layout id
+     * @returns {Promise}
+     */
+    setLayout(layoutId: LayoutId): Promise<void>;
+    /**
+     * Returns the currently selected layout id
+     *
+     * @returns {LayoutId}
+     */
+    getLayoutId(): LayoutId | undefined;
+    /**
+     * sets the preferLiveVideo
+     */
+    setPreferLiveVideo(preferLiveVideo: boolean): void;
+    /**
+     * Sets CSIs for multiple RemoteMedia instances belonging to RemoteMediaGroup.
+     * For each entry in the remoteMediaCsis array:
+     * - if csi is specified, the RemoteMedia instance is pinned to that CSI
+     * - if csi is undefined, the RemoteMedia instance is unpinned
+     */
+    setActiveSpeakerCsis(remoteMediaCsis: {
+        remoteMedia: RemoteMedia;
+        csi?: number;
+    }[]): void;
+    /**
+     * Sets which named media group need receiving
+     * @param {MediaType} mediaType of the stream
+     * @param {number} languageCode of the stream. If the languageId is 0, the named media group request will be canceled,
+     * and only receive the main audio stream.
+     * @returns {void}
+     */
+    setReceiveNamedMediaGroup(mediaType: MediaType, languageId: number): Promise<void>;
+    /**
+     * Creates the audio slots
+     */
+    private createAudioMedia;
+    /**
+     * Creates the audio slots for named media
+     */
+    private createInterpretationAudioMedia;
+    /**
+     * Creates receive slots required for receiving screen share audio and video
+     */
+    private createScreenShareReceiveSlots;
+    /**
+     * Creates RemoteMedia objects for screen share
+     */
+    private createScreenShareAudioMedia;
+    /**
+     * Goes over all receiver-selected slots and keeps only the ones that are required by a given layout,
+     * the rest are all moved to the "unused" list
+     */
+    private trimReceiverSelectedSlots;
+    /**
+     * Releases all the "unused" video slots.
+     */
+    private releaseUnusedVideoSlots;
+    /**
+     * Allocates receive slots to all active speaker video panes
+     * in the current selected layout.
+     *
+     * Allocation tries to keep the same order of the slots between the previous
+     * layout and the new one. Sorting helps making sure that highest priority slots
+     * go in the same order in the new layout.
+     */
+    private allocateSlotsToActiveSpeakerPaneGroups;
+    /**
+     * Allocates receive slots to all receiver selected video panes
+     * in the current selected layout
+     */
+    private allocateSlotsToReceiverSelectedVideoPaneGroups;
+    /**
+     * Ensures that we have enough slots for the current layout.
+     */
+    private refillRequiredSlotsIfNeeded;
+    /**
+     * Move all active speaker slots to "unused"
+     */
+    private trimActiveSpeakerSlots;
+    /**
+     * Logs the state of the receive slots
+     */
+    private logMainVideoReceiveSlots;
+    /** logs main audio slots */
+    private logMainAudioReceiveSlots;
+    /** logs slides video slots */
+    private logSlidesVideoReceiveSlots;
+    /** logs slides audio slots */
+    private logSlidesAudioReceiveSlots;
+    /** Logs all current receive slots */
+    logAllReceiveSlots(): void;
+    /**
+     * Makes sure we have the right number of receive slots created for the current layout
+     * and allocates them to the right video panes / pane groups
+     *
+     * @returns {Promise}
+     */
+    private updateVideoReceiveSlots;
+    /**
+     * Creates new RemoteMedia and RemoteMediaGroup objects for the current layout
+     * and sends the media requests for all of them.
+     */
+    private updateVideoRemoteMediaObjects;
+    /**
+     * Checks if current layout requires a screen share.
+     * If it does, it creates new RemoteMediaGroup object for screen share
+     * and sends the media requests for it.
+     * If it doesn't, it makes sure we clean up any RemoteMediaGroup objects
+     * created earlier for screen share (for previous layout).
+     */
+    private updateScreenShareVideoRemoteMediaObject;
+    /**
+     * Invalidates all remote media objects belonging to currently selected layout
+     */
+    private invalidateCurrentRemoteMedia;
+    /** emits Event.VideoLayoutChanged */
+    private emitVideoLayoutChangedEvent;
+    /**
+     * Sets a new CSI on a given remote media object
+     *
+     * @param {RemoteMedia} remoteMedia remote Media object to modify
+     * @param {CSI} csi new CSI value, can be null if we want to stop receiving media
+     */
+    setRemoteVideoCsi(remoteMedia: RemoteMedia, csi: CSI | null): void;
+    /**
+     * Adds a new member video pane to the currently selected layout.
+     *
+     * Changes to the layout are lost after a layout change.
+     *
+     * @param {MemberVideoPane} newPane
+     * @returns {Promise<RemoteMedia>}
+     */
+    addMemberVideoPane(newPane: MemberVideoPane): Promise<RemoteMedia>;
+    /**
+     * Removes a member video pane from the currently selected layout.
+     *
+     * Changes to the layout are lost after a layout change.
+     *
+     * @param {PaneId} paneId pane id of the pane to remove
+     * @returns {Promise<void>}
+     */
+    removeMemberVideoPane(paneId: PaneId): Promise<void>;
+    /**
+     * Pins an active speaker remote media object to the given CSI value. From that moment
+     * onwards the remote media will only play audio/video from that specific CSI until
+     * unpinActiveSpeakerVideoPane() is called or current layout is changed.
+     *
+     * @param {RemoteMedia} remoteMedia remote media object reference
+     * @param {CSI} csi CSI value to pin to, if undefined, then current CSI value is used
+     */
+    pinActiveSpeakerVideoPane(remoteMedia: RemoteMedia, csi?: CSI): void;
+    /**
+     * Unpins a remote media object from the fixed CSI value it was pinned to.
+     *
+     * @param {RemoteMedia} remoteMedia remote media object reference
+     */
+    unpinActiveSpeakerVideoPane(remoteMedia: RemoteMedia): void;
+    /**
+     * Returns true if a given remote media object belongs to an active speaker group and has been pinned.
+     * Throws an error if the remote media object doesn't belong to any active speaker remote media group.
+     *
+     * @param {RemoteMedia} remoteMedia remote media object
+     * @returns {boolean}
+     */
+    isPinned(remoteMedia: RemoteMedia): boolean;
+}

package/dist/types/multistream/sendSlotManager.d.ts

@@ -0,0 +1,69 @@
+import { SendSlot, MediaType, LocalStream, MultistreamRoapMediaConnection, NamedMediaGroup } from '@webex/internal-media-core';
+export default class SendSlotManager {
+    private readonly slots;
+    private readonly LoggerProxy;
+    constructor(LoggerProxy: any);
+    /**
+     * This method is used to create a sendSlot for the given mediaType and returns the created sendSlot
+     * @param {MultistreamRoapMediaConnection} mediaConnection MultistreamRoapMediaConnection for which a sendSlot needs to be created
+     * @param {MediaType} mediaType MediaType for which a sendSlot needs to be created (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)
+     * @param {boolean} active This is optional boolean to set the active state of the sendSlot. Default is true
+     * @returns {SendSlot} slot The created sendSlot
+     */
+    createSlot(mediaConnection: MultistreamRoapMediaConnection, mediaType: MediaType, active?: boolean): SendSlot;
+    /**
+     * This method is used to retrieve the sendSlot for the given mediaType
+     * @param {MediaType} mediaType of which the slot needs to be retrieved
+     * @returns {SendSlot}
+     */
+    getSlot(mediaType: MediaType): SendSlot;
+    /**
+     * Allow users to specify 'namedMediaGroups' to indicate which named media group its audio should be sent to.
+     * @param {MediaType} mediaType MediaType of the sendSlot to which the audio stream needs to be send to the media group
+     * @param {[]}namedMediaGroups - Allow users to specify 'namedMediaGroups'.If the value of 'namedMediaGroups' is zero,
+     * named media group will be canceled and the audio stream will be sent to the floor.
+     * @returns {void}
+     */
+    setNamedMediaGroups(mediaType: MediaType, namedMediaGroups: NamedMediaGroup[]): void;
+    /**
+     * This method publishes the given stream to the sendSlot for the given mediaType
+     * @param {MediaType} mediaType MediaType of the sendSlot to which a stream needs to be published (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)
+     * @param {LocalStream} stream LocalStream to be published
+     * @returns {Promise<void>}
+     */
+    publishStream(mediaType: MediaType, stream: LocalStream): Promise<void>;
+    /**
+     * This method unpublishes the stream from the sendSlot of the given mediaType
+     * @param {MediaType} mediaType MediaType of the sendSlot from which a stream needs to be unpublished (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)
+     * @returns {Promise<void>}
+     */
+    unpublishStream(mediaType: MediaType): Promise<void>;
+    /**
+     * This method is used to set the active state of the sendSlot for the given mediaType
+     * @param {MediaType} mediaType The MediaType of the sendSlot for which the active state needs to be set (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)
+     * @param {boolean} active The boolean to set the active state of the sendSlot. Default is true
+     * @returns {void}
+     */
+    setActive(mediaType: MediaType, active?: boolean): void;
+    /**
+     * 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
+     * @returns {Promise<void>}
+     */
+    setCodecParameters(mediaType: MediaType, codecParameters: {
+        [key: string]: string | undefined;
+    }): Promise<void>;
+    /**
+     * 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
+     * @returns {Promise<void>}
+     */
+    deleteCodecParameters(mediaType: MediaType, parameters: string[]): Promise<void>;
+    /**
+     * This method is used to reset the SendSlotsManager by deleting all the sendSlots
+     * @returns {undefined}
+     */
+    reset(): void;
+}

package/dist/types/networkQualityMonitor/index.d.ts

@@ -0,0 +1,70 @@
+import EventsScope from '../common/events/events-scope';
+/**
+ * Meeting - network quality event
+ * Emitted on each interval of retrieving stats Analyzer data
+ * @event network:quality
+ * @type {Object}
+ * @property {string} mediaType {video|audio}
+ * @property {number} networkQualityScore - value determined in determineUplinkNetworkQuality
+ * @memberof NetworkQualityMonitor
+ */
+/**
+ * NetworkQualityMonitor class that will emit events based on detected quality
+ *
+ * @class NetworkQualityMonitor
+ * @extends {EventsScope}
+ */
+export default class NetworkQualityMonitor extends EventsScope {
+    config: any;
+    frequencyTypes: any;
+    indicatorTypes: any;
+    mediaType: any;
+    networkQualityScore: any;
+    networkQualityStatus: any;
+    /**
+     * Creates a new instance of NetworkQualityMonitor
+     * @constructor
+     * @public
+     * @param {Object} config
+     * @property {Object} indicatorTypes - network properties used to evaluate network quality used as constants
+     * @property {Object} frequencyTypes - frequency properties used as constants {uplink|send} {downlink|receive}
+     * @property {number} networkQualityScore  - 0|1 1 is acceptable 0 is bad/unknown
+     * @property {Object} networkQualityStatus - hash object based on indicatorTypes and frequencyTypes
+     * @property {string} mediaType - audio|video
+     */
+    constructor(config: any);
+    /**
+     * emits NETWORK_QUALITY event on meeting with payload of media type and uplinkNetworkQuality score
+     *
+     * @memberof NetworkQualityMonitor
+     * @returns {void}
+     */
+    emitNetworkQuality(): void;
+    /**
+     * invokes emitNetworkQuality method resets values back to default
+     * @returns {void}
+     * @memberof NetworkQualityMonitor
+     */
+    updateNetworkQualityStatus(): void;
+    /**
+     * filter data to determine uplink network quality, invoked on same interval as stats analyzer remote-inbout-rtp
+     * @param {Object} configObj
+     * @param {string} configObj.mediaType {audio|video}
+     * @param {RTCStats} configObj.remoteRtpResults RTC stats remote obj
+     * @param {Object} configObj.statsAnalyzerCurrentStats statsResults
+     * @returns {void}
+     * @public
+     * @memberof NetworkQualityMonitor
+     */
+    determineUplinkNetworkQuality({ mediaType, remoteRtpResults, statsAnalyzerCurrentStats, }: {
+        mediaType: string;
+        remoteRtpResults: any;
+        statsAnalyzerCurrentStats: object;
+    }): void;
+    /**
+     * Get the current status of network quaility object - networkQualityStatus
+     * @returns {Object}
+     * @public
+     */
+    get networkQualityStats(): any;
+}

package/dist/types/personal-meeting-room/index.d.ts

@@ -0,0 +1,47 @@
+import { StatelessWebexPlugin } from '@webex/webex-core';
+/**
+ * @class PersonalMeetingRoom
+ */
+export default class PersonalMeetingRoom extends StatelessWebexPlugin {
+    link: any;
+    meetingInfo: any;
+    name: any;
+    personalMeetingRoomRequest: any;
+    pmr: any;
+    sipUri: any;
+    userId: any;
+    meetingLink: any;
+    number: any;
+    namespace: string;
+    /**
+     *
+     * @param {Object} attrs
+     * @param {Object} options
+     */
+    constructor(attrs: any, options: any);
+    /**
+     * claims a pmr and updates the cached PMR values
+     * @param {String} link
+     * @param {String} pin
+     * @param {Boolean} [preferred] defaults to true to set this claimed PMR as the preferred
+     * @returns {Promise}
+     * @public
+     * @memberof PersonalMeetingRoom
+     */
+    claim(link: string, pin: string, preferred?: boolean): any;
+    /**
+     * @param {Object} body the response body from meeting info request
+     * @returns {undefined}
+     * @private
+     * @memberof PersonalMeetingRoom
+     */
+    private set;
+    /**
+     * TODO: implement TTL for syncing and caching so to not request again and again
+     * @param {Object} options
+     * @returns {Promise}
+     * @public
+     * @memberof PersonalMeetingRoom
+     */
+    get(): any;
+}

package/dist/types/personal-meeting-room/request.d.ts

@@ -0,0 +1,14 @@
+import { StatelessWebexPlugin } from '@webex/webex-core';
+/**
+ * @class MeetingInfoRequest
+ */
+export default class PersonalMeetingRoomRequest extends StatelessWebexPlugin {
+    namespace: string;
+    /**
+     *
+     * @param {Object} options with format of {userId, passcode, meetingAddress, preferred}
+     * @returns {Promise} returns a promise that resolves/rejects the result of the request
+     * @memberof PersonalMeetingRoomRequest
+     */
+    claimPmr(options: any): any;
+}

package/dist/types/personal-meeting-room/util.d.ts

@@ -0,0 +1,2 @@
+declare const PersonalMeetingRoomUtil: any;
+export default PersonalMeetingRoomUtil;

package/dist/types/reachability/clusterReachability.d.ts

@@ -0,0 +1,110 @@
+import { ClusterNode } from './request';
+export type TransportResult = {
+    result: 'reachable' | 'unreachable' | 'untested';
+    latencyInMilliseconds?: number;
+    clientMediaIPs?: string[];
+};
+export type ClusterReachabilityResult = {
+    udp: TransportResult;
+    tcp: TransportResult;
+    xtls: TransportResult;
+};
+/**
+ * A class that handles reachability checks for a single cluster.
+ */
+export declare class ClusterReachability {
+    private numUdpUrls;
+    private numTcpUrls;
+    private numXTlsUrls;
+    private result;
+    private pc?;
+    private defer;
+    private startTimestamp;
+    readonly isVideoMesh: boolean;
+    readonly name: any;
+    /**
+     * Constructor for ClusterReachability
+     * @param {string} name cluster name
+     * @param {ClusterNode} clusterInfo information about the media cluster
+     */
+    constructor(name: string, clusterInfo: ClusterNode);
+    /**
+     * Gets total elapsed time, can be called only after start() is called
+     * @returns {Number} Milliseconds
+     */
+    private getElapsedTime;
+    /**
+     * Generate peerConnection config settings
+     * @param {ClusterNode} cluster
+     * @returns {RTCConfiguration} peerConnectionConfig
+     */
+    private buildPeerConnectionConfig;
+    /**
+     * Creates an RTCPeerConnection
+     * @param {ClusterNode} clusterInfo information about the media cluster
+     * @returns {RTCPeerConnection} peerConnection
+     */
+    private createPeerConnection;
+    /**
+     * @returns {ClusterReachabilityResult} reachability result for this cluster
+     */
+    getResult(): ClusterReachabilityResult;
+    /**
+     * Closes the peerConnection
+     *
+     * @returns {void}
+     */
+    private closePeerConnection;
+    /**
+     * Resolves the defer, indicating that reachability checks for this cluster are completed
+     *
+     * @returns {void}
+     */
+    private finishReachabilityCheck;
+    /**
+     * Adds public IP (client media IPs)
+     * @param {string} protocol
+     * @param {string} publicIP
+     * @returns {void}
+     */
+    private addPublicIP;
+    /**
+     * Registers a listener for the iceGatheringStateChange event
+     *
+     * @returns {void}
+     */
+    private registerIceGatheringStateChangeListener;
+    /**
+     * Checks if we have the results for all the protocols (UDP and TCP)
+     *
+     * @returns {boolean} true if we have all results, false otherwise
+     */
+    private haveWeGotAllResults;
+    /**
+     * Stores the latency in the result for the given protocol and marks it as reachable
+     *
+     * @param {string} protocol
+     * @param {number} latency
+     * @returns {void}
+     */
+    private storeLatencyResult;
+    /**
+     * Registers a listener for the icecandidate event
+     *
+     * @returns {void}
+     */
+    private registerIceCandidateListener;
+    /**
+     * Starts the process of doing UDP and TCP reachability checks on the media cluster.
+     * XTLS reachability checking is not supported.
+     *
+     * @returns {Promise}
+     */
+    start(): Promise<ClusterReachabilityResult>;
+    /**
+     * Starts the process of gathering ICE candidates
+     *
+     * @returns {Promise} promise that's resolved once reachability checks for this cluster are completed or timeout is reached
+     */
+    private gatherIceCandidates;
+}