mediasfu-shared 1.0.1 → 1.0.2

package/src/methods/whiteboard/captureCanvasStream.ts

@@ -0,0 +1,128 @@
+import type { Producer } from 'mediasoup-client/lib/types';
+import type {
+  ConnectSendTransportScreenParameters,
+  ConnectSendTransportScreenType,
+  CreateSendTransportParameters,
+  CreateSendTransportType,
+  DisconnectSendTransportScreenParameters,
+  DisconnectSendTransportScreenType,
+  SleepType,
+} from '../../types/types';
+import type { Socket } from 'socket.io-client';
+
+export interface CaptureCanvasStreamParameters
+  extends CreateSendTransportParameters,
+    DisconnectSendTransportScreenParameters,
+    ConnectSendTransportScreenParameters {
+  canvasWhiteboard: HTMLCanvasElement | null;
+  canvasStream: MediaStream | null;
+  updateCanvasStream: (stream: MediaStream | null) => void;
+  screenProducer: Producer | null;
+  localScreenProducer?: Producer | null;
+  transportCreated: boolean;
+  localTransportCreated?: boolean;
+  localSocket?: Socket;
+  updateScreenProducer: (producer: Producer | null) => void;
+  updateLocalScreenProducer?: (localProducer: Producer | null) => void;
+
+  sleep: SleepType;
+  createSendTransport: CreateSendTransportType;
+  connectSendTransportScreen: ConnectSendTransportScreenType;
+  disconnectSendTransportScreen: DisconnectSendTransportScreenType;
+
+  getUpdatedAllParams: () => CaptureCanvasStreamParameters;
+  [key: string]: any;
+}
+
+export interface CaptureCanvasStreamOptions {
+  parameters: CaptureCanvasStreamParameters;
+  start?: boolean;
+}
+
+export type CaptureCanvasStreamType = (options: CaptureCanvasStreamOptions) => Promise<void>;
+
+/**
+ * Captures or tears down a whiteboard canvas stream used for screen-style sharing.
+ *
+ * When starting, this helper captures the canvas at 30 FPS and ensures the
+ * correct screen transport is created or reconnected. When stopping, it ends all
+ * canvas tracks and disconnects the corresponding transport.
+ *
+ * @param options Function options for starting or stopping the captured canvas stream.
+ * @returns A promise that resolves after the whiteboard stream lifecycle step completes.
+ */
+export const captureCanvasStream = async ({
+  parameters,
+  start = true,
+}: CaptureCanvasStreamOptions): Promise<void> => {
+  try {
+    let {
+      canvasWhiteboard,
+      canvasStream,
+      updateCanvasStream,
+      screenProducer,
+      localScreenProducer,
+      transportCreated,
+      localTransportCreated,
+      updateScreenProducer,
+      updateLocalScreenProducer,
+      localSocket,
+      sleep,
+      createSendTransport,
+      connectSendTransportScreen,
+      disconnectSendTransportScreen,
+    } = parameters;
+
+    if (start && !canvasStream) {
+      const stream = canvasWhiteboard!.captureStream(30);
+      canvasStream = stream;
+      updateCanvasStream(stream);
+
+      if (localSocket && !localSocket.id) {
+        try {
+          if (!localTransportCreated) {
+            await createSendTransport({ option: 'screen', parameters });
+          } else {
+            try {
+              if (localScreenProducer) {
+                localScreenProducer.close();
+                if (updateLocalScreenProducer) {
+                  updateLocalScreenProducer(null);
+                }
+                await sleep({ ms: 500 });
+              }
+            } catch (error) {
+              console.error(error);
+            }
+            await connectSendTransportScreen({ stream, parameters });
+          }
+        } catch {
+        }
+
+        return;
+      }
+
+      if (!transportCreated) {
+        await createSendTransport({ option: 'screen', parameters });
+      } else {
+        try {
+          if (screenProducer) {
+            screenProducer.close();
+            updateScreenProducer(null);
+            await sleep({ ms: 500 });
+          }
+        } catch (error) {
+          console.error(error);
+        }
+        await connectSendTransportScreen({ stream, parameters });
+      }
+    } else if (canvasStream && !start) {
+      canvasStream.getTracks().forEach((track) => track.stop());
+      canvasStream = null;
+      updateCanvasStream(null);
+      disconnectSendTransportScreen({ parameters });
+    }
+  } catch (error) {
+    console.error(error, 'error in captureCanvasStream');
+  }
+};

package/src/producers/producerEmits/joinConRoom.ts

@@ -89,11 +89,11 @@ export async function joinConRoom(
     }
 
     // Validate roomName starts with 's' or 'p'
-    if (!(roomName.startsWith("s") || roomName.startsWith("p"))) {
+    if (!(roomName.startsWith("s") || roomName.startsWith("p") || roomName.startsWith("d"))) {
       const validationError: JoinConRoomResponse = {
         success: false,
         rtpCapabilities: null,
-        reason: "Invalid roomName, must start with s or p",
+        reason: "Invalid roomName, must start with s or p or d",
       };
       reject(validationError);
       return;

package/src/producers/producerEmits/joinLocalRoom.ts

@@ -0,0 +1,240 @@
+import { Socket } from 'socket.io-client';
+import {
+  JoinMediaSFURoomOptions,
+  PreJoinPageParameters,
+  ResponseJoinLocalRoom,
+} from '../../types/shared-base-types';
+import { validateAlphanumeric } from '../../methods/utils/validateAlphanumeric';
+import { joinRoomOnMediaSFU, JoinRoomOnMediaSFUType } from '../../methods/utils/joinRoomOnMediaSFU';
+import { checkLimitsAndMakeRequest } from '../../methods/utils/checkLimitsAndMakeRequest';
+
+export interface JoinLocalRoomOptions {
+  socket: Socket;
+  roomName: string;
+  islevel: string;
+  member: string;
+  sec: string;
+  apiUserName: string;
+  parameters: PreJoinPageParameters;
+  checkConnect?: boolean;
+  joinMediaSFURoom?: JoinRoomOnMediaSFUType;
+  localLink?: string;
+}
+
+export type JoinLocalRoomType = (
+  options: JoinLocalRoomOptions,
+) => Promise<ResponseJoinLocalRoom>;
+
+export interface CheckMediasfuURLOptions {
+  data: ResponseJoinLocalRoom;
+  member: string;
+  roomName: string;
+  islevel: string;
+  socket: Socket;
+  parameters: PreJoinPageParameters;
+  joinMediaSFURoom?: JoinRoomOnMediaSFUType;
+  localLink?: string;
+}
+
+export type CheckMediasfuURLType = (options: CheckMediasfuURLOptions) => Promise<void>;
+
+export async function checkMediasfuURL({
+  data,
+  member,
+  roomName,
+  islevel,
+  socket,
+  parameters,
+  joinMediaSFURoom = joinRoomOnMediaSFU,
+  localLink = '',
+}: CheckMediasfuURLOptions): Promise<void> {
+  if (
+    data.mediasfuURL
+    && data.mediasfuURL !== ''
+    && data.mediasfuURL.length > 10
+  ) {
+    let link;
+    let secretCode;
+
+    try {
+      const splitTexts = ['/meet/', '/chat/', '/broadcast/'];
+      const splitText = splitTexts.find((text) => data.mediasfuURL.includes(text)) || '/meet/';
+
+      const urlParts = data.mediasfuURL.split(splitText);
+      link = urlParts[0];
+      secretCode = urlParts[1].split('/')[1];
+    } catch {
+      link = data.mediasfuURL;
+      return;
+    }
+
+    await checkLimitsAndMakeRequest({
+      apiUserName: roomName,
+      apiToken: secretCode,
+      link,
+      apiKey: '',
+      userName: member,
+      parameters,
+      validate: false,
+    });
+
+    return;
+  }
+
+  if (
+    (!data.mediasfuURL || data.mediasfuURL.length < 10)
+    && islevel !== '2'
+    && data.allowRecord
+    && (data.allowRecord === true || data.allowRecord === 'true')
+    && data.apiKey
+    && data.apiKey.length === 64
+    && data.apiUserName
+    && data.apiUserName.length > 5
+    && (roomName.startsWith('s') || roomName.startsWith('p'))
+  ) {
+    const payload: JoinMediaSFURoomOptions = {
+      action: 'join',
+      meetingID: roomName,
+      userName: member,
+    };
+
+    const response = await joinMediaSFURoom({
+      payload,
+      apiKey: data.apiKey,
+      apiUserName: data.apiUserName,
+      localLink,
+    });
+
+    if (response.success && response.data && 'roomName' in response.data) {
+      try {
+        socket.emit(
+          'updateMediasfuURL',
+          { eventID: roomName, mediasfuURL: response.data.publicURL },
+          async () => {},
+        );
+      } catch {
+        // Do nothing
+      }
+
+      await checkLimitsAndMakeRequest({
+        apiUserName: response.data.roomName,
+        apiToken: response.data.secret,
+        link: response.data.link,
+        userName: member,
+        parameters,
+        validate: false,
+      });
+      parameters.updateApiToken(response.data.secret);
+    }
+  }
+}
+
+export async function joinLocalRoom({
+  socket,
+  roomName,
+  islevel,
+  member,
+  sec,
+  apiUserName,
+  parameters,
+  checkConnect = false,
+  joinMediaSFURoom = joinRoomOnMediaSFU,
+  localLink = '',
+}: JoinLocalRoomOptions): Promise<ResponseJoinLocalRoom> {
+  return new Promise((resolve, reject) => {
+    if (!(sec && roomName && islevel && apiUserName && member)) {
+      const validationError = {
+        success: false,
+        rtpCapabilities: null,
+        reason: 'Missing required parameters',
+      };
+      reject(validationError);
+      return;
+    }
+
+    try {
+      validateAlphanumeric({ str: roomName });
+      validateAlphanumeric({ str: apiUserName });
+      validateAlphanumeric({ str: member });
+    } catch {
+      const validationError = {
+        success: false,
+        rtpCapabilities: null,
+        reason: 'Invalid roomName or apiUserName or member',
+      };
+      reject(validationError);
+      return;
+    }
+
+    if (!(roomName.startsWith('s') || roomName.startsWith('p') || roomName.startsWith('m') || roomName.startsWith('d'))) {
+      const validationError = {
+        success: false,
+        rtpCapabilities: null,
+        reason: 'Invalid roomName, must start with s or p or m or d',
+      };
+      reject(validationError);
+      return;
+    }
+
+    if (
+      !(
+        sec.length === 32
+        && roomName.length >= 8
+        && islevel.length === 1
+        && apiUserName.length >= 6
+        && (islevel === '0' || islevel === '1' || islevel === '2')
+      )
+    ) {
+      const validationError = {
+        success: false,
+        rtpCapabilities: null,
+        reason: 'Invalid roomName or islevel or apiUserName or secret',
+      };
+      reject(validationError);
+      return;
+    }
+
+    socket.emit(
+      'joinRoom',
+      { roomName, islevel, member, sec, apiUserName },
+      async (data: ResponseJoinLocalRoom) => {
+        try {
+          if (data.rtpCapabilities === null) {
+            if (data.isBanned) {
+              throw new Error('User is banned.');
+            }
+            if (data.hostNotJoined) {
+              throw new Error('Host has not joined the room yet.');
+            }
+
+            resolve(data);
+          } else {
+            if (checkConnect) {
+              await checkMediasfuURL({
+                data,
+                member,
+                roomName,
+                islevel,
+                socket,
+                parameters,
+                joinMediaSFURoom,
+                localLink,
+              });
+            } else if (data.mediasfuURL && data.mediasfuURL !== '' && data.mediasfuURL.length > 10) {
+              const splitTexts = ['/meet/', '/chat/', '/broadcast/'];
+              const splitText = splitTexts.find((text) => data.mediasfuURL.includes(text)) || '/meet/';
+              const urlParts = data.mediasfuURL.split(splitText);
+              const secretCode = urlParts[1].split('/')[1];
+              parameters.updateApiToken(secretCode);
+            }
+
+            resolve(data);
+          }
+        } catch (error) {
+          console.log('Error joining room:', error);
+          reject(error);
+        }
+      },
+    );
+  });
+}

package/src/producers/producerEmits/joinRoom.ts

@@ -0,0 +1,129 @@
+import { Socket } from 'socket.io-client';
+import type { RtpCapabilities } from 'mediasoup-client/lib/types';
+import { validateAlphanumeric } from '../../methods/utils/validateAlphanumeric';
+
+export interface JoinRoomOptions {
+  socket: Socket;
+  roomName: string;
+  islevel: string;
+  member: string;
+  sec: string;
+  apiUserName: string;
+}
+
+export interface JoinRoomResponse {
+  success: boolean;
+  rtpCapabilities: RtpCapabilities | null;
+  reason?: string;
+  banned?: boolean;
+  suspended?: boolean;
+  noAdmin?: boolean;
+  [key: string]: any;
+}
+
+export type JoinRoomType = (options: JoinRoomOptions) => Promise<JoinRoomResponse>;
+
+/**
+ * Joins a user to a specified room via a socket connection.
+ *
+ * @param {JoinRoomOptions} options - The options for joining the room.
+ * @param {Socket} options.socket - The socket instance to use for communication.
+ * @param {string} options.roomName - The name of the room to join.
+ * @param {string} options.islevel - The level of the user.
+ * @param {string} options.member - The member identifier.
+ * @param {string} options.sec - The security token.
+ * @param {string} options.apiUserName - The API username of the user.
+ *
+ * @returns {Promise<JoinRoomResponse>} A promise that resolves with the data received from the 'joinRoom' event or rejects with a validation error.
+ */
+export async function joinRoom({
+  socket,
+  roomName,
+  islevel,
+  member,
+  sec,
+  apiUserName,
+}: JoinRoomOptions): Promise<JoinRoomResponse> {
+  return new Promise((resolve, reject) => {
+    if (!(sec && roomName && islevel && apiUserName && member)) {
+      const validationError: JoinRoomResponse = {
+        success: false,
+        rtpCapabilities: null,
+        reason: 'Missing required parameters',
+      };
+      reject(validationError);
+      return;
+    }
+
+    try {
+      validateAlphanumeric({ str: roomName });
+      validateAlphanumeric({ str: apiUserName });
+      validateAlphanumeric({ str: member });
+    } catch {
+      const validationError: JoinRoomResponse = {
+        success: false,
+        rtpCapabilities: null,
+        reason: 'Invalid roomName or apiUserName or member',
+      };
+      reject(validationError);
+      return;
+    }
+
+    if (!(roomName.startsWith('s') || roomName.startsWith('p') || roomName.startsWith('d'))) {
+      const validationError: JoinRoomResponse = {
+        success: false,
+        rtpCapabilities: null,
+        reason: 'Invalid roomName, must start with s or p or d',
+      };
+      reject(validationError);
+      return;
+    }
+
+    if (
+      !(
+        sec.length === 64
+        && roomName.length >= 8
+        && islevel.length === 1
+        && apiUserName.length >= 6
+        && (islevel === '0' || islevel === '1' || islevel === '2')
+      )
+    ) {
+      const validationError: JoinRoomResponse = {
+        success: false,
+        rtpCapabilities: null,
+        reason: 'Invalid roomName or islevel or apiUserName or secret',
+      };
+      reject(validationError);
+      return;
+    }
+
+    socket.emit(
+      'joinRoom',
+      {
+        roomName, islevel, member, sec, apiUserName,
+      },
+      async (data: JoinRoomResponse) => {
+        try {
+          if (data.rtpCapabilities == null) {
+            if (data.banned) {
+              throw new Error('User is banned.');
+            }
+            if (data.suspended) {
+              throw new Error('User is suspended.');
+            }
+            if (data.noAdmin) {
+              throw new Error('Host has not joined the room yet.');
+            }
+
+            resolve(data);
+          } else {
+            resolve(data);
+          }
+        } catch (error) {
+          console.log('Error joining room:', error);
+          reject(error);
+        }
+      },
+    );
+  });
+}

package/src/types/shared-base-types.ts

@@ -81,7 +81,7 @@ export interface AudioDecibels {
   averageLoudness: number;
 }
 
-export type ShowAlert = (options: { message: string; type: 'success' | 'danger'; duration?: number }) => void;
+export type ShowAlert = (options: { message: string; type: 'success' | 'danger' | 'info'; duration?: number }) => void;
 
 export interface CoHostResponsibility {
   name: string;
@@ -679,6 +679,12 @@ export interface CreateJoinRoomResult {
   success: boolean;
 }
 
+export interface PendingRequestStorage {
+  getItem: (key: string) => Promise<string | null>;
+  setItem: (key: string, value: string) => Promise<void>;
+  removeItem: (key: string) => Promise<void>;
+}
+
 export type CreateJoinRoomType = (options: {
   payload: CreateMediaSFURoomOptions | JoinMediaSFURoomOptions;
   apiUserName: string;
@@ -686,12 +692,17 @@ export type CreateJoinRoomType = (options: {
   localLink?: string;
 }) => Promise<CreateJoinRoomResult>;
 
-export type CreateRoomOnMediaSFUType = (options: {
+export interface CreateRoomOnMediaSFUOptions {
   payload: CreateMediaSFURoomOptions;
   apiUserName: string;
   apiKey: string;
   localLink?: string;
-}) => Promise<CreateJoinRoomResult>;
+  pendingRequestStorage?: PendingRequestStorage;
+}
+
+export type CreateRoomOnMediaSFUType = (
+  options: CreateRoomOnMediaSFUOptions,
+) => Promise<CreateJoinRoomResult>;
 
 export type JoinRoomOnMediaSFUType = (options: {
   payload: JoinMediaSFURoomOptions;