mediasfu-angular 1.0.0

package/dist/esm2022/lib/consumers/stop-share-screen.service.mjs

@@ -0,0 +1,120 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export 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 = async ({ parameters }) => {
+        let { getUpdatedAllParams } = parameters;
+        parameters = getUpdatedAllParams();
+        let { shared, shareScreenStarted, shareEnded, updateMainWindow, defer_receive, hostLabel, lock_screen, forceFullDisplay, firstAll, first_round, localStreamScreen, eventType, prevForceFullDisplay, annotateScreenStream, 
+        // updates for the above
+        updateShared, updateShareScreenStarted, updateShareEnded, updateUpdateMainWindow, updateDefer_receive, updateLock_screen, updateForceFullDisplay, updateFirstAll, updateFirst_round, updateLocalStreamScreen, updateMainHeightWidth, updateAnnotateScreenStream, updateIsScreenboardModalVisible, 
+        // mediasfu functions
+        disconnectSendTransportScreen, prepopulateUserMedia, reorderStreams, getVideos, } = parameters;
+        shared = false;
+        updateShared(shared);
+        shareScreenStarted = false;
+        updateShareScreenStarted(shareScreenStarted);
+        shareEnded = true;
+        updateShareEnded(shareEnded);
+        updateMainWindow = true;
+        updateUpdateMainWindow(updateMainWindow);
+        if (defer_receive) {
+            defer_receive = false;
+            updateDefer_receive(defer_receive);
+            await getVideos({
+                participants: parameters.participants,
+                allVideoStreams: parameters.allVideoStreams,
+                oldAllStreams: parameters.oldAllStreams,
+                adminVidID: parameters.adminVidID,
+                updateAllVideoStreams: parameters['updateAllVideoStreams'],
+                updateOldAllStreams: parameters['updateOldAllStreams'],
+            });
+        }
+        localStreamScreen?.getTracks().forEach((track) => track.stop());
+        updateLocalStreamScreen(localStreamScreen);
+        await disconnectSendTransportScreen({ parameters });
+        try {
+            if (annotateScreenStream) {
+                annotateScreenStream = false;
+                updateAnnotateScreenStream(annotateScreenStream);
+                updateIsScreenboardModalVisible(true);
+                await new Promise((resolve) => setTimeout(resolve, 500));
+                updateIsScreenboardModalVisible(false);
+            }
+        }
+        catch (error) {
+            console.log('Error handling screen annotation:', error);
+        }
+        if (eventType == 'conference') {
+            updateMainHeightWidth(0);
+        }
+        try {
+            await prepopulateUserMedia({ name: hostLabel, parameters });
+        }
+        catch (error) {
+            console.log('Error in prepopulateUserMedia:', error);
+        }
+        try {
+            await reorderStreams({ add: false, screenChanged: true, parameters });
+        }
+        catch (error) {
+            console.log('Error in reorderStreams:', error);
+        }
+        lock_screen = false;
+        updateLock_screen(lock_screen);
+        forceFullDisplay = prevForceFullDisplay;
+        updateForceFullDisplay(forceFullDisplay);
+        firstAll = false;
+        updateFirstAll(firstAll);
+        first_round = false;
+        updateFirst_round(first_round);
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: StopShareScreen, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: StopShareScreen, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: StopShareScreen, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stop-share-screen.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/stop-share-screen.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  DisconnectSendTransportScreenType,\n  PrepopulateUserMediaType,\n  ReorderStreamsType,\n  GetVideosType,\n  DisconnectSendTransportScreenParameters,\n  PrepopulateUserMediaParameters,\n  ReorderStreamsParameters,\n  EventType,\n} from '../@types/types';\nexport interface StopShareScreenParameters\n  extends DisconnectSendTransportScreenParameters,\n    PrepopulateUserMediaParameters,\n    ReorderStreamsParameters {\n  shared: boolean;\n  shareScreenStarted: boolean;\n  shareEnded: boolean;\n  updateMainWindow: boolean;\n  defer_receive: boolean;\n  hostLabel: string;\n  lock_screen: boolean;\n  forceFullDisplay: boolean;\n  firstAll: boolean;\n  first_round: boolean;\n  localStreamScreen: MediaStream | null;\n  eventType: EventType;\n  prevForceFullDisplay: boolean;\n  annotateScreenStream: boolean;\n\n  updateShared: (shared: boolean) => void;\n  updateShareScreenStarted: (shareScreenStarted: boolean) => void;\n  updateShareEnded: (shareEnded: boolean) => void;\n  updateUpdateMainWindow: (updateMainWindow: boolean) => void;\n  updateDefer_receive: (defer_receive: boolean) => void;\n  updateLock_screen: (lock_screen: boolean) => void;\n  updateForceFullDisplay: (forceFullDisplay: boolean) => void;\n  updateFirstAll: (firstAll: boolean) => void;\n  updateFirst_round: (first_round: boolean) => void;\n  updateLocalStreamScreen: (localStreamScreen: MediaStream | null) => void;\n  updateMainHeightWidth: (mainHeightWidth: number) => void;\n  updateAnnotateScreenStream: (annotateScreenStream: boolean) => void;\n  updateIsScreenboardModalVisible: (isVisible: boolean) => void;\n\n  // mediasfu functions\n  disconnectSendTransportScreen: DisconnectSendTransportScreenType;\n  prepopulateUserMedia: PrepopulateUserMediaType;\n  reorderStreams: ReorderStreamsType;\n  getVideos: GetVideosType;\n\n  getUpdatedAllParams: () => StopShareScreenParameters;\n  [key: string]: any;\n}\n\nexport interface StopShareScreenOptions {\n  parameters: StopShareScreenParameters;\n}\n\n// Export the type definition for the function\nexport type StopShareScreenType = (options: StopShareScreenOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class StopShareScreen {\n  /**\n   * Stops the screen sharing process and updates the relevant parameters and states.\n   *\n   * @param {StopShareScreenOptions} options - The options for stopping the screen share.\n   * @param {Object} options.parameters - The parameters required for stopping the screen share.\n   * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.\n   * @param {boolean} options.parameters.shared - Indicates if the screen is currently shared.\n   * @param {boolean} options.parameters.shareScreenStarted - Indicates if the screen sharing has started.\n   * @param {boolean} options.parameters.shareEnded - Indicates if the screen sharing has ended.\n   * @param {boolean} options.parameters.updateMainWindow - Indicates if the main window needs to be updated.\n   * @param {boolean} options.parameters.defer_receive - Indicates if receiving is deferred.\n   * @param {string} options.parameters.hostLabel - The label of the host.\n   * @param {boolean} options.parameters.lock_screen - Indicates if the screen is locked.\n   * @param {boolean} options.parameters.forceFullDisplay - Indicates if full display is forced.\n   * @param {boolean} options.parameters.firstAll - Indicates if it is the first all.\n   * @param {boolean} options.parameters.first_round - Indicates if it is the first round.\n   * @param {MediaStream} options.parameters.localStreamScreen - The local screen stream.\n   * @param {string} options.parameters.eventType - The type of event.\n   * @param {boolean} options.parameters.prevForceFullDisplay - Indicates if full display was previously forced.\n   * @param {boolean} options.parameters.annotateScreenStream - Indicates if the screen stream is annotated.\n   * @param {Function} options.parameters.updateShared - Function to update the shared state.\n   * @param {Function} options.parameters.updateShareScreenStarted - Function to update the share screen started state.\n   * @param {Function} options.parameters.updateShareEnded - Function to update the share ended state.\n   * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window state.\n   * @param {Function} options.parameters.updateDefer_receive - Function to update the defer receive state.\n   * @param {Function} options.parameters.updateLock_screen - Function to update the lock screen state.\n   * @param {Function} options.parameters.updateForceFullDisplay - Function to update the force full display state.\n   * @param {Function} options.parameters.updateFirstAll - Function to update the first all state.\n   * @param {Function} options.parameters.updateFirst_round - Function to update the first round state.\n   * @param {Function} options.parameters.updateLocalStreamScreen - Function to update the local screen stream.\n   * @param {Function} options.parameters.updateMainHeightWidth - Function to update the main height and width.\n   * @param {Function} options.parameters.updateAnnotateScreenStream - Function to update the annotate screen stream state.\n   * @param {Function} options.parameters.updateIsScreenboardModalVisible - Function to update the screenboard modal visibility.\n   * @param {Function} options.parameters.disconnectSendTransportScreen - Function to disconnect the send transport screen.\n   * @param {Function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.\n   * @param {Function} options.parameters.reorderStreams - Function to reorder streams.\n   * @param {Function} options.parameters.getVideos - Function to get videos.\n   *\n   * @returns {Promise<void>} A promise that resolves when the screen sharing process is stopped.\n   */\n  stopShareScreen = async ({ parameters }: StopShareScreenOptions): Promise<void> => {\n    let { getUpdatedAllParams } = parameters;\n    parameters = getUpdatedAllParams();\n\n    let {\n      shared,\n      shareScreenStarted,\n      shareEnded,\n      updateMainWindow,\n      defer_receive,\n      hostLabel,\n      lock_screen,\n      forceFullDisplay,\n      firstAll,\n      first_round,\n      localStreamScreen,\n      eventType,\n      prevForceFullDisplay,\n      annotateScreenStream,\n\n      // updates for the above\n      updateShared,\n      updateShareScreenStarted,\n      updateShareEnded,\n      updateUpdateMainWindow,\n      updateDefer_receive,\n      updateLock_screen,\n      updateForceFullDisplay,\n      updateFirstAll,\n      updateFirst_round,\n      updateLocalStreamScreen,\n      updateMainHeightWidth,\n      updateAnnotateScreenStream,\n      updateIsScreenboardModalVisible,\n\n      // mediasfu functions\n      disconnectSendTransportScreen,\n      prepopulateUserMedia,\n      reorderStreams,\n      getVideos,\n    } = parameters;\n\n    shared = false;\n    updateShared(shared);\n    shareScreenStarted = false;\n    updateShareScreenStarted(shareScreenStarted);\n    shareEnded = true;\n    updateShareEnded(shareEnded);\n    updateMainWindow = true;\n    updateUpdateMainWindow(updateMainWindow);\n\n    if (defer_receive) {\n      defer_receive = false;\n      updateDefer_receive(defer_receive);\n      await getVideos({\n        participants: parameters.participants,\n        allVideoStreams: parameters.allVideoStreams,\n        oldAllStreams: parameters.oldAllStreams,\n        adminVidID: parameters.adminVidID,\n        updateAllVideoStreams: parameters['updateAllVideoStreams'],\n        updateOldAllStreams: parameters['updateOldAllStreams'],\n      });\n    }\n\n    localStreamScreen?.getTracks().forEach((track: MediaStreamTrack) => track.stop());\n    updateLocalStreamScreen(localStreamScreen);\n    await disconnectSendTransportScreen({ parameters });\n\n    try {\n      if (annotateScreenStream) {\n        annotateScreenStream = false;\n        updateAnnotateScreenStream(annotateScreenStream);\n        updateIsScreenboardModalVisible(true);\n        await new Promise((resolve) => setTimeout(resolve, 500));\n        updateIsScreenboardModalVisible(false);\n      }\n    } catch (error) {\n      console.log('Error handling screen annotation:', error);\n    }\n\n    if (eventType == 'conference') {\n      updateMainHeightWidth(0);\n    }\n\n    try {\n      await prepopulateUserMedia({ name: hostLabel, parameters });\n    } catch (error) {\n      console.log('Error in prepopulateUserMedia:', error);\n    }\n\n    try {\n      await reorderStreams({ add: false, screenChanged: true, parameters });\n    } catch (error) {\n      console.log('Error in reorderStreams:', error);\n    }\n\n    lock_screen = false;\n    updateLock_screen(lock_screen);\n    forceFullDisplay = prevForceFullDisplay;\n    updateForceFullDisplay(forceFullDisplay);\n    firstAll = false;\n    updateFirstAll(firstAll);\n    first_round = false;\n    updateFirst_round(first_round);\n  };\n}\n"]}

package/dist/esm2022/lib/consumers/stream-success-audio-switch.service.mjs

@@ -0,0 +1,132 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export 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.
+     */
+    async streamSuccessAudioSwitch({ stream, parameters, }) {
+        let { audioProducer, socket, roomName, localStream, localStreamAudio, audioParams, audioPaused, audioAlreadyOn, transportCreated, audioParamse, defAudioID, userDefaultAudioInputDevice, hostLabel, updateMainWindow, videoAlreadyOn, islevel, lock_screen, shared, updateAudioProducer, updateLocalStream, updateAudioParams, updateDefAudioID, updateUserDefaultAudioInputDevice, updateUpdateMainWindow, 
+        // mediasfu functions
+        sleep, prepopulateUserMedia, createSendTransport, connectSendTransportAudio, } = parameters;
+        // Get the new default audio device ID
+        let newDefAudioID = stream.getAudioTracks()[0].getSettings().deviceId;
+        // Check if the audio device has changed
+        if (newDefAudioID != defAudioID) {
+            // Close the current audioProducer
+            if (audioProducer) {
+                audioProducer.close();
+                updateAudioProducer(audioProducer);
+            }
+            // Emit a pauseProducerMedia event to pause the audio media
+            socket.emit('pauseProducerMedia', { mediaTag: 'audio', roomName: roomName, force: true });
+            // Update the localStreamAudio with the new audio tracks
+            localStreamAudio = stream;
+            // If localStream is null, create a new MediaStream with the new audio track
+            if (localStream == null) {
+                localStream = new MediaStream([localStreamAudio.getAudioTracks()[0]]);
+            }
+            else {
+                // Remove all existing audio tracks from localStream and add the new audio track
+                localStream.getAudioTracks().forEach((track) => {
+                    localStream?.removeTrack(track);
+                });
+                localStream.addTrack(localStreamAudio.getAudioTracks()[0]);
+            }
+            // Update localStream
+            updateLocalStream(localStream);
+            // Get the new default audio device ID from the new audio track
+            const audioTracked = localStream.getAudioTracks()[0];
+            defAudioID = audioTracked.getSettings().deviceId ?? '';
+            updateDefAudioID(defAudioID);
+            // Update userDefaultAudioInputDevice
+            userDefaultAudioInputDevice = defAudioID;
+            updateUserDefaultAudioInputDevice(userDefaultAudioInputDevice);
+            // Update audioParams with the new audio track
+            audioParams = { track: localStream.getAudioTracks()[0], ...audioParamse };
+            updateAudioParams(audioParams);
+            // Sleep for 500 milliseconds
+            await sleep({ ms: 500 });
+            // Create a new send transport if not created, otherwise, connect the existing transport
+            if (!transportCreated) {
+                try {
+                    await createSendTransport({
+                        parameters: {
+                            ...parameters,
+                            audioParams: audioParams,
+                        },
+                        option: 'audio',
+                    });
+                }
+                catch (error) {
+                    console.error('Error creating send transport:', error);
+                }
+            }
+            else {
+                await connectSendTransportAudio({
+                    audioParams,
+                    parameters,
+                });
+            }
+            // If audio is paused and not already on, pause the audioProducer and emit a pauseProducerMedia event
+            if (audioPaused && !audioAlreadyOn) {
+                audioProducer?.pause();
+                updateAudioProducer(audioProducer);
+                socket.emit('pauseProducerMedia', { mediaTag: 'audio', roomName: roomName });
+            }
+        }
+        // Update the UI based on the participant's level and screen lock status
+        if (!videoAlreadyOn && islevel === '2') {
+            if (!lock_screen && !shared) {
+                // Set updateMainWindow to true, prepopulate user media, and set updateMainWindow back to false
+                updateMainWindow = true;
+                updateUpdateMainWindow(updateMainWindow);
+                await prepopulateUserMedia({ name: hostLabel, parameters });
+                updateMainWindow = false;
+                updateUpdateMainWindow(updateMainWindow);
+            }
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: StreamSuccessAudioSwitch, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: StreamSuccessAudioSwitch, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: StreamSuccessAudioSwitch, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stream-success-audio-switch.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/stream-success-audio-switch.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Producer, ProducerCodecOptions, ProducerOptions } from 'mediasoup-client/lib/types';\nimport { Socket } from 'socket.io-client';\nimport {\n  PrepopulateUserMediaParameters,\n  PrepopulateUserMediaType,\n  CreateSendTransportParameters,\n  CreateSendTransportType,\n  ConnectSendTransportAudioParameters,\n  ConnectSendTransportAudioType,\n  SleepType,\n} from '../@types/types';\n\n/**\n * Handles the success of switching audio devices in a streaming context.\n * @async\n * @function\n * @param {Object} parameters - The parameters object containing necessary variables.\n * @param {MediaStream} stream - The new MediaStream with the switched audio device.\n */\nexport interface StreamSuccessAudioSwitchParameters\n  extends PrepopulateUserMediaParameters,\n    CreateSendTransportParameters,\n    ConnectSendTransportAudioParameters {\n  audioProducer: Producer | null;\n  socket: Socket;\n  roomName: string;\n  localStream: MediaStream | null;\n  localStreamAudio: MediaStream | null;\n  audioParams: ProducerOptions;\n  audioPaused: boolean;\n  audioAlreadyOn: boolean;\n  transportCreated: boolean;\n  audioParamse?: ProducerCodecOptions;\n  defAudioID: string;\n  userDefaultAudioInputDevice: string;\n  hostLabel: string;\n  updateMainWindow: boolean;\n  videoAlreadyOn: boolean;\n  islevel: string;\n  lock_screen: boolean;\n  shared: boolean;\n\n  updateAudioProducer: (audioProducer: Producer | null) => void;\n  updateLocalStream: (localStream: MediaStream | null) => void;\n  updateAudioParams: (audioParams: ProducerOptions) => void;\n  updateDefAudioID: (defAudioID: string) => void;\n  updateUserDefaultAudioInputDevice: (userDefaultAudioInputDevice: string) => void;\n  updateUpdateMainWindow: (updateMainWindow: boolean) => void;\n\n  // mediasfu functions\n  sleep: SleepType;\n  prepopulateUserMedia: PrepopulateUserMediaType;\n  createSendTransport: CreateSendTransportType;\n  connectSendTransportAudio: ConnectSendTransportAudioType;\n\n  getUpdatedAllParams: () => StreamSuccessAudioSwitchParameters;\n  [key: string]: any;\n}\n\nexport interface StreamSuccessAudioSwitchOptions {\n  stream: MediaStream;\n  parameters: StreamSuccessAudioSwitchParameters;\n}\n\n// Export the type definition for the function\nexport type StreamSuccessAudioSwitchType = (\n  options: StreamSuccessAudioSwitchOptions,\n) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class StreamSuccessAudioSwitch {\n  /**\n   * Handles the switching of the audio stream upon successful stream connection.\n   *\n   * @param {Object} options - The options for the stream success audio switch.\n   * @param {MediaStream} options.stream - The new media stream.\n   * @param {Object} options.parameters - The parameters required for the audio switch.\n   * @param {Producer} options.parameters.audioProducer - The current audio producer.\n   * @param {Socket} options.parameters.socket - The socket connection.\n   * @param {string} options.parameters.roomName - The name of the room.\n   * @param {MediaStream} options.parameters.localStream - The local media stream.\n   * @param {MediaStream} options.parameters.localStreamAudio - The local audio stream.\n   * @param {Object} options.parameters.audioParams - The audio parameters.\n   * @param {boolean} options.parameters.audioPaused - Indicates if the audio is paused.\n   * @param {boolean} options.parameters.audioAlreadyOn - Indicates if the audio is already on.\n   * @param {boolean} options.parameters.transportCreated - Indicates if the transport is created.\n   * @param {Object} options.parameters.audioParamse - Additional audio parameters.\n   * @param {string} options.parameters.defAudioID - The default audio device ID.\n   * @param {string} options.parameters.userDefaultAudioInputDevice - The user default audio input device.\n   * @param {string} options.parameters.hostLabel - The host label.\n   * @param {boolean} options.parameters.updateMainWindow - Indicates if the main window should be updated.\n   * @param {boolean} options.parameters.videoAlreadyOn - Indicates if the video is already on.\n   * @param {string} options.parameters.islevel - The participant's level.\n   * @param {boolean} options.parameters.lock_screen - Indicates if the screen is locked.\n   * @param {boolean} options.parameters.shared - Indicates if the screen is shared.\n   * @param {Function} options.parameters.updateAudioProducer - Function to update the audio producer.\n   * @param {Function} options.parameters.updateLocalStream - Function to update the local stream.\n   * @param {Function} options.parameters.updateAudioParams - Function to update the audio parameters.\n   * @param {Function} options.parameters.updateDefAudioID - Function to update the default audio device ID.\n   * @param {Function} options.parameters.updateUserDefaultAudioInputDevice - Function to update the user default audio input device.\n   * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window.\n   * @param {Function} options.parameters.sleep - Function to pause execution for a specified time.\n   * @param {Function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.\n   * @param {Function} options.parameters.createSendTransport - Function to create a send transport.\n   * @param {Function} options.parameters.connectSendTransportAudio - Function to connect the send transport for audio.\n   *\n   * @returns {Promise<void>} A promise that resolves when the audio switch is complete.\n   */\n\n  async streamSuccessAudioSwitch({\n    stream,\n    parameters,\n  }: StreamSuccessAudioSwitchOptions): Promise<void> {\n    let {\n      audioProducer,\n      socket,\n      roomName,\n      localStream,\n      localStreamAudio,\n      audioParams,\n      audioPaused,\n      audioAlreadyOn,\n      transportCreated,\n      audioParamse,\n      defAudioID,\n      userDefaultAudioInputDevice,\n      hostLabel,\n      updateMainWindow,\n      videoAlreadyOn,\n      islevel,\n      lock_screen,\n      shared,\n      updateAudioProducer,\n      updateLocalStream,\n      updateAudioParams,\n      updateDefAudioID,\n      updateUserDefaultAudioInputDevice,\n      updateUpdateMainWindow,\n\n      // mediasfu functions\n      sleep,\n      prepopulateUserMedia,\n      createSendTransport,\n      connectSendTransportAudio,\n    } = parameters;\n\n    // Get the new default audio device ID\n    let newDefAudioID = stream.getAudioTracks()[0].getSettings().deviceId;\n\n    // Check if the audio device has changed\n    if (newDefAudioID != defAudioID) {\n      // Close the current audioProducer\n      if (audioProducer) {\n        audioProducer.close();\n        updateAudioProducer(audioProducer);\n      }\n\n      // Emit a pauseProducerMedia event to pause the audio media\n      socket.emit('pauseProducerMedia', { mediaTag: 'audio', roomName: roomName, force: true });\n\n      // Update the localStreamAudio with the new audio tracks\n      localStreamAudio = stream;\n\n      // If localStream is null, create a new MediaStream with the new audio track\n      if (localStream == null) {\n        localStream = new MediaStream([localStreamAudio.getAudioTracks()[0]]);\n      } else {\n        // Remove all existing audio tracks from localStream and add the new audio track\n        localStream.getAudioTracks().forEach((track: MediaStreamTrack) => {\n          localStream?.removeTrack(track);\n        });\n        localStream.addTrack(localStreamAudio.getAudioTracks()[0]);\n      }\n\n      // Update localStream\n      updateLocalStream(localStream);\n\n      // Get the new default audio device ID from the new audio track\n      const audioTracked = localStream.getAudioTracks()[0];\n      defAudioID = audioTracked.getSettings().deviceId ?? '';\n      updateDefAudioID(defAudioID);\n\n      // Update userDefaultAudioInputDevice\n      userDefaultAudioInputDevice = defAudioID;\n      updateUserDefaultAudioInputDevice(userDefaultAudioInputDevice);\n\n      // Update audioParams with the new audio track\n      audioParams = { track: localStream.getAudioTracks()[0], ...audioParamse };\n      updateAudioParams(audioParams);\n\n      // Sleep for 500 milliseconds\n      await sleep({ ms: 500 });\n\n      // Create a new send transport if not created, otherwise, connect the existing transport\n      if (!transportCreated) {\n        try {\n          await createSendTransport({\n            parameters: {\n              ...parameters,\n              audioParams: audioParams,\n            },\n            option: 'audio',\n          });\n        } catch (error) {\n          console.error('Error creating send transport:', error);\n        }\n      } else {\n        await connectSendTransportAudio({\n          audioParams,\n          parameters,\n        });\n      }\n\n      // If audio is paused and not already on, pause the audioProducer and emit a pauseProducerMedia event\n      if (audioPaused && !audioAlreadyOn) {\n        audioProducer?.pause();\n        updateAudioProducer(audioProducer);\n        socket.emit('pauseProducerMedia', { mediaTag: 'audio', roomName: roomName });\n      }\n    }\n\n    // Update the UI based on the participant's level and screen lock status\n    if (!videoAlreadyOn && islevel === '2') {\n      if (!lock_screen && !shared) {\n        // Set updateMainWindow to true, prepopulate user media, and set updateMainWindow back to false\n        updateMainWindow = true;\n        updateUpdateMainWindow(updateMainWindow);\n        await prepopulateUserMedia({ name: hostLabel, parameters });\n        updateMainWindow = false;\n        updateUpdateMainWindow(updateMainWindow);\n      }\n    }\n  }\n}\n"]}

package/dist/esm2022/lib/consumers/stream-success-audio.service.mjs

@@ -0,0 +1,149 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export 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.
+     */
+    async streamSuccessAudio({ stream, parameters }) {
+        let { socket, participants, localStream, transportCreated, transportCreatedAudio, audioAlreadyOn, micAction, audioParams, localStreamAudio, defAudioID, userDefaultAudioInputDevice, params, audioParamse, aParams, hostLabel, islevel, member, updateMainWindow, lock_screen, shared, videoAlreadyOn, showAlert, 
+        // update functions
+        updateParticipants, updateTransportCreated, updateTransportCreatedAudio, updateAudioAlreadyOn, updateMicAction, updateAudioParams, updateLocalStream, updateLocalStreamAudio, updateDefAudioID, updateUserDefaultAudioInputDevice, updateUpdateMainWindow, 
+        // mediasfu functions
+        createSendTransport, connectSendTransportAudio, resumeSendTransportAudio, prepopulateUserMedia, } = parameters;
+        localStreamAudio = stream;
+        updateLocalStreamAudio(localStreamAudio);
+        // Add the audio stream track to the localStream
+        if (localStream == null) {
+            localStream = new MediaStream([localStreamAudio.getAudioTracks()[0]]);
+            updateLocalStream(localStream);
+        }
+        else {
+            localStream.addTrack(localStreamAudio.getAudioTracks()[0]);
+            updateLocalStream(localStream);
+        }
+        const audioTracked = localStream.getAudioTracks()[0];
+        defAudioID = audioTracked.getSettings().deviceId || '';
+        userDefaultAudioInputDevice = defAudioID;
+        // Update the state variables
+        updateDefAudioID(defAudioID);
+        updateUserDefaultAudioInputDevice(userDefaultAudioInputDevice);
+        try {
+            params = aParams;
+            audioParamse = { ...params };
+            audioParams = { track: localStream.getAudioTracks()[0], ...audioParamse };
+            updateAudioParams(audioParams);
+            // Create transport if not created else connect transport
+            if (!transportCreated) {
+                try {
+                    await createSendTransport({
+                        parameters: {
+                            ...parameters,
+                            audioParams: audioParams,
+                        },
+                        option: 'audio',
+                    });
+                }
+                catch (error) {
+                    console.error('Error creating send transport:', error);
+                }
+            }
+            else {
+                if (!transportCreatedAudio) {
+                    await connectSendTransportAudio({
+                        audioParams,
+                        parameters,
+                    });
+                }
+                else {
+                    await resumeSendTransportAudio({ parameters });
+                }
+            }
+        }
+        catch (error) {
+            showAlert?.({
+                message: error.message,
+                type: 'danger',
+                duration: 3000,
+            });
+        }
+        // Update the participants array to reflect the change
+        audioAlreadyOn = true;
+        updateAudioAlreadyOn(audioAlreadyOn);
+        if (micAction) {
+            micAction = false;
+            updateMicAction(micAction);
+        }
+        participants.forEach((participant) => {
+            if (participant.socketId == socket.id && participant.name == member) {
+                participant.muted = false;
+            }
+        });
+        updateParticipants(participants);
+        // Update the transport created state
+        transportCreated = true;
+        transportCreatedAudio = true;
+        updateTransportCreated(transportCreated);
+        updateTransportCreatedAudio(transportCreatedAudio);
+        // Reupdate screen display if host
+        if (videoAlreadyOn == false && islevel == '2') {
+            if (!lock_screen && !shared) {
+                updateMainWindow = true;
+                updateUpdateMainWindow(updateMainWindow);
+                await prepopulateUserMedia({ name: hostLabel, parameters });
+                updateMainWindow = false;
+                updateUpdateMainWindow(updateMainWindow);
+            }
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: StreamSuccessAudio, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: StreamSuccessAudio, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: StreamSuccessAudio, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stream-success-audio.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/stream-success-audio.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Socket } from 'socket.io-client';\nimport {\n  Participant,\n  PrepopulateUserMediaParameters,\n  ShowAlert,\n  CreateSendTransportParameters,\n  ConnectSendTransportAudioParameters,\n  ResumeSendTransportAudioParameters,\n  PrepopulateUserMediaType,\n  CreateSendTransportType,\n  ConnectSendTransportAudioType,\n  ResumeSendTransportAudioType,\n} from '../@types/types';\nimport { ProducerOptions } from 'mediasoup-client/lib/types';\nexport interface StreamSuccessAudioParameters\n  extends CreateSendTransportParameters,\n    ConnectSendTransportAudioParameters,\n    ResumeSendTransportAudioParameters,\n    PrepopulateUserMediaParameters {\n  socket: Socket;\n  participants: Participant[];\n  localStream: MediaStream | null;\n  transportCreated: boolean;\n  transportCreatedAudio: boolean;\n  audioAlreadyOn: boolean;\n  micAction: boolean;\n  audioParams: ProducerOptions;\n  localStreamAudio: MediaStream | null;\n  defAudioID: string;\n  userDefaultAudioInputDevice: string;\n  params: ProducerOptions;\n  audioParamse?: ProducerOptions;\n  aParams: ProducerOptions;\n  hostLabel: string;\n  islevel: string;\n  member: string;\n  updateMainWindow: boolean;\n  lock_screen: boolean;\n  shared: boolean;\n  videoAlreadyOn: boolean;\n  showAlert?: ShowAlert;\n\n  updateParticipants: (participants: Participant[]) => void;\n  updateTransportCreated: (transportCreated: boolean) => void;\n  updateTransportCreatedAudio: (transportCreatedAudio: boolean) => void;\n  updateAudioAlreadyOn: (audioAlreadyOn: boolean) => void;\n  updateMicAction: (micAction: boolean) => void;\n  updateAudioParams: (audioParams: ProducerOptions) => void;\n  updateLocalStream: (localStream: MediaStream | null) => void;\n  updateLocalStreamAudio: (localStreamAudio: MediaStream | null) => void;\n  updateDefAudioID: (defAudioID: string) => void;\n  updateUserDefaultAudioInputDevice: (userDefaultAudioInputDevice: string) => void;\n  updateUpdateMainWindow: (updateMainWindow: boolean) => void;\n\n  // mediasfu functions\n  createSendTransport: CreateSendTransportType;\n  connectSendTransportAudio: ConnectSendTransportAudioType;\n  resumeSendTransportAudio: ResumeSendTransportAudioType;\n  prepopulateUserMedia: PrepopulateUserMediaType;\n\n  getUpdatedAllParams: () => StreamSuccessAudioParameters;\n  [key: string]: any;\n}\n\nexport interface StreamSuccessAudioOptions {\n  stream: MediaStream;\n  parameters: StreamSuccessAudioParameters;\n}\n\n// Export the type definition for the function\nexport type StreamSuccessAudioType = (options: StreamSuccessAudioOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class StreamSuccessAudio {\n  /**\n   * Handles the successful streaming of audio by setting up the necessary transports and updating the relevant states.\n   *\n   * @param {Object} options - The options for streaming success audio.\n   * @param {MediaStream} options.stream - The media stream containing the audio track.\n   * @param {Object} options.parameters - The parameters required for setting up the audio stream.\n   * @param {Object} options.parameters.socket - The socket connection.\n   * @param {Array} options.parameters.participants - The list of participants.\n   * @param {MediaStream} options.parameters.localStream - The local media stream.\n   * @param {boolean} options.parameters.transportCreated - Flag indicating if the transport is created.\n   * @param {boolean} options.parameters.transportCreatedAudio - Flag indicating if the audio transport is created.\n   * @param {boolean} options.parameters.audioAlreadyOn - Flag indicating if the audio is already on.\n   * @param {boolean} options.parameters.micAction - Flag indicating the microphone action.\n   * @param {Object} options.parameters.audioParams - The audio parameters.\n   * @param {MediaStream} options.parameters.localStreamAudio - The local audio stream.\n   * @param {string} options.parameters.defAudioID - The default audio device ID.\n   * @param {string} options.parameters.userDefaultAudioInputDevice - The user default audio input device.\n   * @param {Object} options.parameters.params - Additional parameters.\n   * @param {Object} options.parameters.audioParamse - Additional audio parameters.\n   * @param {Object} options.parameters.aParams - Additional parameters for audio.\n   * @param {string} options.parameters.hostLabel - The label of the host.\n   * @param {string} options.parameters.islevel - The level of the user.\n   * @param {string} options.parameters.member - The member name.\n   * @param {boolean} options.parameters.updateMainWindow - Flag indicating if the main window should be updated.\n   * @param {boolean} options.parameters.lock_screen - Flag indicating if the screen is locked.\n   * @param {boolean} options.parameters.shared - Flag indicating if the screen is shared.\n   * @param {boolean} options.parameters.videoAlreadyOn - Flag indicating if the video is already on.\n   * @param {Function} options.parameters.showAlert - Function to show alert messages.\n   * @param {Function} options.parameters.updateParticipants - Function to update participants.\n   * @param {Function} options.parameters.updateTransportCreated - Function to update transport created flag.\n   * @param {Function} options.parameters.updateTransportCreatedAudio - Function to update audio transport created flag.\n   * @param {Function} options.parameters.updateAudioAlreadyOn - Function to update audio already on flag.\n   * @param {Function} options.parameters.updateMicAction - Function to update microphone action flag.\n   * @param {Function} options.parameters.updateAudioParams - Function to update audio parameters.\n   * @param {Function} options.parameters.updateLocalStream - Function to update local stream.\n   * @param {Function} options.parameters.updateLocalStreamAudio - Function to update local audio stream.\n   * @param {Function} options.parameters.updateDefAudioID - Function to update default audio device ID.\n   * @param {Function} options.parameters.updateUserDefaultAudioInputDevice - Function to update user default audio input device.\n   * @param {Function} options.parameters.updateUpdateMainWindow - Function to update main window flag.\n   * @param {Function} options.parameters.createSendTransport - Function to create send transport.\n   * @param {Function} options.parameters.connectSendTransportAudio - Function to connect send transport audio.\n   * @param {Function} options.parameters.resumeSendTransportAudio - Function to resume send transport audio.\n   * @param {Function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.\n   * @returns {Promise<void>} A promise that resolves when the audio streaming setup is complete.\n   */\n\n  async streamSuccessAudio({ stream, parameters }: StreamSuccessAudioOptions): Promise<void> {\n    let {\n      socket,\n      participants,\n      localStream,\n      transportCreated,\n      transportCreatedAudio,\n      audioAlreadyOn,\n      micAction,\n      audioParams,\n      localStreamAudio,\n      defAudioID,\n      userDefaultAudioInputDevice,\n      params,\n      audioParamse,\n      aParams,\n      hostLabel,\n      islevel,\n      member,\n      updateMainWindow,\n      lock_screen,\n      shared,\n      videoAlreadyOn,\n      showAlert,\n\n      // update functions\n      updateParticipants,\n      updateTransportCreated,\n      updateTransportCreatedAudio,\n      updateAudioAlreadyOn,\n      updateMicAction,\n      updateAudioParams,\n      updateLocalStream,\n      updateLocalStreamAudio,\n      updateDefAudioID,\n      updateUserDefaultAudioInputDevice,\n      updateUpdateMainWindow,\n\n      // mediasfu functions\n      createSendTransport,\n      connectSendTransportAudio,\n      resumeSendTransportAudio,\n      prepopulateUserMedia,\n    } = parameters;\n\n    localStreamAudio = stream;\n    updateLocalStreamAudio(localStreamAudio);\n\n    // Add the audio stream track to the localStream\n    if (localStream == null) {\n      localStream = new MediaStream([localStreamAudio.getAudioTracks()[0]]);\n      updateLocalStream(localStream);\n    } else {\n      localStream.addTrack(localStreamAudio.getAudioTracks()[0]);\n      updateLocalStream(localStream);\n    }\n\n    const audioTracked = localStream.getAudioTracks()[0];\n    defAudioID = audioTracked.getSettings().deviceId || '';\n    userDefaultAudioInputDevice = defAudioID;\n\n    // Update the state variables\n    updateDefAudioID(defAudioID);\n    updateUserDefaultAudioInputDevice(userDefaultAudioInputDevice);\n\n    try {\n      params = aParams;\n      audioParamse = { ...params };\n\n      audioParams = { track: localStream.getAudioTracks()[0], ...audioParamse };\n      updateAudioParams(audioParams);\n\n      // Create transport if not created else connect transport\n      if (!transportCreated) {\n        try {\n          await createSendTransport({\n            parameters: {\n              ...parameters,\n              audioParams: audioParams,\n            },\n            option: 'audio',\n          });\n        } catch (error) {\n          console.error('Error creating send transport:', error);\n        }\n      } else {\n        if (!transportCreatedAudio) {\n          await connectSendTransportAudio({\n            audioParams,\n            parameters,\n          });\n        } else {\n          await resumeSendTransportAudio({ parameters });\n        }\n      }\n    } catch (error: any) {\n      showAlert?.({\n        message: error.message,\n        type: 'danger',\n        duration: 3000,\n      });\n    }\n\n    // Update the participants array to reflect the change\n    audioAlreadyOn = true;\n    updateAudioAlreadyOn(audioAlreadyOn);\n\n    if (micAction) {\n      micAction = false;\n      updateMicAction(micAction);\n    }\n\n    participants.forEach((participant: any) => {\n      if (participant.socketId == socket.id && participant.name == member) {\n        participant.muted = false;\n      }\n    });\n    updateParticipants(participants);\n\n    // Update the transport created state\n    transportCreated = true;\n    transportCreatedAudio = true;\n    updateTransportCreated(transportCreated);\n    updateTransportCreatedAudio(transportCreatedAudio);\n\n    // Reupdate screen display if host\n    if (videoAlreadyOn == false && islevel == '2') {\n      if (!lock_screen && !shared) {\n        updateMainWindow = true;\n        updateUpdateMainWindow(updateMainWindow);\n        await prepopulateUserMedia({ name: hostLabel, parameters });\n        updateMainWindow = false;\n        updateUpdateMainWindow(updateMainWindow);\n      }\n    }\n  }\n}\n"]}