Class useMeeting

constructor

• new useMeeting(): useMeeting

  Returns useMeeting

activeSpeakerId

hlsState

hlsUrls

isRecording

livestreamState

localMicOn

localParticipant

localScreenShareOn

localWebcamOn

meeting

meetingId

participants

pinnedParticipants

presenterId

recordingState

selectedCameraDevice

selectedMicrophoneDevice

transcriptionState

changeMic

• changeMic(object: string | MediaStream): Promise<void>
  • This method can be used to change the active microphone device.
  • If multiple microphones are available, this method allows switching between them dynamically during the meeting.

  Parameters

  • object: string | MediaStream

    Either:

    • A deviceId string of the microphone to switch to, or
    • A MediaStream to be used as the audio input source.

  Returns Promise<void>

  Throws

  • Everything Meeting.muteMic | muteMic and Meeting.unmuteMic | unmuteMic can throw
  • Errors.ERROR_NO_MICROPHONE_DEVICE_FOUND — no microphone device found for the given id

  Example

  const { getMics, changeMic } = useMeeting();
  
  async function switchMic() {
    try {
      const mics = await getMics();
      const { deviceId, label } = mics[0];
      await changeMic(deviceId);
    } catch (err) {
      console.log("changeMic failed", err);
    }
  }
  Copy

changeMode

• changeMode(
      mode: "SEND_AND_RECV" | "SIGNALLING_ONLY" | "RECV_ONLY",
  ): Promise<void>
  • This method can be used to change the local participant's mode.
  • You can switch between the following modes: modes.

  Info

  Important changes introduced in React SDK v0.2.0:

  • CONFERENCE has been replaced with SEND_AND_RECV
  • VIEWER has been replaced with SIGNALLING_ONLY

  Events associated with changeMode():

  • The participant receives a onParticipantModeChanged event when the mode is successfully updated.

  Parameters

  • mode: "SEND_AND_RECV" | "SIGNALLING_ONLY" | "RECV_ONLY"

  Returns Promise<void>

  Throws

  • Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
  • Errors.ERROR_ALREADY_IN_REQUESTED_STATE — already in that mode
  • Errors.CHANGE_MODE_FAILED — server rejected the change-mode request

  Example

  import { Constants, useMeeting } from "@videosdk.live/react-sdk";
  
  const { changeMode } = useMeeting();
  
  async function switchToSendAndRecv() {
    try {
      await changeMode(Constants.modes.SEND_AND_RECV);
    } catch (err) {
      console.log("changeMode failed", err);
    }
  }
  Copy

changeWebcam

• changeWebcam(object: string | MediaStream): Promise<void>
  • This method can be used to change the active webcam device.
  • If multiple cameras are connected, this method allows switching between them dynamically during the meeting.

  Parameters

  • object: string | MediaStream

    Either:

    • A deviceId of the webcam to switch to, or
    • A MediaStream to be used as the video source.

  Returns Promise<void>

  Throws

  • Everything Meeting.disableWebcam | disableWebcam and Meeting.enableWebcam | enableWebcam can throw
  • Errors.ERROR_NO_WEBCAM_DEVICE_FOUND — no webcam device found for the given id
  • Errors.ERROR_OPERATION_IN_PROGRESS — a webcam change/enable is already in flight

  Example

  const { getWebcam, changeWebcam } = useMeeting();
  
  async function switchWebcam() {
    try {
      const webcams = await getWebcams();
      const { deviceId, label } = webcams[0];
      await changeWebcam(deviceId);
    } catch (err) {
      console.log("changeWebcam failed", err);
    }
  }
  Copy

disableAdaptiveSubscription

• disableAdaptiveSubscription(): Promise<void>
  • This method can be used to disable Adaptive Subscription.
  • When disabled, all video streams remain subscribed regardless of visibility or network conditions.

  Returns Promise<void>

  Throws

  • Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
  • Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
  • Errors.ADAPTIVE_SUBSCRIPTION_DISABLE_FAILED — adaptive subscription is already disabled

  Example

  const { disableAdaptiveSubscription } = useMeeting();
  
  async function turnOffAdaptiveSubscription() {
    try {
      await disableAdaptiveSubscription();
    } catch (err) {
      console.log("disableAdaptiveSubscription failed", err);
    }
  }
  Copy

disableScreenShare

• disableScreenShare(): Promise<void>
  • This method can be used to disable screen sharing for the local participant.

  Events associated with disableScreenShare():

  • A onStreamDisabled event is emitted with the corresponding Stream object.
  • A onPresenterChanged event is emitted with null as the presenter.

  Returns Promise<void>

  Throws

  • Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
  • Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
  • Errors.ERROR_ACTION_NOT_SUPPORTED_IN_MODE — not allowed in viewer/RECV_ONLY mode
  • Errors.ERROR_OPERATION_IN_PROGRESS — share-enable is in flight or share is already disabling
  • Errors.ERROR_ALREADY_IN_REQUESTED_STATE — screen share is already disabled

  Example

  const { disableScreenShare } = useMeeting();
  
  async function stopScreenShare() {
    try {
      await disableScreenShare();
    } catch (err) {
      console.log("disableScreenShare failed", err);
    }
  }
  Copy

disableWebcam

• disableWebcam(): Promise<void>
  • This method can be used to disable the local participant’s webcam.

  Events associated with disableWebcam():

  • A onStreamDisabled event is emitted with the corresponding Stream object.

  Returns Promise<void>

  Throws

  • Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
  • Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
  • Errors.ERROR_ACTION_NOT_SUPPORTED_IN_MODE — not allowed in viewer/RECV_ONLY mode
  • Errors.ERROR_OPERATION_IN_PROGRESS — change-mode / webcam-enable / webcam-disable already in flight
  • Errors.ERROR_ALREADY_IN_REQUESTED_STATE — webcam is already disabled

  Example

  const { disableWebcam } = useMeeting();
  
  async function turnOffWebcam() {
    try {
      await disableWebcam();
    } catch (err) {
      console.log("disableWebcam failed", err);
    }
  }
  Copy

enableAdaptiveSubscription

• enableAdaptiveSubscription(): Promise<void>
  • This method can be used to enable Adaptive Subscription.
  • Adaptive Subscription dynamically adjusts which video streams are subscribed to, based on participant visibility and current network conditions.

  Returns Promise<void>

  Throws

  • Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
  • Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
  • Errors.ADAPTIVE_SUBSCRIPTION_ENABLE_FAILED — adaptive subscription is already enabled

  Example

  const { enableAdaptiveSubscription } = useMeeting();
  
  async function turnOnAdaptiveSubscription() {
    try {
      await enableAdaptiveSubscription();
    } catch (err) {
      console.log("enableAdaptiveSubscription failed", err);
    }
  }
  Copy

enableScreenShare

• enableScreenShare(customScreenShareTrack?: MediaStream): Promise<void>
  • This method can be used to enable screen sharing for the local participant.

  Events associated with enableScreenShare():

  • A onStreamEnabled event is emitted with the corresponding Stream object.
  • A onPresenterChanged event is emitted with the presenterId.

  Parameters

  • OptionalcustomScreenShareTrack: MediaStream

    An optional custom screen share track to be used instead of the default one.

    To learn more checkout this reference

  Returns Promise<void>

  Throws

  • Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
  • Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
  • Errors.ERROR_ACTION_NOT_SUPPORTED_IN_MODE — not allowed in viewer/RECV_ONLY mode
  • Errors.ERROR_OPERATION_IN_PROGRESS — share-disable is in flight
  • Errors.ERROR_MEDIA_DEVICE_NOT_INITIALIZED — media device not initialized
  • Errors.ERROR_MEDIA_DEVICE_NOT_LOADED — media device not loaded
  • Errors.ERROR_GET_DISPLAY_MEDIA — browser cannot getDisplayMedia
  • Errors.ERROR_MEDIA_NOT_READY — transport not ready
  • Errors.ERROR_SCREENSHARE_PRODUCE_FAILED — screen-share track could not be published

  Example

  const { enableScreenShare } = useMeeting();
  
  async function startScreenShare() {
    try {
      await enableScreenShare();
    } catch (err) {
      console.log("enableScreenShare failed", err);
    }
  }
  Copy

enableWebcam

• enableWebcam(customVideoTrack?: MediaStream): Promise<void>
  • This method can be used to enable the local participant’s webcam.

  Events associated with enableWebcam():

  • A onStreamEnabled event is emitted with the corresponding Stream object.

  Parameters

  • OptionalcustomVideoTrack: MediaStream

    An optional custom video track to be used instead of the default one.

    To learn more, checkout this reference

  Returns Promise<void>

  Throws

  • Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
  • Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
  • Errors.ERROR_ACTION_NOT_SUPPORTED_IN_MODE — not allowed in viewer/RECV_ONLY mode
  • Errors.ERROR_OPERATION_IN_PROGRESS — change-mode / webcam-enable / webcam-disable already in flight
  • Errors.ERROR_ALREADY_IN_REQUESTED_STATE — webcam is already enabled
  • Errors.ERROR_MEDIA_DEVICE_NOT_LOADED — media device not loaded
  • Errors.ERROR_CAMERA_ACCESS_UNAVAILABLE — camera access unavailable
  • Errors.ERROR_MEDIA_DEVICE_NOT_INITIALIZED — media device not initialized
  • Errors.ERROR_NO_WEBCAM_DEVICE_FOUND — no webcam device found
  • Errors.ERROR_NO_SUPPORTED_VIDEO_CODEC — no supported video codec available
  • Errors.ERROR_MEDIA_NOT_READY — transport not ready
  • Errors.ERROR_WEBCAM_PRODUCE_FAILED — webcam track could not be published

  Example

  const { enableWebcam } = useMeeting();
  
  async function turnOnWebcam() {
    try {
      await enableWebcam();
    } catch (err) {
      console.log("enableWebcam failed", err);
    }
  }
  Copy

end

• end(): Promise<void>
  • This method can be used to end the current meeting session for all participants.
  • Calling end() removes all participants, including the local participant, and permanently terminates the meeting.

  Events associated with end():

  • All participants receive the onMeetingLeft event.

  Returns Promise<void>

  Throws

  • Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
  • Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
  • Errors.ERROR_END_MEETING_FAILED — server rejected the end request (reason bubbled up)

  Example

  const { end } = useMeeting();
  
  async function endMeeting() {
    try {
      await end();
    } catch (err) {
      console.log("end failed", err);
    }
  }
  Copy

getMics

• getMics(): Promise<{ deviceId: string; label: string }[]>
  • This method can be used to retrieve all available microphone devices connected to the system.

  Returns Promise<{ deviceId: string; label: string }[]>

  Example

  const { getMics } = useMeeting();
  
  async function loadMics() {
    try {
      const mics = await getMics();
  
      console.log(mics);
    } catch (err) {
      console.log("getMics failed", err);
    }
  }
  Copy

getWebcams

• getWebcams(): Promise<
      { deviceId: string; facingMode: "front"
      | "environment"; label: string }[],
  >
  • This method can be used to retrieve all available camera devices connected to the system.

  Returns Promise<
      { deviceId: string; facingMode: "front"
      | "environment"; label: string }[],
  >

  Example

  const { getWebcams } = useMeeting();
  
  async function loadWebcams() {
    try {
      const webcams = await getWebcams();
  
      console.log(webcams);
    } catch (err) {
      console.log("getWebcams failed", err);
    }
  }
  Copy

join

• join(): Promise<void>
  • This method can be used to join the meeting.
  • During initialization using the <MeetingProvider>, if joinWithoutUserInteraction is set to true, participant will automatically join the meeting. If it is false explicity call for join() should be made.

  Events associated with join():

  • The local participant receives a onMeetingJoined event once the meeting is successfully joined.
  • Remote participants receive a onParticipantJoined event containing the newly joined participant.

  Returns Promise<void>

  Throws

  • Errors.ERROR_OPERATION_IN_PROGRESS — join is already in progress
  • Errors.ERROR_ALREADY_IN_REQUESTED_STATE — already joined
  • Errors.ERROR_UNABLE_TO_JOIN_MEETING — server/network failure (invalid token, unauthorized meetingId, media connection failed, etc.)

  Example

  const { join } = useMeeting();
  
  async function joinMeeting() {
    try {
      await join();
    } catch (err) {
      console.log("join failed", err);
    }
  }
  Copy

leave

• leave(): Promise<void>
  • This method can be used to leave the currently joined meeting.

  Events associated with leave():

  • The local participant receives a onMeetingLeft event.
  • All remote participants receive a onParticipantLeft event containing the participant ID of the user who left.

  Returns Promise<void>

  Throws

  • Errors.ERROR_ALREADY_IN_REQUESTED_STATE — already left (double leave, host closed, disconnected)
  • Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — never joined

  Example

  const { leave } = useMeeting();
  
  async function leaveMeeting() {
    try {
      await leave();
    } catch (err) {
      console.log("leave failed", err);
    }
  }
  Copy

muteMic

• muteMic(): Promise<void>
  • This method can be used to disable the local participant’s microphone.

  Events associated with muteMic():

  • A onStreamDisabled event is emitted with the corresponding Stream object.

  Returns Promise<void>

  Throws

  • Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
  • Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
  • Errors.ERROR_ACTION_NOT_SUPPORTED_IN_MODE — not allowed in viewer/RECV_ONLY mode
  • Errors.ERROR_OPERATION_IN_PROGRESS — change-mode / mic-enable / mic-disable already in flight
  • Errors.ERROR_ALREADY_IN_REQUESTED_STATE — mic is already disabled

  Example

  const { muteMic } = useMeeting();
  
  async function turnOffMic() {
    try {
      await muteMic();
    } catch (err) {
      console.log("muteMic failed", err);
    }
  }
  Copy

pauseAllStreams

• pauseAllStreams(
      kind?: "audio" | "video" | "share" | "shareAudio" | "all",
  ): Promise<void>
  • This method can be used to pause active media streams in the meeting.
  • The local participant will receive the onPausedAllStreams event.

  Parameters

  • Optionalkind: "audio" | "video" | "share" | "shareAudio" | "all"

    Specifies which type of media stream should be paused. If not provided, all media streams (audio, video, and screen share) will be paused.

  Returns Promise<void>

  Throws

  • Errors.PAUSE_ALL_STREAMS_FAILED — server rejected the request

  Example

  const { pauseAllStreams } = useMeeting();
  
  async function pauseStreams() {
    try {
      await pauseAllStreams("video");
    } catch (err) {
      console.log("pauseAllStreams failed", err);
    }
  }
  Copy

replaceWebcamStream

• replaceWebcamStream(stream: MediaStream): Promise<void>
  • This method replaces the current outgoing webcam stream with the provided MediaStream.

  Parameters

  • stream: MediaStream

    The new MediaStream to broadcast in place of the current webcam stream.

  Returns Promise<void>

  Throws

  • Everything Meeting.enableWebcam | enableWebcam can throw (publish failure is re-thrown)
  • Errors.ERROR_WEBCAM_PRODUCE_FAILED — new webcam track could not be published

  Example

  const { replaceWebcamStream } = useMeeting();
  
  async function swapWebcamStream() {
    try {
      await replaceWebcamStream(customStream);
    } catch (err) {
      console.log("replaceWebcamStream failed", err);
    }
  }
  Copy

requestMediaRelay

• requestMediaRelay(
      options: {
          destinationMeetingId: string;
          kinds?: ("audio" | "video" | "share" | "share_audio")[];
          token?: string;
      },
  ): Promise<void>
  • This method is used to request media relay to another meeting.

  Parameters

  • options: {
        destinationMeetingId: string;
        kinds?: ("audio" | "video" | "share" | "share_audio")[];
        token?: string;
    }

    • destinationMeetingId: string

      The meeting ID to relay media to.

    • Optionalkinds?: ("audio" | "video" | "share" | "share_audio")[]

      Optional array of media kinds to relay.

    • Optionaltoken?: string

      Optional token for the destination meeting.

  Returns Promise<void>

  Throws

  • Errors.ERROR_INVALID_PARAMETER — missing destinationMeetingId
  • Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
  • Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
  • Errors.REQUEST_MEDIA_RELAY_FAILED — server rejected the request

  Example

  const { requestMediaRelay } = useMeeting();
  
  async function startMediaRelay() {
    try {
      await requestMediaRelay({
        destinationMeetingId: "meeting-id",
        token: "auth-token",
        kinds: ["audio", "video"],
      });
    } catch (err) {
      console.log("requestMediaRelay failed", err);
    }
  }
  Copy

respondEntry

• respondEntry(participantId: string, decision: string): Promise<void>
  • This method is used to respond to a participant's entry request when the meeting has ask_join enabled.

  Parameters

  • participantId: string

    The participantId of the participant whose entry request is being responded to.

  • decision: string

    "allow" to admit the participant, "deny" to reject.

  Returns Promise<void>

  Throws

  • Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
  • Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
  • Errors.RESPOND_ENTRY_FAILED — server rejected the entry-response

  Example

  const { respondEntry } = useMeeting();
  
  async function allowEntry() {
    try {
      await respondEntry("participant-id", "allow");
    } catch (err) {
      console.log("respondEntry failed", err);
    }
  }
  Copy

resumeAllStreams

• resumeAllStreams(
      kind?: "audio" | "video" | "share" | "shareAudio" | "all",
  ): Promise<void>
  • This method can be used to resume media streams that were previously paused.
  • The local participant will receive the onResumedAllStreams event.

  Parameters

  • Optionalkind: "audio" | "video" | "share" | "shareAudio" | "all"

    Specifies which type of media stream should be resumed.If not provided, all media streams (audio, video, and screen share) will be resumed.

  Returns Promise<void>

  Throws

  • Errors.RESUME_ALL_STREAMS_FAILED — server rejected the request

  Example

  const { resumeAllStreams } = useMeeting();
  
  async function resumeStreams() {
    try {
      await resumeAllStreams("video");
    } catch (err) {
      console.log("resumeAllStreams failed", err);
    }
  }
  Copy

send

• send(
      payload: string | Blob | ArrayBuffer | ArrayBufferView<ArrayBufferLike>,
      options?: { reliability?: "RELIABLE" | "UNRELIABLE" },
  ): Promise<boolean>
  • This method can be used to send a message to all participants in the meeting using the data channel.

  Parameters

  • payload: string | Blob | ArrayBuffer | ArrayBufferView<ArrayBufferLike>

    The data to be sent.

    • Supported types: string, Blob, ArrayBuffer, ArrayBufferView
    • Maximum allowed size: 15 KiB
  • Optionaloptions: { reliability?: "RELIABLE" | "UNRELIABLE" }

    • Optionalreliability?: "RELIABLE" | "UNRELIABLE"

      Determines how the message is delivered:

      • reliabilityMode.RELIABLE — Guarantees delivery and preserves order (may introduce latency).
      • reliabilityMode.UNRELIABLE — Faster delivery but messages may be dropped under poor network conditions.

  Returns Promise<boolean>

  Throws

  • Errors.ERROR_ACTION_NOT_SUPPORTED — invalid or too-large payload
  • Errors.ERROR_MEDIA_NOT_READY — transport not ready
  • Errors.ERROR_ACTION_NOT_SUPPORTED_IN_MODE — not allowed in viewer/RECV_ONLY mode
  • Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
  • Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
  • Errors.ERROR_SEND_FAILED — data-producer / send failed

  Example

  const { send } = useMeeting();
  
  async function sendMessage() {
    try {
      await send("Hello everyone!", {
        reliability: Constants.reliabilityMode.UNRELIABLE,
      });
    } catch (err) {
      console.log("send failed", err);
    }
  }
  Copy

startHls

• startHls(
      config?: {
          layout?: {
              gridSize?: number;
              priority?: "SPEAKER" | "PIN";
              type?: "GRID" | "SPOTLIGHT" | "SIDEBAR";
          };
          mode?: "audio"
          | "video-and-audio";
          quality?: "low" | "med" | "high";
          recording?: { enabled: boolean };
          theme?: "DEFAULT" | "DARK" | "LIGHT";
      },
      transcription?: {
          enabled: boolean;
          summary?: { enabled: boolean; prompt?: string };
      },
  ): Promise<void>
  • This method can be used to start HLS streaming for the meeting.
  • This allows participants and viewers to watch the meeting via HLS playback.
  • All participants, including the local participant, will receive the HLS_STARTING event state in the onHlsStateChanged event.

  Parameters

  • Optionalconfig: {
        layout?: {
            gridSize?: number;
            priority?: "SPEAKER" | "PIN";
            type?: "GRID" | "SPOTLIGHT" | "SIDEBAR";
        };
        mode?: "audio"
        | "video-and-audio";
        quality?: "low" | "med" | "high";
        recording?: { enabled: boolean };
        theme?: "DEFAULT" | "DARK" | "LIGHT";
    }

    Configuration used to control the HLS stream.

    • Optionallayout?: {
          gridSize?: number;
          priority?: "SPEAKER" | "PIN";
          type?: "GRID" | "SPOTLIGHT" | "SIDEBAR";
      }

      • OptionalgridSize?: number

        Specifies the maximum number of participants shown in the grid.

      • Optionalpriority?: "SPEAKER" | "PIN"

        Determines participant priority when composing the layout.

      • Optionaltype?: "GRID" | "SPOTLIGHT" | "SIDEBAR"

        Defines the layout used in the HLS stream.

    • Optionalmode?: "audio" | "video-and-audio"

      Determines whether the stream includes video and audio or audio only.

    • Optionalquality?: "low" | "med" | "high"

      Defines the output video quality of the HLS stream.

    • Optionalrecording?: { enabled: boolean }

      This can be used to enable or disable recording.

    • Optionaltheme?: "DEFAULT" | "DARK" | "LIGHT"

      Defines the visual theme of the HLS stream.

  • Optionaltranscription: { enabled: boolean; summary?: { enabled: boolean; prompt?: string } }

    Configuration for post-meeting transcription and summary generation.

    • enabled: boolean

      Enables or disables transcription.

    • Optionalsummary?: { enabled: boolean; prompt?: string }

      • enabled: boolean

        Enables or disables summary generation.

      • Optionalprompt?: string

        Custom prompt used for generating the summary.

  Returns Promise<void>

  Throws

  • Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
  • Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
  • Errors.START_HLS_FAILED — server rejected the request

  Example

  const config = {
    layout: {
      type: "SPOTLIGHT",
      priority: "PIN",
      gridSize: 9,
    },
    theme: "DEFAULT",
    recording = {
      enabled: true,
    };
  };
  
  const transcription = {
    enabled: true,
    summary: {
      enabled: true,
    },
  };
  
  const { startHls } = useMeeting();
  
  async function beginHls() {
    try {
      await startHls(config, transcription);
    } catch (err) {
      console.log("startHls failed", err);
    }
  }
  Copy

startLivestream

• startLivestream(
      outputs: { streamKey: string; url: string }[],
      config?: {
          layout?: {
              gridSize?: number;
              priority?: "SPEAKER" | "PIN";
              type?: "GRID" | "SPOTLIGHT" | "SIDEBAR";
          };
          recording?: { enabled: boolean };
          theme?: "DEFAULT" | "DARK" | "LIGHT";
      },
  ): Promise<void>
  • This method can be used to start live streaming the meeting.
  • This allows you to stream the meeting to external platforms such as YouTube, Facebook, or any service that supports RTMP.
  • All participants, including the local participant, will receive the LIVESTREAM_STARTING state in the onLivestreamStateChanged event.

  Parameters

  • outputs: { streamKey: string; url: string }[]

    An array of RTMP output destinations where the livestream will be broadcast.

  • Optionalconfig: {
        layout?: {
            gridSize?: number;
            priority?: "SPEAKER" | "PIN";
            type?: "GRID" | "SPOTLIGHT" | "SIDEBAR";
        };
        recording?: { enabled: boolean };
        theme?: "DEFAULT" | "DARK" | "LIGHT";
    }

    Configuration options for the RTMP livestream.

    • Optionallayout?: {
          gridSize?: number;
          priority?: "SPEAKER" | "PIN";
          type?: "GRID" | "SPOTLIGHT" | "SIDEBAR";
      }

      • OptionalgridSize?: number

        Specifies the maximum number of participants displayed in the grid.

      • Optionalpriority?: "SPEAKER" | "PIN"

        Determines participant priority when composing the livestream layout.

      • Optionaltype?: "GRID" | "SPOTLIGHT" | "SIDEBAR"

        Defines the layout used for the livestream.

    • Optionalrecording?: { enabled: boolean }

      This can be used to enable or disable recording.

    • Optionaltheme?: "DEFAULT" | "DARK" | "LIGHT"

      Defines the color theme of the livestream.

  Returns Promise<void>

  Throws

  • Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
  • Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
  • Errors.START_LIVESTREAM_FAILED — server rejected the request

  Example

  const outputs = [
    {
      url: "rtmp://a.rtmp.youtube.com/live2",
      streamKey: "<STREAM_KEY>",
    },
    {
      url: "rtmps://",
      streamKey: "<STREAM_KEY>",
    },
  ];
  
  const config = {
    layout: {
      type: "SPOTLIGHT",
      priority: "PIN",
      gridSize: 9,
    },
    theme: "DEFAULT",
    recording: {
      enabled: true,
    },
  };
  
  const { startLivestream } = useMeeting();
  
  async function beginLivestream() {
    try {
      await startLivestream(outputs, config, transcription);
    } catch (err) {
      console.log("startLivestream failed", err);
    }
  }
  Copy

startRecording

• startRecording(
      webhookUrl?: string,
      awsDirPath?: string,
      config?: {
          layout: {
              gridSize: number;
              priority: "SPEAKER" | "PIN";
              type: "GRID" | "SPOTLIGHT" | "SIDEBAR";
          };
          mode: "audio"
          | "video-and-audio";
          orientation: "landscape" | "portrait";
          quality: "low" | "med" | "high";
          theme: "DEFAULT" | "DARK" | "LIGHT";
      },
      transcription?: {
          enabled: boolean;
          language?: string;
          summary?: { enabled: boolean; prompt?: string };
      },
  ): Promise<void>

  • This method can be used to start recording the meeting.

  • All participants, including the local participant, will receive the RECORDING_STARTING event state in the onRecordingStateChanged event.

  Parameters

  • OptionalwebhookUrl: string

    Webhook URL triggered when the recording state changes.

  • OptionalawsDirPath: string

    Path to the directory in your S3 bucket where recordings are stored.

  • Optionalconfig: {
        layout: {
            gridSize: number;
            priority: "SPEAKER" | "PIN";
            type: "GRID" | "SPOTLIGHT" | "SIDEBAR";
        };
        mode: "audio"
        | "video-and-audio";
        orientation: "landscape" | "portrait";
        quality: "low" | "med" | "high";
        theme: "DEFAULT" | "DARK" | "LIGHT";
    }

    Recording configuration options.

    • layout: {
          gridSize: number;
          priority: "SPEAKER" | "PIN";
          type: "GRID" | "SPOTLIGHT" | "SIDEBAR";
      }

      Defines how participants are arranged in the recording.

      • gridSize: number

        Maximum number of participants displayed simultaneously.

      • priority: "SPEAKER" | "PIN"

        Determines participant prioritization.

      • type: "GRID" | "SPOTLIGHT" | "SIDEBAR"

        Layout type for the recording.

    • mode: "audio" | "video-and-audio"

      Defines whether the recording includes video or audio only.

    • orientation: "landscape" | "portrait"

    • quality: "low" | "med" | "high"

      Controls the output quality of the recording.

    • theme: "DEFAULT" | "DARK" | "LIGHT"

      Visual theme applied to the recording.

  • Optionaltranscription: {
        enabled: boolean;
        language?: string;
        summary?: { enabled: boolean; prompt?: string };
    }

    Configuration for post-recording transcription and summary generation.

    • enabled: boolean

      Enables or disables transcription.

    • Optionallanguage?: string

    • Optionalsummary?: { enabled: boolean; prompt?: string }

      • enabled: boolean

        Enables or disables summary generation.

      • Optionalprompt?: string

        Custom prompt used for generating transcription summaries.

  Returns Promise<void>

  Throws

  • Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
  • Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
  • Errors.START_RECORDING_FAILED — server rejected the request

  Example

  const webhookUrl = "https://webhook.your-api-server.com";
  
  const awsDirPath = "/meeting-recordings/";
  
  const config = {
    layout: {
      type: "SPOTLIGHT",
      priority: "PIN",
      gridSize: 9,
    },
    theme: "DEFAULT",
  };
  
  const transcription = {
    enabled: true,
    summary: {
      enabled: true,
    },
  };
  
  const { startRecording } = useMeeting();
  
  async function beginRecording() {
    try {
      await startRecording(webhookUrl, awsDirPath, config, transcription);
    } catch (err) {
      console.log("startRecording failed", err);
    }
  }
  Copy

stopHls

• stopHls(): Promise<void>
  • This method can be used to stop the active HLS stream.
  • All participants, including the local participant, will receive the HLS_STOPPING event state in the onHlsStateChanged event.

  Returns Promise<void>

  Throws

  • Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
  • Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
  • Errors.STOP_HLS_FAILED — server rejected the request

  Example

  const { stopHls } = useMeeting();
  
  async function endHls() {
    try {
      await stopHls();
    } catch (err) {
      console.log("stopHls failed", err);
    }
  }
  Copy

stopLivestream

• stopLivestream(): Promise<void>
  • This method can be used to stop the ongoing livestream.
  • All participants, including the local participant, will receive the LIVESTREAM_STOPPING state in the onLivestreamStateChanged event.

  Returns Promise<void>

  Throws

  • Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
  • Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
  • Errors.STOP_LIVESTREAM_FAILED — server rejected the request

  Example

  const { stopLivestream } = useMeeting();
  
  async function endLivestream() {
    try {
      await stopLivestream();
    } catch (err) {
      console.log("stopLivestream failed", err);
    }
  }
  Copy

stopMediaRelay

• stopMediaRelay(destinationMeetingId: string): Promise<void>
  • This method stops relaying media to the given destination meeting.

  Parameters

  • destinationMeetingId: string

    The meeting ID to stop media relay to.

  Returns Promise<void>

  Throws

  • Errors.ERROR_INVALID_PARAMETER — missing destinationMeetingId
  • Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
  • Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
  • Errors.STOP_MEDIA_RELAY_FAILED — server rejected the request

  Example

  const { stopMediaRelay } = useMeeting();
  
  async function endMediaRelay() {
    try {
      await stopMediaRelay("destination-meeting-id");
    } catch (err) {
      console.log("stopMediaRelay failed", err);
    }
  }
  Copy

stopRecording

• stopRecording(): Promise<void>

  • This method can be used to stop the ongoing meeting recording.

  • All participants, including the local participant, will receive the RECORDING_STOPPING event state in the onRecordingStateChanged event.

  Returns Promise<void>

  Throws

  • Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
  • Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
  • Errors.STOP_RECORDING_FAILED — server rejected the request

  Example

  const { stopRecording } = useMeeting();
  
  async function endRecording() {
    try {
      await stopRecording();
    } catch (err) {
      console.log("stopRecording failed", err);
    }
  }
  Copy

switchTo

• switchTo(options: { meetingId: string; token?: string }): Promise<void>
  • This method can be used to switch the current session to another meeting without disconnecting.
  • This allows a seamless transition between meetings while preserving the active session context.

  Parameters

  • options: { meetingId: string; token?: string }

    • meetingId: string

      The ID of the meeting to switch to.

    • Optionaltoken?: string

      Authentication token for the destination meeting.

  Returns Promise<void>

  Throws

  • Errors.ERROR_INVALID_PARAMETER — invalid meetingId
  • Errors.SWITCH_MEETING_FAILED — server rejected the switch-meeting request
  • Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
  • Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting

  Example

  const { switchTo } = useMeeting();
  
  async function switchMeeting() {
    try {
      await switchTo({
        meetingId: "new-meeting-id",
        token: "optional-auth-token",
      });
    } catch (err) {
      console.log("switchTo failed", err);
    }
  }
  Copy

toggleMic

• toggleMic(customAudioTrack?: MediaStream): Promise<void>

  This method can be used to toggle the local participant’s microphone

  Events associated with toggleMic():

  • A onStreamEnabled event is emitted with the corresponding Stream object if mic is turned on.
  • A onStreamDisabled event is emitted with the corresponding Stream object if mic is turned off.

  Parameters

  • OptionalcustomAudioTrack: MediaStream

    An optional custom audio track to be used instead of the default one.

    To learn more, checkout this reference.

  Returns Promise<void>

  Example

  const { toggleMic } = useMeeting();
  
  async function handleToggleMic() {
    try {
      await toggleMic();
    } catch (err) {
      console.log("toggleMic failed", err);
    }
  }
  Copy

toggleScreenShare

• toggleScreenShare(customScreenShareTrack?: MediaStream): Promise<void>
  • This method can be used to toggle screen sharing for the local participant.

  Events associated with toggleScreenShare():

  • A onStreamEnabled event is emitted with the corresponding Stream object if screen share is turned on.
  • A onStreamDisabled event is emitted with the corresponding Stream object if screen share is turned off.

  Parameters

  • OptionalcustomScreenShareTrack: MediaStream

    An optional custom screen share track to be used instead of the default one.

    To learn more checkout this reference.

  Returns Promise<void>

  Example

  const { toggleScreenShare } = useMeeting();
  
  async function handleToggleScreenShare() {
    try {
      await toggleScreenShare();
    } catch (err) {
      console.log("toggleScreenShare failed", err);
    }
  }
  Copy

toggleWebcam

• toggleWebcam(customVideoTrack?: MediaStream): Promise<void>
  • This method can be used to toggle the local participant’s webcam.

  Events associated with toggleWebcam():

  • A onStreamEnabled event is emitted with the corresponding Stream object if webcam is turned on.
  • A onStreamDisabled event is emitted with the corresponding Stream object if webcam is turned off.

  Parameters

  • OptionalcustomVideoTrack: MediaStream

    An optional custom video track to be used instead of the default one.

    To learn more, checkout this reference

  Returns Promise<void>

  Example

  const { toggleWebcam } = useMeeting();
  
  async function handleToggleWebcam() {
    try {
      await toggleWebcam();
    } catch (err) {
      console.log("toggleWebcam failed", err);
    }
  }
  Copy

unmuteMic

• unmuteMic(customAudioTrack?: MediaStream): Promise<void>
  • This method can be used to enable the local participant’s microphone.

  Events associated with unmuteMic():

  • A onStreamEnabled event is emitted with the corresponding Stream object.

  Parameters

  • OptionalcustomAudioTrack: MediaStream

    An optional custom audio track to be used instead of the default one.

    To learn more, checkout this reference

  Returns Promise<void>

  Throws

  • Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
  • Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
  • Errors.ERROR_ACTION_NOT_SUPPORTED_IN_MODE — not allowed in viewer/RECV_ONLY mode
  • Errors.ERROR_OPERATION_IN_PROGRESS — change-mode / mic-enable / mic-disable already in flight
  • Errors.ERROR_ALREADY_IN_REQUESTED_STATE — mic is already enabled
  • Errors.ERROR_MEDIA_DEVICE_NOT_LOADED — media device not loaded
  • Errors.ERROR_MICROPHONE_ACCESS_UNAVAILABLE — microphone access unavailable
  • Errors.ERROR_MEDIA_DEVICE_NOT_INITIALIZED — media device not initialized
  • Errors.ERROR_NO_MICROPHONE_DEVICE_FOUND — no microphone device found
  • Errors.ERROR_MEDIA_NOT_READY — transport not ready
  • Errors.ERROR_MICROPHONE_PRODUCE_FAILED — microphone track could not be published

  Example

  const { unmuteMic } = useMeeting();
  
  async function turnOnMic() {
    try {
      await unmuteMic();
    } catch (err) {
      console.log("unmuteMic failed", err);
    }
  }
  Copy

onAudioInputSilence

• onAudioInputSilence(
      option: {
          devicelabel?: string;
          state: "detected" | "resolved";
          timestamp: number;
      },
  ): void
  • Triggered when local microphone silence is detected or resolved.
  • Useful for detecting muted hardware or when the local participant's audio track is not capturing any signal.

  Parameters

  • option: { devicelabel?: string; state: "detected" | "resolved"; timestamp: number }

    • Optionaldevicelabel?: string

      Label of the audio input device associated with the event, when available.

    • state: "detected" | "resolved"

      Indicates whether silence has just been "detected" on the audio input, or previously detected silence has been "resolved".

    • timestamp: number

      Time (in milliseconds since epoch) when the event occurred.

  Returns void

  Example

  function onAudioInputSilence({ devicelabel, state, timestamp }) {
    //
  }
  
  const {
    meetingId
    ...
  } = useMeeting({
    onAudioInputSilence,
    ...
  });
  Copy

onCodecChanged

• onCodecChanged(
      data: {
          causedBy?: Participant;
          currentCodec: string;
          kind: "video";
          previousCodec: string;
          unsupportedRemoteCodec: string;
      },
  ): void
  • Triggered when the meeting's active media codec changes because a newly joined participant does not support the current codec.
  • The meeting automatically negotiates and switches to a mutually compatible codec to maintain connectivity for all participants.

  Parameters

  • data: {
        causedBy?: Participant;
        currentCodec: string;
        kind: "video";
        previousCodec: string;
        unsupportedRemoteCodec: string;
    }

    • OptionalcausedBy?: Participant

      The Participant instance of the participant whose joining triggered the codec change.

    • currentCodec: string

      The new codec that the meeting switched to after the change.

    • kind: "video"

      The media type for which the codec changed.

    • previousCodec: string

      The codec that was in use before the change.

    • unsupportedRemoteCodec: string

      The codec that the newly joined participant did not support, which triggered the switch.

  Returns void

  Example

  function onCodecChanged(data) {
    const { previousCodec, currentCodec, kind, causedBy, unsupportedRemoteCodec} = data;
  }
  
  const {
    meetingId
    ...
  } = useMeeting({
    onCodecChanged,
    ...
  });
  Copy

onData

• onData(
      data: {
          from: string;
          payload: string | Uint8Array<ArrayBufferLike>;
          reliability: string;
          timestamp: string;
      },
  ): void
  • Triggered whenever a message is received over the DataStream.

  Parameters

  • data: {
        from: string;
        payload: string | Uint8Array<ArrayBufferLike>;
        reliability: string;
        timestamp: string;
    }

    • from: string

      ID of the participant who sent the message.

    • payload: string | Uint8Array<ArrayBufferLike>

      The received message payload.

      • string for text messages
      • Uint8Array for binary data

    • reliability: string

      Indicates whether the message delivery was reliable or unreliable.

    • timestamp: string

      Timestamp (in milliseconds since epoch) when the message was sent.

  Returns void

  Example

  function onData({ payload, from, timestamp, reliability }){
    if (typeof payload === "string") {
      console.log(`Text message from ${from}: ${payload}`);
    } else {
      console.log(`Binary data from ${from}:`, payload);
    }
  
    console.log(`Received at: ${new Date(timestamp).toLocaleTimeString()}`);
    console.log(`Reliability: ${reliability}`);
  };
  
  const {
    meetingId
    ...
  } = useMeeting({
    onData,
    ...
  });
  Copy

onEntryRequested

• onEntryRequested(
      option: {
          allow: () => void;
          deny: () => void;
          name: string;
          participantId: string;
      },
  ): void
  • Triggered when a participant requests to join the meeting and their token includes the ask_join permission.
  • This event is emitted only to participants whose token includes the allow_join permission.

  Parameters

  • option: { allow: () => void; deny: () => void; name: string; participantId: string }

    • allow: () => void

      Call this function to allow the participant to join the meeting.

    • deny: () => void

      Call this function to deny the participant’s request.

    • name: string

      Display name of the participant requesting to join.

    • participantId: string

      Unique ID of the participant requesting to join the meeting.

  Returns void

  Example

  function onEntryRequested(data) {
    const { participantId, name, allow, deny } = data;
  
    console.log(`${name} requested to join the meeting.`);
  
    // If you want to allow the entry request
    allow();
  
    // if you want to deny the entry request
    deny();
  }
  
  const {
    meetingId
    ...
  } = useMeeting({
    onEntryRequested,
    ...
  });
  Copy

onEntryResponded

• onEntryResponded(participantId: string, decision: string): void
  • Triggered when a participant’s join() request is responded to with an allow or deny decision.

  This event is emitted to:

  • All participants whose token includes the allow_join permission.
  • The participant who requested to join the meeting.

  Parameters

  • participantId: string

    ID of the participant who requested to join the meeting.

  • decision: string

    The final decision for the join request.

    Possible values:

    • "allowed" – The participant was allowed to join.
    • "denied" – The participant was denied entry.

  Returns void

  Example

  function onEntryResponded(participantId, decision) {
    // participantId will be id of participant who requested to join meeting
  
    if (decision === "allowed") {
      // entry allowed
    } else {
      // entry denied
    }
  }
  
  const {
    meetingId
    ...
  } = useMeeting({
    onEntryResponded,
    ...
  });
  Copy

onError

• onError(option: { code: number; message: string }): void
  • Triggered when an error occurs during the meeting lifecycle.
  • The event provides an error code and a descriptive message. Refer to Errors for a complete list of supported error codes.

  Parameters

  • option: { code: number; message: string }

    • code: number

      Numeric error code representing the type of error.

    • message: string

      Human-readable description of the error.

  Returns void

  Example

  function onError(data) {
    const { code, message } = data;
  }
  
  const {
    meetingId
    ...
  } = useMeeting({
    onError,
    ...
  });
  Copy

onHlsStateChanged

• onHlsStateChanged(
      option: {
          livestreamUrl: string;
          playbackHlsUrl: string;
          status:
              | "HLS_STOPPED"
              | "HLS_STARTING"
              | "HLS_STARTED"
              | "HLS_PLAYABLE"
              | "HLS_STOPPING";
      },
  ): void
  • Triggered when the HLS (HTTP Live Streaming) state changes.

  Parameters

  • option: {
        livestreamUrl: string;
        playbackHlsUrl: string;
        status:
            | "HLS_STOPPED"
            | "HLS_STARTING"
            | "HLS_STARTED"
            | "HLS_PLAYABLE"
            | "HLS_STOPPING";
    }

    • livestreamUrl: string

      Live HLS without playback support

    • playbackHlsUrl: string

      Live HLS with playback support

    • status: "HLS_STOPPED" | "HLS_STARTING" | "HLS_STARTED" | "HLS_PLAYABLE" | "HLS_STOPPING"

      Possible values:

      • HLS_STARTING - Hls is in starting phase and hasn't started yet.
      • HLS_STARTED- Hls has started successfully will return playbackHlsUrl and livestreamUrl.
      • HLS_PLAYABLE - Hls has started and the playbackHlsUrl and livestreamUrl is now playable.
      • HLS_STOPPING - Hls is in stopping phase and hasn't stopped yet.
      • HLS_STOPPED- Hls has stopped successfully.

  Returns void

  Example

  import { Constants, useMeeting } from "@videosdk.live/react-sdk";
  
  function onHlsStateChanged(data) {
     const { status } = data;
  
    if (status === Constants.hlsEvents.HLS_STARTING) {
      console.log("Meeting Hls is starting");
    } else if (status === Constants.hlsEvents.HLS_STARTED) {
      console.log("Meeting Hls is started");
    } else if (status === Constants.hlsEvents.HLS_PLAYABLE) {
      // on hlsStateChanged started you will receive  playbaclHlsUrl and livestreamUrl.
      const {playbackHlsUrl} = data;
      console.log("Meeting Hls is playable");
    } else if (status === Constants.hlsEvents.HLS_STOPPING) {
      console.log("Meeting Hls is stopping");
    } else if (status === Constants.hlsEvents.HLS_STOPPED) {
      console.log("Meeting Hls is stopped");
    } else {
      //
    }
   }
  
  const {
    meetingId
    ...
  } = useMeeting({
    onHlsStateChanged,
    ...
  });
  Copy

onLivestreamStateChanged

• onLivestreamStateChanged(
      option: {
          status:
              | "LIVESTREAM_STOPPED"
              | "LIVESTREAM_STARTING"
              | "LIVESTREAM_STARTED"
              | "LIVESTREAM_STOPPING";
      },
  ): void
  • Triggered when the meeting’s livestream state changes.

  Parameters

  • option: {
        status:
            | "LIVESTREAM_STOPPED"
            | "LIVESTREAM_STARTING"
            | "LIVESTREAM_STARTED"
            | "LIVESTREAM_STOPPING";
    }

    • status:
          | "LIVESTREAM_STOPPED"
          | "LIVESTREAM_STARTING"
          | "LIVESTREAM_STARTED"
          | "LIVESTREAM_STOPPING"

      Possible values:

      • LIVESTREAM_STARTING - Livestream is in starting phase and hasn't started yet.
      • LIVESTREAM_STARTED - Livestream has started successfully.
      • LIVESTREAM_STOPPING - Livestream is in stopping phase and hasn't stopped yet.
      • LIVESTREAM_STOPPED - Livestream has stopped successfully.

  Returns void

  Example

  import { Constants, useMeeting } from "@videosdk.live/react-sdk";
  
  function onLivestreamStateChanged(data) {
    const { status } = data;
  
    if (status === Constants.livestreamEvents.LIVESTREAM_STARTING) {
      console.log("Meeting livestream is starting");
    } else if (status === Constants.livestreamEvents.LIVESTREAM_STARTED) {
      console.log("Meeting livestream is started");
    } else if (status === Constants.livestreamEvents.LIVESTREAM_STOPPING) {
      console.log("Meeting livestream is stopping");
    } else if (status === Constants.livestreamEvents.LIVESTREAM_STOPPED) {
      console.log("Meeting livestream is stopped");
    } else {
      //
    }
   }
  
  const {
    meetingId
    ...
  } = useMeeting({
    onLivestreamStateChanged,
  });
  Copy

onMainParticipantChanged

• onMainParticipantChanged(participant: Participant): void
  • Triggered when the main participant in the meeting changes.

  Parameters

  • participant: Participant

    The Participant instance who is now the main participant.

  Returns void

  Example

  function onMainParticipantChanged(participantId) {
    console.log("onMainParticipantChanged", participantId);
  }
  
  const {
    meetingId
    ...
  } = useMeeting({
    onMainParticipantChanged,
    ...
  });
  Copy

onMediaRelayError

• onMediaRelayError(option: { error: string; meetingId: string }): void
  • Triggered when an error occurs during media relay.

  Parameters

  • option: { error: string; meetingId: string }

    • error: string

      Description of the error.

    • meetingId: string

      ID of the meeting where the error occurred.

  Returns void

  Example

  function onMediaRelayError({meetingId, error}) {
    console.error(`Relay error to ${meetingId}: ${error}`);
  }
  
  const {
    meetingId
    ...
  } = useMeeting({
    onMediaRelayError,
    ...
  });
  Copy

onMediaRelayRequestReceived

• onMediaRelayRequestReceived(
      option: {
          accept: () => void;
          displayName: string;
          meetingId: string;
          participantId: string;
          reject: () => void;
      },
  ): void
  • Triggered when a media relay request is received in the destination meeting.

  Parameters

  • option: {
        accept: () => void;
        displayName: string;
        meetingId: string;
        participantId: string;
        reject: () => void;
    }

    • accept: () => void

      Call this function to accept the media relay request.

    • displayName: string

      Display name of the participant requesting the media relay.

    • meetingId: string

      ID of the meeting from which the media relay request originated.

    • participantId: string

      ID of the participant who initiated the media relay request.

    • reject: () => void

      Call this function to reject the media relay request.

  Returns void

  Example

  function onMediaRelayRequestReceived(data) {
      const {participantId , meetingId , displayName} = data;
      console.log(
        `Relay request from ${displayName} (${participantId}) in meeting ${meetingId}`
      );
  }
  
  const {
    meetingId
    ...
  } = useMeeting({
    onMediaRelayRequestReceived,
    ...
  });
  Copy