Class useRoom

constructor

• new useRoom(): useRoom

  Returns useRoom

activeSpeakerId

baseUrl

hlsState

hlsUrls

isCamEnabled

isHls

isLiveStreaming

isMicEnabled

isRecording

isRoomJoined

isScreenSharing

liveStreamState

localParticipant

messages

participants

pinnedParticipants

presenterId

recordingState

room

roomId

selectedCameraDevice

selectedMicrophoneDevice

transcriptionState

translationState

"TRANSLATION_STOPPED"
Copy

changeCam

• changeCam(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 room.

  Parameters

  • Optionalobject: string | MediaStream

    Either:

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

    Omit it to move to the camera after the current one in useMediaDevice's getCameras() list, wrapping around.

  Returns Promise<void>

  Throws

  • Everything Room.disableCam | disableCam and Room.enableCam | enableCam can throw
  • VideoSDKError.ERROR_NO_WEBCAM_DEVICE_FOUND — no webcam device found for the given id
  • VideoSDKError.ERROR_OPERATION_IN_PROGRESS — a webcam change/enable is already in flight
  • VideoSDKError.ERROR_OPERATION_TIMED_OUT — the request timed out

  Example

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

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 room.

  Parameters

  • Optionalobject: string | MediaStream

    Either:

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

    Omit it to move to the microphone after the current one in useMediaDevice's getMics() list, wrapping around.

  Returns Promise<void>

  Throws

  • Everything Room.muteMic | muteMic and Room.unmuteMic | unmuteMic can throw
  • VideoSDKError.ERROR_NO_MICROPHONE_DEVICE_FOUND — no microphone device found for the given id
  • VideoSDKError.ERROR_OPERATION_TIMED_OUT — the request timed out

  Example

  const { changeMic } = useRoom();
  const { getMics } = useMediaDevice();
  
  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: Mode.

  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

  • VideoSDKError.ERROR_ACTION_PERFORMED_BEFORE_ROOM_JOINED — called before room is joined
  • VideoSDKError.ERROR_ALREADY_IN_REQUESTED_STATE — already in that mode
  • VideoSDKError.CHANGE_MODE_FAILED — server rejected the change-mode request
  • VideoSDKError.ERROR_OPERATION_TIMED_OUT — the request timed out

  Example

  import { Constants, useRoom } from "@videosdk.live/react-native-sdk";
  
  const { changeMode } = useRoom();
  
  async function switchToSendAndRecv() {
    try {
      await changeMode(Constants.Mode.SEND_AND_RECV);
    } catch (err) {
      console.log("changeMode 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

  • VideoSDKError.ERROR_ACTION_PERFORMED_BEFORE_ROOM_JOINED — called before room is joined
  • VideoSDKError.ERROR_ROOM_RECONNECTING — room is reconnecting
  • VideoSDKError.ADAPTIVE_SUBSCRIPTION_DISABLE_FAILED — adaptive subscription is already disabled
  • VideoSDKError.ERROR_OPERATION_TIMED_OUT — the request timed out

  Example

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

disableCam

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

  Events associated with disableCam():

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

  Returns Promise<void>

  Throws

  • VideoSDKError.ERROR_ACTION_PERFORMED_BEFORE_ROOM_JOINED — called before room is joined
  • VideoSDKError.ERROR_ROOM_RECONNECTING — room is reconnecting
  • VideoSDKError.ERROR_ACTION_NOT_SUPPORTED_IN_MODE — not allowed in viewer/RECV_ONLY mode
  • VideoSDKError.ERROR_OPERATION_IN_PROGRESS — change-mode / webcam-enable / webcam-disable already in flight
  • VideoSDKError.ERROR_ALREADY_IN_REQUESTED_STATE — webcam is already disabled
  • VideoSDKError.ERROR_WEBCAM_CLOSE_PRODUCER_FAILED — The camera could not be turned off.
  • VideoSDKError.ERROR_OPERATION_TIMED_OUT — the request timed out

  Example

  const { disableCam } = useRoom();
  
  async function turnOffWebcam() {
    try {
      await disableCam();
    } catch (err) {
      console.log("disableCam 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 RTCStream object.
  • A onPresenterChanged event is emitted with null as the presenter.

  Returns Promise<void>

  Throws

  • VideoSDKError.ERROR_ACTION_PERFORMED_BEFORE_ROOM_JOINED — called before room is joined
  • VideoSDKError.ERROR_ROOM_RECONNECTING — room is reconnecting
  • VideoSDKError.ERROR_ACTION_NOT_SUPPORTED_IN_MODE — not allowed in viewer/RECV_ONLY mode
  • VideoSDKError.ERROR_OPERATION_IN_PROGRESS — share-disable is in flight
  • VideoSDKError.ERROR_ALREADY_IN_REQUESTED_STATE — screen share is already disabled

  Example

  const { disableScreenShare } = useRoom();
  
  async function stopScreenShare() {
    try {
      await disableScreenShare();
    } catch (err) {
      console.log("disableScreenShare 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

  • VideoSDKError.ERROR_ACTION_PERFORMED_BEFORE_ROOM_JOINED — called before room is joined
  • VideoSDKError.ERROR_ROOM_RECONNECTING — room is reconnecting
  • VideoSDKError.ADAPTIVE_SUBSCRIPTION_ENABLE_FAILED — adaptive subscription is already enabled
  • VideoSDKError.ERROR_OPERATION_TIMED_OUT — the request timed out

  Example

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

enableCam

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

  Events associated with enableCam():

  • A onStreamEnabled event is emitted with the corresponding RTCStream 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

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

  Example

  const { enableCam } = useRoom();
  
  async function turnOnWebcam() {
    try {
      await enableCam();
    } catch (err) {
      console.log("enableCam 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 RTCStream 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

  • VideoSDKError.ERROR_ACTION_PERFORMED_BEFORE_ROOM_JOINED — called before room is joined
  • VideoSDKError.ERROR_ROOM_RECONNECTING — room is reconnecting
  • VideoSDKError.ERROR_ACTION_NOT_SUPPORTED_IN_MODE — not allowed in viewer/RECV_ONLY mode
  • VideoSDKError.ERROR_OPERATION_IN_PROGRESS — share-disable is in flight
  • VideoSDKError.ERROR_MEDIA_DEVICE_NOT_INITIALIZED — media device not initialized
  • VideoSDKError.ERROR_MEDIA_DEVICE_NOT_LOADED — media device not loaded
  • VideoSDKError.ERROR_GET_DISPLAY_MEDIA — browser cannot getDisplayMedia
  • VideoSDKError.ERROR_MEDIA_NOT_READY — transport not ready
  • VideoSDKError.ERROR_SCREENSHARE_PRODUCE_FAILED — screen-share track could not be published
  • VideoSDKError.ERROR_OPERATION_TIMED_OUT — the request timed out

  Example

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

end

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

  Events associated with end():

  • All participants receive the onRoomLeft event.

  Returns Promise<void>

  Throws

  • VideoSDKError.ERROR_ACTION_PERFORMED_BEFORE_ROOM_JOINED — called before room is joined
  • VideoSDKError.ERROR_ROOM_RECONNECTING — room is reconnecting
  • VideoSDKError.ERROR_END_ROOM_FAILED — server rejected the end request (reason bubbled up)
  • VideoSDKError.ERROR_OPERATION_TIMED_OUT — the request timed out

  Example

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

getActivePresenterId

• getActivePresenterId(): string

  The participant presenting now, or null.

  Returns string

getActiveSpeakerId

• getActiveSpeakerId(): string

  The participant speaking now, or null.

  Returns string

join

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

  Events associated with join():

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

  Returns Promise<void>

  Throws

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

  Example

  const { join } = useRoom();
  
  async function joinRoom() {
    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 room.

  Events associated with leave():

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

  Returns Promise<void>

  Throws

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

  Example

  const { leave } = useRoom();
  
  async function leaveRoom() {
    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 RTCStream object.

  Returns Promise<void>

  Throws

  • VideoSDKError.ERROR_ACTION_PERFORMED_BEFORE_ROOM_JOINED — called before room is joined
  • VideoSDKError.ERROR_ROOM_RECONNECTING — room is reconnecting
  • VideoSDKError.ERROR_ACTION_NOT_SUPPORTED_IN_MODE — not allowed in viewer/RECV_ONLY mode
  • VideoSDKError.ERROR_OPERATION_IN_PROGRESS — change-mode / mic-enable / mic-disable already in flight
  • VideoSDKError.ERROR_ALREADY_IN_REQUESTED_STATE — mic is already disabled
  • VideoSDKError.ERROR_MICROPHONE_CLOSE_PRODUCER_FAILED — The microphone could not be turned off.
  • VideoSDKError.ERROR_OPERATION_TIMED_OUT — the request timed out

  Example

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

pauseAllStreams

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

  Parameters

  • Optionalkind: "audio" | "video" | "share" | "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

  • VideoSDKError.PAUSE_ALL_STREAMS_FAILED — server rejected the request
  • VideoSDKError.ERROR_OPERATION_TIMED_OUT — the request timed out

  Example

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

removeVideoProcessor

• removeVideoProcessor(): Promise<void>

  Uninstalls the applied frame processor; idempotent.

  Returns Promise<void>

requestMediaRelay

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

  Parameters

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

    • destinationRoomId: string

      The room ID to relay media to.

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

      Optional array of media kinds to relay. Relays every kind when omitted; an empty array relays none.

    • Optionaltoken?: string

      Optional token for the destination room.

  Returns Promise<void>

  Throws

  • VideoSDKError.ERROR_INVALID_PARAMETER — missing destinationRoomId
  • VideoSDKError.ERROR_ACTION_PERFORMED_BEFORE_ROOM_JOINED — called before room is joined
  • VideoSDKError.ERROR_ROOM_RECONNECTING — room is reconnecting
  • VideoSDKError.REQUEST_MEDIA_RELAY_FAILED — server rejected the request
  • VideoSDKError.ERROR_OPERATION_TIMED_OUT — the request timed out

  Example

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

respondEntry

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

  Parameters

  • participantId: string

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

  • decision: "allowed" | "denied"

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

  Returns Promise<void>

  Throws

  • VideoSDKError.ERROR_ACTION_PERFORMED_BEFORE_ROOM_JOINED — called before room is joined
  • VideoSDKError.ERROR_ROOM_RECONNECTING — room is reconnecting
  • VideoSDKError.RESPOND_ENTRY_FAILED — server rejected the entry-response
  • VideoSDKError.ERROR_OPERATION_TIMED_OUT — the request timed out

  Example

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

resumeAllStreams

• resumeAllStreams(kind?: "audio" | "video" | "share" | "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" | "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

  • VideoSDKError.RESUME_ALL_STREAMS_FAILED — server rejected the request
  • VideoSDKError.ERROR_OPERATION_TIMED_OUT — the request timed out

  Example

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

send

• send(
      message: string | ArrayBuffer | ArrayBufferView<ArrayBufferLike>,
      reliable?: boolean,
  ): Promise<void>
  • This method can be used to send a message to all participants in the room using the data channel.

  Parameters

  • message: string | ArrayBuffer | ArrayBufferView<ArrayBufferLike>
  • Optionalreliable: boolean

    Retransmit until delivered, preserving order, at the cost of some latency. false is faster but a frame may be dropped on a poor network. Defaults to true.

  Returns Promise<void>

  Throws

  • VideoSDKError.ERROR_ACTION_NOT_SUPPORTED — invalid or too-large payload
  • VideoSDKError.ERROR_MEDIA_NOT_READY — transport not ready
  • VideoSDKError.ERROR_ACTION_NOT_SUPPORTED_IN_MODE — not allowed in viewer/RECV_ONLY mode
  • VideoSDKError.ERROR_ACTION_PERFORMED_BEFORE_ROOM_JOINED — called before room is joined
  • VideoSDKError.ERROR_ROOM_RECONNECTING — room is reconnecting
  • VideoSDKError.ERROR_SEND_FAILED — data-producer / send failed
  • VideoSDKError.ERROR_OPERATION_TIMED_OUT — the request timed out

  Example

  const { send } = useRoom();
  
  async function sendMessage() {
    try {
      await send("Hello everyone!", false);
    } catch (err) {
      console.log("send failed", err);
    }
  }
  Copy

setVideoProcessor

• setVideoProcessor(processor: string): Promise<void>

  Applies the native frame processor registered under processor.

  A JS function cannot process frames: the processor is native code the host app registers by name (Kotlin VideoProcessorRegistry.register, Swift VideoProcessorRegistry.shared.register), and this selects it.

  Parameters

  • processor: string

  Returns Promise<void>

startHLS

• startHLS(
      config?: HLSConfig,
      transcription?: {
          enabled: boolean;
          modelId?: string;
          summary?: { enabled: boolean; prompt?: string };
      },
  ): Promise<void>
  • This method can be used to start HLS streaming for the room.
  • This allows participants and viewers to watch the room via HLS playback.
  • All participants, including the local participant, will receive the HLS_STARTING event state in the onHlsStateChanged event.

  Parameters

  • Optionalconfig: HLSConfig

    Configuration used to control the HLS stream.

    How an HLS stream looks, for useRoom's startHLS. A field left out takes the server's default.

    • Optionallayout?: ConfigLayout

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

      Whether video is streamed or audio only.

    • Optionalorientation?: "landscape" | "portrait"

      The output orientation.

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

      The output quality.

    • Optionalrecording?: { enabled: boolean }

      Whether the HLS stream is also recorded.

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

      The background theme.

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

    Configuration for post-room transcription and summary generation.

    • enabled: boolean

      Enables or disables transcription.

    • OptionalmodelId?: string

      Transcription model to use; the server default when left out.

    • 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

  • VideoSDKError.ERROR_ACTION_PERFORMED_BEFORE_ROOM_JOINED — called before room is joined
  • VideoSDKError.ERROR_ROOM_RECONNECTING — room is reconnecting
  • VideoSDKError.START_HLS_FAILED — server rejected the request
  • VideoSDKError.ERROR_OPERATION_TIMED_OUT — the request timed out

  Example

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

startLivestream

• startLivestream(
      outputs: LivestreamOutput[],
      config?: LivestreamConfig,
  ): Promise<void>
  • This method can be used to start live streaming the room.
  • This allows you to stream the room 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: LivestreamOutput[]

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

  • Optionalconfig: LivestreamConfig

    Configuration options for the RTMP livestream.

    How an RTMP livestream looks, for useRoom's startLivestream. A field left out takes the server's default.

    • Optionallayout?: ConfigLayout

    • Optionalrecording?: { enabled: boolean }

      Whether the livestream is also recorded.

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

      The background theme.

  Returns Promise<void>

  Throws

  • VideoSDKError.ERROR_ACTION_PERFORMED_BEFORE_ROOM_JOINED — called before room is joined
  • VideoSDKError.ERROR_ROOM_RECONNECTING — room is reconnecting
  • VideoSDKError.START_LIVESTREAM_FAILED — server rejected the request
  • VideoSDKError.ERROR_OPERATION_TIMED_OUT — the request timed out

  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 } = useRoom();
  
  async function beginLivestream() {
    try {
      await startLivestream(outputs, config, transcription);
    } catch (err) {
      console.log("startLivestream failed", err);
    }
  }
  Copy

startRecording

• startRecording(
      webhookUrl?: string,
      awsDirPath?: string,
      config?: RecordingConfig,
      transcription?: {
          enabled: boolean;
          language?: string;
          modelId?: string;
          summary?: { enabled: boolean; prompt?: string };
      },
  ): Promise<void>

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

  • 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: RecordingConfig

    Recording configuration options.

    How a cloud recording looks, for useRoom's startRecording. A field left out takes the server's default.

    • Optionallayout?: ConfigLayout

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

      Whether video is recorded or audio only.

    • Optionalorientation?: "landscape" | "portrait"

      The output orientation.

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

      The output quality.

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

      The background theme.

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

    Configuration for post-recording transcription and summary generation.

    • enabled: boolean

      Enables or disables transcription.

    • Optionallanguage?: string

    • OptionalmodelId?: string

      Transcription model to use; the server default when left out.

    • 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

  • VideoSDKError.ERROR_ACTION_PERFORMED_BEFORE_ROOM_JOINED — called before room is joined
  • VideoSDKError.ERROR_ROOM_RECONNECTING — room is reconnecting
  • VideoSDKError.START_RECORDING_FAILED — server rejected the request
  • VideoSDKError.ERROR_OPERATION_TIMED_OUT — the request timed out

  Example

  const webhookUrl = "https://webhook.your-api-server.com";
  
  const awsDirPath = "/room-recordings/";
  
  const config = {
    layout: {
      type: "SPOTLIGHT",
      priority: "PIN",
      gridSize: 9,
    },
    theme: "DEFAULT",
  };
  
  const transcription = {
    enabled: true,
    summary: {
      enabled: true,
    },
  };
  
  const { startRecording } = useRoom();
  
  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

  • VideoSDKError.ERROR_ACTION_PERFORMED_BEFORE_ROOM_JOINED — called before room is joined
  • VideoSDKError.ERROR_ROOM_RECONNECTING — room is reconnecting
  • VideoSDKError.STOP_HLS_FAILED — server rejected the request
  • VideoSDKError.ERROR_OPERATION_TIMED_OUT — the request timed out

  Example

  const { stopHLS } = useRoom();
  
  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

  • VideoSDKError.ERROR_ACTION_PERFORMED_BEFORE_ROOM_JOINED — called before room is joined
  • VideoSDKError.ERROR_ROOM_RECONNECTING — room is reconnecting
  • VideoSDKError.STOP_LIVESTREAM_FAILED — server rejected the request
  • VideoSDKError.ERROR_OPERATION_TIMED_OUT — the request timed out

  Example

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

stopMediaRelay

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

  Parameters

  • destinationRoomId: string

    The room ID to stop media relay to.

  Returns Promise<void>

  Throws

  • VideoSDKError.ERROR_INVALID_PARAMETER — missing destinationRoomId
  • VideoSDKError.ERROR_ACTION_PERFORMED_BEFORE_ROOM_JOINED — called before room is joined
  • VideoSDKError.ERROR_ROOM_RECONNECTING — room is reconnecting
  • VideoSDKError.STOP_MEDIA_RELAY_FAILED — server rejected the request
  • VideoSDKError.ERROR_OPERATION_TIMED_OUT — the request timed out

  Example

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

stopRecording

• stopRecording(): Promise<void>

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

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

  Returns Promise<void>

  Throws

  • VideoSDKError.ERROR_ACTION_PERFORMED_BEFORE_ROOM_JOINED — called before room is joined
  • VideoSDKError.ERROR_ROOM_RECONNECTING — room is reconnecting
  • VideoSDKError.STOP_RECORDING_FAILED — server rejected the request
  • VideoSDKError.ERROR_OPERATION_TIMED_OUT — the request timed out

  Example

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

switchTo

• switchTo(roomId: string, token?: string): Promise<void>
  • This method can be used to switch the current session to another room without disconnecting.
  • This allows a seamless transition between rooms while preserving the active session context.

  Parameters

  • roomId: string
  • Optionaltoken: string

  Returns Promise<void>

  Throws

  • VideoSDKError.ERROR_INVALID_PARAMETER — invalid roomId
  • VideoSDKError.SWITCH_ROOM_FAILED — server rejected the switch-room request
  • VideoSDKError.ERROR_ACTION_PERFORMED_BEFORE_ROOM_JOINED — called before room is joined
  • VideoSDKError.ERROR_ROOM_RECONNECTING — room is reconnecting
  • VideoSDKError.ERROR_OPERATION_TIMED_OUT — the request timed out

  Example

  const { switchTo } = useRoom();
  
  async function switchRoom() {
    try {
      await switchTo("new-room-id", "optional-auth-token");
    } catch (err) {
      console.log("switchTo failed", err);
    }
  }
  Copy

toggleCam

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

  Events associated with toggleCam():

  • A onStreamEnabled event is emitted with the corresponding RTCStream object if webcam is turned on.
  • A onStreamDisabled event is emitted with the corresponding RTCStream 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 { toggleCam } = useRoom();
  
  async function handleToggleWebcam() {
    try {
      await toggleCam();
    } catch (err) {
      console.log("toggleCam 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 RTCStream object if mic is turned on.
  • A onStreamDisabled event is emitted with the corresponding RTCStream 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 } = useRoom();
  
  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 RTCStream object if screen share is turned on.
  • A onStreamDisabled event is emitted with the corresponding RTCStream 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 } = useRoom();
  
  async function handleToggleScreenShare() {
    try {
      await toggleScreenShare();
    } catch (err) {
      console.log("toggleScreenShare 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 RTCStream 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

  • VideoSDKError.ERROR_ACTION_PERFORMED_BEFORE_ROOM_JOINED — called before room is joined
  • VideoSDKError.ERROR_ROOM_RECONNECTING — room is reconnecting
  • VideoSDKError.ERROR_ACTION_NOT_SUPPORTED_IN_MODE — not allowed in viewer/RECV_ONLY mode
  • VideoSDKError.ERROR_OPERATION_IN_PROGRESS — change-mode / mic-enable / mic-disable already in flight
  • VideoSDKError.ERROR_ALREADY_IN_REQUESTED_STATE — mic is already enabled
  • VideoSDKError.ERROR_MEDIA_DEVICE_NOT_LOADED — media device not loaded
  • VideoSDKError.ERROR_MICROPHONE_ACCESS_UNAVAILABLE — microphone access unavailable
  • VideoSDKError.ERROR_MEDIA_DEVICE_NOT_INITIALIZED — media device not initialized
  • VideoSDKError.ERROR_NO_MICROPHONE_DEVICE_FOUND — no microphone device found
  • VideoSDKError.ERROR_MEDIA_NOT_READY — transport not ready
  • VideoSDKError.ERROR_MICROPHONE_PRODUCE_FAILED — microphone track could not be published
  • VideoSDKError.ERROR_OPERATION_TIMED_OUT — the request timed out

  Example

  const { unmuteMic } = useRoom();
  
  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

  Not emitted on React Native. The native modules have no event behind it, so a handler passed here never runs. Present for parity with the JS SDK.

  • 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 {
    roomId
    ...
  } = useRoom({
    onAudioInputSilence,
    ...
  });
  Copy

onCodecChanged

• onCodecChanged(
      data: {
          causedBy?: Participant;
          currentCodec: string;
          kind: "video";
          previousCodec: string;
          unsupportedRemoteCodec: string;
      },
  ): void
  • Triggered when the room's active media codec changes because a newly joined participant does not support the current codec.
  • The room 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 room 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 {
    roomId
    ...
  } = useRoom({
    onCodecChanged,
    ...
  });
  Copy

onDataReceived

• onDataReceived(
      data: {
          data: Uint8Array<ArrayBufferLike>;
          isBinary: boolean;
          reliable: boolean;
          senderId: string;
          text: string;
          timestamp: number;
      },
  ): void
  • Triggered whenever a message is received over the DataStream.

  Parameters

  • data: {
        data: Uint8Array<ArrayBufferLike>;
        isBinary: boolean;
        reliable: boolean;
        senderId: string;
        text: string;
        timestamp: number;
    }

    • data: Uint8Array<ArrayBufferLike>

    • isBinary: boolean

    • reliable: boolean

      Whether the frame was sent on the reliable channel.

    • senderId: string

    • text: string

    • timestamp: number

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

  Returns void

  Example

  function onDataReceived({ senderId, text, data, isBinary, timestamp }){
    if (isBinary) {
      console.log(`Binary data from ${senderId}:`, data);
    } else {
      console.log(`Text message from ${senderId}: ${text}`);
    }
  
    console.log(`Received at: ${new Date(timestamp).toLocaleTimeString()}`);
  };
  
  const {
    roomId
    ...
  } = useRoom({
    onDataReceived,
    ...
  });
  Copy

onEntryRequested

• onEntryRequested(
      option: {
          allow: () => void;
          deny: () => void;
          name: string;
          participantId: string;
      },
  ): void
  • Triggered when a participant requests to join the room 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 room.

    • 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 room.

  Returns void

  Example

  function onEntryRequested(data) {
    const { participantId, name, allow, deny } = data;
  
    console.log(`${name} requested to join the room.`);
  
    // If you want to allow the entry request
    allow();
  
    // if you want to deny the entry request
    deny();
  }
  
  const {
    roomId
    ...
  } = useRoom({
    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 room.

  Parameters

  • participantId: string

    ID of the participant who requested to join the room.

  • 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 room
  
    if (decision === "allowed") {
      // entry allowed
    } else {
      // entry denied
    }
  }
  
  const {
    roomId
    ...
  } = useRoom({
    onEntryResponded,
    ...
  });
  Copy

onError

• onError(option: { code: number; message: string }): void
  • Triggered when an error occurs during the room lifecycle.
  • The event provides an error code and a descriptive message. Refer to VideoSDKError 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 {
    roomId
    ...
  } = useRoom({
    onError,
    ...
  });
  Copy

onExternalCallAnswered

• onExternalCallAnswered(data: { callType: "incoming" | "outgoing" }): void
  • Triggered when the external phone call is answered.

  Parameters

  • data: { callType: "incoming" | "outgoing" }

  Returns void

onExternalCallHangup

• onExternalCallHangup(data: { callType: "incoming" | "outgoing" }): void
  • Triggered when an answered external call ends.

  Parameters

  • data: { callType: "incoming" | "outgoing" }

  Returns void

onExternalCallRejected

• onExternalCallRejected(data: { callType: "incoming" | "outgoing" }): void
  • Triggered when a ringing call ends without being answered. A missed call reports here too.

  Parameters

  • data: { callType: "incoming" | "outgoing" }

  Returns void

onExternalCallRinging

• onExternalCallRinging(data: { callType: "incoming" | "outgoing" }): void
  • Triggered when an incoming phone call starts ringing on the device.

  Parameters

  • data: { callType: "incoming" | "outgoing" }

  Returns void

onHlsStateChanged

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

  Parameters

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

    • hlsUrl: { livestreamUrl: string; playbackHlsUrl: string }

      • livestreamUrl: string

        Live HLS without playback support

      • playbackHlsUrl: string

        Live HLS with playback support

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

      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, useRoom } from "@videosdk.live/react-native-sdk";
  
  function onHlsStateChanged(data) {
     const { state } = data;
  
    if (state === Constants.hlsEvents.HLS_STARTING) {
      console.log("Room Hls is starting");
    } else if (state === Constants.hlsEvents.HLS_STARTED) {
      console.log("Room Hls is started");
    } else if (state === Constants.hlsEvents.HLS_PLAYABLE) {
      // on hlsStateChanged started you will receive  playbaclHlsUrl and livestreamUrl.
      const { playbackHlsUrl } = data.hlsUrl;
      console.log("Room Hls is playable");
    } else if (state === Constants.hlsEvents.HLS_STOPPING) {
      console.log("Room Hls is stopping");
    } else if (state === Constants.hlsEvents.HLS_STOPPED) {
      console.log("Room Hls is stopped");
    } else {
      //
    }
   }
  
  const {
    roomId
    ...
  } = useRoom({
    onHlsStateChanged,
    ...
  });
  Copy

onLivestreamStarted

• onLivestreamStarted(): void

  • Triggered when the server confirms the livestream is running.

  • Prefer onLivestreamStateChanged for the full lifecycle.

  Returns void

  Example

  import { useRoom } from "@videosdk.live/react-native-sdk";
  
  function onLivestreamStarted() {
    console.log("livestream is running");
  }
  
  useRoom({ onLivestreamStarted });
  Copy

onLivestreamStateChanged

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

  Parameters

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

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

      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, useRoom } from "@videosdk.live/react-native-sdk";
  
  function onLivestreamStateChanged(data) {
    const { state } = data;
  
    if (state === Constants.livestreamEvents.LIVESTREAM_STARTING) {
      console.log("Room livestream is starting");
    } else if (state === Constants.livestreamEvents.LIVESTREAM_STARTED) {
      console.log("Room livestream is started");
    } else if (state === Constants.livestreamEvents.LIVESTREAM_STOPPING) {
      console.log("Room livestream is stopping");
    } else if (state === Constants.livestreamEvents.LIVESTREAM_STOPPED) {
      console.log("Room livestream is stopped");
    } else {
      //
    }
   }
  
  const {
    roomId
    ...
  } = useRoom({
    onLivestreamStateChanged,
  });
  Copy

onLivestreamStopped

• onLivestreamStopped(): void

  • Triggered when the server confirms the livestream has stopped.

  • Prefer onLivestreamStateChanged for the full lifecycle.

  Returns void

  Example

  import { useRoom } from "@videosdk.live/react-native-sdk";
  
  function onLivestreamStopped() {
    console.log("livestream has stopped");
  }
  
  useRoom({ onLivestreamStopped });
  Copy

onMediaRelayError

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

  Parameters

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

    • error: string

      Description of the error.

    • roomId: string

      ID of the room where the error occurred.

  Returns void

  Example

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

onMediaRelayRequestReceived

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

  Parameters

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

    • accept: () => void

      Call this function to accept the media relay request.

    • displayName: string

      Display name of the participant requesting the media relay.

    • participantId: string

      ID of the participant who initiated the media relay request.

    • reject: () => void

      Call this function to reject the media relay request.

    • roomId: string

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

  Returns void

  Example

  function onMediaRelayRequestReceived(data) {
      const {participantId , roomId , displayName} = data;
      console.log(
        `Relay request from ${displayName} (${participantId}) in room ${roomId}`
      );
  }
  
  const {
    roomId
    ...
  } = useRoom({
    onMediaRelayRequestReceived,
    ...
  });
  Copy

onMediaRelayRequestResponse

• onMediaRelayRequestResponse(
      option: {
          decidedBy: string;
          decision: "ACCEPTED" | "REJECTED";
          participantId: string;
      },
  ): void
  • Triggered when a response is received for a media relay request in the source room.

  Parameters

  • option: { decidedBy: string; decision: "ACCEPTED" | "REJECTED"; participantId: string }

    • decidedBy: string

      ID of the participant who decided the decision.

    • decision: "ACCEPTED" | "REJECTED"

      Decision taken for the request.

    • participantId: string

      ID of the participant who responded to the media relay request.

  Returns void

  Example

  function onMediaRelayRequestResponse(data) {
      const {decision , decidedBy , participantId} = data;
      console.log(
        `Relay response from (${participantId}) : ${decision} `
      );
  }
  
  const {
    roomId
    ...
  } = useRoom({
    onMediaRelayRequestResponse,
    ...
  });
  Copy