mediasfu-shared 1.0.1 → 1.0.3

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;

package/src/consumers/socketReceiveMethods/newPipeProducer.ts

@@ -2,6 +2,14 @@ import { Socket } from 'socket.io-client';
 import { signalNewConsumerTransport } from '../signalNewConsumerTransport';
 import { ReorderStreamsParameters, ReorderStreamsType, SignalNewConsumerTransportParameters, ConnectRecvTransportParameters, ConnectRecvTransportType, ShowAlert } from '../../types/types';
 import type { Device } from 'mediasoup-client/lib/types';
+
+export interface TranslationMeta {
+  speakerId: string;
+  speakerName: string;
+  language: string;
+  originalProducerId?: string;
+  isSpeakerControlled?: boolean;
+}
 export interface NewPipeProducerParameters extends ReorderStreamsParameters, SignalNewConsumerTransportParameters, ConnectRecvTransportParameters {
 
   first_round: boolean;
@@ -21,6 +29,15 @@ export interface NewPipeProducerParameters extends ReorderStreamsParameters, Sig
   connectRecvTransport: ConnectRecvTransportType;
   reorderStreams: ReorderStreamsType;
   getUpdatedAllParams: () => NewPipeProducerParameters;
+
+  startConsumingTranslation?: (producerId: string, speakerId: string, language: string, originalProducerId?: string, nsock?: Socket) => Promise<void>;
+  translationSubscriptions?: Map<string, { speakerId: string; language: string }>;
+  speakerTranslationStates?: Map<string, { speakerId: string; speakerName: string; inputLanguage: string; outputLanguage: string; originalProducerId: string; enabled: boolean }>;
+  listenerTranslationOverrides?: Map<string, { speakerId: string; wantOriginal: boolean; preferredLanguage?: string }>;
+  listenerTranslationPreferences?: {
+    perSpeaker: Map<string, { speakerId: string; language: string | null; wantOriginal: boolean }>;
+    globalLanguage: string | null;
+  };
   [key: string]: any;
 
 }
@@ -30,6 +47,8 @@ export interface NewPipeProducerOptions {
   islevel: string;
   nsock: Socket;
   parameters: NewPipeProducerParameters;
+  isTranslation?: boolean;
+  translationMeta?: TranslationMeta;
 }
 
 // Export the type definition for the function
@@ -96,7 +115,102 @@ export const newPipeProducer = async ({
   islevel,
   nsock,
   parameters,
+  isTranslation,
+  translationMeta,
 }: NewPipeProducerOptions): Promise<void> => {
+  if (isTranslation && translationMeta) {
+    const freshParams = parameters.getUpdatedAllParams ? parameters.getUpdatedAllParams() : parameters;
+
+    const {
+      startConsumingTranslation,
+      translationSubscriptions,
+      speakerTranslationStates,
+      listenerTranslationOverrides,
+      listenerTranslationPreferences,
+    } = freshParams;
+
+    const normalizedLang = translationMeta.language?.toLowerCase();
+    const isSpeakerControlledFromMeta = translationMeta.isSpeakerControlled === true;
+    const speakerState = speakerTranslationStates?.get(translationMeta.speakerId);
+    const isSpeakerControlledFromState = speakerState?.enabled
+      && speakerState?.outputLanguage?.toLowerCase() === normalizedLang;
+    const shouldSkipBecauseWrongLanguage = isSpeakerControlledFromMeta
+      && speakerState?.enabled
+      && speakerState?.outputLanguage?.toLowerCase() !== normalizedLang;
+
+    const subscriptionKey = `${translationMeta.speakerId}_${normalizedLang}`;
+    const isListenerSubscribed = translationSubscriptions?.has(subscriptionKey)
+      || translationSubscriptions?.has(translationMeta.speakerId);
+
+    let overrideBlocksConsumption = false;
+    let shouldConsumeForOverride = false;
+    let shouldConsumeForGlobal = false;
+
+    const perSpeakerPref = listenerTranslationPreferences?.perSpeaker?.get(translationMeta.speakerId);
+    const globalPref = listenerTranslationPreferences?.globalLanguage;
+    const listenerOverride = listenerTranslationOverrides?.get(translationMeta.speakerId);
+
+    if (perSpeakerPref) {
+      if (perSpeakerPref.wantOriginal) {
+        overrideBlocksConsumption = true;
+      } else if (perSpeakerPref.language) {
+        if (perSpeakerPref.language === normalizedLang) {
+          shouldConsumeForOverride = true;
+        } else {
+          overrideBlocksConsumption = true;
+        }
+      }
+    } else if (globalPref) {
+      if (globalPref === normalizedLang) {
+        shouldConsumeForGlobal = true;
+      } else {
+        overrideBlocksConsumption = true;
+      }
+    } else if (listenerOverride) {
+      if (listenerOverride.wantOriginal) {
+        overrideBlocksConsumption = true;
+      } else if (listenerOverride.preferredLanguage) {
+        if (listenerOverride.preferredLanguage.toLowerCase() === normalizedLang) {
+          shouldConsumeForOverride = true;
+        } else {
+          overrideBlocksConsumption = true;
+        }
+      }
+    }
+
+    const shouldConsumeForSpeakerControlled =
+      isSpeakerControlledFromMeta
+      && (!speakerState?.enabled || speakerState?.outputLanguage?.toLowerCase() === normalizedLang);
+    const hasNoPreference = !perSpeakerPref && !globalPref && !listenerOverride;
+    const isListenerInitiated = !isSpeakerControlledFromMeta && !isSpeakerControlledFromState;
+    const blockBecauseNotRelevant = hasNoPreference && isListenerInitiated && !isListenerSubscribed;
+
+    const shouldConsume =
+      !overrideBlocksConsumption
+      && !shouldSkipBecauseWrongLanguage
+      && !blockBecauseNotRelevant
+      && (shouldConsumeForOverride
+        || shouldConsumeForGlobal
+        || shouldConsumeForSpeakerControlled
+        || isSpeakerControlledFromState
+        || isListenerSubscribed);
+
+    if (shouldConsume && startConsumingTranslation) {
+      try {
+        await startConsumingTranslation(
+          producerId,
+          translationMeta.speakerId,
+          translationMeta.language,
+          translationMeta.originalProducerId,
+          nsock,
+        );
+      } catch {
+      }
+    }
+
+    return;
+  }
+
   const {
     shareScreenStarted,
     shared,

package/src/consumers/socketReceiveMethods/producerClosed.ts

@@ -63,6 +63,19 @@ export const producerClosed = async ({
 }: ProducerClosedOptions): Promise<void> => {
   let { consumerTransports, closeAndResize, screenId, updateConsumerTransports } = parameters;
 
+  const activeTranslationProducerIds = parameters.activeTranslationProducerIds;
+  const isTranslationProducer = activeTranslationProducerIds?.has?.(remoteProducerId);
+
+  if (isTranslationProducer) {
+    activeTranslationProducerIds?.delete?.(remoteProducerId);
+
+    const removeTranslationStream = parameters.removeTranslationStream as ((producerId: string) => void) | undefined;
+
+    if (removeTranslationStream) {
+      removeTranslationStream(remoteProducerId);
+    }
+  }
+
   // Handle producer closed
   const producerToClose = consumerTransports.find(
     (transportData: any) => transportData.producerId === remoteProducerId

package/src/consumers/streamSuccessScreen.ts

@@ -3,11 +3,11 @@
 import { Socket } from "socket.io-client";
 import {
   SleepType, CreateSendTransportType, ConnectSendTransportScreenType, DisconnectSendTransportScreenType, StopShareScreenType, ReorderStreamsType, PrepopulateUserMediaType, RePortType,
-  ShowAlert, CreateSendTransportParameters, ConnectSendTransportScreenParameters, DisconnectSendTransportScreenParameters, StopShareScreenParameters, ReorderStreamsParameters, PrepopulateUserMediaParameters,
+  ShowAlert, CreateSendTransportParameters, ConnectSendTransportScreenParameters, DisconnectSendTransportScreenParameters, StopShareScreenParameters, ReorderStreamsParameters, PrepopulateUserMediaParameters, RePortParameters,
   EventType
 } from "../types/types";
 
-export interface StreamSuccessScreenParameters extends CreateSendTransportParameters, ConnectSendTransportScreenParameters, DisconnectSendTransportScreenParameters, StopShareScreenParameters, ReorderStreamsParameters, PrepopulateUserMediaParameters {
+export interface StreamSuccessScreenParameters extends CreateSendTransportParameters, ConnectSendTransportScreenParameters, DisconnectSendTransportScreenParameters, StopShareScreenParameters, ReorderStreamsParameters, PrepopulateUserMediaParameters, RePortParameters {
   socket: Socket;
   transportCreated: boolean;
   localStreamScreen: MediaStream | null;

package/src/consumers/streamSuccessVideo.ts

@@ -30,6 +30,7 @@ export interface StreamSuccessVideoParameters extends CreateSendTransportParamet
   keepBackground: boolean;
   appliedBackground: boolean;
   videoProducer: Producer | null;
+  removeSingleVideoEncoding?: boolean;
 
   // Update functions
   updateTransportCreatedVideo: (created: boolean) => void;
@@ -275,6 +276,10 @@ export const streamSuccessVideo = async ({
         (codec: RtpCodecCapability) => codec.mimeType.toLowerCase() !== "video/vp9" && codec.kind === "video"
       ) || [];
 
+      if (parameters.removeSingleVideoEncoding && videoParamse.encodings && videoParamse.encodings.length <= 1) {
+        delete videoParamse.encodings;
+      }
+
       videoParams = {
         track: localStream.getVideoTracks()[0],
         ...videoParamse,

package/src/consumers/translationConsumerSwitch.ts

@@ -0,0 +1,321 @@
+import { BreakoutParticipant, EventType, Participant, Transport } from '../types/types';
+
+export interface TranslationConsumerSwitchParameters {
+  consumerTransports: Transport[];
+  roomName: string;
+  member: string;
+  updateConsumerTransports: (transports: Transport[]) => void;
+  breakOutRoomStarted?: boolean;
+  breakOutRoomEnded?: boolean;
+  breakoutRooms?: BreakoutParticipant[][];
+  limitedBreakRoom?: BreakoutParticipant[];
+  participants?: Participant[];
+  ref_participants?: Participant[];
+  islevel?: string;
+  eventType?: EventType;
+  hostNewRoom?: number;
+  [key: string]: any;
+}
+
+export interface PauseOriginalProducerOptions {
+  originalProducerId: string;
+  speakerId?: string;
+  parameters: TranslationConsumerSwitchParameters;
+}
+
+export interface ResumeOriginalProducerOptions {
+  originalProducerId: string;
+  speakerId?: string;
+  parameters: TranslationConsumerSwitchParameters;
+}
+
+export type PauseOriginalProducerType = (options: PauseOriginalProducerOptions) => Promise<void>;
+export type ResumeOriginalProducerType = (options: ResumeOriginalProducerOptions) => Promise<void>;
+
+export interface StopConsumingTranslationOptions {
+  speakerId?: string;
+  language: string;
+  translationProducerMap: Record<string, Record<string, string>>;
+  parameters: TranslationConsumerSwitchParameters;
+}
+
+export type StopConsumingTranslationType = (options: StopConsumingTranslationOptions) => Promise<string | null>;
+
+export const isSpeakerInMyBreakoutRoom = (
+  speakerName: string,
+  parameters: TranslationConsumerSwitchParameters
+): boolean => {
+  const {
+    breakOutRoomStarted = false,
+    breakOutRoomEnded = false,
+    limitedBreakRoom = [],
+    participants = [],
+    islevel = '1',
+    eventType = 'conference',
+    hostNewRoom = -1,
+    breakoutRooms = [],
+    member = '',
+  } = parameters;
+
+  if (!breakOutRoomStarted || breakOutRoomEnded) {
+    return true;
+  }
+
+  const host = participants.find((p) => p.islevel === '2');
+  const speakerIsHost = host?.name === speakerName;
+
+  if (islevel !== '2') {
+    if (eventType === 'webinar' && speakerIsHost) {
+      return true;
+    }
+
+    if (eventType === 'conference' && speakerIsHost) {
+      const roomMember = breakoutRooms.find((r) =>
+        r.find((p) => p.name === member)
+      );
+      const memberBreakRoom = roomMember ? breakoutRooms.indexOf(roomMember) : -1;
+      const inBreakRoom = memberBreakRoom !== -1;
+
+      if (inBreakRoom) {
+        return memberBreakRoom === hostNewRoom;
+      }
+
+      if (hostNewRoom === -1) {
+        return true;
+      }
+
+      return hostNewRoom === memberBreakRoom && memberBreakRoom !== -1;
+    }
+  }
+
+  return limitedBreakRoom.some((p) => p.name === speakerName);
+};
+
+export const pauseOriginalProducer = async ({
+  originalProducerId,
+  speakerId,
+  parameters,
+}: PauseOriginalProducerOptions): Promise<void> => {
+  try {
+    const { consumerTransports } = parameters;
+
+    if (speakerId && !isSpeakerInMyBreakoutRoom(speakerId, parameters)) {
+      return;
+    }
+
+    const transport = consumerTransports.find(
+      (t) => t.producerId === originalProducerId && t.consumer?.kind === 'audio'
+    );
+
+    if (!transport?.consumer) {
+      return;
+    }
+
+    if (transport.consumer.track) {
+      transport.consumer.track.enabled = false;
+    }
+
+    if (transport.consumer.paused) {
+      return;
+    }
+
+    transport.consumer.pause();
+
+    transport.socket_?.emit(
+      'consumer-pause',
+      { serverConsumerId: transport.serverConsumerTransportId },
+      async () => {}
+    );
+  } catch (error) {
+    console.error('[TranslationSwitch] Error pausing original producer:', error);
+  }
+};
+
+export const resumeOriginalProducer = async ({
+  originalProducerId,
+  speakerId,
+  parameters,
+}: ResumeOriginalProducerOptions): Promise<void> => {
+  try {
+    const { consumerTransports } = parameters;
+
+    if (speakerId && !isSpeakerInMyBreakoutRoom(speakerId, parameters)) {
+      return;
+    }
+
+    const transport = consumerTransports.find(
+      (t) => t.producerId === originalProducerId && t.consumer?.kind === 'audio'
+    );
+
+    if (!transport?.consumer) {
+      return;
+    }
+
+    if (!transport.consumer.paused) {
+      if (transport.consumer.track) {
+        transport.consumer.track.enabled = true;
+      }
+      return;
+    }
+
+    transport.socket_?.emit(
+      'consumer-resume',
+      { serverConsumerId: transport.serverConsumerTransportId },
+      async ({ resumed }: { resumed: boolean }) => {
+        if (resumed) {
+          if (transport.consumer.track) {
+            transport.consumer.track.enabled = true;
+          }
+          transport.consumer.resume();
+        }
+      }
+    );
+  } catch (error) {
+    console.error('[TranslationSwitch] Error resuming original producer:', error);
+  }
+};
+
+export const isConsumingTranslationForSpeaker = (
+  speakerId: string,
+  consumerTransports: Transport[],
+  translationProducerMap: Map<string, { translationProducerId: string; originalProducerId: string; language: string }>
+): { consuming: boolean; language?: string; translationProducerId?: string; originalProducerId?: string } => {
+  const translationInfo = translationProducerMap.get(speakerId);
+
+  if (translationInfo) {
+    const hasConsumer = consumerTransports.some(
+      (t) => t.producerId === translationInfo.translationProducerId
+    );
+
+    if (hasConsumer) {
+      return {
+        consuming: true,
+        language: translationInfo.language,
+        translationProducerId: translationInfo.translationProducerId,
+        originalProducerId: translationInfo.originalProducerId,
+      };
+    }
+  }
+
+  return { consuming: false };
+};
+
+export const getActiveTranslationConsumers = (
+  translationProducerMap: Map<string, { translationProducerId: string; originalProducerId: string; language: string }>,
+  consumerTransports: Transport[]
+): Array<{ speakerId: string; translationProducerId: string; originalProducerId: string; language: string }> => {
+  const results: Array<{ speakerId: string; translationProducerId: string; originalProducerId: string; language: string }> = [];
+
+  translationProducerMap.forEach((info, speakerId) => {
+    const hasConsumer = consumerTransports.some(
+      (t) => t.producerId === info.translationProducerId
+    );
+
+    if (hasConsumer) {
+      results.push({
+        speakerId,
+        ...info,
+      });
+    }
+  });
+
+  return results;
+};
+
+export const findOriginalProducerForSpeaker = (
+  speakerId: string,
+  allAudioStreams: Array<{ producerId: string; name?: string; [key: string]: any }>
+): string | null => {
+  const stream = allAudioStreams.find(
+    (s) => s.name === speakerId || s.producerId?.includes(speakerId)
+  );
+  return stream?.producerId || null;
+};
+
+export const stopConsumingTranslation = async (options: StopConsumingTranslationOptions): Promise<string | null> => {
+  const { language, translationProducerMap, parameters } = options;
+  try {
+    const { consumerTransports, updateConsumerTransports } = parameters;
+
+    let originalProducerId: string | null = null;
+    let translationProducerId: string | null = null;
+
+    for (const [origId, langMap] of Object.entries(translationProducerMap)) {
+      if (langMap && langMap[language]) {
+        translationProducerId = langMap[language];
+        originalProducerId = origId;
+        break;
+      }
+    }
+
+    if (!translationProducerId) {
+      return originalProducerId;
+    }
+
+    const transportIndex = consumerTransports.findIndex(
+      (t) => t.producerId === translationProducerId
+    );
+
+    if (transportIndex === -1) {
+      return originalProducerId;
+    }
+
+    const transport = consumerTransports[transportIndex];
+
+    if (transport.socket_ && transport.consumer) {
+      transport.socket_.emit(
+        'consumer-close',
+        { serverConsumerId: transport.serverConsumerTransportId },
+        () => {}
+      );
+    }
+
+    if (transport.consumer) {
+      transport.consumer.close();
+    }
+
+    const updatedTransports = consumerTransports.filter((_, i) => i !== transportIndex);
+    updateConsumerTransports(updatedTransports);
+
+    return originalProducerId;
+  } catch (error) {
+    console.error('[TranslationSwitch] Error stopping translation consumer:', error);
+    return null;
+  }
+};
+
+export const syncTranslationStateAfterBreakoutChange = async (
+  translationProducerMap: Record<string, Record<string, string>>,
+  speakerIdByProducerId: Record<string, string>,
+  parameters: TranslationConsumerSwitchParameters
+): Promise<void> => {
+  try {
+    const { consumerTransports } = parameters;
+
+    for (const [originalProducerId, langMap] of Object.entries(translationProducerMap)) {
+      const speakerId = speakerIdByProducerId[originalProducerId];
+      if (!speakerId) continue;
+
+      const inMyRoom = isSpeakerInMyBreakoutRoom(speakerId, parameters);
+      const hasTranslation = Object.keys(langMap).length > 0;
+
+      const originalConsumer = consumerTransports.find(
+        (t) => t.producerId === originalProducerId && t.consumer?.kind === 'audio'
+      );
+
+      if (!originalConsumer) continue;
+
+      if (inMyRoom && hasTranslation) {
+        if (!originalConsumer.consumer.paused) {
+          await pauseOriginalProducer({
+            originalProducerId,
+            speakerId,
+            parameters,
+          });
+        }
+      }
+    }
+  } catch (error) {
+    console.error('[TranslationSwitch] Error syncing translation state:', error);
+  }
+};