mediasfu-shared 1.0.1 → 1.0.2

package/src/consumers/readjust.ts

@@ -1,6 +1,11 @@
 
  
-import { PrepopulateUserMediaType, PrepopulateUserMediaParameters, EventType } from '../types/types';
+import { PrepopulateUserMediaParameters, PrepopulateUserMediaOptions, EventType } from '../types/types';
+
+type PrepopulateUserMediaInvoker = {
+  bivarianceHack: (options: PrepopulateUserMediaOptions) => Promise<unknown>;
+}['bivarianceHack'];
+
 export interface ReadjustParameters extends PrepopulateUserMediaParameters {
   eventType: EventType;
   shareScreenStarted: boolean;
@@ -13,19 +18,21 @@ export interface ReadjustParameters extends PrepopulateUserMediaParameters {
   updateMainHeightWidth: (value: number) => void;
 
   // mediasfu functions
-  prepopulateUserMedia: PrepopulateUserMediaType;
+  prepopulateUserMedia: PrepopulateUserMediaInvoker;
   getUpdatedAllParams: () => ReadjustParameters;
   [key: string]: any;
 }
 
-export interface ReadjustOptions {
+export interface ReadjustOptions<TParameters extends ReadjustParameters = ReadjustParameters> {
   n: number;
   state: number;
-  parameters: ReadjustParameters;
+  parameters: TParameters;
 }
 
 // Export the type definition for the function
-export type ReadjustType = (options: ReadjustOptions) => Promise<void>;
+export type ReadjustType = <TParameters extends ReadjustParameters = ReadjustParameters>(
+  options: ReadjustOptions<TParameters>
+) => Promise<void>;
 
 /**
  * Adjusts the layout parameters based on the provided options.
@@ -69,9 +76,13 @@ export type ReadjustType = (options: ReadjustOptions) => Promise<void>;
  * ```
  */
 
-export async function readjust({ n, state, parameters }: ReadjustOptions): Promise<void> {
-  let { getUpdatedAllParams } = parameters;
-  parameters = getUpdatedAllParams();
+export async function readjust<TParameters extends ReadjustParameters = ReadjustParameters>({
+  n,
+  state,
+  parameters,
+}: ReadjustOptions<TParameters>): Promise<void> {
+  const { getUpdatedAllParams } = parameters;
+  const updatedParameters = getUpdatedAllParams() as TParameters;
 
   try {
     // Destructure parameters
@@ -79,6 +90,8 @@ export async function readjust({ n, state, parameters }: ReadjustOptions): Promi
       eventType,
       shareScreenStarted,
       shared,
+      whiteboardStarted,
+      whiteboardEnded,
       mainHeightWidth,
       prevMainHeightWidth,
       hostLabel,
@@ -86,7 +99,8 @@ export async function readjust({ n, state, parameters }: ReadjustOptions): Promi
       lock_screen,
       updateMainHeightWidth,
       prepopulateUserMedia,
-    } = parameters;
+    } = updatedParameters;
+    const screenFlowActive = shareScreenStarted || shared || (whiteboardStarted && !whiteboardEnded);
 
     if (state === 0) {
       prevMainHeightWidth = mainHeightWidth;
@@ -107,12 +121,12 @@ export async function readjust({ n, state, parameters }: ReadjustOptions): Promi
       }
     } else if (
       eventType === "chat" ||
-      (eventType === "conference" && !(shareScreenStarted || shared))
+      (eventType === "conference" && !screenFlowActive)
     ) {
       val1 = 12;
       val2 = 12 - val1;
     } else {
-      if (shareScreenStarted || shared) {
+      if (screenFlowActive) {
         val2 = 10;
         val1 = 12 - val2;
       } else {
@@ -151,13 +165,15 @@ export async function readjust({ n, state, parameters }: ReadjustOptions): Promi
     cal1 = Math.floor((val1 / 12) * 100);
     cal2 = 100 - cal1;
 
-    updateMainHeightWidth(cal2);
+    if (mainHeightWidth !== cal2) {
+      updateMainHeightWidth(cal2);
+    }
 
     if (prevMainHeightWidth !== mainHeightWidth) {
       if (!lock_screen && !shared) {
-        await prepopulateUserMedia({ name: hostLabel, parameters });
+        await prepopulateUserMedia({ name: hostLabel, parameters: updatedParameters });
       } else if (!first_round) {
-        await prepopulateUserMedia({ name: hostLabel, parameters });
+        await prepopulateUserMedia({ name: hostLabel, parameters: updatedParameters });
       }
     }
   } catch (error) {

package/src/consumers/reorderStreams.ts

@@ -1,42 +1,74 @@
  
-import { Participant, Stream, ChangeVidsParameters, ChangeVidsType } from "../types/types";
+import { Participant, Stream } from "../types/types";
 
-export interface ReorderStreamsParameters extends ChangeVidsParameters {
-  allVideoStreams: (Stream | Participant)[];
-  participants: Participant[];
-  oldAllStreams: (Stream | Participant)[];
+interface ReorderStreamLike {
+  producerId?: string | null;
+}
+
+interface ReorderParticipantLike {
+  name: string;
+  islevel?: string | null;
+  videoID?: string | null;
+  ScreenID?: string | null;
+}
+
+type ChangeVidsInvoker = (options: {
+  screenChanged?: boolean;
+  parameters: any;
+}) => Promise<void>;
+
+type StreamCollectionUpdater<TEntry> = {
+  bivarianceHack: (streams: TEntry[]) => void;
+}["bivarianceHack"];
+
+const getProducerId = (value: unknown): string | null | undefined => {
+  return (value as ReorderStreamLike | null | undefined)?.producerId;
+};
+
+export interface ReorderStreamsParameters<
+  TStream extends ReorderStreamLike = Stream,
+  TParticipant extends ReorderParticipantLike = Participant,
+  TChangeVidsParameters = unknown,
+> {
+  allVideoStreams: (TStream | TParticipant)[];
+  participants: TParticipant[];
+  oldAllStreams: (TStream | TParticipant)[];
   screenId?: string;
   adminVidID?: string;
-  newLimitedStreams: (Stream | Participant)[];
+  newLimitedStreams: (TStream | TParticipant)[];
   newLimitedStreamsIDs: string[];
   activeSounds: string[];
   screenShareIDStream?: string;
   screenShareNameStream?: string;
   adminIDStream?: string;
   adminNameStream?: string;
-  updateNewLimitedStreams: (streams: (Stream | Participant)[]) => void;
+  updateNewLimitedStreams: StreamCollectionUpdater<TStream | TParticipant>;
   updateNewLimitedStreamsIDs: (ids: string[]) => void;
   updateActiveSounds: (sounds: string[]) => void;
   updateScreenShareIDStream: (id: string) => void;
   updateScreenShareNameStream: (name: string) => void;
   updateAdminIDStream: (id: string) => void;
   updateAdminNameStream: (name: string) => void;
-  updateYouYouStream: (streams: (Stream | Participant)[]) => void;
+  updateYouYouStream: StreamCollectionUpdater<TStream | TParticipant>;
 
   // mediasfu functions
-  changeVids: ChangeVidsType;
-  getUpdatedAllParams: () => ReorderStreamsParameters;
+  changeVids: ChangeVidsInvoker;
+  getUpdatedAllParams: () => ReorderStreamsParameters<TStream, TParticipant, TChangeVidsParameters>;
   [key: string]: any;
 }
 
-export interface ReorderStreamsOptions {
+export interface ReorderStreamsOptions<
+  TParameters extends ReorderStreamsParameters<any, any, any> = ReorderStreamsParameters,
+> {
   add?: boolean;
   screenChanged?: boolean;
-  parameters: ReorderStreamsParameters;
+  parameters: TParameters;
 }
 
 
-export type ReorderStreamsType = (options: ReorderStreamsOptions) => Promise<void>;
+export type ReorderStreamsType = <
+  TParameters extends ReorderStreamsParameters<any, any, any> = ReorderStreamsParameters,
+>(options: ReorderStreamsOptions<TParameters>) => Promise<void>;
 
 /**
  * Reorders the video streams based on the provided options and updates the UI accordingly.
@@ -86,13 +118,15 @@ export type ReorderStreamsType = (options: ReorderStreamsOptions) => Promise<voi
  * ```
  */
 
-export const reorderStreams = async ({
+export const reorderStreams = async <
+  TParameters extends ReorderStreamsParameters<any, any, any> = ReorderStreamsParameters,
+>({
   add = false,
   screenChanged = false,
   parameters,
-}: ReorderStreamsOptions): Promise<void> => {
+}: ReorderStreamsOptions<TParameters>): Promise<void> => {
   const { getUpdatedAllParams } = parameters;
-  parameters = getUpdatedAllParams();
+  const updatedParameters = getUpdatedAllParams() as TParameters;
 
   let {
     allVideoStreams,
@@ -118,7 +152,7 @@ export const reorderStreams = async ({
 
     //mediasfu functions
     changeVids,
-  } = parameters;
+  } = updatedParameters;
 
   // function to reorder streams on the ui
   if (!add) {
@@ -127,27 +161,27 @@ export const reorderStreams = async ({
     activeSounds = [];
   }
 
-  const youyou = allVideoStreams.filter((stream) => stream.producerId === "youyou");
+  const youyou = allVideoStreams.filter((stream) => getProducerId(stream) === "youyou");
   const admin = participants.filter((participant) => participant.islevel === "2");
 
   if (admin.length > 0) {
-    adminVidID = admin[0].videoID;
+    adminVidID = admin[0].videoID ?? undefined;
   } else {
     adminVidID = "";
   }
 
   if (adminVidID) {
-    const adminStream = allVideoStreams.find((stream) => stream.producerId === adminVidID);
+    const adminStream = allVideoStreams.find((stream) => getProducerId(stream) === adminVidID);
 
     if (!add) {
       newLimitedStreams = [...newLimitedStreams, ...youyou];
-      newLimitedStreamsIDs = [...newLimitedStreamsIDs, ...youyou.map((stream) => stream.producerId)];
+      newLimitedStreamsIDs = [...newLimitedStreamsIDs, ...youyou.map((stream) => getProducerId(stream) ?? "")];
     } else {
-      const youyouStream = newLimitedStreams.find((stream) => stream.producerId === "youyou");
+      const youyouStream = newLimitedStreams.find((stream) => getProducerId(stream) === "youyou");
 
       if (!youyouStream) {
         newLimitedStreams = [...newLimitedStreams, ...youyou];
-        newLimitedStreamsIDs = [...newLimitedStreamsIDs, ...youyou.map((stream) => stream.producerId)];
+        newLimitedStreamsIDs = [...newLimitedStreamsIDs, ...youyou.map((stream) => getProducerId(stream) ?? "")];
       }
     }
 
@@ -156,17 +190,17 @@ export const reorderStreams = async ({
 
       if (!add) {
         newLimitedStreams = [...newLimitedStreams, adminStream];
-        newLimitedStreamsIDs = [...newLimitedStreamsIDs, adminStream.producerId];
+        newLimitedStreamsIDs = [...newLimitedStreamsIDs, getProducerId(adminStream) ?? ""];
       } else {
-        const adminStreamer = newLimitedStreams.find((stream) => stream.producerId === adminVidID);
+        const adminStreamer = newLimitedStreams.find((stream) => getProducerId(stream) === adminVidID);
 
         if (!adminStreamer) {
           newLimitedStreams = [...newLimitedStreams, adminStream];
-          newLimitedStreamsIDs = [...newLimitedStreamsIDs, adminStream.producerId];
+          newLimitedStreamsIDs = [...newLimitedStreamsIDs, getProducerId(adminStream) ?? ""];
         }
       }
     } else {
-      const oldAdminStream = oldAllStreams.find((stream) => stream.producerId === adminVidID);
+      const oldAdminStream = oldAllStreams.find((stream) => getProducerId(stream) === adminVidID);
 
       if (oldAdminStream) {
         //add it to the allVideoStream
@@ -176,13 +210,13 @@ export const reorderStreams = async ({
 
         if (!add) {
           newLimitedStreams = [...newLimitedStreams, oldAdminStream];
-          newLimitedStreamsIDs = [...newLimitedStreamsIDs, oldAdminStream.producerId];
+          newLimitedStreamsIDs = [...newLimitedStreamsIDs, getProducerId(oldAdminStream) ?? ""];
         } else {
-          const adminStreamer = newLimitedStreams.find((stream) => stream.producerId === adminVidID);
+          const adminStreamer = newLimitedStreams.find((stream) => getProducerId(stream) === adminVidID);
 
           if (!adminStreamer) {
             newLimitedStreams = [...newLimitedStreams, oldAdminStream];
-            newLimitedStreamsIDs = [...newLimitedStreamsIDs, oldAdminStream.producerId];
+            newLimitedStreamsIDs = [...newLimitedStreamsIDs, getProducerId(oldAdminStream) ?? ""];
           }
         }
       }
@@ -191,42 +225,42 @@ export const reorderStreams = async ({
     const screenParticipant = participants.filter((participant) => participant.ScreenID === screenId);
 
     if (screenParticipant.length > 0) {
-      const screenParticipantVidID = screenParticipant[0].videoID;
-      const screenParticipantVidID_ = newLimitedStreams.filter((stream) => stream.producerId === screenParticipantVidID);
+      const screenParticipantVidID = screenParticipant[0].videoID ?? undefined;
+      const screenParticipantVidID_ = newLimitedStreams.filter((stream) => getProducerId(stream) === screenParticipantVidID);
 
       if (screenParticipantVidID_?.length < 1 && screenParticipantVidID) {
         screenShareIDStream = screenParticipantVidID;
         screenShareNameStream = screenParticipant[0].name;
-        const screenParticipantVidID__ = allVideoStreams.filter((stream) => stream.producerId === screenParticipantVidID);
+        const screenParticipantVidID__ = allVideoStreams.filter((stream) => getProducerId(stream) === screenParticipantVidID);
         newLimitedStreams = [...newLimitedStreams, ...screenParticipantVidID__];
-        newLimitedStreamsIDs = [...newLimitedStreamsIDs, ...screenParticipantVidID__.map((stream) => stream.producerId)];
+        newLimitedStreamsIDs = [...newLimitedStreamsIDs, ...screenParticipantVidID__.map((stream) => getProducerId(stream) ?? "")];
       }
     }
   } else {
     if (!add) {
       newLimitedStreams = [...newLimitedStreams, ...youyou];
-      newLimitedStreamsIDs = [...newLimitedStreamsIDs, ...youyou.map((stream) => stream.producerId)];
+      newLimitedStreamsIDs = [...newLimitedStreamsIDs, ...youyou.map((stream) => getProducerId(stream) ?? "")];
     } else {
-      const youyouStream = newLimitedStreams.find((stream) => stream.producerId === "youyou");
+      const youyouStream = newLimitedStreams.find((stream) => getProducerId(stream) === "youyou");
 
       if (!youyouStream) {
         newLimitedStreams = [...newLimitedStreams, ...youyou];
-        newLimitedStreamsIDs = [...newLimitedStreamsIDs, ...youyou.map((stream) => stream.producerId)];
+        newLimitedStreamsIDs = [...newLimitedStreamsIDs, ...youyou.map((stream) => getProducerId(stream) ?? "")];
       }
     }
 
     const screenParticipant = participants.filter((participant) => participant.ScreenID === screenId);
 
     if (screenParticipant.length > 0) {
-      const screenParticipantVidID = screenParticipant[0].videoID;
-      const screenParticipantVidID_ = newLimitedStreams.filter((stream) => stream.producerId === screenParticipantVidID);
+      const screenParticipantVidID = screenParticipant[0].videoID ?? undefined;
+      const screenParticipantVidID_ = newLimitedStreams.filter((stream) => getProducerId(stream) === screenParticipantVidID);
 
       if (screenParticipantVidID_?.length < 1 && screenParticipantVidID) {
         screenShareIDStream = screenParticipantVidID;
         screenShareNameStream = screenParticipant[0].name;
-        const screenParticipantVidID__ = allVideoStreams.filter((stream) => stream.producerId === screenParticipantVidID);
+        const screenParticipantVidID__ = allVideoStreams.filter((stream) => getProducerId(stream) === screenParticipantVidID);
         newLimitedStreams = [...newLimitedStreams, ...screenParticipantVidID__];
-        newLimitedStreamsIDs = [...newLimitedStreamsIDs, ...screenParticipantVidID__.map((stream) => stream.producerId)];
+        newLimitedStreamsIDs = [...newLimitedStreamsIDs, ...screenParticipantVidID__.map((stream) => getProducerId(stream) ?? "")];
       }
     }
   }
@@ -241,6 +275,6 @@ export const reorderStreams = async ({
   updateYouYouStream(youyou);
 
   //reflect the changes on the ui
-  await changeVids({ screenChanged, parameters });
+  await changeVids({ screenChanged, parameters: updatedParameters });
 };
 

package/src/consumers/resumePauseAudioStreams.ts

@@ -1,28 +1,74 @@
-import { Participant, Stream, ProcessConsumerTransportsAudioType, ProcessConsumerTransportsAudioParameters, Transport, BreakoutParticipant, EventType } from '../types/types';
+import { Participant, Stream, ProcessConsumerTransportsAudioParameters, Transport, EventType } from '../types/types';
 
-export interface ResumePauseAudioStreamsParameters extends ProcessConsumerTransportsAudioParameters {
-  breakoutRooms: BreakoutParticipant[][];
-  ref_participants: Participant[];
-  allAudioStreams: (Stream | Participant)[];
-  participants: Participant[];
+interface BreakoutParticipantLike {
+  name: string;
+  breakRoom?: number | null;
+}
+
+interface ParticipantLike {
+  name: string;
+  islevel?: string | null;
+  audioID?: string | null;
+  producerId?: string | null;
+  breakRoom?: number | null;
+}
+
+interface MediaEntryLike {
+  producerId?: string | null;
+  audioID?: string | null;
+}
+
+interface AudioTransportLike {
+  producerId?: string | null;
+  consumer?: {
+    paused?: boolean;
+    kind?: string;
+    pause: () => unknown;
+    resume: () => unknown;
+  };
+  socket_: {
+    emit: (
+      event: string,
+      payload: { serverConsumerId: string },
+      callback?: ((payload?: { resumed: boolean }) => void | Promise<unknown>)
+    ) => void;
+  };
+  serverConsumerTransportId: string;
+}
+
+export interface ResumePauseAudioStreamsParameters<
+  TTransport extends AudioTransportLike = Transport,
+  TMediaEntry extends MediaEntryLike | ParticipantLike = Stream | Participant,
+> extends ProcessConsumerTransportsAudioParameters {
+  breakoutRooms: BreakoutParticipantLike[][];
+  ref_participants: ParticipantLike[];
+  allAudioStreams: TMediaEntry[];
+  participants: ParticipantLike[];
   islevel: string;
   eventType: EventType;
-  consumerTransports: Transport[];
-  limitedBreakRoom: BreakoutParticipant[];
+  consumerTransports: TTransport[];
+  limitedBreakRoom: BreakoutParticipantLike[];
   hostNewRoom: number;
   member: string;
-  updateLimitedBreakRoom: (limitedBreakRoom: BreakoutParticipant[]) => void;
+  updateLimitedBreakRoom: (limitedBreakRoom: BreakoutParticipantLike[]) => void;
 
   // mediasfu functions
-  processConsumerTransportsAudio: ProcessConsumerTransportsAudioType;
-  getUpdatedAllParams: () => ResumePauseAudioStreamsParameters;
+  processConsumerTransportsAudio: (options: {
+    consumerTransports: TTransport[];
+    lStreams: TMediaEntry[];
+    parameters: ProcessConsumerTransportsAudioParameters;
+  }) => Promise<void>;
+  getUpdatedAllParams: () => ResumePauseAudioStreamsParameters<TTransport, TMediaEntry>;
   [key: string]: any;
 }
 
-export interface ResumePauseAudioStreamsOptions {
+export interface ResumePauseAudioStreamsOptions<
+  TTransport extends AudioTransportLike = Transport,
+  TMediaEntry extends MediaEntryLike | ParticipantLike = Stream | Participant,
+> {
   breakRoom?: number;
   inBreakRoom?: boolean;
-  parameters: ResumePauseAudioStreamsParameters;
+  parameters: ResumePauseAudioStreamsParameters<TTransport, TMediaEntry>;
 }
 
 // Export the type definition for the function
@@ -54,11 +100,14 @@ export type ResumePauseAudioStreamsType = (
  * ```
  */
 
-export const resumePauseAudioStreams = async ({
+export const resumePauseAudioStreams = async <
+  TTransport extends AudioTransportLike = Transport,
+  TMediaEntry extends MediaEntryLike | ParticipantLike = Stream | Participant,
+>({
   breakRoom = -1,
   inBreakRoom = false,
   parameters,
-}: ResumePauseAudioStreamsOptions): Promise<void> => {
+}: ResumePauseAudioStreamsOptions<TTransport, TMediaEntry>): Promise<void> => {
   const { getUpdatedAllParams } = parameters;
   parameters = getUpdatedAllParams();
 
@@ -76,8 +125,8 @@ export const resumePauseAudioStreams = async ({
     processConsumerTransportsAudio,
   } = parameters;
 
-  let room: BreakoutParticipant[] = [];
-  let currentStreams: (Stream | Participant)[] = [];
+  let room: BreakoutParticipantLike[] = [];
+  let currentStreams: TMediaEntry[] = [];
   // Determine the room based on breakout status
   if (inBreakRoom && breakRoom !== -1) {
     room = breakoutRooms[breakRoom];

package/src/consumers/resumePauseStreams.ts

@@ -1,24 +1,62 @@
 import { Participant, Transport, Stream } from "../types/types";
 
-export interface ResumePauseStreamsParameters {
-  participants: Participant[];
+interface ParticipantLike {
+  name: string;
+  islevel?: string | null;
+  videoID?: string | null;
+}
+
+interface ConsumerLike {
+  kind?: string;
+  resume: () => unknown;
+}
+
+interface SocketLike {
+  emit: (
+    event: string,
+    payload: { serverConsumerId: string },
+    callback?: ((payload: { resumed: boolean }) => void | Promise<unknown>)
+  ) => void;
+}
+
+interface TransportLike {
+  producerId?: string | null;
+  consumer: ConsumerLike;
+  socket_: SocketLike;
+  serverConsumerTransportId: string;
+}
+
+export interface ResumePauseStreamsParameters<
+  TParticipant extends ParticipantLike = Participant,
+  TTransport extends TransportLike = Transport,
+  TStream = Stream,
+> {
+  participants: TParticipant[];
   dispActiveNames: string[];
-  remoteScreenStream: Stream[];
-  consumerTransports: Transport[];
+  remoteScreenStream: TStream[];
+  consumerTransports: TTransport[];
   screenId?: string;
   islevel: string;
 
   // mediasfu functions
-  getUpdatedAllParams: () => ResumePauseStreamsParameters;
+  getUpdatedAllParams: () => ResumePauseStreamsParameters<TParticipant, TTransport, TStream>;
   [key: string]: any;
 }
 
-export interface ResumePauseStreamsOptions {
-  parameters: ResumePauseStreamsParameters;
+export interface ResumePauseStreamsOptions<
+  TParticipant extends ParticipantLike = Participant,
+  TTransport extends TransportLike = Transport,
+  TStream = Stream,
+> {
+  parameters: ResumePauseStreamsParameters<TParticipant, TTransport, TStream>;
 }
 
 // Export the type definition for the function
-export type ResumePauseStreamsType = (options: ResumePauseStreamsOptions) => Promise<void>;
+export type ResumePauseStreamsType = <
+  TParticipant extends ParticipantLike = Participant,
+  TTransport extends TransportLike = Transport,
+  TStream = Stream,
+>(options: ResumePauseStreamsOptions<TParticipant, TTransport, TStream>) => Promise<void>;
 
 /**
  * Resumes or pauses streams based on the provided parameters.
@@ -49,9 +87,13 @@ export type ResumePauseStreamsType = (options: ResumePauseStreamsOptions) => Pro
  * ```
  */
 
-export async function resumePauseStreams({
+export async function resumePauseStreams<
+  TParticipant extends ParticipantLike = Participant,
+  TTransport extends TransportLike = Transport,
+  TStream = Stream,
+>({
   parameters,
-}: ResumePauseStreamsOptions): Promise<void> {
+}: ResumePauseStreamsOptions<TParticipant, TTransport, TStream>): Promise<void> {
   try {
     // Destructure parameters
     const { participants, dispActiveNames, consumerTransports, screenId, islevel } = parameters;
@@ -85,6 +127,7 @@ export async function resumePauseStreams({
       // Get consumer transports with producerId in allVideoIDs
       const consumerTransportsToResume = consumerTransports.filter(
         (transport) =>
+          transport.producerId &&
           allVideoIDs.includes(transport.producerId) &&
           transport.consumer.kind !== "audio"
       );

package/src/consumers/socketReceiveMethods/joinConsumeRoom.ts

@@ -120,6 +120,14 @@ export const joinConsumeRoom = async ({
 
       // Receive all piped transports
       await receiveAllPipedTransports({ nsock: remote_sock, parameters });
+
+      setTimeout(async () => {
+        try {
+          await receiveAllPipedTransports({ nsock: remote_sock, parameters });
+        } catch (error) {
+          console.log('[joinConsumeRoom] Retry receiveAllPipedTransports failed:', error);
+        }
+      }, 30000);
     }
 
     return data;