@webex/plugin-meetings 2.60.1-next.9 → 2.60.2

package/dist/meeting/muteState.d.ts

@@ -1,94 +1,45 @@
-import { ServerMuteReason } from '@webex/media-helpers';
-export declare const createMuteState: (type: any, meeting: any, enabled: boolean) => MuteState;
+declare const createMuteState: (type: any, meeting: any, mediaDirection: any) => MuteState;
 /** The purpose of this class is to manage the local and remote mute state and make sure that the server state always matches
    the last requested state by the client.
 
    More info about Locus muting API: https://sqbu-github.cisco.com/pages/WebExSquared/locus/guides/mute.html#
-
-   This class is exported only for unit tests. It should never be instantiated directly with new MuteState(), instead createMuteState() should be called
 */
-export declare class MuteState {
-    state: {
-        client: {
-            enabled: boolean;
-            localMute: boolean;
-        };
-        server: {
-            localMute: boolean;
-            remoteMute: boolean;
-            unmuteAllowed: boolean;
-        };
-        syncToServerInProgress: boolean;
-    };
+declare class MuteState {
+    pendingPromiseReject: any;
+    pendingPromiseResolve: any;
+    state: any;
     type: any;
-    ignoreMuteStateChange: boolean;
     /**
      * Constructor
      *
      * @param {String} type - audio or video
      * @param {Object} meeting - the meeting object (used for reading current remote mute status)
-     * @param {boolean} enabled - whether the client audio/video is enabled at all
-     */
-    constructor(type: string, meeting: any, enabled: boolean);
-    /**
-     * Starts the mute state machine. Needs to be called after a new MuteState instance is created.
-     *
-     * @param {Object} meeting - the meeting object
-     * @returns {void}
      */
-    init(meeting: any): void;
+    constructor(type: string, meeting: any);
     /**
-     * This method needs to be called whenever the local audio/video stream has changed.
-     * It reapplies the remote mute state onto the new stream and also reads the current
-     * local mute state from the stream and updates the internal state machine and sends
-     * any required requests to the server.
+     * Handles mute/unmute request from the client/user. Returns a promise that's resolved once the server update is completed or
+     * at the point that this request becomese superseded by another client request.
      *
-     * @param {Object} meeting - the meeting object
-     * @returns {void}
-     */
-    handleLocalStreamChange(meeting: any): void;
-    /**
-     * Enables/disables audio/video
+     * The client doesn't have to wait for the returned promise to resolve before calling handleClientRequest() again. If
+     * handleClientRequest() is called again before the previous one resolved, the MuteState class will make sure that eventually
+     * the server state will match the last requested state from the client.
      *
-     * @param {Object} meeting - the meeting object
-     * @param {boolean} enable
-     * @returns {void}
-     */
-    enable(meeting: any, enable: boolean): void;
-    /**
-     * Mutes/unmutes local stream
-     *
-     * @param {Object} meeting - the meeting object
-     * @param {Boolean} mute - true to mute the stream, false to unmute it
-     * @param {ServerMuteReason} reason - reason for muting/unmuting
-     * @returns {void}
-     */
-    private muteLocalStream;
-    /**
-     * This method should be called when the local stream mute state is changed
      * @public
      * @memberof MuteState
      * @param {Object} [meeting] the meeting object
      * @param {Boolean} [mute] true for muting, false for unmuting request
-     * @returns {void}
+     * @returns {Promise}
      */
-    handleLocalStreamMuteStateChange(meeting?: object, mute?: boolean): void;
+    handleClientRequest(meeting?: object, mute?: boolean): Promise<unknown>;
     /**
-     * Applies the current mute state to the local stream (by enabling or disabling it accordingly)
+     * Applies the current mute state to the local track (by enabling or disabling it accordingly)
      *
      * @public
      * @param {Object} [meeting] the meeting object
-     * @param {ServerMuteReason} reason - reason why we're applying our client state to the local stream
      * @memberof MuteState
      * @returns {void}
      */
-    applyClientStateLocally(meeting?: any, reason?: ServerMuteReason): void;
-    /** Returns true if client is locally muted - it takes into account not just the client local mute state,
-     *  but also whether audio/video is enabled at all
-     *
-     * @returns {boolean}
-     */
-    private getClientLocalMuteState;
+    applyClientStateLocally(meeting?: any): void;
     /**
      * Updates the server local and remote mute values so that they match the current client desired state.
      *
@@ -116,29 +67,16 @@ export declare class MuteState {
      * @returns {Promise}
      */
     private sendRemoteMuteRequestToServer;
-    /** Sets the mute state of the local stream according to what server thinks is our state
-     * @param {Object} meeting - the meeting object
-     * @param {ServerMuteReason} serverMuteReason - reason why we're applying server mute to the local stream
-     * @returns {void}
-     */
-    private applyServerMuteToLocalStream;
-    /** Applies the current value for unmute allowed to the underlying stream
-     *
-     * @param {Meeting} meeting
-     * @returns {void}
-     */
-    private applyUnmuteAllowedToStream;
     /**
      * This method should be called whenever the server remote mute state is changed
      *
      * @public
      * @memberof MuteState
-     * @param {Meeting} meeting
      * @param {Boolean} [muted] true if user is remotely muted, false otherwise
      * @param {Boolean} [unmuteAllowed] indicates if user is allowed to unmute self (false when "hard mute" feature is used)
      * @returns {undefined}
      */
-    handleServerRemoteMuteUpdate(meeting: any, muted?: boolean, unmuteAllowed?: boolean): void;
+    handleServerRemoteMuteUpdate(muted?: boolean, unmuteAllowed?: boolean): void;
     /**
      * This method should be called whenever we receive from the server a requirement to locally unmute
      *
@@ -149,36 +87,30 @@ export declare class MuteState {
      */
     handleServerLocalUnmuteRequired(meeting?: object): void;
     /**
-     * Returns true if the user is locally or remotely muted.
-     * It only checks the mute status, ignoring the fact whether audio/video is enabled.
-     *
-     * @public
-     * @memberof MuteState
-     * @returns {Boolean}
-     */
-    isMuted(): boolean;
-    /**
-     * Returns true if the user is remotely muted
+     * Returns true if the user is locally or remotely muted
      *
      * @public
      * @memberof MuteState
      * @returns {Boolean}
      */
-    isRemotelyMuted(): boolean;
+    isMuted(): any;
     /**
-     * Returns true if unmute is allowed
+     * Returns true if the user is locally muted
      *
      * @public
      * @memberof MuteState
      * @returns {Boolean}
      */
-    isUnmuteAllowed(): boolean;
+    isLocallyMuted(): any;
     /**
-     * Returns true if the user is locally muted or audio/video is disabled
+     * Returns true if the user is muted as a result of the client request (and not remotely muted)
      *
      * @public
      * @memberof MuteState
      * @returns {Boolean}
      */
-    isLocallyMuted(): boolean;
+    isSelf(): boolean;
+    get muted(): any;
+    get self(): boolean;
 }
+export default createMuteState;