mediasfu-shared 1.0.0

package/src/consumers/startShareScreen.ts

@@ -0,0 +1,124 @@
+
+import { StreamSuccessScreenType, StreamSuccessScreenParameters, ShowAlert } from "../types/types";
+export interface StartShareScreenParameters extends StreamSuccessScreenParameters {
+  shared: boolean;
+  showAlert?: ShowAlert;
+  updateShared: (shared: boolean) => void;
+  mediaDevices: MediaDevices;
+  onWeb: boolean;
+  targetWidth?: number;
+  targetHeight?: number;
+
+  // mediasfu functions
+  streamSuccessScreen: StreamSuccessScreenType;
+  [key: string]: any;
+}
+
+export interface StartShareScreenOptions {
+  parameters: StartShareScreenParameters;
+}
+
+// Export the type definition for the function
+export type StartShareScreenType = (options: StartShareScreenOptions) => Promise<void>;
+
+/**
+ * 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 {MediaDevices} options.parameters.mediaDevices - The media devices available for screen sharing.
+ * @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.
+ *
+ * @example
+ * const options = {
+ *   parameters: {
+ *     shared: false,
+ *     showAlert: showAlertFunction,
+ *     updateShared: updateSharedFunction,
+ *     mediaDevices: navigator.mediaDevices,
+ *     onWeb: true,
+ *     targetWidth: 1280,
+ *     targetHeight: 720,
+ *     streamSuccessScreen: streamSuccessFunction,
+ *   },
+ * };
+ * 
+ * startShareScreen(options)
+ *   .then(() => {
+ *     console.log('Screen sharing started successfully');
+ *   })
+ *   .catch(error => {
+ *     console.error('Error starting screen share:', error);
+ *   });
+ */
+
+export async function startShareScreen({ parameters }: StartShareScreenOptions): Promise<void> {
+  let {
+    shared,
+    showAlert,
+    updateShared,
+    mediaDevices,
+    onWeb,
+    targetWidth = 1280,
+    targetHeight = 720,
+
+    streamSuccessScreen,
+  } = parameters;
+
+  try {
+    if (!onWeb) {
+      showAlert?.({
+        message: "You cannot share screen while on mobile",
+        type: "danger",
+        duration: 3000,
+      });
+      return;
+    }
+
+    if (mediaDevices && mediaDevices.getDisplayMedia) {
+      shared = true;
+      await mediaDevices
+        .getDisplayMedia({
+          video: {
+            width: targetWidth,
+            height: targetHeight,
+            frameRate: 30,
+          },
+          audio: false,
+        })
+        .then(async (stream: MediaStream) => {
+          await streamSuccessScreen({ stream, parameters });
+        })
+        .catch(async () => {
+          shared = false;
+          showAlert?.({
+            message: "Could not share screen, check and retry",
+            type: "danger",
+            duration: 3000,
+          });
+        });
+    } else {
+      showAlert?.({
+        message: "Could not share screen, check and retry",
+        type: "danger",
+        duration: 3000,
+      });
+    }
+
+    // Update the shared variable
+    updateShared(shared);
+  } catch (error) {
+    console.log("Error starting screen share", error);
+  }
+}
+

package/src/consumers/stopShareScreen.ts

@@ -0,0 +1,241 @@
+import { DisconnectSendTransportScreenType, PrepopulateUserMediaType, ReorderStreamsType, GetVideosType, DisconnectSendTransportScreenParameters, PrepopulateUserMediaParameters, ReorderStreamsParameters, EventType } from '../types/types';
+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;
+
+  // mediasfu functions
+  disconnectSendTransportScreen: DisconnectSendTransportScreenType;
+  prepopulateUserMedia: PrepopulateUserMediaType;
+  reorderStreams: ReorderStreamsType;
+  getVideos: GetVideosType;
+
+  getUpdatedAllParams: () => StopShareScreenParameters;
+  [key: string]: any;
+}
+
+export interface StopShareScreenOptions {
+  parameters: StopShareScreenParameters;
+}
+
+// Export the type definition for the function
+export type StopShareScreenType = (options: StopShareScreenOptions) => Promise<void>;
+
+/**
+ * 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.
+ *
+ * @example
+ * const options = {
+ *   parameters: {
+ *     shared: true,
+ *     shareScreenStarted: true,
+ *     shareEnded: false,
+ *     updateMainWindow: true,
+ *     defer_receive: false,
+ *     hostLabel: "Host",
+ *     lock_screen: false,
+ *     forceFullDisplay: false,
+ *     firstAll: false,
+ *     first_round: false,
+ *     localStreamScreen: localStream, // MediaStream object
+ *     eventType: "conference",
+ *     prevForceFullDisplay: false,
+ *     annotateScreenStream: false,
+ *     updateShared: updateSharedFunction,
+ *     updateShareScreenStarted: updateShareScreenStartedFunction,
+ *     updateShareEnded: updateShareEndedFunction,
+ *     updateUpdateMainWindow: updateUpdateMainWindowFunction,
+ *     updateDefer_receive: updateDefer_receiveFunction,
+ *     updateLock_screen: updateLock_screenFunction,
+ *     updateForceFullDisplay: updateForceFullDisplayFunction,
+ *     updateFirstAll: updateFirstAllFunction,
+ *     updateFirst_round: updateFirst_roundFunction,
+ *     updateLocalStreamScreen: updateLocalStreamScreenFunction,
+ *     updateMainHeightWidth: updateMainHeightWidthFunction,
+ *     updateAnnotateScreenStream: updateAnnotateScreenStreamFunction,
+ *     updateIsScreenboardModalVisible: updateIsScreenboardModalVisibleFunction,
+ *     disconnectSendTransportScreen: disconnectSendTransportScreenFunction,
+ *     prepopulateUserMedia: prepopulateUserMediaFunction,
+ *     reorderStreams: reorderStreamsFunction,
+ *     getVideos: getVideosFunction,
+ *   },
+ * };
+ * 
+ * stopShareScreen(options)
+ *   .then(() => {
+ *     console.log('Screen sharing stopped successfully');
+ *   })
+ *   .catch(error => {
+ *     console.error('Error stopping screen share:', error);
+ *   });
+ */
+
+export async function stopShareScreen({ parameters }: StopShareScreenOptions): Promise<void> {
+  let { getUpdatedAllParams } = parameters;
+  parameters = getUpdatedAllParams();
+
+  let {
+    shared,
+    shareScreenStarted,
+    shareEnded,
+    updateMainWindow,
+    defer_receive,
+    hostLabel,
+    lock_screen,
+    forceFullDisplay,
+    firstAll,
+    first_round,
+    localStreamScreen,
+    eventType,
+    prevForceFullDisplay,
+    annotateScreenStream,
+
+    updateShared,
+    updateShareScreenStarted,
+    updateShareEnded,
+    updateUpdateMainWindow,
+    updateDefer_receive,
+    updateLock_screen,
+    updateForceFullDisplay,
+    updateFirstAll,
+    updateFirst_round,
+    updateLocalStreamScreen,
+    updateMainHeightWidth,
+    updateAnnotateScreenStream,
+    updateIsScreenboardModalVisible,
+
+    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
+    });
+  }
+  try {
+    localStreamScreen!.getTracks().forEach(track => track.stop());
+  } catch {
+    // Do nothing
+  }
+  updateLocalStreamScreen(null);
+  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);
+}
+

package/src/consumers/streamSuccessAudio.ts

@@ -0,0 +1,297 @@
+ 
+
+import { Socket } from "socket.io-client";
+import type { ProducerOptions } from 'mediasoup-client/lib/types';
+import { Participant, PrepopulateUserMediaParameters, ShowAlert, CreateSendTransportParameters, ConnectSendTransportAudioParameters, ResumeSendTransportAudioParameters, PrepopulateUserMediaType, CreateSendTransportType, ConnectSendTransportAudioType, ResumeSendTransportAudioType } from "../types/types";
+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;
+
+  // mediasfu functions
+  createSendTransport: CreateSendTransportType;
+  connectSendTransportAudio: ConnectSendTransportAudioType;
+  resumeSendTransportAudio: ResumeSendTransportAudioType;
+  prepopulateUserMedia: PrepopulateUserMediaType;
+  
+  getUpdatedAllParams: () => StreamSuccessAudioParameters;
+  [key: string]: any;
+}
+
+export interface StreamSuccessAudioOptions {
+  stream: MediaStream;
+  parameters: StreamSuccessAudioParameters;
+}
+
+// Export the type definition for the function
+export type StreamSuccessAudioType = (options: StreamSuccessAudioOptions) => Promise<void>;
+
+/**
+ * Handles the successful streaming of audio by setting up the necessary transports and updating the relevant states.
+ *
+ * @param {StreamSuccessAudioOptions} 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 {Socket} options.parameters.socket - The socket connection for communication.
+ * @param {Array<Participant>} options.parameters.participants - The list of participants.
+ * @param {MediaStream | null} 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 {ProducerOptions} options.parameters.audioParams - The audio parameters.
+ * @param {MediaStream | null} 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 {ProducerOptions} options.parameters.params - Additional parameters.
+ * @param {ProducerOptions} options.parameters.audioParamse - Additional audio parameters.
+ * @param {ProducerOptions} 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.
+ *
+ * @example
+ * const options = {
+ *   stream: localStream, // MediaStream object containing the audio track
+ *   parameters: {
+ *     socket: socketInstance,
+ *     participants: participantList,
+ *     localStream: null,
+ *     transportCreated: false,
+ *     transportCreatedAudio: false,
+ *     audioAlreadyOn: false,
+ *     micAction: false,
+ *     audioParams: {},
+ *     localStreamAudio: null,
+ *     defAudioID: "",
+ *     userDefaultAudioInputDevice: "",
+ *     params: {},
+ *     audioParamse: {},
+ *     aParams: {},
+ *     hostLabel: "Host",
+ *     islevel: "1",
+ *     member: "user1",
+ *     updateMainWindow: true,
+ *     lock_screen: false,
+ *     shared: false,
+ *     videoAlreadyOn: false,
+ *     showAlert: alertFunction,
+ *     updateParticipants: updateParticipantsFunction,
+ *     updateTransportCreated: updateTransportCreatedFunction,
+ *     updateTransportCreatedAudio: updateTransportCreatedAudioFunction,
+ *     updateAudioAlreadyOn: updateAudioAlreadyOnFunction,
+ *     updateMicAction: updateMicActionFunction,
+ *     updateAudioParams: updateAudioParamsFunction,
+ *     updateLocalStream: updateLocalStreamFunction,
+ *     updateLocalStreamAudio: updateLocalStreamAudioFunction,
+ *     updateDefAudioID: updateDefAudioIDFunction,
+ *     updateUserDefaultAudioInputDevice: updateUserDefaultAudioInputDeviceFunction,
+ *     updateUpdateMainWindow: updateUpdateMainWindowFunction,
+ *     createSendTransport: createSendTransportFunction,
+ *     connectSendTransportAudio: connectSendTransportAudioFunction,
+ *     resumeSendTransportAudio: resumeSendTransportAudioFunction,
+ *     prepopulateUserMedia: prepopulateUserMediaFunction,
+ *   },
+ * };
+ * 
+ * streamSuccessAudio(options)
+ *   .then(() => {
+ *     console.log('Audio streaming setup successfully');
+ *   })
+ *   .catch(error => {
+ *     console.error('Error setting up audio streaming:', error);
+ *   });
+ */
+
+export const streamSuccessAudio = async ({
+  stream,
+  parameters,
+}: StreamSuccessAudioOptions): Promise<void> => {
+  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);
+
+  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;
+
+  updateDefAudioID(defAudioID);
+  updateUserDefaultAudioInputDevice(userDefaultAudioInputDevice);
+
+  try {
+    params = aParams;
+    audioParamse = { ...params };
+
+    audioParams = {
+      track: localStream.getAudioTracks()[0],
+      ...audioParamse,
+    };
+    updateAudioParams(audioParams);
+
+    if (!transportCreated) {
+      try {
+        await createSendTransport({
+          parameters: {
+            ...parameters,
+            audioParams: audioParams,
+          },
+          option: "audio",
+        });
+      } catch (error) {
+        console.error("Error creating transport:", error);
+      }
+    } else {
+      if (!transportCreatedAudio) {
+        await connectSendTransportAudio({
+          audioParams,
+          parameters,
+        });
+      } else {
+        await resumeSendTransportAudio({ parameters });
+      }
+    }
+  } catch (error: any) {
+    if (showAlert) {
+      showAlert({
+        message: error.message,
+        type: "danger",
+        duration: 3000,
+      });
+    }
+  }
+
+  audioAlreadyOn = true;
+  updateAudioAlreadyOn(audioAlreadyOn);
+
+  if (micAction === true) {
+    micAction = false;
+    updateMicAction(micAction);
+  }
+
+  participants.forEach((participant) => {
+    if (participant.socketId === socket.id && participant.name === member) {
+      participant.muted = false;
+    }
+  });
+  updateParticipants(participants);
+
+  transportCreated = true;
+  transportCreatedAudio = true;
+  updateTransportCreated(transportCreated);
+  updateTransportCreatedAudio(transportCreatedAudio);
+
+  if (!videoAlreadyOn && islevel === "2") {
+    if (!lock_screen && !shared) {
+      updateMainWindow = true;
+      updateUpdateMainWindow(updateMainWindow);
+      await prepopulateUserMedia({ name: hostLabel, parameters });
+      updateMainWindow = false;
+      updateUpdateMainWindow(updateMainWindow);
+    }
+  }
+};
+