mediasfu-angular 1.0.0

package/dist/lib/consumers/resume-pause-audio-streams.service.d.ts

@@ -0,0 +1,41 @@
+import { Participant, Stream, ProcessConsumerTransportsAudioType, ProcessConsumerTransportsAudioParameters, Transport, BreakoutParticipant, EventType } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface ResumePauseAudioStreamsParameters extends ProcessConsumerTransportsAudioParameters {
+    breakoutRooms: BreakoutParticipant[][];
+    ref_participants: Participant[];
+    allAudioStreams: (Stream | Participant)[];
+    participants: Participant[];
+    islevel: string;
+    eventType: EventType;
+    consumerTransports: Transport[];
+    limitedBreakRoom: BreakoutParticipant[];
+    hostNewRoom: number;
+    member: string;
+    updateLimitedBreakRoom: (limitedBreakRoom: BreakoutParticipant[]) => void;
+    processConsumerTransportsAudio: ProcessConsumerTransportsAudioType;
+    getUpdatedAllParams: () => ResumePauseAudioStreamsParameters;
+    [key: string]: any;
+}
+export interface ResumePauseAudioStreamsOptions {
+    breakRoom?: number;
+    inBreakRoom?: boolean;
+    parameters: ResumePauseAudioStreamsParameters;
+}
+export type ResumePauseAudioStreamsType = (options: ResumePauseAudioStreamsOptions) => Promise<void>;
+export declare class ResumePauseAudioStreams {
+    /**
+     * Resumes or pauses audio streams based on the provided options.
+     *
+     * @param {ResumePauseAudioStreamsOptions} options - The options for resuming or pausing audio streams.
+     * @param {number} [options.breakRoom=-1] - The ID of the break room.
+     * @param {boolean} [options.inBreakRoom=false] - Indicates if the participant is in a break room.
+     * @param {Parameters} options.parameters - The parameters required for processing audio streams.
+     *
+     * @returns {Promise<void>} A promise that resolves when the audio streams have been processed.
+     *
+     * @throws Will log an error message if there is an issue processing the audio streams.
+     */
+    resumePauseAudioStreams: ({ breakRoom, inBreakRoom, parameters, }: ResumePauseAudioStreamsOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResumePauseAudioStreams, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResumePauseAudioStreams>;
+}

package/dist/lib/consumers/resume-pause-streams.service.d.ts

@@ -0,0 +1,36 @@
+import { Participant, Transport, Stream } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface ResumePauseStreamsParameters {
+    participants: Participant[];
+    dispActiveNames: string[];
+    remoteScreenStream: Stream[];
+    consumerTransports: Transport[];
+    screenId?: string;
+    islevel: string;
+    getUpdatedAllParams: () => ResumePauseStreamsParameters;
+    [key: string]: any;
+}
+export interface ResumePauseStreamsOptions {
+    parameters: ResumePauseStreamsParameters;
+}
+export type ResumePauseStreamsType = (options: ResumePauseStreamsOptions) => Promise<void>;
+export declare class ResumePauseStreams {
+    /**
+     * Resumes or pauses streams based on the provided parameters.
+     *
+     * @param {ResumePauseStreamsOptions} options - The options for resuming or pausing streams.
+     * @param {Object} options.parameters - The parameters for the function.
+     * @param {Array} options.parameters.participants - The list of participants.
+     * @param {Array} options.parameters.dispActiveNames - The list of active display names.
+     * @param {Array} options.parameters.consumerTransports - The list of consumer transports.
+     * @param {string} options.parameters.screenId - The screen producer ID.
+     * @param {string} options.parameters.islevel - The level of the user.
+     *
+     * @returns {Promise<void>} A promise that resolves when the streams have been resumed or paused.
+     *
+     * @throws Will throw an error if there is an issue during the process of resuming or pausing streams.
+     */
+    resumePauseStreams: ({ parameters }: ResumePauseStreamsOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResumePauseStreams, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResumePauseStreams>;
+}

package/dist/lib/consumers/resume-send-transport-audio.service.d.ts

@@ -0,0 +1,43 @@
+import { Producer } from 'mediasoup-client/lib/types';
+import { PrepopulateUserMediaParameters, PrepopulateUserMediaType } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface ResumeSendTransportAudioParameters extends PrepopulateUserMediaParameters {
+    audioProducer: Producer | null;
+    islevel: string;
+    hostLabel: string;
+    lock_screen: boolean;
+    shared: boolean;
+    videoAlreadyOn: boolean;
+    updateAudioProducer: (audioProducer: Producer | null) => void;
+    updateUpdateMainWindow: (updateMainWindow: boolean) => void;
+    prepopulateUserMedia: PrepopulateUserMediaType;
+    [key: string]: any;
+}
+export interface ResumeSendTransportAudioOptions {
+    parameters: ResumeSendTransportAudioParameters;
+}
+export type ResumeSendTransportAudioType = (options: ResumeSendTransportAudioOptions) => Promise<void>;
+export declare class ResumeSendTransportAudio {
+    /**
+     * Resumes the send transport for audio and updates the UI and audio producer state accordingly.
+     *
+     * @param {ResumeSendTransportAudioOptions} options - The options for resuming the send transport.
+     * @param {Object} options.parameters - The parameters required for resuming the send transport.
+     * @param {Producer} options.parameters.audioProducer - The audio producer to be resumed.
+     * @param {string} options.parameters.islevel - The level of the user.
+     * @param {string} options.parameters.hostLabel - The label of the host.
+     * @param {boolean} options.parameters.lock_screen - Indicates if the screen is locked.
+     * @param {boolean} options.parameters.shared - Indicates if the screen is shared.
+     * @param {Function} options.parameters.updateAudioProducer - Function to update the audio producer state.
+     * @param {boolean} options.parameters.videoAlreadyOn - Indicates if the video is already on.
+     * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window state.
+     * @param {Function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.
+     *
+     * @returns {Promise<void>} A promise that resolves when the send transport is resumed and the UI is updated.
+     *
+     * @throws {Error} Throws an error if there is an issue during the process of resuming the audio send transport.
+     */
+    resumeSendTransportAudio({ parameters }: ResumeSendTransportAudioOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResumeSendTransportAudio, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResumeSendTransportAudio>;
+}

package/dist/lib/consumers/signal-new-consumer-transport.service.d.ts

@@ -0,0 +1,63 @@
+import { Socket } from 'socket.io-client';
+import { ReorderStreamsParameters, ReorderStreamsType, ConnectRecvTransportType, ConnectRecvTransportParameters } from '../@types/types';
+import { Device } from 'mediasoup-client/lib/types';
+import * as i0 from "@angular/core";
+export interface SignalNewConsumerTransportParameters extends ReorderStreamsParameters, ConnectRecvTransportParameters {
+    device: Device | null;
+    consumingTransports: string[];
+    lock_screen: boolean;
+    updateConsumingTransports: (transports: string[]) => void;
+    connectRecvTransport: ConnectRecvTransportType;
+    reorderStreams: ReorderStreamsType;
+    getUpdatedAllParams: () => SignalNewConsumerTransportParameters;
+    [key: string]: any;
+}
+export interface SignalNewConsumerTransportOptions {
+    remoteProducerId: string;
+    islevel: string;
+    nsock: Socket;
+    parameters: SignalNewConsumerTransportParameters;
+}
+export type SignalNewConsumerTransportType = (options: SignalNewConsumerTransportOptions) => Promise<string[] | void>;
+export declare class SignalNewConsumerTransport {
+    /**
+     * Signals the creation of a new consumer transport.
+     *
+     * @param {Object} options - The options for signaling a new consumer transport.
+     * @param {string} options.remoteProducerId - The ID of the remote producer.
+     * @param {boolean} options.islevel - Indicates the level of the consumer.
+     * @param {any} options.nsock - The socket instance for communication.
+     * @param {SignalNewConsumerTransportOptions} options.parameters - The parameters for the transport.
+     *
+     * @returns {Promise<string[] | void>} A promise that resolves to an array of consuming transports or void.
+     *
+     * @throws Will throw an error if the signaling process fails.
+     *
+     * @example
+     * const options = {
+     *   remoteProducerId: 'producer-id',
+     *   islevel: true,
+     *   nsock: socketInstance,
+     *   parameters: {
+     *     device: mediaDevice,
+     *     consumingTransports: [],
+     *     lock_screen: false,
+     *     updateConsumingTransports: updateFunction,
+     *     connectRecvTransport: connectFunction,
+     *     reorderStreams: reorderFunction,
+     *     getUpdatedAllParams: getUpdatedParamsFunction,
+     *   },
+     * };
+     *
+     * signalNewConsumerTransport(options)
+     *   .then(consumingTransports => {
+     *     console.log('Consuming Transports:', consumingTransports);
+     *   })
+     *   .catch(error => {
+     *     console.error('Error signaling new consumer transport:', error);
+     *   });
+     */
+    signalNewConsumerTransport: ({ remoteProducerId, islevel, nsock, parameters, }: SignalNewConsumerTransportOptions) => Promise<string[] | void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SignalNewConsumerTransport, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SignalNewConsumerTransport>;
+}

package/dist/lib/consumers/socket-receive-methods/join-consume-room.service.d.ts

@@ -0,0 +1,43 @@
+import { JoinConRoom } from '../../producers/producer-emits/join-con-room.service';
+import { Socket } from 'socket.io-client';
+import { ReceiveAllPipedTransportsType, ReceiveAllPipedTransportsParameters, CreateDeviceClientType } from '../../@types/types';
+import { Device, RtpCapabilities } from 'mediasoup-client/lib/types';
+import * as i0 from "@angular/core";
+export interface JoinConsumeRoomParameters extends ReceiveAllPipedTransportsParameters {
+    roomName: string;
+    islevel: string;
+    member: string;
+    device: Device | null;
+    updateDevice: (device: Device | null) => void;
+    receiveAllPipedTransports: ReceiveAllPipedTransportsType;
+    createDeviceClient: CreateDeviceClientType;
+    [key: string]: any;
+}
+export interface JoinConsumeRoomOptions {
+    remote_sock: Socket;
+    apiToken: string;
+    apiUserName: string;
+    parameters: JoinConsumeRoomParameters;
+}
+interface JoinConsumeRoomResponse {
+    success: boolean;
+    rtpCapabilities?: RtpCapabilities;
+}
+export type JoinConsumeRoomType = (options: JoinConsumeRoomOptions) => Promise<JoinConsumeRoomResponse>;
+export declare class JoinConsumeRoom {
+    private JoinConRoomService;
+    constructor(JoinConRoomService: JoinConRoom);
+    /**
+     * Joins a consumption room by sending a request to the server and handles the necessary setup.
+     * @param {Object} options - The options object containing necessary variables.
+     * @param {any} options.remote_sock - The remote socket information.
+     * @param {string} options.apiToken - The API token for authentication.
+     * @param {string} options.apiUserName - The API username for authentication.
+     * @param {any} options.parameters - Additional parameters required for the function.
+     * @returns {Promise<any>} - A promise that resolves with data related to the success of joining the room.
+     */
+    joinConsumeRoom: ({ remote_sock, apiToken, apiUserName, parameters, }: JoinConsumeRoomOptions) => Promise<JoinConsumeRoomResponse>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JoinConsumeRoom, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<JoinConsumeRoom>;
+}
+export {};

package/dist/lib/consumers/socket-receive-methods/new-pipe-producer.service.d.ts

@@ -0,0 +1,46 @@
+import { SignalNewConsumerTransport } from '../signal-new-consumer-transport.service';
+import { Socket } from 'socket.io-client';
+import { ReorderStreamsParameters, ReorderStreamsType, SignalNewConsumerTransportParameters, ConnectRecvTransportParameters, ConnectRecvTransportType, ShowAlert } from '../../@types/types';
+import { Device } from 'mediasoup-client/lib/types';
+import * as i0 from "@angular/core";
+export interface NewPipeProducerParameters extends ReorderStreamsParameters, SignalNewConsumerTransportParameters, ConnectRecvTransportParameters {
+    first_round: boolean;
+    shareScreenStarted: boolean;
+    shared: boolean;
+    landScaped: boolean;
+    showAlert?: ShowAlert;
+    isWideScreen: boolean;
+    updateFirst_round: (firstRound: boolean) => void;
+    updateLandScaped: (landScaped: boolean) => void;
+    device: Device | null;
+    consumingTransports: string[];
+    lock_screen: boolean;
+    updateConsumingTransports: (transports: string[]) => void;
+    connectRecvTransport: ConnectRecvTransportType;
+    reorderStreams: ReorderStreamsType;
+    getUpdatedAllParams: () => NewPipeProducerParameters;
+    [key: string]: any;
+}
+export interface NewPipeProducerOptions {
+    producerId: string;
+    islevel: string;
+    nsock: Socket;
+    parameters: NewPipeProducerParameters;
+}
+export type NewPipeProducerType = (options: NewPipeProducerOptions) => Promise<void>;
+export declare class NewPipeProducer {
+    private signalNewConsumerTransportService;
+    constructor(signalNewConsumerTransportService: SignalNewConsumerTransport);
+    /**
+     * Handles new pipe producer events and updates relevant states.
+     * @param {Object} options - The options object containing necessary variables.
+     * @param {string} options.producerId - The ID of the producer.
+     * @param {string} options.islevel - The level of the producer.
+     * @param {any} options.nsock - The socket object.
+     * @param {any} options.parameters - Additional parameters required for the function.
+     * @returns {Promise<void>}
+     */
+    newPipeProducer: ({ producerId, islevel, nsock, parameters, }: NewPipeProducerOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NewPipeProducer, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NewPipeProducer>;
+}

package/dist/lib/consumers/socket-receive-methods/producer-closed.service.d.ts

@@ -0,0 +1,27 @@
+import { Transport, CloseAndResizeParameters, CloseAndResizeType } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface ProducerClosedParameters extends CloseAndResizeParameters {
+    consumerTransports: Transport[];
+    screenId?: string;
+    updateConsumerTransports: (transports: Transport[]) => void;
+    closeAndResize: CloseAndResizeType;
+    getUpdatedAllParams: () => ProducerClosedParameters;
+    [key: string]: any;
+}
+export interface ProducerClosedOptions {
+    remoteProducerId: string;
+    parameters: ProducerClosedParameters;
+}
+export type ProducerClosedType = (options: ProducerClosedOptions) => Promise<void>;
+export declare class ProducerClosed {
+    /**
+     * Handles the closing of a producer and resizes video elements.
+     * @param {Object} options - The options object containing necessary variables.
+     * @param {string} options.remoteProducerId - The ID of the remote producer.
+     * @param {any} options.parameters - Additional parameters required for the function.
+     * @returns {Promise<void>}
+     */
+    producerClosed: ({ remoteProducerId, parameters, }: ProducerClosedOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProducerClosed, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProducerClosed>;
+}

package/dist/lib/consumers/start-share-screen.service.d.ts

@@ -0,0 +1,38 @@
+import { StreamSuccessScreenType, StreamSuccessScreenParameters, ShowAlert } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface StartShareScreenParameters extends StreamSuccessScreenParameters {
+    shared: boolean;
+    showAlert?: ShowAlert;
+    updateShared: (shared: boolean) => void;
+    onWeb: boolean;
+    targetWidth?: number;
+    targetHeight?: number;
+    streamSuccessScreen: StreamSuccessScreenType;
+    [key: string]: any;
+}
+export interface StartShareScreenOptions {
+    parameters: StartShareScreenParameters;
+}
+export type StartShareScreenType = (options: StartShareScreenOptions) => Promise<void>;
+export declare class StartShareScreen {
+    /**
+     * Starts the screen sharing process.
+     *
+     * @param {StartShareScreenOptions} options - The options for starting screen sharing.
+     * @param {Object} options.parameters - The parameters for screen sharing.
+     * @param {boolean} options.parameters.shared - Indicates if the screen is currently being shared.
+     * @param {Function} options.parameters.showAlert - Function to show alert messages.
+     * @param {Function} options.parameters.updateShared - Function to update the shared state.
+     * @param {boolean} options.parameters.onWeb - Indicates if the application is running on a web platform.
+     * @param {number} [options.parameters.targetWidth] - The target width for screen sharing.
+     * @param {number} [options.parameters.targetHeight] - The target height for screen sharing.
+     * @param {Function} options.parameters.streamSuccessScreen - Function to handle successful screen sharing.
+     *
+     * @returns {Promise<void>} A promise that resolves when the screen sharing process is complete.
+     *
+     * @throws Will log an error message if there is an issue starting the screen share.
+     */
+    startShareScreen: ({ parameters }: StartShareScreenOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StartShareScreen, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StartShareScreen>;
+}

package/dist/lib/consumers/stop-share-screen.service.d.ts

@@ -0,0 +1,86 @@
+import { DisconnectSendTransportScreenType, PrepopulateUserMediaType, ReorderStreamsType, GetVideosType, DisconnectSendTransportScreenParameters, PrepopulateUserMediaParameters, ReorderStreamsParameters, EventType } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface StopShareScreenParameters extends DisconnectSendTransportScreenParameters, PrepopulateUserMediaParameters, ReorderStreamsParameters {
+    shared: boolean;
+    shareScreenStarted: boolean;
+    shareEnded: boolean;
+    updateMainWindow: boolean;
+    defer_receive: boolean;
+    hostLabel: string;
+    lock_screen: boolean;
+    forceFullDisplay: boolean;
+    firstAll: boolean;
+    first_round: boolean;
+    localStreamScreen: MediaStream | null;
+    eventType: EventType;
+    prevForceFullDisplay: boolean;
+    annotateScreenStream: boolean;
+    updateShared: (shared: boolean) => void;
+    updateShareScreenStarted: (shareScreenStarted: boolean) => void;
+    updateShareEnded: (shareEnded: boolean) => void;
+    updateUpdateMainWindow: (updateMainWindow: boolean) => void;
+    updateDefer_receive: (defer_receive: boolean) => void;
+    updateLock_screen: (lock_screen: boolean) => void;
+    updateForceFullDisplay: (forceFullDisplay: boolean) => void;
+    updateFirstAll: (firstAll: boolean) => void;
+    updateFirst_round: (first_round: boolean) => void;
+    updateLocalStreamScreen: (localStreamScreen: MediaStream | null) => void;
+    updateMainHeightWidth: (mainHeightWidth: number) => void;
+    updateAnnotateScreenStream: (annotateScreenStream: boolean) => void;
+    updateIsScreenboardModalVisible: (isVisible: boolean) => void;
+    disconnectSendTransportScreen: DisconnectSendTransportScreenType;
+    prepopulateUserMedia: PrepopulateUserMediaType;
+    reorderStreams: ReorderStreamsType;
+    getVideos: GetVideosType;
+    getUpdatedAllParams: () => StopShareScreenParameters;
+    [key: string]: any;
+}
+export interface StopShareScreenOptions {
+    parameters: StopShareScreenParameters;
+}
+export type StopShareScreenType = (options: StopShareScreenOptions) => Promise<void>;
+export declare class StopShareScreen {
+    /**
+     * Stops the screen sharing process and updates the relevant parameters and states.
+     *
+     * @param {StopShareScreenOptions} options - The options for stopping the screen share.
+     * @param {Object} options.parameters - The parameters required for stopping the screen share.
+     * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+     * @param {boolean} options.parameters.shared - Indicates if the screen is currently shared.
+     * @param {boolean} options.parameters.shareScreenStarted - Indicates if the screen sharing has started.
+     * @param {boolean} options.parameters.shareEnded - Indicates if the screen sharing has ended.
+     * @param {boolean} options.parameters.updateMainWindow - Indicates if the main window needs to be updated.
+     * @param {boolean} options.parameters.defer_receive - Indicates if receiving is deferred.
+     * @param {string} options.parameters.hostLabel - The label of the host.
+     * @param {boolean} options.parameters.lock_screen - Indicates if the screen is locked.
+     * @param {boolean} options.parameters.forceFullDisplay - Indicates if full display is forced.
+     * @param {boolean} options.parameters.firstAll - Indicates if it is the first all.
+     * @param {boolean} options.parameters.first_round - Indicates if it is the first round.
+     * @param {MediaStream} options.parameters.localStreamScreen - The local screen stream.
+     * @param {string} options.parameters.eventType - The type of event.
+     * @param {boolean} options.parameters.prevForceFullDisplay - Indicates if full display was previously forced.
+     * @param {boolean} options.parameters.annotateScreenStream - Indicates if the screen stream is annotated.
+     * @param {Function} options.parameters.updateShared - Function to update the shared state.
+     * @param {Function} options.parameters.updateShareScreenStarted - Function to update the share screen started state.
+     * @param {Function} options.parameters.updateShareEnded - Function to update the share ended state.
+     * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window state.
+     * @param {Function} options.parameters.updateDefer_receive - Function to update the defer receive state.
+     * @param {Function} options.parameters.updateLock_screen - Function to update the lock screen state.
+     * @param {Function} options.parameters.updateForceFullDisplay - Function to update the force full display state.
+     * @param {Function} options.parameters.updateFirstAll - Function to update the first all state.
+     * @param {Function} options.parameters.updateFirst_round - Function to update the first round state.
+     * @param {Function} options.parameters.updateLocalStreamScreen - Function to update the local screen stream.
+     * @param {Function} options.parameters.updateMainHeightWidth - Function to update the main height and width.
+     * @param {Function} options.parameters.updateAnnotateScreenStream - Function to update the annotate screen stream state.
+     * @param {Function} options.parameters.updateIsScreenboardModalVisible - Function to update the screenboard modal visibility.
+     * @param {Function} options.parameters.disconnectSendTransportScreen - Function to disconnect the send transport screen.
+     * @param {Function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.
+     * @param {Function} options.parameters.reorderStreams - Function to reorder streams.
+     * @param {Function} options.parameters.getVideos - Function to get videos.
+     *
+     * @returns {Promise<void>} A promise that resolves when the screen sharing process is stopped.
+     */
+    stopShareScreen: ({ parameters }: StopShareScreenOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StopShareScreen, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StopShareScreen>;
+}

package/dist/lib/consumers/stream-success-audio-switch.service.d.ts

@@ -0,0 +1,90 @@
+import { Producer, ProducerCodecOptions, ProducerOptions } from 'mediasoup-client/lib/types';
+import { Socket } from 'socket.io-client';
+import { PrepopulateUserMediaParameters, PrepopulateUserMediaType, CreateSendTransportParameters, CreateSendTransportType, ConnectSendTransportAudioParameters, ConnectSendTransportAudioType, SleepType } from '../@types/types';
+import * as i0 from "@angular/core";
+/**
+ * Handles the success of switching audio devices in a streaming context.
+ * @async
+ * @function
+ * @param {Object} parameters - The parameters object containing necessary variables.
+ * @param {MediaStream} stream - The new MediaStream with the switched audio device.
+ */
+export interface StreamSuccessAudioSwitchParameters extends PrepopulateUserMediaParameters, CreateSendTransportParameters, ConnectSendTransportAudioParameters {
+    audioProducer: Producer | null;
+    socket: Socket;
+    roomName: string;
+    localStream: MediaStream | null;
+    localStreamAudio: MediaStream | null;
+    audioParams: ProducerOptions;
+    audioPaused: boolean;
+    audioAlreadyOn: boolean;
+    transportCreated: boolean;
+    audioParamse?: ProducerCodecOptions;
+    defAudioID: string;
+    userDefaultAudioInputDevice: string;
+    hostLabel: string;
+    updateMainWindow: boolean;
+    videoAlreadyOn: boolean;
+    islevel: string;
+    lock_screen: boolean;
+    shared: boolean;
+    updateAudioProducer: (audioProducer: Producer | null) => void;
+    updateLocalStream: (localStream: MediaStream | null) => void;
+    updateAudioParams: (audioParams: ProducerOptions) => void;
+    updateDefAudioID: (defAudioID: string) => void;
+    updateUserDefaultAudioInputDevice: (userDefaultAudioInputDevice: string) => void;
+    updateUpdateMainWindow: (updateMainWindow: boolean) => void;
+    sleep: SleepType;
+    prepopulateUserMedia: PrepopulateUserMediaType;
+    createSendTransport: CreateSendTransportType;
+    connectSendTransportAudio: ConnectSendTransportAudioType;
+    getUpdatedAllParams: () => StreamSuccessAudioSwitchParameters;
+    [key: string]: any;
+}
+export interface StreamSuccessAudioSwitchOptions {
+    stream: MediaStream;
+    parameters: StreamSuccessAudioSwitchParameters;
+}
+export type StreamSuccessAudioSwitchType = (options: StreamSuccessAudioSwitchOptions) => Promise<void>;
+export declare class StreamSuccessAudioSwitch {
+    /**
+     * Handles the switching of the audio stream upon successful stream connection.
+     *
+     * @param {Object} options - The options for the stream success audio switch.
+     * @param {MediaStream} options.stream - The new media stream.
+     * @param {Object} options.parameters - The parameters required for the audio switch.
+     * @param {Producer} options.parameters.audioProducer - The current audio producer.
+     * @param {Socket} options.parameters.socket - The socket connection.
+     * @param {string} options.parameters.roomName - The name of the room.
+     * @param {MediaStream} options.parameters.localStream - The local media stream.
+     * @param {MediaStream} options.parameters.localStreamAudio - The local audio stream.
+     * @param {Object} options.parameters.audioParams - The audio parameters.
+     * @param {boolean} options.parameters.audioPaused - Indicates if the audio is paused.
+     * @param {boolean} options.parameters.audioAlreadyOn - Indicates if the audio is already on.
+     * @param {boolean} options.parameters.transportCreated - Indicates if the transport is created.
+     * @param {Object} options.parameters.audioParamse - Additional audio parameters.
+     * @param {string} options.parameters.defAudioID - The default audio device ID.
+     * @param {string} options.parameters.userDefaultAudioInputDevice - The user default audio input device.
+     * @param {string} options.parameters.hostLabel - The host label.
+     * @param {boolean} options.parameters.updateMainWindow - Indicates if the main window should be updated.
+     * @param {boolean} options.parameters.videoAlreadyOn - Indicates if the video is already on.
+     * @param {string} options.parameters.islevel - The participant's level.
+     * @param {boolean} options.parameters.lock_screen - Indicates if the screen is locked.
+     * @param {boolean} options.parameters.shared - Indicates if the screen is shared.
+     * @param {Function} options.parameters.updateAudioProducer - Function to update the audio producer.
+     * @param {Function} options.parameters.updateLocalStream - Function to update the local stream.
+     * @param {Function} options.parameters.updateAudioParams - Function to update the audio parameters.
+     * @param {Function} options.parameters.updateDefAudioID - Function to update the default audio device ID.
+     * @param {Function} options.parameters.updateUserDefaultAudioInputDevice - Function to update the user default audio input device.
+     * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window.
+     * @param {Function} options.parameters.sleep - Function to pause execution for a specified time.
+     * @param {Function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.
+     * @param {Function} options.parameters.createSendTransport - Function to create a send transport.
+     * @param {Function} options.parameters.connectSendTransportAudio - Function to connect the send transport for audio.
+     *
+     * @returns {Promise<void>} A promise that resolves when the audio switch is complete.
+     */
+    streamSuccessAudioSwitch({ stream, parameters, }: StreamSuccessAudioSwitchOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StreamSuccessAudioSwitch, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StreamSuccessAudioSwitch>;
+}

package/dist/lib/consumers/stream-success-audio.service.d.ts

@@ -0,0 +1,100 @@
+import { Socket } from 'socket.io-client';
+import { Participant, PrepopulateUserMediaParameters, ShowAlert, CreateSendTransportParameters, ConnectSendTransportAudioParameters, ResumeSendTransportAudioParameters, PrepopulateUserMediaType, CreateSendTransportType, ConnectSendTransportAudioType, ResumeSendTransportAudioType } from '../@types/types';
+import { ProducerOptions } from 'mediasoup-client/lib/types';
+import * as i0 from "@angular/core";
+export interface StreamSuccessAudioParameters extends CreateSendTransportParameters, ConnectSendTransportAudioParameters, ResumeSendTransportAudioParameters, PrepopulateUserMediaParameters {
+    socket: Socket;
+    participants: Participant[];
+    localStream: MediaStream | null;
+    transportCreated: boolean;
+    transportCreatedAudio: boolean;
+    audioAlreadyOn: boolean;
+    micAction: boolean;
+    audioParams: ProducerOptions;
+    localStreamAudio: MediaStream | null;
+    defAudioID: string;
+    userDefaultAudioInputDevice: string;
+    params: ProducerOptions;
+    audioParamse?: ProducerOptions;
+    aParams: ProducerOptions;
+    hostLabel: string;
+    islevel: string;
+    member: string;
+    updateMainWindow: boolean;
+    lock_screen: boolean;
+    shared: boolean;
+    videoAlreadyOn: boolean;
+    showAlert?: ShowAlert;
+    updateParticipants: (participants: Participant[]) => void;
+    updateTransportCreated: (transportCreated: boolean) => void;
+    updateTransportCreatedAudio: (transportCreatedAudio: boolean) => void;
+    updateAudioAlreadyOn: (audioAlreadyOn: boolean) => void;
+    updateMicAction: (micAction: boolean) => void;
+    updateAudioParams: (audioParams: ProducerOptions) => void;
+    updateLocalStream: (localStream: MediaStream | null) => void;
+    updateLocalStreamAudio: (localStreamAudio: MediaStream | null) => void;
+    updateDefAudioID: (defAudioID: string) => void;
+    updateUserDefaultAudioInputDevice: (userDefaultAudioInputDevice: string) => void;
+    updateUpdateMainWindow: (updateMainWindow: boolean) => void;
+    createSendTransport: CreateSendTransportType;
+    connectSendTransportAudio: ConnectSendTransportAudioType;
+    resumeSendTransportAudio: ResumeSendTransportAudioType;
+    prepopulateUserMedia: PrepopulateUserMediaType;
+    getUpdatedAllParams: () => StreamSuccessAudioParameters;
+    [key: string]: any;
+}
+export interface StreamSuccessAudioOptions {
+    stream: MediaStream;
+    parameters: StreamSuccessAudioParameters;
+}
+export type StreamSuccessAudioType = (options: StreamSuccessAudioOptions) => Promise<void>;
+export declare class StreamSuccessAudio {
+    /**
+     * Handles the successful streaming of audio by setting up the necessary transports and updating the relevant states.
+     *
+     * @param {Object} options - The options for streaming success audio.
+     * @param {MediaStream} options.stream - The media stream containing the audio track.
+     * @param {Object} options.parameters - The parameters required for setting up the audio stream.
+     * @param {Object} options.parameters.socket - The socket connection.
+     * @param {Array} options.parameters.participants - The list of participants.
+     * @param {MediaStream} options.parameters.localStream - The local media stream.
+     * @param {boolean} options.parameters.transportCreated - Flag indicating if the transport is created.
+     * @param {boolean} options.parameters.transportCreatedAudio - Flag indicating if the audio transport is created.
+     * @param {boolean} options.parameters.audioAlreadyOn - Flag indicating if the audio is already on.
+     * @param {boolean} options.parameters.micAction - Flag indicating the microphone action.
+     * @param {Object} options.parameters.audioParams - The audio parameters.
+     * @param {MediaStream} options.parameters.localStreamAudio - The local audio stream.
+     * @param {string} options.parameters.defAudioID - The default audio device ID.
+     * @param {string} options.parameters.userDefaultAudioInputDevice - The user default audio input device.
+     * @param {Object} options.parameters.params - Additional parameters.
+     * @param {Object} options.parameters.audioParamse - Additional audio parameters.
+     * @param {Object} options.parameters.aParams - Additional parameters for audio.
+     * @param {string} options.parameters.hostLabel - The label of the host.
+     * @param {string} options.parameters.islevel - The level of the user.
+     * @param {string} options.parameters.member - The member name.
+     * @param {boolean} options.parameters.updateMainWindow - Flag indicating if the main window should be updated.
+     * @param {boolean} options.parameters.lock_screen - Flag indicating if the screen is locked.
+     * @param {boolean} options.parameters.shared - Flag indicating if the screen is shared.
+     * @param {boolean} options.parameters.videoAlreadyOn - Flag indicating if the video is already on.
+     * @param {Function} options.parameters.showAlert - Function to show alert messages.
+     * @param {Function} options.parameters.updateParticipants - Function to update participants.
+     * @param {Function} options.parameters.updateTransportCreated - Function to update transport created flag.
+     * @param {Function} options.parameters.updateTransportCreatedAudio - Function to update audio transport created flag.
+     * @param {Function} options.parameters.updateAudioAlreadyOn - Function to update audio already on flag.
+     * @param {Function} options.parameters.updateMicAction - Function to update microphone action flag.
+     * @param {Function} options.parameters.updateAudioParams - Function to update audio parameters.
+     * @param {Function} options.parameters.updateLocalStream - Function to update local stream.
+     * @param {Function} options.parameters.updateLocalStreamAudio - Function to update local audio stream.
+     * @param {Function} options.parameters.updateDefAudioID - Function to update default audio device ID.
+     * @param {Function} options.parameters.updateUserDefaultAudioInputDevice - Function to update user default audio input device.
+     * @param {Function} options.parameters.updateUpdateMainWindow - Function to update main window flag.
+     * @param {Function} options.parameters.createSendTransport - Function to create send transport.
+     * @param {Function} options.parameters.connectSendTransportAudio - Function to connect send transport audio.
+     * @param {Function} options.parameters.resumeSendTransportAudio - Function to resume send transport audio.
+     * @param {Function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.
+     * @returns {Promise<void>} A promise that resolves when the audio streaming setup is complete.
+     */
+    streamSuccessAudio({ stream, parameters }: StreamSuccessAudioOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StreamSuccessAudio, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StreamSuccessAudio>;
+}