mediasfu-angular 1.0.0

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

@@ -0,0 +1,143 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class StreamSuccessScreen {
+    /**
+     * Handles the successful initiation of screen sharing.
+     *
+     * @param {StreamSuccessScreenOptions} options - The options for the screen sharing success handler.
+     * @param {MediaStream} options.stream - The media stream to be shared.
+     * @param {Object} options.parameters - The parameters required for screen sharing.
+     * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+     * @param {Socket} options.parameters.socket - The socket instance for communication.
+     * @param {boolean} options.parameters.transportCreated - Flag indicating if the transport is already created.
+     * @param {MediaStream} options.parameters.localStreamScreen - The local screen media stream.
+     * @param {boolean} options.parameters.screenAlreadyOn - Flag indicating if the screen is already being shared.
+     * @param {boolean} options.parameters.screenAction - Flag indicating if the screen share action is requested.
+     * @param {boolean} options.parameters.transportCreatedScreen - Flag indicating if the screen transport is created.
+     * @param {string} options.parameters.hostLabel - The label of the host.
+     * @param {string} options.parameters.eventType - The type of the event (e.g., conference).
+     * @param {Function} options.parameters.showAlert - Function to show alerts.
+     * @param {boolean} options.parameters.annotateScreenStream - Flag indicating if screen annotation is enabled.
+     * @param {Function} options.parameters.updateTransportCreatedScreen - Function to update the screen transport creation state.
+     * @param {Function} options.parameters.updateScreenAlreadyOn - Function to update the screen sharing state.
+     * @param {Function} options.parameters.updateScreenAction - Function to update the screen action state.
+     * @param {Function} options.parameters.updateTransportCreated - Function to update the transport creation state.
+     * @param {Function} options.parameters.updateLocalStreamScreen - Function to update the local screen stream.
+     * @param {Function} options.parameters.updateShared - Function to update the shared state.
+     * @param {Function} options.parameters.updateIsScreenboardModalVisible - Function to update the screenboard modal visibility.
+     * @param {Function} options.parameters.sleep - Function to pause execution for a specified duration.
+     * @param {Function} options.parameters.createSendTransport - Function to create a send transport.
+     * @param {Function} options.parameters.connectSendTransportScreen - Function to connect the send transport for screen sharing.
+     * @param {Function} options.parameters.disconnectSendTransportScreen - Function to disconnect the send transport for screen sharing.
+     * @param {Function} options.parameters.stopShareScreen - Function to stop screen sharing.
+     * @param {Function} options.parameters.reorderStreams - Function to reorder streams.
+     * @param {Function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.
+     * @param {Function} options.parameters.rePort - Function to reinitialize ports.
+     *
+     * @returns {Promise<void>} A promise that resolves when the screen sharing setup is complete.
+     */
+    async streamSuccessScreen({ stream, parameters }) {
+        let { getUpdatedAllParams } = parameters;
+        parameters = getUpdatedAllParams();
+        let { socket, transportCreated, localStreamScreen, screenAlreadyOn, screenAction, transportCreatedScreen, hostLabel, eventType, showAlert, annotateScreenStream, 
+        // updates for the above
+        updateTransportCreatedScreen, updateScreenAlreadyOn, updateScreenAction, updateTransportCreated, updateLocalStreamScreen, updateShared, updateIsScreenboardModalVisible, sleep, 
+        // mediasfu functions
+        createSendTransport, connectSendTransportScreen, disconnectSendTransportScreen, stopShareScreen, reorderStreams, prepopulateUserMedia, rePort, } = parameters;
+        // Share screen on success
+        localStreamScreen = stream;
+        updateLocalStreamScreen(localStreamScreen);
+        try {
+            // Create transport if not created else connect transport
+            if (!transportCreated) {
+                await createSendTransport({
+                    option: 'screen',
+                    parameters: { ...parameters, localStreamScreen },
+                });
+            }
+            else {
+                await connectSendTransportScreen({
+                    stream: localStreamScreen,
+                    parameters: { ...parameters, localStreamScreen },
+                });
+            }
+            // Alert the socket that you are sharing screen
+            socket.emit('startScreenShare');
+        }
+        catch (error) {
+            showAlert?.({
+                message: error.message,
+                type: 'danger',
+                duration: 3000,
+            });
+        }
+        // Reupdate the screen display
+        try {
+            updateShared(true);
+            await prepopulateUserMedia({
+                name: hostLabel,
+                parameters: { ...parameters, localStreamScreen, shared: true },
+            });
+        }
+        catch {
+            /* handle error */
+        }
+        // Update the participants array to reflect the change
+        screenAlreadyOn = true;
+        updateScreenAlreadyOn(screenAlreadyOn);
+        // Reorder streams if required
+        try {
+            if (eventType == 'conference') {
+                await reorderStreams({ add: false, screenChanged: true, parameters });
+                await prepopulateUserMedia({ name: hostLabel, parameters });
+            }
+            else {
+                await reorderStreams({ parameters });
+            }
+        }
+        catch (error) {
+            try {
+                await rePort({ parameters });
+            }
+            catch {
+                /* handle error */
+            }
+        }
+        // Handle screen share end
+        localStreamScreen.getVideoTracks()[0].onended = async function () {
+            // Supports both manual and automatic screen share end
+            await disconnectSendTransportScreen({ parameters });
+            await stopShareScreen({ parameters });
+        };
+        // If user requested to share screen, update the screenAction state
+        if (screenAction == true) {
+            screenAction = false;
+        }
+        updateScreenAction(screenAction);
+        // Update the transport created state
+        transportCreatedScreen = true;
+        updateTransportCreatedScreen(transportCreatedScreen);
+        updateTransportCreated(transportCreated);
+        // Handle screen annotation modal
+        try {
+            if (annotateScreenStream) {
+                annotateScreenStream = false;
+                updateIsScreenboardModalVisible(true);
+                await sleep({ ms: 500 });
+                updateIsScreenboardModalVisible(false);
+            }
+        }
+        catch (error) {
+            //console.log('Error handling screen annotation:', error);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: StreamSuccessScreen, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: StreamSuccessScreen, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: StreamSuccessScreen, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stream-success-screen.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/stream-success-screen.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Socket } from 'socket.io-client';\nimport {\n  SleepType,\n  CreateSendTransportType,\n  ConnectSendTransportScreenType,\n  DisconnectSendTransportScreenType,\n  StopShareScreenType,\n  ReorderStreamsType,\n  PrepopulateUserMediaType,\n  RePortType,\n  ShowAlert,\n  CreateSendTransportParameters,\n  ConnectSendTransportScreenParameters,\n  DisconnectSendTransportScreenParameters,\n  StopShareScreenParameters,\n  ReorderStreamsParameters,\n  PrepopulateUserMediaParameters,\n  EventType,\n} from '../@types/types';\n\nexport interface StreamSuccessScreenParameters\n  extends CreateSendTransportParameters,\n    ConnectSendTransportScreenParameters,\n    DisconnectSendTransportScreenParameters,\n    StopShareScreenParameters,\n    ReorderStreamsParameters,\n    PrepopulateUserMediaParameters {\n  socket: Socket;\n  transportCreated: boolean;\n  localStreamScreen: MediaStream | null;\n  screenAlreadyOn: boolean;\n  screenAction: boolean;\n  transportCreatedScreen: boolean;\n  hostLabel: string;\n  eventType: EventType;\n  showAlert?: ShowAlert;\n  annotateScreenStream: boolean;\n  shared: boolean;\n\n  updateTransportCreatedScreen: (transportCreatedScreen: boolean) => void;\n  updateScreenAlreadyOn: (screenAlreadyOn: boolean) => void;\n  updateScreenAction: (screenAction: boolean) => void;\n  updateTransportCreated: (transportCreated: boolean) => void;\n  updateLocalStreamScreen: (localStreamScreen: MediaStream | null) => void;\n  updateShared: (shared: boolean) => void;\n  updateIsScreenboardModalVisible: (isVisible: boolean) => void;\n\n  // mediasfu functions\n  sleep: SleepType;\n  createSendTransport: CreateSendTransportType;\n  connectSendTransportScreen: ConnectSendTransportScreenType;\n  disconnectSendTransportScreen: DisconnectSendTransportScreenType;\n  stopShareScreen: StopShareScreenType;\n  reorderStreams: ReorderStreamsType;\n  prepopulateUserMedia: PrepopulateUserMediaType;\n  rePort: RePortType;\n\n  getUpdatedAllParams: () => StreamSuccessScreenParameters;\n  [key: string]: any;\n}\n\nexport interface StreamSuccessScreenOptions {\n  stream: MediaStream;\n  parameters: StreamSuccessScreenParameters;\n}\n\n// Export the type definition for the function\nexport type StreamSuccessScreenType = (options: StreamSuccessScreenOptions) => Promise<void>;\n@Injectable({\n  providedIn: 'root',\n})\nexport class StreamSuccessScreen {\n  /**\n   * Handles the successful initiation of screen sharing.\n   *\n   * @param {StreamSuccessScreenOptions} options - The options for the screen sharing success handler.\n   * @param {MediaStream} options.stream - The media stream to be shared.\n   * @param {Object} options.parameters - The parameters required for screen sharing.\n   * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.\n   * @param {Socket} options.parameters.socket - The socket instance for communication.\n   * @param {boolean} options.parameters.transportCreated - Flag indicating if the transport is already created.\n   * @param {MediaStream} options.parameters.localStreamScreen - The local screen media stream.\n   * @param {boolean} options.parameters.screenAlreadyOn - Flag indicating if the screen is already being shared.\n   * @param {boolean} options.parameters.screenAction - Flag indicating if the screen share action is requested.\n   * @param {boolean} options.parameters.transportCreatedScreen - Flag indicating if the screen transport is created.\n   * @param {string} options.parameters.hostLabel - The label of the host.\n   * @param {string} options.parameters.eventType - The type of the event (e.g., conference).\n   * @param {Function} options.parameters.showAlert - Function to show alerts.\n   * @param {boolean} options.parameters.annotateScreenStream - Flag indicating if screen annotation is enabled.\n   * @param {Function} options.parameters.updateTransportCreatedScreen - Function to update the screen transport creation state.\n   * @param {Function} options.parameters.updateScreenAlreadyOn - Function to update the screen sharing state.\n   * @param {Function} options.parameters.updateScreenAction - Function to update the screen action state.\n   * @param {Function} options.parameters.updateTransportCreated - Function to update the transport creation state.\n   * @param {Function} options.parameters.updateLocalStreamScreen - Function to update the local screen stream.\n   * @param {Function} options.parameters.updateShared - Function to update the shared state.\n   * @param {Function} options.parameters.updateIsScreenboardModalVisible - Function to update the screenboard modal visibility.\n   * @param {Function} options.parameters.sleep - Function to pause execution for a specified duration.\n   * @param {Function} options.parameters.createSendTransport - Function to create a send transport.\n   * @param {Function} options.parameters.connectSendTransportScreen - Function to connect the send transport for screen sharing.\n   * @param {Function} options.parameters.disconnectSendTransportScreen - Function to disconnect the send transport for screen sharing.\n   * @param {Function} options.parameters.stopShareScreen - Function to stop screen sharing.\n   * @param {Function} options.parameters.reorderStreams - Function to reorder streams.\n   * @param {Function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.\n   * @param {Function} options.parameters.rePort - Function to reinitialize ports.\n   *\n   * @returns {Promise<void>} A promise that resolves when the screen sharing setup is complete.\n   */\n  async streamSuccessScreen({ stream, parameters }: StreamSuccessScreenOptions): Promise<void> {\n    let { getUpdatedAllParams } = parameters;\n    parameters = getUpdatedAllParams();\n\n    let {\n      socket,\n      transportCreated,\n      localStreamScreen,\n      screenAlreadyOn,\n      screenAction,\n      transportCreatedScreen,\n      hostLabel,\n      eventType,\n      showAlert,\n      annotateScreenStream,\n\n      // updates for the above\n      updateTransportCreatedScreen,\n      updateScreenAlreadyOn,\n      updateScreenAction,\n      updateTransportCreated,\n      updateLocalStreamScreen,\n      updateShared,\n      updateIsScreenboardModalVisible,\n      sleep,\n\n      // mediasfu functions\n      createSendTransport,\n      connectSendTransportScreen,\n      disconnectSendTransportScreen,\n      stopShareScreen,\n      reorderStreams,\n      prepopulateUserMedia,\n      rePort,\n    } = parameters;\n\n    // Share screen on success\n    localStreamScreen = stream;\n    updateLocalStreamScreen(localStreamScreen);\n\n    try {\n      // Create transport if not created else connect transport\n      if (!transportCreated) {\n        await createSendTransport({\n          option: 'screen',\n          parameters: { ...parameters, localStreamScreen },\n        });\n      } else {\n        await connectSendTransportScreen({\n          stream: localStreamScreen,\n          parameters: { ...parameters, localStreamScreen },\n        });\n      }\n\n      // Alert the socket that you are sharing screen\n      socket.emit('startScreenShare');\n    } catch (error: any) {\n      showAlert?.({\n        message: error.message,\n        type: 'danger',\n        duration: 3000,\n      });\n    }\n\n    // Reupdate the screen display\n    try {\n      updateShared(true);\n      await prepopulateUserMedia({\n        name: hostLabel,\n        parameters: { ...parameters, localStreamScreen, shared: true },\n      });\n    } catch {\n      /* handle error */\n    }\n\n    // Update the participants array to reflect the change\n    screenAlreadyOn = true;\n    updateScreenAlreadyOn(screenAlreadyOn);\n\n    // Reorder streams if required\n    try {\n      if (eventType == 'conference') {\n        await reorderStreams({ add: false, screenChanged: true, parameters });\n        await prepopulateUserMedia({ name: hostLabel, parameters });\n      } else {\n        await reorderStreams({ parameters });\n      }\n    } catch (error) {\n      try {\n        await rePort({ parameters });\n      } catch {\n        /* handle error */\n      }\n    }\n\n    // Handle screen share end\n    localStreamScreen.getVideoTracks()[0].onended = async function () {\n      // Supports both manual and automatic screen share end\n      await disconnectSendTransportScreen({ parameters });\n      await stopShareScreen({ parameters });\n    };\n\n    // If user requested to share screen, update the screenAction state\n    if (screenAction == true) {\n      screenAction = false;\n    }\n    updateScreenAction(screenAction);\n\n    // Update the transport created state\n    transportCreatedScreen = true;\n    updateTransportCreatedScreen(transportCreatedScreen);\n    updateTransportCreated(transportCreated);\n\n    // Handle screen annotation modal\n    try {\n      if (annotateScreenStream) {\n        annotateScreenStream = false;\n        updateIsScreenboardModalVisible(true);\n        await sleep({ ms: 500 });\n        updateIsScreenboardModalVisible(false);\n      }\n    } catch (error) {\n      //console.log('Error handling screen annotation:', error);\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,202 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class StreamSuccessVideo {
+    /**
+     * Streams a video successfully by managing the local stream, updating parameters, and handling video transport.
+     *
+     * @param {StreamSuccessVideoOptions} options - The options for streaming the video.
+     * @param {MediaStream} options.stream - The media stream to be used for the video.
+     * @param {Object} options.parameters - The parameters required for streaming.
+     * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+     *
+     * @returns {Promise<void>} A promise that resolves when the video has been successfully streamed.
+     *
+     * @throws Will throw an error if there is an issue with streaming the video.
+     */
+    streamSuccessVideo = async ({ stream, parameters }) => {
+        let { getUpdatedAllParams } = parameters;
+        parameters = getUpdatedAllParams();
+        try {
+            let { socket, participants, localStream, transportCreated, transportCreatedVideo, videoAlreadyOn, videoAction, videoParams, localStreamVideo, defVideoID, userDefaultVideoInputDevice, params, videoParamse, islevel, member, updateMainWindow, lock_screen, shared, shareScreenStarted, vParams, hParams, allowed, currentFacingMode, device, keepBackground, appliedBackground, videoProducer, 
+            // update functions
+            updateTransportCreatedVideo, updateVideoAlreadyOn, updateVideoAction, updateLocalStream, updateLocalStreamVideo, updateUserDefaultVideoInputDevice, updateCurrentFacingMode, updateDefVideoID, updateAllowed, updateUpdateMainWindow, updateParticipants, updateVideoParams, updateIsBackgroundModalVisible, updateAutoClickBackground, 
+            // mediasfu functions
+            createSendTransport, connectSendTransportVideo, showAlert, reorderStreams, sleep, } = parameters;
+            localStreamVideo = stream;
+            updateLocalStreamVideo(localStreamVideo);
+            // Add the video stream track to localStream
+            if (localStream == null) {
+                localStream = new MediaStream([localStreamVideo.getVideoTracks()[0]]);
+                updateLocalStream(localStream);
+            }
+            else {
+                // Remove all video tracks that are currently in the localStream
+                localStream.getVideoTracks().forEach((track) => {
+                    localStream?.removeTrack(track);
+                });
+                // Add the new video track to the localStream
+                localStream.addTrack(localStreamVideo.getVideoTracks()[0]);
+                updateLocalStream(localStream);
+            }
+            // Get the video track settings
+            const videoTracked = localStream.getVideoTracks()[0];
+            defVideoID = videoTracked.getSettings().deviceId ?? '';
+            userDefaultVideoInputDevice = defVideoID;
+            currentFacingMode = videoTracked.getSettings().facingMode ?? 'user';
+            // Update the state variables
+            if (defVideoID) {
+                updateDefVideoID(defVideoID);
+            }
+            if (userDefaultVideoInputDevice) {
+                updateUserDefaultVideoInputDevice(userDefaultVideoInputDevice);
+            }
+            if (currentFacingMode) {
+                updateCurrentFacingMode(currentFacingMode);
+            }
+            allowed = true;
+            updateAllowed(allowed);
+            try {
+                // Apply the video constraints
+                if (islevel == '2') {
+                    if (!shared || !shareScreenStarted) {
+                        params = hParams;
+                        videoParamse = { ...params };
+                    }
+                    else {
+                        params = vParams;
+                        videoParamse = { ...params };
+                    }
+                }
+                else {
+                    params = vParams;
+                    videoParamse = { ...params };
+                }
+                // Remove VP9 codec from the video codecs; support only VP8 and H264
+                let codec = device?.rtpCapabilities?.codecs?.filter((codec) => codec.mimeType.toLowerCase() !== 'video/vp9' && codec.kind === 'video');
+                // Create transport if not created else connect transport
+                if (codec && codec.length > 0) {
+                    videoParams = {
+                        track: localStream.getVideoTracks()[0],
+                        ...videoParamse,
+                        codec: codec[0],
+                    };
+                }
+                else {
+                    throw new Error('No suitable video codec found');
+                }
+                updateVideoParams(videoParams);
+                if (keepBackground && appliedBackground) {
+                    videoAlreadyOn = true;
+                    updateVideoAlreadyOn(videoAlreadyOn);
+                    updateAutoClickBackground(true);
+                    updateIsBackgroundModalVisible(true);
+                    await sleep({ ms: 500 });
+                    updateIsBackgroundModalVisible(false);
+                    updateAutoClickBackground(false);
+                }
+                else {
+                    if (!transportCreated) {
+                        try {
+                            await createSendTransport({
+                                parameters: {
+                                    ...parameters,
+                                    videoParams: videoParams,
+                                },
+                                option: 'video',
+                            });
+                        }
+                        catch (error) {
+                            console.log('Error creating send transport:', error);
+                        }
+                    }
+                    else {
+                        try {
+                            videoProducer?.close();
+                            await sleep({ ms: 500 });
+                        }
+                        catch {
+                            /* handle error */
+                        }
+                        await connectSendTransportVideo({
+                            parameters: parameters,
+                            videoParams: videoParams,
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                showAlert?.({
+                    message: error.message,
+                    type: 'danger',
+                    duration: 3000,
+                });
+            }
+            // Update the videoAlreadyOn state
+            videoAlreadyOn = true;
+            updateVideoAlreadyOn(videoAlreadyOn);
+            // If user requested to share video, update the videoAction state
+            if (videoAction) {
+                videoAction = false;
+                updateVideoAction(videoAction);
+            }
+            // Update the display screen if host
+            if (islevel == '2') {
+                updateMainWindow = true;
+                updateUpdateMainWindow(updateMainWindow);
+            }
+            // Update the participants array to reflect the change
+            participants.forEach((participant) => {
+                if (participant.socketId == socket.id && participant.name == member) {
+                    participant.videoOn = true;
+                }
+            });
+            updateParticipants(participants);
+            // Update the transport created state
+            transportCreatedVideo = true;
+            updateTransportCreatedVideo(transportCreatedVideo);
+            // Reupdate the screen display
+            if (lock_screen) {
+                try {
+                    await reorderStreams({
+                        add: true,
+                        screenChanged: true,
+                        parameters: { ...parameters, videoAlreadyOn },
+                    });
+                }
+                catch (error) {
+                    console.log('Error reordering streams with lock screen:', error);
+                }
+            }
+            else {
+                try {
+                    await reorderStreams({
+                        add: false,
+                        screenChanged: true,
+                        parameters: { ...parameters, videoAlreadyOn },
+                    });
+                }
+                catch (error) {
+                    console.log('Error reordering streams without lock screen:', error);
+                }
+            }
+        }
+        catch (error) {
+            const { showAlert } = parameters;
+            console.log('Error in streamSuccessVideo:', error);
+            showAlert?.({
+                message: error.message,
+                type: 'danger',
+                duration: 3000,
+            });
+        }
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: StreamSuccessVideo, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: StreamSuccessVideo, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: StreamSuccessVideo, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stream-success-video.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/stream-success-video.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Device, ProducerOptions, Producer, RtpCodecCapability } from 'mediasoup-client/lib/types';\nimport { Socket } from 'socket.io-client';\nimport {\n  ConnectSendTransportVideoParameters,\n  Participant,\n  ShowAlert,\n  CreateSendTransportParameters,\n  ReorderStreamsParameters,\n  SleepType,\n  CreateSendTransportType,\n  ConnectSendTransportVideoType,\n  ReorderStreamsType,\n  VParamsType,\n  HParamsType,\n} from '../@types/types';\n\nexport interface StreamSuccessVideoParameters\n  extends CreateSendTransportParameters,\n    ConnectSendTransportVideoParameters,\n    ReorderStreamsParameters {\n  socket: Socket;\n  participants: Participant[];\n  localStream: MediaStream | null;\n  transportCreated: boolean;\n  transportCreatedVideo: boolean;\n  videoAlreadyOn: boolean;\n  videoAction: boolean;\n  videoParams: ProducerOptions;\n  localStreamVideo: MediaStream | null;\n  defVideoID: string;\n  userDefaultVideoInputDevice: string;\n  params: ProducerOptions;\n  videoParamse?: ProducerOptions;\n  islevel: string;\n  member: string;\n  updateMainWindow: boolean;\n  lock_screen: boolean;\n  shared: boolean;\n  shareScreenStarted: boolean;\n  vParams: VParamsType;\n  hParams: HParamsType;\n  allowed: boolean;\n  currentFacingMode: string;\n  device: Device | null;\n  keepBackground: boolean;\n  appliedBackground: boolean;\n  videoProducer: Producer | null;\n\n  // Update functions\n  updateTransportCreatedVideo: (created: boolean) => void;\n  updateVideoAlreadyOn: (videoOn: boolean) => void;\n  updateVideoAction: (videoAction: boolean) => void;\n  updateLocalStream: (stream: MediaStream | null) => void;\n  updateLocalStreamVideo: (stream: MediaStream | null) => void;\n  updateUserDefaultVideoInputDevice: (device: string) => void;\n  updateCurrentFacingMode: (mode: string) => void;\n  updateDefVideoID: (id: string) => void;\n  updateAllowed: (allowed: boolean) => void;\n  updateUpdateMainWindow: (updateMainWindow: boolean) => void;\n  updateParticipants: (participants: Participant[]) => void;\n  updateVideoParams: (params: ProducerOptions) => void;\n  updateIsBackgroundModalVisible: (isVisible: boolean) => void;\n  updateAutoClickBackground: (autoClick: boolean) => void;\n\n  showAlert?: ShowAlert;\n\n  // Media functions\n  createSendTransport: CreateSendTransportType;\n  connectSendTransportVideo: ConnectSendTransportVideoType;\n  reorderStreams: ReorderStreamsType;\n  sleep: SleepType;\n\n  getUpdatedAllParams: () => StreamSuccessVideoParameters;\n  [key: string]: any;\n}\n\nexport interface StreamSuccessVideoOptions {\n  stream: MediaStream;\n  parameters: StreamSuccessVideoParameters;\n}\n\n// Export the type definition for the function\nexport type StreamSuccessVideoType = (options: StreamSuccessVideoOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class StreamSuccessVideo {\n  /**\n   * Streams a video successfully by managing the local stream, updating parameters, and handling video transport.\n   *\n   * @param {StreamSuccessVideoOptions} options - The options for streaming the video.\n   * @param {MediaStream} options.stream - The media stream to be used for the video.\n   * @param {Object} options.parameters - The parameters required for streaming.\n   * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.\n   *\n   * @returns {Promise<void>} A promise that resolves when the video has been successfully streamed.\n   *\n   * @throws Will throw an error if there is an issue with streaming the video.\n   */\n  streamSuccessVideo = async ({ stream, parameters }: StreamSuccessVideoOptions): Promise<void> => {\n    let { getUpdatedAllParams } = parameters;\n    parameters = getUpdatedAllParams();\n\n    try {\n      let {\n        socket,\n        participants,\n        localStream,\n        transportCreated,\n        transportCreatedVideo,\n        videoAlreadyOn,\n        videoAction,\n        videoParams,\n        localStreamVideo,\n        defVideoID,\n        userDefaultVideoInputDevice,\n        params,\n        videoParamse,\n        islevel,\n        member,\n        updateMainWindow,\n        lock_screen,\n        shared,\n        shareScreenStarted,\n        vParams,\n        hParams,\n        allowed,\n        currentFacingMode,\n        device,\n        keepBackground,\n        appliedBackground,\n        videoProducer,\n\n        // update functions\n        updateTransportCreatedVideo,\n        updateVideoAlreadyOn,\n        updateVideoAction,\n        updateLocalStream,\n        updateLocalStreamVideo,\n        updateUserDefaultVideoInputDevice,\n        updateCurrentFacingMode,\n        updateDefVideoID,\n        updateAllowed,\n        updateUpdateMainWindow,\n        updateParticipants,\n        updateVideoParams,\n        updateIsBackgroundModalVisible,\n        updateAutoClickBackground,\n\n        // mediasfu functions\n        createSendTransport,\n        connectSendTransportVideo,\n        showAlert,\n        reorderStreams,\n        sleep,\n      } = parameters;\n\n      localStreamVideo = stream;\n      updateLocalStreamVideo(localStreamVideo);\n\n      // Add the video stream track to localStream\n      if (localStream == null) {\n        localStream = new MediaStream([localStreamVideo.getVideoTracks()[0]]);\n        updateLocalStream(localStream);\n      } else {\n        // Remove all video tracks that are currently in the localStream\n        localStream.getVideoTracks().forEach((track: MediaStreamTrack) => {\n          localStream?.removeTrack(track);\n        });\n        // Add the new video track to the localStream\n        localStream.addTrack(localStreamVideo.getVideoTracks()[0]);\n        updateLocalStream(localStream);\n      }\n\n      // Get the video track settings\n      const videoTracked = localStream.getVideoTracks()[0];\n      defVideoID = videoTracked.getSettings().deviceId ?? '';\n      userDefaultVideoInputDevice = defVideoID;\n      currentFacingMode = videoTracked.getSettings().facingMode ?? 'user';\n\n      // Update the state variables\n      if (defVideoID) {\n        updateDefVideoID(defVideoID);\n      }\n      if (userDefaultVideoInputDevice) {\n        updateUserDefaultVideoInputDevice(userDefaultVideoInputDevice);\n      }\n      if (currentFacingMode) {\n        updateCurrentFacingMode(currentFacingMode);\n      }\n\n      allowed = true;\n      updateAllowed(allowed);\n\n      try {\n        // Apply the video constraints\n        if (islevel == '2') {\n          if (!shared || !shareScreenStarted) {\n            params = hParams;\n            videoParamse = { ...params };\n          } else {\n            params = vParams;\n            videoParamse = { ...params };\n          }\n        } else {\n          params = vParams;\n          videoParamse = { ...params };\n        }\n\n        // Remove VP9 codec from the video codecs; support only VP8 and H264\n        let codec = device?.rtpCapabilities?.codecs?.filter(\n          (codec: RtpCodecCapability) =>\n            codec.mimeType.toLowerCase() !== 'video/vp9' && codec.kind === 'video',\n        );\n\n        // Create transport if not created else connect transport\n        if (codec && codec.length > 0) {\n          videoParams = {\n            track: localStream.getVideoTracks()[0],\n            ...videoParamse,\n            codec: codec[0],\n          };\n        } else {\n          throw new Error('No suitable video codec found');\n        }\n        updateVideoParams(videoParams);\n\n        if (keepBackground && appliedBackground) {\n          videoAlreadyOn = true;\n          updateVideoAlreadyOn(videoAlreadyOn);\n\n          updateAutoClickBackground(true);\n          updateIsBackgroundModalVisible(true);\n          await sleep({ ms: 500 });\n          updateIsBackgroundModalVisible(false);\n          updateAutoClickBackground(false);\n        } else {\n          if (!transportCreated) {\n            try {\n              await createSendTransport({\n                parameters: {\n                  ...parameters,\n                  videoParams: videoParams,\n                },\n                option: 'video',\n              });\n            } catch (error) {\n              console.log('Error creating send transport:', error);\n            }\n          } else {\n            try {\n              videoProducer?.close();\n              await sleep({ ms: 500 });\n            } catch {\n              /* handle error */\n            }\n            await connectSendTransportVideo({\n              parameters: parameters,\n              videoParams: videoParams,\n            });\n          }\n        }\n      } catch (error: any) {\n        showAlert?.({\n          message: error.message,\n          type: 'danger',\n          duration: 3000,\n        });\n      }\n\n      // Update the videoAlreadyOn state\n      videoAlreadyOn = true;\n      updateVideoAlreadyOn(videoAlreadyOn);\n\n      // If user requested to share video, update the videoAction state\n      if (videoAction) {\n        videoAction = false;\n        updateVideoAction(videoAction);\n      }\n\n      // Update the display screen if host\n      if (islevel == '2') {\n        updateMainWindow = true;\n        updateUpdateMainWindow(updateMainWindow);\n      }\n\n      // Update the participants array to reflect the change\n      participants.forEach((participant: any) => {\n        if (participant.socketId == socket.id && participant.name == member) {\n          participant.videoOn = true;\n        }\n      });\n      updateParticipants(participants);\n\n      // Update the transport created state\n      transportCreatedVideo = true;\n      updateTransportCreatedVideo(transportCreatedVideo);\n\n      // Reupdate the screen display\n      if (lock_screen) {\n        try {\n          await reorderStreams({\n            add: true,\n            screenChanged: true,\n            parameters: { ...parameters, videoAlreadyOn },\n          });\n        } catch (error) {\n          console.log('Error reordering streams with lock screen:', error);\n        }\n      } else {\n        try {\n          await reorderStreams({\n            add: false,\n            screenChanged: true,\n            parameters: { ...parameters, videoAlreadyOn },\n          });\n        } catch (error) {\n          console.log('Error reordering streams without lock screen:', error);\n        }\n      }\n    } catch (error: any) {\n      const { showAlert } = parameters;\n      console.log('Error in streamSuccessVideo:', error);\n      showAlert?.({\n        message: error.message,\n        type: 'danger',\n        duration: 3000,\n      });\n    }\n  };\n}\n"]}

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

@@ -0,0 +1,87 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class SwitchUserAudio {
+    /**
+     * Switches the user's audio input device based on the provided audio preference.
+     *
+     * @param {SwitchUserAudioOptions} options - The options for switching the user's audio input device.
+     * @param {string} options.audioPreference - The preferred audio input device ID.
+     * @param {Object} options.parameters - Additional parameters required for switching the audio input device.
+     * @param {string} options.parameters.prevAudioInputDevice - The previous audio input device ID.
+     * @param {Function} options.parameters.showAlert - Function to show alert messages.
+     * @param {boolean} options.parameters.hasAudioPermission - Flag indicating if the user has granted audio permission.
+     * @param {Function} options.parameters.updateUserDefaultAudioInputDevice - Function to update the user's default audio input device.
+     * @param {Function} options.parameters.streamSuccessAudioSwitch - Function to handle successful audio stream switch.
+     * @param {Function} options.parameters.requestPermissionAudio - Function to request audio permission from the user.
+     * @param {Function} options.parameters.checkMediaPermission - Function to check if media permission is granted.
+     *
+     * @returns {Promise<void>} A promise that resolves when the audio input device has been successfully switched.
+     *
+     * @throws Will throw an error if the audio input device cannot be accessed or if there is an unexpected error.
+     */
+    async switchUserAudio({ audioPreference, parameters }) {
+        let { userDefaultAudioInputDevice, prevAudioInputDevice, showAlert, hasAudioPermission, updateUserDefaultAudioInputDevice, 
+        // media functions
+        streamSuccessAudioSwitch, requestPermissionAudio, checkMediaPermission, } = parameters;
+        try {
+            // Check if audio permission is granted
+            if (!hasAudioPermission) {
+                if (checkMediaPermission) {
+                    let statusMic = await requestPermissionAudio();
+                    if (statusMic !== 'granted') {
+                        showAlert?.({
+                            message: 'Allow access to your microphone or check if your microphone is not being used by another application.',
+                            type: 'danger',
+                            duration: 3000,
+                        });
+                        return;
+                    }
+                }
+            }
+            let mediaConstraints = {
+                audio: {
+                    deviceId: { exact: audioPreference },
+                    echoCancellation: false,
+                    noiseSuppression: false,
+                    autoGainControl: false,
+                },
+                video: false,
+            };
+            // Get user media with the defined audio constraints
+            await navigator.mediaDevices
+                .getUserMedia(mediaConstraints)
+                .then(async (stream) => {
+                await streamSuccessAudioSwitch({ stream, parameters });
+            })
+                .catch(() => {
+                // Handle errors and revert to the previous audio input device
+                userDefaultAudioInputDevice = prevAudioInputDevice;
+                updateUserDefaultAudioInputDevice(userDefaultAudioInputDevice);
+                showAlert?.({
+                    message: 'Error switching; the specified microphone could not be accessed.',
+                    type: 'danger',
+                    duration: 3000,
+                });
+            });
+        }
+        catch (error) {
+            // Handle unexpected errors and revert to the previous audio input device
+            userDefaultAudioInputDevice = prevAudioInputDevice;
+            updateUserDefaultAudioInputDevice(userDefaultAudioInputDevice);
+            showAlert?.({
+                message: 'Error switching; the specified microphone could not be accessed.',
+                type: 'danger',
+                duration: 3000,
+            });
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: SwitchUserAudio, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: SwitchUserAudio, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: SwitchUserAudio, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"switch-user-audio.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/switch-user-audio.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAkC3C,MAAM,OAAO,eAAe;IAC1B;;;;;;;;;;;;;;;;;OAiBG;IACH,KAAK,CAAC,eAAe,CAAC,EAAE,eAAe,EAAE,UAAU,EAA0B;QAC3E,IAAI,EACF,2BAA2B,EAC3B,oBAAoB,EACpB,SAAS,EACT,kBAAkB,EAClB,iCAAiC;QAEjC,kBAAkB;QAClB,wBAAwB,EACxB,sBAAsB,EACtB,oBAAoB,GACrB,GAAG,UAAU,CAAC;QAEf,IAAI,CAAC;YACH,uCAAuC;YACvC,IAAI,CAAC,kBAAkB,EAAE,CAAC;gBACxB,IAAI,oBAAoB,EAAE,CAAC;oBACzB,IAAI,SAAS,GAAG,MAAM,sBAAsB,EAAE,CAAC;oBAC/C,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;wBAC5B,SAAS,EAAE,CAAC;4BACV,OAAO,EACL,uGAAuG;4BACzG,IAAI,EAAE,QAAQ;4BACd,QAAQ,EAAE,IAAI;yBACf,CAAC,CAAC;wBAEH,OAAO;oBACT,CAAC;gBACH,CAAC;YACH,CAAC;YAED,IAAI,gBAAgB,GAA2B;gBAC7C,KAAK,EAAE;oBACL,QAAQ,EAAE,EAAE,KAAK,EAAE,eAAe,EAAE;oBACpC,gBAAgB,EAAE,KAAK;oBACvB,gBAAgB,EAAE,KAAK;oBACvB,eAAe,EAAE,KAAK;iBACvB;gBACD,KAAK,EAAE,KAAK;aACb,CAAC;YAEF,oDAAoD;YACpD,MAAM,SAAS,CAAC,YAAY;iBACzB,YAAY,CAAC,gBAAgB,CAAC;iBAC9B,IAAI,CAAC,KAAK,EAAE,MAAmB,EAAE,EAAE;gBAClC,MAAM,wBAAwB,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC,CAAC;YACzD,CAAC,CAAC;iBACD,KAAK,CAAC,GAAG,EAAE;gBACV,8DAA8D;gBAC9D,2BAA2B,GAAG,oBAAoB,CAAC;gBACnD,iCAAiC,CAAC,2BAA2B,CAAC,CAAC;gBAE/D,SAAS,EAAE,CAAC;oBACV,OAAO,EAAE,kEAAkE;oBAC3E,IAAI,EAAE,QAAQ;oBACd,QAAQ,EAAE,IAAI;iBACf,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;QACP,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,yEAAyE;YACzE,2BAA2B,GAAG,oBAAoB,CAAC;YACnD,iCAAiC,CAAC,2BAA2B,CAAC,CAAC;YAE/D,SAAS,EAAE,CAAC;gBACV,OAAO,EAAE,kEAAkE;gBAC3E,IAAI,EAAE,QAAQ;gBACd,QAAQ,EAAE,IAAI;aACf,CAAC,CAAC;QACL,CAAC;IACH,CAAC;uGAzFU,eAAe;2GAAf,eAAe,cAFd,MAAM;;2FAEP,eAAe;kBAH3B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  ShowAlert,\n  StreamSuccessAudioSwitchType,\n  RequestPermissionAudioType,\n  StreamSuccessAudioSwitchParameters,\n} from '../@types/types';\n\nexport interface SwitchUserAudioParameters extends StreamSuccessAudioSwitchParameters {\n  userDefaultAudioInputDevice: string;\n  prevAudioInputDevice: string;\n  showAlert?: ShowAlert;\n  hasAudioPermission: boolean;\n  updateUserDefaultAudioInputDevice: (deviceId: string) => void;\n\n  // mediasfu functions\n  streamSuccessAudioSwitch: StreamSuccessAudioSwitchType;\n  requestPermissionAudio: RequestPermissionAudioType;\n  checkMediaPermission: boolean;\n\n  [key: string]: any;\n}\n\nexport interface SwitchUserAudioOptions {\n  audioPreference: string;\n  parameters: SwitchUserAudioParameters;\n}\n\n// Export the type definition for the function\nexport type SwitchUserAudioType = (options: SwitchUserAudioOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class SwitchUserAudio {\n  /**\n   * Switches the user's audio input device based on the provided audio preference.\n   *\n   * @param {SwitchUserAudioOptions} options - The options for switching the user's audio input device.\n   * @param {string} options.audioPreference - The preferred audio input device ID.\n   * @param {Object} options.parameters - Additional parameters required for switching the audio input device.\n   * @param {string} options.parameters.prevAudioInputDevice - The previous audio input device ID.\n   * @param {Function} options.parameters.showAlert - Function to show alert messages.\n   * @param {boolean} options.parameters.hasAudioPermission - Flag indicating if the user has granted audio permission.\n   * @param {Function} options.parameters.updateUserDefaultAudioInputDevice - Function to update the user's default audio input device.\n   * @param {Function} options.parameters.streamSuccessAudioSwitch - Function to handle successful audio stream switch.\n   * @param {Function} options.parameters.requestPermissionAudio - Function to request audio permission from the user.\n   * @param {Function} options.parameters.checkMediaPermission - Function to check if media permission is granted.\n   *\n   * @returns {Promise<void>} A promise that resolves when the audio input device has been successfully switched.\n   *\n   * @throws Will throw an error if the audio input device cannot be accessed or if there is an unexpected error.\n   */\n  async switchUserAudio({ audioPreference, parameters }: SwitchUserAudioOptions): Promise<void> {\n    let {\n      userDefaultAudioInputDevice,\n      prevAudioInputDevice,\n      showAlert,\n      hasAudioPermission,\n      updateUserDefaultAudioInputDevice,\n\n      // media functions\n      streamSuccessAudioSwitch,\n      requestPermissionAudio,\n      checkMediaPermission,\n    } = parameters;\n\n    try {\n      // Check if audio permission is granted\n      if (!hasAudioPermission) {\n        if (checkMediaPermission) {\n          let statusMic = await requestPermissionAudio();\n          if (statusMic !== 'granted') {\n            showAlert?.({\n              message:\n                'Allow access to your microphone or check if your microphone is not being used by another application.',\n              type: 'danger',\n              duration: 3000,\n            });\n\n            return;\n          }\n        }\n      }\n\n      let mediaConstraints: MediaStreamConstraints = {\n        audio: {\n          deviceId: { exact: audioPreference },\n          echoCancellation: false,\n          noiseSuppression: false,\n          autoGainControl: false,\n        },\n        video: false,\n      };\n\n      // Get user media with the defined audio constraints\n      await navigator.mediaDevices\n        .getUserMedia(mediaConstraints)\n        .then(async (stream: MediaStream) => {\n          await streamSuccessAudioSwitch({ stream, parameters });\n        })\n        .catch(() => {\n          // Handle errors and revert to the previous audio input device\n          userDefaultAudioInputDevice = prevAudioInputDevice;\n          updateUserDefaultAudioInputDevice(userDefaultAudioInputDevice);\n\n          showAlert?.({\n            message: 'Error switching; the specified microphone could not be accessed.',\n            type: 'danger',\n            duration: 3000,\n          });\n        });\n    } catch (error) {\n      // Handle unexpected errors and revert to the previous audio input device\n      userDefaultAudioInputDevice = prevAudioInputDevice;\n      updateUserDefaultAudioInputDevice(userDefaultAudioInputDevice);\n\n      showAlert?.({\n        message: 'Error switching; the specified microphone could not be accessed.',\n        type: 'danger',\n        duration: 3000,\n      });\n    }\n  }\n}\n"]}