mediasfu-shared 1.0.0

package/src/consumers/checkGrid.ts

@@ -0,0 +1,100 @@
+export interface CheckGridOptions {
+  rows: number;
+  cols: number;
+  actives: number;
+}
+
+export type CheckGridType = (options: CheckGridOptions) => Promise<[boolean, number, number, number, number, number, number] | void>;
+
+/**
+ * Checks the grid configuration and calculates various parameters based on the number of rows, columns, and active elements.
+ *
+ * @param {CheckGridOptions} options - The options for checking the grid.
+ * @param {number} options.rows - The number of rows in the grid.
+ * @param {number} options.cols - The number of columns in the grid.
+ * @param {number} options.actives - The number of active elements in the grid.
+ * @returns {Promise<[boolean, number, number, number, number, number, number] | void>} A promise that resolves to a tuple containing:
+ * - `removeAltGrid` (boolean): Indicates whether to remove the alternate grid.
+ * - `numtoadd` (number): The number of elements to add.
+ * - `numRows` (number): The number of rows.
+ * - `numCols` (number): The number of columns.
+ * - `remainingVideos` (number): The number of remaining videos.
+ * - `actualRows` (number): The actual number of rows.
+ * - `lastrowcols` (number): The number of columns in the last row.
+ * 
+ * If an error occurs, it logs the error to the console.
+ *
+ * @example
+ * const options = {
+ *   rows: 3,
+ *   cols: 4,
+ *   actives: 10,
+ * };
+ * 
+ * checkGrid(options)
+ *   .then(result => {
+ *     console.log('Grid check result:', result);
+ *     // Example output: [true, 2, 3, 4, 2, 3, 4]
+ *   })
+ *   .catch(error => {
+ *     console.error('Error checking grid:', error);
+ *   });
+ */
+
+export async function checkGrid({ rows, cols, actives }: CheckGridOptions): Promise<[boolean, number, number, number, number, number, number] | void> {
+  try {
+    let numRows = 0;
+    let numCols = 0;
+    let lastrow = 0;
+    let lastrowcols = 0;
+    let remainingVideos = 0;
+    let numtoadd = 0;
+    let actualRows = 0;
+    let removeAltGrid = false;
+
+    if (rows * cols !== actives) {
+      if (rows * cols > actives) {
+        const res = actives - (rows - 1) * cols;
+        if (cols * 0.5 < res) {
+          lastrow = rows;
+          lastrowcols = res;
+          remainingVideos = lastrowcols;
+        } else {
+          lastrowcols = res + cols;
+          lastrow = rows - 1;
+          remainingVideos = lastrowcols;
+        }
+
+        numRows = lastrow - 1;
+        numCols = cols;
+        numtoadd = (lastrow - 1) * numCols;
+        actualRows = lastrow;
+
+        removeAltGrid = false;
+      }
+    } else {
+      // Perfect fit
+      numCols = cols;
+      numRows = rows;
+      lastrow = rows;
+      lastrowcols = cols;
+      remainingVideos = 0;
+      numtoadd = lastrow * numCols;
+      actualRows = lastrow;
+      removeAltGrid = true;
+    }
+
+    return [
+      removeAltGrid,
+      numtoadd,
+      numRows,
+      numCols,
+      remainingVideos,
+      actualRows,
+      lastrowcols,
+    ];
+  } catch (error) {
+    console.log("checkGrid error", error);
+    // throw error;
+  }
+}

package/src/consumers/checkPermission.ts

@@ -0,0 +1,89 @@
+export interface CheckPermissionOptions {
+  audioSetting: string;
+  videoSetting: string;
+  screenshareSetting: string;
+  chatSetting: string;
+  permissionType: 'audioSetting' | 'videoSetting' | 'screenshareSetting' | 'chatSetting';
+}
+
+// Export the type definition for the function
+export type CheckPermissionType = (options: CheckPermissionOptions) => Promise<number>;
+
+/**
+ * Checks the permission based on the provided settings.
+ *
+ * @param {CheckPermissionOptions} options - The options for checking permissions.
+ * @param {string} options.permissionType - The type of permission to check. Can be "audioSetting", "videoSetting", "screenshareSetting", or "chatSetting".
+ * @param {string} options.audioSetting - The setting for audio permission. Can be "allow", "approval", or other.
+ * @param {string} options.videoSetting - The setting for video permission. Can be "allow", "approval", or other.
+ * @param {string} options.screenshareSetting - The setting for screenshare permission. Can be "allow", "approval", or other.
+ * @param {string} options.chatSetting - The setting for chat permission. Can be "allow", "approval", or other.
+ * @returns {Promise<number>} - Returns 0 if the setting is "allow", 1 if the setting is "approval", and 2 for other settings or invalid permission types.
+ * @throws Will throw an error if an unexpected error occurs during the permission check.
+ *
+ * @example
+ * const options = {
+ *   permissionType: 'audioSetting',
+ *   audioSetting: 'allow',
+ *   videoSetting: 'approval',
+ *   screenshareSetting: 'approval',
+ *   chatSetting: 'allow',
+ * };
+ * 
+ * checkPermission(options)
+ *   .then(result => {
+ *     console.log('Permission result:', result);
+ *   })
+ *   .catch(error => {
+ *     console.error('Error checking permission:', error);
+ *   });
+ */
+
+export async function checkPermission({ permissionType, audioSetting, videoSetting, screenshareSetting, chatSetting }: CheckPermissionOptions) {
+  try {
+
+    // PermissionType is audioSetting, videoSetting, screenshareSetting, chatSetting
+    // Perform a switch case to check for the permissionType and return the response
+    switch (permissionType) {
+      case "audioSetting":
+        if (audioSetting === "allow") {
+          return 0;
+        } else if (audioSetting === "approval") {
+          return 1;
+        } else {
+          return 2;
+        }
+      case "videoSetting":
+        if (videoSetting === "allow") {
+          return 0;
+        } else if (videoSetting === "approval") {
+          return 1;
+        } else {
+          return 2;
+        }
+      case "screenshareSetting":
+        if (screenshareSetting === "allow") {
+          return 0;
+        } else if (screenshareSetting === "approval") {
+          return 1;
+        } else {
+          return 2;
+        }
+      case "chatSetting":
+        if (chatSetting === "allow") {
+          return 0;
+        } else if (chatSetting === "approval") {
+          return 1;
+        } else {
+          return 2;
+        }
+      default:
+        // throw new Error(`Invalid permissionType: ${permissionType}`);
+        return 2;
+    }
+  } catch {
+    // console.log('checkPermission error', error);
+    // throw error;
+    return 2;
+  }
+}

package/src/consumers/checkScreenShare.ts

@@ -0,0 +1,114 @@
+import { StopShareScreenType, StopShareScreenParameters, RequestScreenShareType, RequestScreenShareParameters, ShowAlert } from "../types/types";
+export interface CheckScreenShareParameters extends StopShareScreenParameters, RequestScreenShareParameters {
+  shared: boolean;
+  whiteboardStarted: boolean;
+  whiteboardEnded: boolean;
+  breakOutRoomStarted: boolean;
+  breakOutRoomEnded: boolean;
+  showAlert?: ShowAlert;
+
+  // Mediasfu functions
+  stopShareScreen: StopShareScreenType;
+  requestScreenShare: RequestScreenShareType;
+  
+  getUpdatedAllParams : () => CheckScreenShareParameters;
+  [key: string]: any;
+}
+
+export interface CheckScreenShareOptions {
+  parameters: CheckScreenShareParameters;
+}
+
+// Export the type definition for the function
+export type CheckScreenShareType = (options: CheckScreenShareOptions) => Promise<void>;
+
+/**
+ * Checks the current screen sharing status and either stops or requests screen sharing based on the provided parameters.
+ * 
+ * @param {CheckScreenShareOptions} options - The options for checking screen share.
+ * @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 alerts.
+ * @param {boolean} options.parameters.whiteboardStarted - Indicates if the whiteboard session has started.
+ * @param {boolean} options.parameters.whiteboardEnded - Indicates if the whiteboard session has ended.
+ * @param {boolean} options.parameters.breakOutRoomStarted - Indicates if the breakout room session has started.
+ * @param {boolean} options.parameters.breakOutRoomEnded - Indicates if the breakout room session has ended.
+ * @param {Function} options.parameters.stopShareScreen - Function to stop screen sharing.
+ * @param {Function} options.parameters.requestScreenShare - Function to request screen sharing.
+ * 
+ * @returns {Promise<void>} A promise that resolves when the screen sharing status has been checked and the appropriate action has been taken.
+ * 
+ * @throws Will log an error message if an error occurs during the process.
+ * 
+ * @example
+ * const options = {
+ *   parameters: {
+ *     shared: false,
+ *     showAlert: showAlertFunction,
+ *     whiteboardStarted: false,
+ *     whiteboardEnded: false,
+ *     breakOutRoomStarted: false,
+ *     breakOutRoomEnded: false,
+ *     stopShareScreen: stopShareScreenFunction,
+ *     requestScreenShare: requestScreenShareFunction,
+ *   },
+ * };
+ * 
+ * checkScreenShare(options)
+ *   .then(() => {
+ *     console.log('Screen share checked successfully');
+ *   })
+ *   .catch((error) => {
+ *     console.error('Error checking screen share:', error);
+ *   });
+ */
+
+export async function checkScreenShare({ parameters }: CheckScreenShareOptions): Promise<void> {
+  try {
+    const {
+      shared,
+      showAlert,
+      whiteboardStarted,
+      whiteboardEnded,
+      breakOutRoomStarted,
+      breakOutRoomEnded,
+
+      //mediasfu functions
+      stopShareScreen,
+      requestScreenShare,
+    } = parameters;
+
+    // Stop screen share if already shared or request screen share if not shared
+    if (shared) {
+      if (whiteboardStarted && !whiteboardEnded) {
+        showAlert?.({
+          message: "Screen share is not allowed when whiteboard is active",
+          type: "danger",
+        });
+        return;
+      }
+      await stopShareScreen({ parameters });
+    } else {
+      // Can't share if breakout room is active
+      if (breakOutRoomStarted && !breakOutRoomEnded) {
+        showAlert?.({
+          message: "Screen share is not allowed when breakout room is active",
+          type: "danger",
+        });
+        return;
+      }
+
+      if (whiteboardStarted && !whiteboardEnded) {
+        showAlert?.({
+          message: "Screen share is not allowed when whiteboard is active",
+          type: "danger",
+        });
+        return;
+      }
+      await requestScreenShare({ parameters });
+    }
+  } catch (error) {
+    console.log("checkScreenShare error", error);
+    // throw error;
+  }
+}

package/src/consumers/closeAndResize.ts

@@ -0,0 +1,401 @@
+import {
+  Stream, Participant, ReorderStreamsType, ReorderStreamsParameters, PrepopulateUserMediaParameters,
+  PrepopulateUserMediaType, GetVideosType, RePortType, RePortParameters, EventType
+} from '../types/types';
+
+
+ 
+
+export interface CloseAndResizeParameters extends ReorderStreamsParameters, PrepopulateUserMediaParameters, RePortParameters {
+  allAudioStreams: (Stream | Participant)[];
+  allVideoStreams: (Stream | Participant)[];
+  activeNames: string[];
+  participants: Participant[];
+  streamNames: Stream[];
+  recordingDisplayType: "video" | "media" | "all";
+  recordingVideoOptimized: boolean;
+  adminIDStream?: string;
+  newLimitedStreams: (Stream | Participant)[];
+  newLimitedStreamsIDs: string[];
+  oldAllStreams: (Stream | Participant)[];
+  shareScreenStarted: boolean;
+  shared: boolean;
+  meetingDisplayType: string;
+  defer_receive: boolean;
+  lock_screen: boolean;
+  firstAll: boolean;
+  first_round: boolean;
+  gotAllVids: boolean;
+  eventType: EventType;
+  hostLabel: string;
+  shareEnded: boolean;
+  updateMainWindow: boolean;
+  updateActiveNames: (activeNames: string[]) => void;
+  updateAllAudioStreams: (allAudioStreams: (Stream | Participant)[]) => void;
+  updateShareScreenStarted: (shareScreenStarted: boolean) => void;
+  updateUpdateMainWindow: (updateMainWindow: boolean) => void;
+  updateNewLimitedStreams: (newLimitedStreams: (Stream | Participant)[]) => void;
+  updateOldAllStreams: (oldAllStreams: (Stream | Participant)[]) => void;
+  updateDefer_receive: (defer_receive: boolean) => void;
+  updateMainHeightWidth: (heightWidth: number) => void;
+  updateShareEnded: (shareEnded: boolean) => void;
+  updateLock_screen: (lock_screen: boolean) => void;
+  updateFirstAll: (firstAll: boolean) => void;
+  updateFirst_round: (first_round: boolean) => void;
+
+  // mediasfu functions
+  reorderStreams: ReorderStreamsType;
+  prepopulateUserMedia: PrepopulateUserMediaType;
+  getVideos: GetVideosType;
+  rePort: RePortType;
+  getUpdatedAllParams: () => CloseAndResizeParameters;
+  [key: string]: any;
+}
+
+export interface CloseAndResizeOptions {
+  producerId: string;
+  kind: string;
+  parameters: CloseAndResizeParameters;
+}
+
+// Export the type definition for the function
+export type CloseAndResizeType = (options: CloseAndResizeOptions) => Promise<void>;
+
+
+/**
+ * Closes and resizes the video and audio elements based on the provided options.
+ *
+ * @param {CloseAndResizeOptions} options - The options for closing and resizing.
+ * @param {string} options.producerId - The ID of the producer.
+ * @param {string} options.kind - The kind of media (audio, video, screenshare, or screen).
+ * @param {object} options.parameters - The parameters for the operation.
+ * @param {function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+ * @param {Array} options.parameters.allAudioStreams - Array of all audio streams.
+ * @param {Array} options.parameters.allVideoStreams - Array of all video streams.
+ * @param {Array} options.parameters.activeNames - Array of active participant names.
+ * @param {Array} options.parameters.participants - Array of participants.
+ * @param {Array} options.parameters.streamNames - Array of stream names.
+ * @param {string} options.parameters.recordingDisplayType - Type of recording display.
+ * @param {boolean} options.parameters.recordingVideoOptimized - Whether recording is video optimized.
+ * @param {string} options.parameters.adminIDStream - ID of the admin stream.
+ * @param {Array} options.parameters.newLimitedStreams - Array of new limited streams.
+ * @param {Array} options.parameters.newLimitedStreamsIDs - Array of new limited stream IDs.
+ * @param {Array} options.parameters.oldAllStreams - Array of old all streams.
+ * @param {boolean} options.parameters.shareScreenStarted - Whether screen sharing has started.
+ * @param {boolean} options.parameters.shared - Whether sharing is active.
+ * @param {string} options.parameters.meetingDisplayType - Type of meeting display.
+ * @param {boolean} options.parameters.defer_receive - Whether to defer receiving.
+ * @param {boolean} options.parameters.lock_screen - Whether the screen is locked.
+ * @param {boolean} options.parameters.firstAll - Whether it is the first all.
+ * @param {boolean} options.parameters.first_round - Whether it is the first round.
+ * @param {boolean} options.parameters.gotAllVids - Whether all videos are received.
+ * @param {string} options.parameters.eventType - Type of event.
+ * @param {string} options.parameters.hostLabel - Label of the host.
+ * @param {boolean} options.parameters.shareEnded - Whether sharing has ended.
+ * @param {boolean} options.parameters.updateMainWindow - Whether to update the main window.
+ * @param {function} options.parameters.updateActiveNames - Function to update active names.
+ * @param {function} options.parameters.updateAllAudioStreams - Function to update all audio streams.
+ * @param {function} options.parameters.updateAllVideoStreams - Function to update all video streams.
+ * @param {function} options.parameters.updateShareScreenStarted - Function to update share screen started status.
+ * @param {function} options.parameters.updateUpdateMainWindow - Function to update main window status.
+ * @param {function} options.parameters.updateNewLimitedStreams - Function to update new limited streams.
+ * @param {function} options.parameters.updateOldAllStreams - Function to update old all streams.
+ * @param {function} options.parameters.updateDefer_receive - Function to update defer receive status.
+ * @param {function} options.parameters.updateMainHeightWidth - Function to update main height and width.
+ * @param {function} options.parameters.updateShareEnded - Function to update share ended status.
+ * @param {function} options.parameters.updateLock_screen - Function to update lock screen status.
+ * @param {function} options.parameters.updateFirstAll - Function to update first all status.
+ * @param {function} options.parameters.updateFirst_round - Function to update first round status.
+ * @param {function} options.parameters.reorderStreams - Function to reorder streams.
+ * @param {function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.
+ * @param {function} options.parameters.getVideos - Function to get videos.
+ * @param {function} options.parameters.rePort - Function to report.
+ *
+ * @returns {Promise<void>} A promise that resolves when the operation is complete.
+ * 
+ * @example
+ * const options = {
+ *   producerId: 'producerId',
+ *   kind: 'video',
+ *   parameters: {
+ *     getUpdatedAllParams: getUpdatedAllParamsFunction,
+ *     allAudioStreams: [],
+ *     allVideoStreams: [],
+ *     activeNames: [],
+ *     participants: [],
+ *     streamNames: [],
+ *     recordingDisplayType: 'video',
+ *     recordingVideoOptimized: true,
+ *     adminIDStream: 'adminId',
+ *     newLimitedStreams: [],
+ *     newLimitedStreamsIDs: [],
+ *     oldAllStreams: [],
+ *     shareScreenStarted: false,
+ *     shared: false,
+ *     meetingDisplayType: 'video',
+ *     defer_receive: false,
+ *     lock_screen: false,
+ *     firstAll: false,
+ *     first_round: false,
+ *     gotAllVids: false,
+ *     eventType: 'conference',
+ *     hostLabel: 'host',
+ *     shareEnded: false,
+ *     updateMainWindow: true,
+ *     updateActiveNames: updateActiveNamesFunction,
+ *     updateAllAudioStreams: updateAllAudioStreamsFunction,
+ *     updateAllVideoStreams: updateAllVideoStreamsFunction,
+ *     updateShareScreenStarted: updateShareScreenStartedFunction,
+ *     updateUpdateMainWindow: updateUpdateMainWindowFunction,
+ *     updateNewLimitedStreams: updateNewLimitedStreamsFunction,
+ *     updateOldAllStreams: updateOldAllStreamsFunction,
+ *     updateDefer_receive: updateDefer_receiveFunction,
+ *     updateMainHeightWidth: updateMainHeightWidthFunction,
+ *     updateShareEnded: updateShareEndedFunction,
+ *     updateLock_screen: updateLock_screenFunction,
+ *     updateFirstAll: updateFirstAllFunction,
+ *     updateFirst_round: updateFirst_roundFunction,
+ *     reorderStreams: reorderStreamsFunction,
+ *     prepopulateUserMedia: prepopulateUserMediaFunction,
+ *     getVideos: getVideosFunction,
+ *     rePort: rePortFunction,
+ *   },
+ * };
+ * 
+ * closeAndResize(options)
+ *   .then(() => {
+ *     console.log('Closed and resized successfully');
+ *   });
+ */
+
+
+export const closeAndResize = async ({ producerId, kind, parameters }: CloseAndResizeOptions): Promise<void> => {
+
+  let { getUpdatedAllParams } = parameters;
+  parameters = getUpdatedAllParams();
+
+  let {
+    allAudioStreams,
+    allVideoStreams,
+    activeNames,
+    participants,
+    streamNames,
+    recordingDisplayType,
+    recordingVideoOptimized,
+    adminIDStream,
+    newLimitedStreams,
+    newLimitedStreamsIDs,
+    oldAllStreams,
+    shareScreenStarted,
+    shared,
+    meetingDisplayType,
+    defer_receive,
+    lock_screen,
+    firstAll,
+    first_round,
+    gotAllVids,
+    eventType,
+
+    hostLabel,
+    shareEnded,
+    updateMainWindow,
+    updateActiveNames,
+    updateAllAudioStreams,
+    updateAllVideoStreams,
+
+    updateShareScreenStarted,
+    updateUpdateMainWindow,
+    updateNewLimitedStreams,
+    updateOldAllStreams,
+    updateDefer_receive,
+    updateMainHeightWidth,
+    updateShareEnded,
+    updateLock_screen,
+    updateFirstAll,
+    updateFirst_round,
+
+    //mediasfu functions
+    reorderStreams,
+    prepopulateUserMedia,
+    getVideos,
+    rePort,
+  } = parameters;
+
+  //function to close and resize the video and audio elements
+
+  let participant: Participant | undefined;
+
+  if (kind === "audio") {
+    //stop the audio by removing the miniAudio with id = producerId
+
+    //remove the audio from the allAudioStreams array
+    allAudioStreams = allAudioStreams.filter(function (audioStream) {
+      return audioStream.producerId !== producerId;
+    });
+
+    updateAllAudioStreams(allAudioStreams);
+
+    if (recordingDisplayType == "video" && recordingVideoOptimized == true) {
+      // optimize the video display
+    } else {
+      //get the name of the participant with the producerId
+      participant = participants.find(
+        (obj) => obj.audioID === producerId
+      );
+
+      if (participant) {
+        //check if the participants videoID is not null or ""
+        if (participant.videoID !== null && participant.videoID !== "") {
+          // found a participant with the producerId
+        } else {
+          //remove the participant from the activeNames array
+          activeNames = activeNames.filter(function (name) {
+            return name !== participant!.name;
+          });
+          updateActiveNames(activeNames);
+        }
+      }
+    }
+
+    let checker = false;
+    let alt_checker = false;
+
+    if (meetingDisplayType == "video") {
+      checker =
+        participant![0].videoID != null &&
+        participant![0].videoID != "" &&
+        participant![0].videoID != undefined;
+    } else {
+      checker = true;
+      alt_checker = true;
+    }
+
+    if (checker) {
+      if (shareScreenStarted || shared) {
+        if (!alt_checker) {
+          await reorderStreams({ parameters });
+        }
+      } else {
+        if (alt_checker && meetingDisplayType != "video") {
+          await reorderStreams({ add: false, screenChanged: true, parameters });
+        }
+      }
+    }
+  } else if (kind === "video") {
+    //update the video elements by removing the miniVideo with id = producerId
+    //remove the video from the allVideoStreams array
+
+    //check if producerId == adminidstream
+    if (producerId == adminIDStream) {
+      updateMainWindow = true;
+      updateUpdateMainWindow(updateMainWindow);
+    }
+
+    try {
+      allVideoStreams = allVideoStreams.filter(function (videoStream) {
+        return videoStream.producerId !== producerId;
+      });
+
+      updateAllVideoStreams(allVideoStreams);
+
+      try {
+        //try remove it from oldVideoStreams
+        oldAllStreams = oldAllStreams.filter(function (videoStream) {
+          return videoStream.producerId !== producerId;
+        });
+
+        updateOldAllStreams(oldAllStreams);
+      } catch { // Handle error
+        }
+
+      try {
+        //try remove it from newLimitedStreams
+        newLimitedStreams = newLimitedStreams.filter(function (
+          videoStream
+        ) {
+          return videoStream.producerId !== producerId;
+        });
+
+        updateNewLimitedStreams(newLimitedStreams);
+      } catch  {
+        // Handle error
+       }
+    } catch {
+      try {
+        //try remove it from oldVideoStreams
+        oldAllStreams = oldAllStreams.filter(function (videoStream) {
+          return videoStream.producerId !== producerId;
+        });
+        updateOldAllStreams(oldAllStreams);
+      } catch {
+        // Handle error
+       }
+    }
+
+    try {
+      //remove the participant from activeNames
+      activeNames = activeNames.filter(function (name) {
+        //get the participant with the producerId
+        let participant = streamNames.find(
+          (obj) => obj.producerId === producerId
+        );
+
+        return name !== participant!['name'];
+      });
+
+      updateActiveNames(activeNames);
+    } catch {
+      // Handle error
+    }
+
+    if (lock_screen) {
+      defer_receive = true;
+      // check if the video is the one being displayed (i.e. (newLimitedStreamsIDs))
+      if (newLimitedStreamsIDs.includes(producerId)) {
+        await prepopulateUserMedia({ name: hostLabel, parameters });
+        await reorderStreams({ add: false, screenChanged: true, parameters });
+      }
+    } else {
+      await prepopulateUserMedia({ name: hostLabel, parameters });
+      await reorderStreams({ add: false, screenChanged: true, parameters });
+    }
+  } else if (kind === "screenshare" || kind === "screen") {
+    //update the video elements by removing the mainVideo with id = producerId
+    updateMainWindow = true;
+
+    //screenshare stuff
+    shareScreenStarted = false;
+    shareEnded = true;
+
+    lock_screen = false;
+    firstAll = false;
+    first_round = false;
+
+    updateUpdateMainWindow(updateMainWindow);
+    updateShareScreenStarted(shareScreenStarted);
+    updateShareEnded(shareEnded);
+    updateLock_screen(lock_screen);
+    updateFirstAll(firstAll);
+    updateFirst_round(first_round);
+
+    if (!gotAllVids || defer_receive) {
+      defer_receive = false;
+      updateDefer_receive(defer_receive);
+      await getVideos({
+        participants,
+        allVideoStreams,
+        oldAllStreams,
+        updateAllVideoStreams,
+        updateOldAllStreams,
+      });
+      await rePort({ parameters });
+    }
+
+    if (eventType == "conference") {
+      updateMainHeightWidth(0);
+    }
+
+    await prepopulateUserMedia({ name: hostLabel, parameters });
+    await reorderStreams({ add: false, screenChanged: true, parameters });
+  }
+}