@webex/jsdoctrinetest 3.0.0-beta.8 → 3.0.0-bnr.0

package/dist/types/@webex/plugin-meetings/src/metrics/index.d.ts

@@ -0,0 +1,160 @@
+/**
+ * @description Metrics handles all the call metrics events
+ * @export
+ * @class Metrics
+ */
+declare class Metrics {
+    static instance: Metrics;
+    _events: any;
+    keys: any;
+    meetingCollection: any;
+    webex: any;
+    /**
+     * Create Metrics Object
+     * @constructor
+     * @public
+     * @memberof Meetings
+     */
+    constructor();
+    /**
+     * Initializes the Metrics singleton with a meeting Collection.
+     *
+     * @param {Object} meetingCollection meetings object
+     * @param {Object} webex  webex SDK object
+     *
+     * @returns {void}
+     */
+    initialSetup(meetingCollection: object, webex: object): void;
+    /**
+     * poste Meeting event metrics
+     * @param {object} options {meetingId/meeting} as a json object
+     * @param {Meeting} options.meeting Meeting object
+     * @param {String} options.meetingId
+     * @param {object} options.data
+     * @param {object} options.event
+     * @returns {object} null
+     */
+    postEvent(options: {
+        meeting?: any;
+        meetingId?: string;
+        data?: object;
+        event?: any;
+    } | any): void;
+    /**
+     *  Docs for Call analyzer metrics
+     *   https://sqbu-github.cisco.com/WebExSquared/call-analyzer/wiki
+     *   https://sqbu-github.cisco.com/WebExSquared/event-dictionary/blob/master/diagnostic-events.raml
+     */
+    initPayload(eventType: any, identifiers: any, options: any): any;
+    /**
+     * returns metrics friendly OS versions
+     * @param {String} osName Os name
+     * @returns {String}
+     * @private
+     * @memberof Metrics
+     */
+    private getOsName;
+    /**
+     * get the payload specific for a media quality event through call analyzer
+     * @param {String} eventType the event name
+     * @param {Object} identifiers contains the identifiers needed for CA
+     * @param {String} identifiers.correlationId
+     * @param {String} identifiers.locusUrl
+     * @param {String} identifiers.locusId
+     * @param {Object} options
+     * @param {Object} options.intervalData
+     * @param {String} options.clientType
+     * @returns {Object}
+     * @public
+     * @memberof Metrics
+     */
+    initMediaPayload(eventType: string, identifiers: {
+        correlationId: string;
+        locusUrl: string;
+        locusId: string;
+    }, options?: {
+        intervalData: object;
+        clientType: string;
+    } | any): {
+        eventId: any;
+        version: number;
+        origin: {
+            audioSetupDelay: any;
+            videoSetupDelay: any;
+            name: string;
+            networkType: any;
+            userAgent: string;
+            clientInfo: {
+                clientType: any;
+                clientVersion: string;
+                localNetworkPrefix: string;
+                os: any;
+                osVersion: any;
+                subClientType: any;
+                browser: any;
+                browserVersion: any;
+            };
+        };
+        originTime: {
+            triggered: string;
+        };
+        senderCountryCode: any;
+        event: {
+            name: string;
+            canProceed: boolean;
+            identifiers: {
+                correlationId: string;
+                locusUrl: string;
+                locusId: string;
+            };
+            intervals: any[];
+            joinTimes: any;
+            eventData: {
+                webClientDomain: any;
+            };
+            sourceMetadata: {
+                applicationSoftwareType: string;
+                applicationSoftwareVersion: any;
+                mediaEngineSoftwareType: any;
+                mediaEngineSoftwareVersion: any;
+                startTime: string;
+            };
+        };
+    };
+    /**
+     * This function Parses a Locus error and returns a diagnostic event payload.
+     * It should keep updating from:
+     * https://sqbu-github.cisco.com/WebExSquared/spark-client-framework/blob/master/spark-client-framework/Adapters/TelephonyAdapter/TelephonyAdapter.cpp#L920
+     *
+     * @param {Object} err the error Object from Locus response
+     * @param {boolean} showToUser true if a toast is shown to user
+     * @returns {{showToUser: boolean, category: string, errorDescription: string,
+     *  errorCode: number, errorData: *, fatal: boolean, name: string}}
+     */
+    parseLocusError(err: any, showToUser: boolean): any;
+    generateErrorPayload(errorCode: any, shownToUser: any, name: any, err: any): any;
+    /**
+     * Returns a formated string of the user agent.
+     *
+     * @returns {string} formatted user agent information
+     */
+    userAgentToString(): string;
+    /**
+     * Uploads given metric to the Metrics service as an Behavioral metric.
+     * Metadata about the environment such as browser, OS, SDK and their versions
+     * are automatically added when the metric is sent.
+     *
+     * The Metrics service will send an Behavioral metric to InfluxDB for
+     * aggregation.
+     * See https://confluence-eng-gpk2.cisco.com/conf/display/WBXT/Getting+started+with+Metrics+Service.
+     *
+     * @param {string} metricName  Name of the metric (measurement) to send
+     * @param {Object} metricFields  Key-valye pairs of data or values about this metric
+     * @param {Object} metricTags  Key-value pairs of metric metadata
+     *
+     * @returns {void}
+     */
+    sendBehavioralMetric(metricName: string, metricFields?: object, metricTags?: object): void;
+}
+declare const instance: Metrics;
+export default instance;

package/dist/types/@webex/plugin-meetings/src/multistream/mediaRequestManager.d.ts

@@ -0,0 +1,51 @@
+import { MediaRequest as WcmeMediaRequest } from '@webex/internal-media-core';
+import { ReceiveSlot } from './receiveSlot';
+export interface ActiveSpeakerPolicyInfo {
+    policy: 'active-speaker';
+    priority: number;
+    crossPriorityDuplication: boolean;
+    crossPolicyDuplication: boolean;
+    preferLiveVideo: boolean;
+}
+export interface ReceiverSelectedPolicyInfo {
+    policy: 'receiver-selected';
+    csi: number;
+}
+export type PolicyInfo = ActiveSpeakerPolicyInfo | ReceiverSelectedPolicyInfo;
+export interface H264CodecInfo {
+    codec: 'h264';
+    maxFs?: number;
+    maxFps?: number;
+    maxMbps?: number;
+    maxWidth?: number;
+    maxHeight?: number;
+}
+export type CodecInfo = H264CodecInfo;
+export interface MediaRequest {
+    policyInfo: PolicyInfo;
+    receiveSlots: Array<ReceiveSlot>;
+    codecInfo?: CodecInfo;
+}
+export type MediaRequestId = string;
+type DegradationPreferences = {
+    maxMacroblocksLimit: number;
+};
+type SendMediaRequestsCallback = (mediaRequests: WcmeMediaRequest[]) => void;
+export declare class MediaRequestManager {
+    private sendMediaRequestsCallback;
+    private counter;
+    private clientRequests;
+    private slotsActiveInLastMediaRequest;
+    private degradationPreferences;
+    private sourceUpdateListener;
+    constructor(degradationPreferences: DegradationPreferences, sendMediaRequestsCallback: SendMediaRequestsCallback);
+    private resetInactiveReceiveSlots;
+    setDegradationPreferences(degradationPreferences: DegradationPreferences): void;
+    private getDegradedClientRequests;
+    private sendRequests;
+    addRequest(mediaRequest: MediaRequest, commit?: boolean): MediaRequestId;
+    cancelRequest(requestId: MediaRequestId, commit?: boolean): void;
+    commit(): void;
+    reset(): void;
+}
+export {};

package/dist/types/@webex/plugin-meetings/src/multistream/receiveSlot.d.ts

@@ -0,0 +1,66 @@
+import { MediaType, ReceiveSlot as WcmeReceiveSlot, SourceState } from '@webex/internal-media-core';
+import EventsScope from '../common/events/events-scope';
+export declare const ReceiveSlotEvents: {
+    SourceUpdate: string;
+};
+export type { SourceState } from '@webex/internal-media-core';
+export type CSI = number;
+export type MemberId = string;
+export type ReceiveSlotId = string;
+export type FindMemberIdCallback = (csi: CSI) => MemberId | undefined;
+/**
+ * Class representing a receive slot. A single receive slot is able to receive a single track
+ * for example some participant's main video or audio
+ */
+export declare class ReceiveSlot extends EventsScope {
+    #private;
+    private readonly mcReceiveSlot;
+    private readonly findMemberIdCallback;
+    readonly id: ReceiveSlotId;
+    readonly mediaType: MediaType;
+    /**
+     * constructor - don't use it directly, you should always use meeting.receiveSlotManager.allocateSlot()
+     * to create any receive slots
+     *
+     * @param {MediaType} mediaType
+     * @param {ReceiveSlot} mcReceiveSlot
+     * @param {FindMemberIdCallback} findMemberIdCallback callback for finding memberId for given CSI
+     */
+    constructor(mediaType: MediaType, mcReceiveSlot: WcmeReceiveSlot, findMemberIdCallback: FindMemberIdCallback);
+    /**
+     * Getter for memberId
+     */
+    get memberId(): string;
+    /**
+     * Getter for csi
+     */
+    get csi(): number;
+    /**
+     * Getter for sourceState
+     */
+    get sourceState(): SourceState;
+    /**
+     * registers event handlers with the underlying ReceiveSlot
+     */
+    private setupEventListeners;
+    /** Tries to find the member id for this receive slot if it hasn't got one */
+    findMemberId(): void;
+    /**
+     * The MediaStream object associated with this slot.
+     *
+     * @returns {MediaStream} The MediaStreamTrack.
+     */
+    get stream(): MediaStream;
+    /**
+     * The underlying WCME receive slot
+     */
+    get wcmeReceiveSlot(): WcmeReceiveSlot;
+    /**
+     * Resets the source state to the default 'no source' value.
+     * This function should be called on receive slots that are
+     * no longer part of a media request. It's needed because WCME
+     * does not send any more events on such slots, so the sourceState
+     * value would not represent the truth anymore.
+     */
+    resetSourceState(): void;
+}

package/dist/types/@webex/plugin-meetings/src/multistream/receiveSlotManager.d.ts

@@ -0,0 +1,46 @@
+import { MediaType } from '@webex/internal-media-core';
+import { ReceiveSlot } from './receiveSlot';
+/**
+ * Manages all receive slots used by a meeting. WMCE receive slots cannot be ever deleted,
+ * so this manager has a pool in order to re-use the slots that were released earlier.
+ */
+export declare class ReceiveSlotManager {
+    private allocatedSlots;
+    private freeSlots;
+    private meeting;
+    /**
+     * Constructor
+     * @param {Meeting} meeting
+     */
+    constructor(meeting: any);
+    /**
+     * Creates a new receive slot or returns one from the existing pool of free slots
+     *
+     * @param {MediaType} mediaType
+     * @returns {Promise<ReceiveSlot>}
+     */
+    allocateSlot(mediaType: MediaType): Promise<ReceiveSlot>;
+    /**
+     * Releases the slot back to the pool so it can be re-used by others in the future
+     * @param {ReceiveSlot} slot
+     */
+    releaseSlot(slot: ReceiveSlot): void;
+    /**
+     * Resets the slot manager - this method should be called when the media connection is torn down
+     */
+    reset(): void;
+    /**
+     * Returns statistics about the managed slots
+     *
+     * @returns {Object}
+     */
+    getStats(): {
+        numAllocatedSlots: {};
+        numFreeSlots: {};
+    };
+    /**
+     * Tries to find the member id on all allocated receive slots
+     * This function should be called when new members are added to the meeting.
+     */
+    updateMemberIds(): void;
+}

package/dist/types/@webex/plugin-meetings/src/multistream/remoteMedia.d.ts

@@ -0,0 +1,93 @@
+import { MediaType, SourceState } from '@webex/internal-media-core';
+import EventsScope from '../common/events/events-scope';
+import { MediaRequestManager } from './mediaRequestManager';
+import { CSI, ReceiveSlot } from './receiveSlot';
+export declare const RemoteMediaEvents: {
+    SourceUpdate: string;
+    Stopped: string;
+};
+export type RemoteVideoResolution = 'thumbnail' | 'very small' | 'small' | 'medium' | 'large' | 'best';
+/**
+ * Converts pane size into h264 maxFs
+ * @param {PaneSize} paneSize
+ * @returns {number}
+ */
+export declare function getMaxFs(paneSize: RemoteVideoResolution): number;
+type Options = {
+    resolution?: RemoteVideoResolution;
+};
+export type RemoteMediaId = string;
+/**
+ * Class representing a remote audio/video stream.
+ *
+ * Internally it is associated with a specific receive slot
+ * and a media request for it.
+ */
+export declare class RemoteMedia extends EventsScope {
+    private receiveSlot?;
+    private readonly mediaRequestManager;
+    private readonly options;
+    private mediaRequestId?;
+    readonly id: RemoteMediaId;
+    /**
+     * Constructs RemoteMedia instance
+     *
+     * @param receiveSlot
+     * @param mediaRequestManager
+     * @param options
+     */
+    constructor(receiveSlot: ReceiveSlot, mediaRequestManager: MediaRequestManager, options?: Options);
+    /**
+     * Invalidates the remote media by clearing the reference to a receive slot and
+     * cancelling the media request.
+     * After this call the remote media is unusable.
+     *
+     * @param {boolean} commit - whether to commit the cancellation of the media request
+     * @internal
+     */
+    stop(commit?: boolean): void;
+    /**
+     * Sends a new media request. This method can only be used for receiver-selected policy,
+     * because only in that policy we have a 1-1 relationship between RemoteMedia and MediaRequest
+     * and the request id is then stored in this RemoteMedia instance.
+     * For active-speaker policy, the same request is shared among many RemoteMedia instances,
+     * so it's managed through RemoteMediaGroup
+     *
+     * @internal
+     */
+    sendMediaRequest(csi: CSI, commit: boolean): void;
+    /**
+     * @internal
+     */
+    cancelMediaRequest(commit: boolean): void;
+    /**
+     * registers event listeners on the receive slot and forwards all the events
+     */
+    private setupEventListeners;
+    /**
+     * Getter for mediaType
+     */
+    get mediaType(): MediaType;
+    /**
+     * Getter for memberId
+     */
+    get memberId(): string;
+    /**
+     * Getter for csi
+     */
+    get csi(): number;
+    /**
+     * Getter for source state
+     */
+    get sourceState(): SourceState;
+    /**
+     * Getter for remote media stream
+     */
+    get stream(): MediaStream;
+    /**
+     * @internal
+     * @returns {ReceiveSlot}
+     */
+    getUnderlyingReceiveSlot(): ReceiveSlot;
+}
+export {};

package/dist/types/@webex/plugin-meetings/src/multistream/remoteMediaGroup.d.ts

@@ -0,0 +1,56 @@
+import { RemoteMedia, RemoteVideoResolution } from './remoteMedia';
+import { MediaRequestManager } from './mediaRequestManager';
+import { CSI, ReceiveSlot } from './receiveSlot';
+type Options = {
+    resolution?: RemoteVideoResolution;
+    preferLiveVideo?: boolean;
+};
+export declare class RemoteMediaGroup {
+    private mediaRequestManager;
+    private priority;
+    private options;
+    private unpinnedRemoteMedia;
+    private mediaRequestId?;
+    private pinnedRemoteMedia;
+    constructor(mediaRequestManager: MediaRequestManager, receiveSlots: ReceiveSlot[], priority: number, commitMediaRequest: boolean, options?: Options);
+    /**
+     * Gets the array of remote media elements from the group
+     *
+     * @param {string} filter - 'all' (default) returns both pinned and unpinned
+     * @returns {Array<RemoteMedia>}
+     */
+    getRemoteMedia(filter?: 'all' | 'pinned' | 'unpinned'): RemoteMedia[];
+    /**
+     * Pins a specific remote media instance to a specfic CSI, so the media will
+     * no longer come from active speaker, but from that CSI.
+     * If no CSI is given, the current CSI value is used.
+     *
+     */
+    pin(remoteMedia: RemoteMedia, csi?: CSI): void;
+    /**
+     * Unpins a remote media instance, so that it will again provide media from active speakers
+     *
+     */
+    unpin(remoteMedia: RemoteMedia): void;
+    isPinned(remoteMedia: RemoteMedia): boolean;
+    private sendActiveSpeakerMediaRequest;
+    private cancelActiveSpeakerMediaRequest;
+    /**
+     * Invalidates the remote media group by clearing the references to the receive slots
+     * used by all remote media from that group and cancelling all media requests.
+     * After this call the remote media group is unusable.
+     *
+     * @param{boolean} commit whether to commit the cancellation of media requests
+     * @internal
+     */
+    stop(commit?: boolean): void;
+    /**
+     * Checks if a given RemoteMedia instance belongs to this group.
+     *
+     * @param remoteMedia RemoteMedia instance to check
+     * @param filter controls which remote media from the group to check
+     * @returns true if remote media is found
+     */
+    includes(remoteMedia: RemoteMedia, filter?: 'all' | 'pinned' | 'unpinned'): boolean;
+}
+export {};