Class useParticipant

constructor

• new useParticipant(): useParticipant

  Returns useParticipant

displayName

isActiveSpeaker

isLocal

isMainParticipant

micOn

micStream

mode

participant

pinState

screenShareAudioOn

screenShareAudioStream

screenShareOn

screenShareStream

webcamOn

webcamStream

captureImage

• captureImage(options: { height?: number; width?: number }): Promise<string>
  • This method can be used to capture an image from the participant’s current video stream.
  • The captured image is returned as a Base64-encoded string.

  Parameters

  • options: { height?: number; width?: number }

    • Optionalheight?: number

      Desired height of the captured image.

    • Optionalwidth?: number

      Desired width of the captured image.

  Returns Promise<string>

  A Base64-encoded string representing the captured image.

  Throws

  • Errors.ERROR_CAPTURE_IMAGE_FAILED — the image could not be captured. This happens when the participant's webcam is off, the video is not playing, the webcam is turned off during the capture, or the video does not load in time. The error message describes the cause.

  Example

  const { captureImage } = useParticipant(participantId);
  
  async function grabImage() {
    try {
      const image = await captureImage({
        width: 640,
        height: 360,
      });
    } catch (err) {
      console.log("captureImage failed", err);
    }
  }
  Copy

consumeMicStreams

• consumeMicStreams(): Promise<void>
  • This method can be used to start consuming the remote participant's microphone audio stream when autoConsume was set to false in initMeeting().

  Returns Promise<void>

  Throws

  • Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
  • Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
  • Errors.CONSUME_MIC_STREAMS_FAILED — server rejected the consume request
  • Errors.ERROR_OPERATION_TIMED_OUT — the request timed out

  Example

  const { consumeMicStreams } = useParticipant(participantId);
  
  async function startMicConsumption() {
    try {
      await consumeMicStreams();
    } catch (err) {
      console.log("consumeMicStreams failed", err);
    }
  }
  Copy

consumeWebcamStreams

• consumeWebcamStreams(): Promise<void>
  • This method can be used to start consuming the remote participant's webcam video stream when autoConsume was set to false in initMeeting().

  Returns Promise<void>

  Throws

  • Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
  • Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
  • Errors.CONSUME_WEBCAM_STREAMS_FAILED — server rejected the consume request
  • Errors.ERROR_OPERATION_TIMED_OUT — the request timed out

  Example

  const { consumeWebcamStreams } = useParticipant(participantId);
  
  async function startWebcamConsumption() {
    try {
      await consumeWebcamStreams();
    } catch (err) {
      console.log("consumeWebcamStreams failed", err);
    }
  }
  Copy

disableMic

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

  Events associated with disableMic():

  • All participants receive a onStreamDisabled event containing 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.DISABLE_PARTICIPANT_MIC_FAILED — server rejected the request
  • Errors.ERROR_OPERATION_TIMED_OUT — the request timed out

  Example

  const { disableMic } = useParticipant(participantId);
  
  async function turnOffParticipantMic() {
    try {
      await disableMic();
    } catch (err) {
      console.log("disableMic failed", err);
    }
  }
  Copy

disableWebcam

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

  Events associated with disableWebcam():

  • All participants receive a onStreamDisabled event containing 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.DISABLE_PARTICIPANT_WEBCAM_FAILED — server rejected the request
  • Errors.ERROR_OPERATION_TIMED_OUT — the request timed out

  Example

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

enableMic

• enableMic(): Promise<void>
  • This method can be used to enable the remote participant’s microphone.

  Events associated with enableMic():

  • The participant first receives a onMicRequested event. Once the request is accepted, the microphone is enabled.
  • All participants receive a onStreamEnabled even containing 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.ENABLE_PARTICIPANT_MIC_FAILED — server rejected the request
  • Errors.ERROR_OPERATION_TIMED_OUT — the request timed out

  Example

  const { enableMic } = useParticipant(participantId);
  
  async function turnOnParticipantMic() {
    try {
      await enableMic();
    } catch (err) {
      console.log("enableMic failed", err);
    }
  }
  Copy

enableWebcam

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

  Events associated with enableWebcam():

  • The participant first receives a onWebcamRequestedevent. Once the request is accepted, the webcam is enabled.

  • All participants receive a onStreamEnabled event containing 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.ENABLE_PARTICIPANT_WEBCAM_FAILED — server rejected the request
  • Errors.ERROR_OPERATION_TIMED_OUT — the request timed out

  Example

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

getAudioStats

• getAudioStats(): Promise<
      {
          bitrate: number;
          codec: string;
          jitter: number;
          network: string;
          packetsLost: number;
          rtt: number;
          totalPackets: number;
      }[],
  >
  • This method can be used to get detailed statistics about the participant’s audio stream.
  • These metrics provide insights into stream quality, network conditions, and transmission performance at the time the method is called.

  Returns Promise<
      {
          bitrate: number;
          codec: string;
          jitter: number;
          network: string;
          packetsLost: number;
          rtt: number;
          totalPackets: number;
      }[],
  >

  An array of objects containing the following metrics:

  • jitter – Represents variation in packet arrival time (stream instability).
  • bitrate – The bitrate at which the audio stream is being transmitted.
  • totalPackets – Total number of packets transmitted for the stream.
  • packetsLost – Total number of packets lost during transmission.
  • rtt – Round-trip time (in milliseconds) between the client and server.
  • codec – Codec used for encoding the audio stream.
  • network – Network type used for transmitting the stream.

  Info

  If the rtt value exceeds 300ms, consider switching to a region closer to the user for improved performance. Learn more visit here.

  Example

  const { getAudioStats } = useParticipant(participantId);
  
  async function fetchAudioStats() {
    try {
      const audioStats = await getAudioStats();
    } catch (err) {
      console.log("getAudioStats failed", err);
    }
  }
  Copy

getShareAudioStats

• getShareAudioStats(): Promise<
      {
          bitrate: number;
          codec: string;
          jitter: number;
          network: string;
          packetsLost: number;
          rtt: number;
          totalPackets: number;
      }[],
  >
  • This method can be used to get detailed statistics about the participant’s screen share audio stream.
  • These metrics provide insights into stream quality, network conditions, and transmission performance at the time the method is called.

  Returns Promise<
      {
          bitrate: number;
          codec: string;
          jitter: number;
          network: string;
          packetsLost: number;
          rtt: number;
          totalPackets: number;
      }[],
  >

  An array of objects containing the following metrics:

  • jitter – Represents variation in packet arrival time (stream instability).
  • bitrate – The bitrate at which the audio stream is being transmitted.
  • totalPackets – Total number of packets transmitted for the stream.
  • packetsLost – Total number of packets lost during transmission.
  • rtt – Round-trip time (in milliseconds) between the client and server.
  • codec – Codec used for encoding the audio stream.
  • network – Network type used for transmitting the stream.

  Info

  If the rtt value exceeds 300ms, consider switching to a region closer to the user for improved performance. Learn more visit here.

  Example

  const { getShareAudioStats } = useParticipant(participantId);
  
  async function fetchShareAudioStats() {
    try {
      const shareAudioStats = await getShareAudioStats();
    } catch (err) {
      console.log("getShareAudioStats failed", err);
    }
  }
  Copy

getShareStats

• getShareStats(): Promise<
      {
          bitrate: number;
          codec: string;
          currentSpatialLayer: number;
          currentTemporalLayer: number;
          jitter: number;
          limitation: any;
          network: string;
          packetsLost: number;
          preferredSpatialLayer: number;
          preferredTemporalLayer: number;
          rtt: number;
          size: any;
          totalPackets: number;
      }[],
  >
  • This method can be used to get detailed statistics about the participant’s screen share video stream.
  • These metrics provide insights into stream quality, network conditions, and transmission performance at the time the method is called.

  Returns Promise<
      {
          bitrate: number;
          codec: string;
          currentSpatialLayer: number;
          currentTemporalLayer: number;
          jitter: number;
          limitation: any;
          network: string;
          packetsLost: number;
          preferredSpatialLayer: number;
          preferredTemporalLayer: number;
          rtt: number;
          size: any;
          totalPackets: number;
      }[],
  >

  An array of objects containing the following metrics:

  • jitter – Represents variation in packet arrival time (stream instability).
  • bitrate – The bitrate at which the video stream is being transmitted.
  • totalPackets – Total number of packets transmitted for the stream.
  • packetsLost – Total number of packets lost during transmission.
  • rtt – Round-trip time (in milliseconds) between the client and server.
  • codec – Codec used for encoding the video stream.
  • network – Network type used for transmitting the stream.
  • limitation – Indicates any limitations affecting stream quality.
  • size – Resolution or size information related to the stream.

  Info

  If the rtt value exceeds 300ms, consider switching to a region closer to the user for improved performance. Learn more visit here.

  Example

  const { getShareStats } = useParticipant(participantId);
  
  async function fetchShareStats() {
    try {
      const shareStats = await getShareStats();
    } catch (err) {
      console.log("getShareStats failed", err);
    }
  }
  Copy

getTransportStats

• getTransportStats(): Promise<
      {
          receive: { incomingBitrate: number; totalReceivedBytes: number };
          send: { outgoingBitrate: number; totalSentBytes: number };
      },
  >
  • This method can be used to get the transport-level statistics for this participant.
  • These metrics provide an overview of the total bandwidth and bytes transferred for sending and receiving media at the transport layer.

  Returns Promise<
      {
          receive: { incomingBitrate: number; totalReceivedBytes: number };
          send: { outgoingBitrate: number; totalSentBytes: number };
      },
  >

  An object with two nested objects, or null:

  • send.outgoingBitrate – The total outgoing bitrate (in kbps) across all media streams sent by this participant. Returns 0 or null when the value is unavailable.
  • send.totalSentBytes – The total number of bytes sent by this participant across all media streams. Returns 0 or null when the value is unavailable.
  • receive.incomingBitrate – The total incoming bitrate (in kbps) across all media streams received by this participant. Returns 0 or null when the value is unavailable.
  • receive.totalReceivedBytes – The total number of bytes received by this participant across all media streams. Returns 0 or null when the value is unavailable.

  Example

  const { getTransportStats } = useParticipant(participantId);
  
  async function fetchTransportStats() {
    try {
      const transportStats = await getTransportStats();
    } catch (err) {
      console.log("getTransportStats failed", err);
    }
  }
  Copy

getVideoStats

• getVideoStats(): Promise<
      {
          bitrate: number;
          codec: string;
          currentSpatialLayer: number;
          currentTemporalLayer: number;
          jitter: number;
          limitation: any;
          network: string;
          packetsLost: number;
          preferredSpatialLayer: number;
          preferredTemporalLayer: number;
          rtt: number;
          size: any;
          totalPackets: number;
      }[],
  >
  • This method can be used to get detailed statistics about the participant’s video stream.
  • These metrics provide insights into stream quality, network conditions, and transmission performance at the time the method is called.

  Returns Promise<
      {
          bitrate: number;
          codec: string;
          currentSpatialLayer: number;
          currentTemporalLayer: number;
          jitter: number;
          limitation: any;
          network: string;
          packetsLost: number;
          preferredSpatialLayer: number;
          preferredTemporalLayer: number;
          rtt: number;
          size: any;
          totalPackets: number;
      }[],
  >

  An array of objects containing the following metrics:

  • jitter – Represents variation in packet arrival time (stream instability).
  • bitrate – The bitrate at which the video stream is being transmitted.
  • totalPackets – Total number of packets transmitted for the stream.
  • packetsLost – Total number of packets lost during transmission.
  • rtt – Round-trip time (in milliseconds) between the client and server.
  • codec – Codec used for encoding the video stream.
  • network – Network type used for transmitting the stream.
  • limitation – Indicates any limitations affecting stream quality.
  • size – Resolution or size information related to the stream.

  Info

  If the rtt value exceeds 300ms, consider switching to a region closer to the user for improved performance. Learn more visit here.

  Example

  const { getVideoStats } = useParticipant(participantId);
  
  async function fetchVideoStats() {
    try {
      const videoStats = await getVideoStats();
    } catch (err) {
      console.log("getVideoStats failed", err);
    }
  }
  Copy

pin

• pin(type: "SHARE_AND_CAM" | "CAM" | "SHARE"): Promise<void>

  • This method can be used to pin the participant’s camera, screen share, or both.

  • Every participant receives a onPinStateChanged event when the pin state is updated.

  Parameters

  • type: "SHARE_AND_CAM" | "CAM" | "SHARE"

    Specifies which stream to pin.

    Allowed values:

    • "SHARE_AND_CAM" – Pins both screen share and camera streams.
    • "CAM" – Pins only the camera stream.
    • "SHARE" – Pins only the screen-share stream.

    Default

    SHARE_AND_CAM
    Copy

  Returns Promise<void>

  Throws

  • Errors.ERROR_ACTION_NOT_SUPPORTED — unknown pin type
  • Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
  • Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
  • Errors.PIN_FAILED — server rejected the pin request
  • Errors.ERROR_OPERATION_TIMED_OUT — the request timed out

  Example

  const { pin } = useParticipant(participantId);
  
  async function pinCamera() {
    try {
      await pin("CAM");
    } catch (err) {
      console.log("pin failed", err);
    }
  }
  Copy

remove

• remove(): Promise<void>
  • This method can be used to removes the remote participant from the meeting.

  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 — participant id is missing
  • Errors.REMOVE_PARTICIPANT_FAILED — server rejected the remove request
  • Errors.ERROR_OPERATION_TIMED_OUT — the request timed out

  Example

  const { remove } = useParticipant(participantId);
  
  async function removeParticipant() {
    try {
      await remove();
    } catch (err) {
      console.log("remove failed", err);
    }
  }
  Copy

setQuality

• setQuality(quality: "low" | "med" | "high"): Promise<void>
  • This method can be used to set the incoming video quality of the remote participant.

  Parameters

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

  Returns Promise<void>

  Throws

  • Errors.ERROR_ACTION_NOT_SUPPORTED — called on the local participant, or no video stream available
  • Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
  • Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
  • Errors.SET_QUALITY_FAILED — server rejected the request
  • Errors.ERROR_OPERATION_TIMED_OUT — the request timed out

  Example

  const { setQuality } = useParticipant(participantId);
  
  async function updateQuality() {
    try {
      await setQuality("low");
    } catch (err) {
      console.log("setQuality failed", err);
    }
  }
  Copy

setScreenShareQuality

• setScreenShareQuality(quality: "low" | "med" | "high"): Promise<void>
  • This method can be used to set the quality of the incoming screen-share video of the remote participant.

  Parameters

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

  Returns Promise<void>

  Throws

  • Errors.ERROR_ACTION_NOT_SUPPORTED — called on the local participant, or no screen-share stream available
  • Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
  • Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
  • Errors.SET_QUALITY_FAILED — server rejected the request
  • Errors.ERROR_OPERATION_TIMED_OUT — the request timed out

  Example

  const { setScreenShareQuality } = useParticipant(participantId);
  
  async function updateScreenShareQuality() {
    try {
      await setScreenShareQuality("low");
    } catch (err) {
      console.log("setScreenShareQuality failed", err);
    }
  }
  Copy

setViewPort

• setViewPort(width: number, height: number): void
  • This method can be used to adjust the video quality of the remote participant based on the specified viewport dimensions.

  Parameters

  • width: number

    The width of the viewport used to determine the video quality.

  • height: number

    The height of the viewport used to determine the video quality.

  Returns void

  Example

  const { setViewPort } = useParticipant(participantId);
  
  setViewPort(480, 360);
  Copy

stopConsumingMicStreams

• stopConsumingMicStreams(): Promise<void>
  • This method can be used to stop consuming the remote participant's microphone audio stream.

  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_CONSUMING_MIC_STREAMS_FAILED — server rejected the stop-consume request
  • Errors.ERROR_OPERATION_TIMED_OUT — the request timed out

  Example

  const { stopConsumingMicStreams } = useParticipant(participantId);
  
  async function endMicConsumption() {
    try {
      await stopConsumingMicStreams();
    } catch (err) {
      console.log("stopConsumingMicStreams failed", err);
    }
  }
  Copy

stopConsumingWebcamStreams

• stopConsumingWebcamStreams(): Promise<void>
  • This method can be used to stop consuming the remote participant's webcam video stream.

  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_CONSUMING_WEBCAM_STREAMS_FAILED — server rejected the stop-consume request
  • Errors.ERROR_OPERATION_TIMED_OUT — the request timed out

  Example

  const { stopConsumingWebcamStreams } = useParticipant(participantId);
  
  async function endWebcamConsumption() {
    try {
      await stopConsumingWebcamStreams();
    } catch (err) {
      console.log("stopConsumingWebcamStreams failed", err);
    }
  }
  Copy

unpin

• unpin(type: "SHARE_AND_CAM" | "CAM" | "SHARE"): Promise<void>

  • This method can be used to unpin the participant’s camera, screen share, or both.

  • Every participant receives a onPinStateChanged event when the pin state is updated.

  Parameters

  • type: "SHARE_AND_CAM" | "CAM" | "SHARE"

    Specifies which stream to unpin.

    Allowed values:

    • "SHARE_AND_CAM" – Unpins both screen share and camera streams.
    • "CAM" – Unpins only the camera stream.
    • "SHARE" – Unpins only the screen-share stream.

    Default

    "SHARE_AND_CAM"
    Copy

  Returns Promise<void>

  Throws

  • Errors.ERROR_ACTION_NOT_SUPPORTED — unknown unpin type
  • Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
  • Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
  • Errors.UNPIN_FAILED — server rejected the unpin request
  • Errors.ERROR_OPERATION_TIMED_OUT — the request timed out

  Example

  const { unpin } = useParticipant(participantId);
  
  async function unpinCamera() {
    try {
      await unpin("CAM");
    } catch (err) {
      console.log("unpin failed", err);
    }
  }
  Copy

onMediaStatusChanged

• onMediaStatusChanged(
      data: {
          kind: "audio" | "video" | "share" | "shareAudio";
          newStatus: boolean;
      },
  ): void

  Triggered when the media status of a participant changes (for example, when audio or video is enabled or disabled).

  Parameters

  • data: { kind: "audio" | "video" | "share" | "shareAudio"; newStatus: boolean }

    • kind: "audio" | "video" | "share" | "shareAudio"

      Type of stream whose status changed.

    • newStatus: boolean

      The updated status of the stream.

  Returns void

  Example

  function onMediaStatusChanged(data) {
    const { kind, newStatus} = data;
  }
  
  const {
    displayName
    ...
  } = useParticipant(participantId,{
    onMediaStatusChanged,
    ...
  });
  Copy

onStreamDisabled

• onStreamDisabled(stream: Stream): void

  Triggered when a participant’s audio, video, or screen-share stream is disabled.

  Parameters

  • stream: Stream

    The Stream that was disabled.

  Returns void

  Example

  function onStreamDisabled(stream) {
    console.log("onStreamDisabled", stream);
  }
  
  const {
    displayName
    ...
  } = useParticipant(participantId,{
    onStreamDisabled,
    ...
  });
  Copy

onStreamEnabled

• onStreamEnabled(stream: Stream): void

  Triggered when a participant’s audio, video, or screen-share stream is enabled.

  Parameters

  • stream: Stream

    The Stream that was enabled.

  Returns void

  Example

  function onStreamEnabled(stream) {
    console.log("onStreamEnabled", stream);
  }
  
  const {
    displayName
    ...
  } = useParticipant(participantId,{
    onStreamEnabled,
    ...
  });
  Copy

onStreamPaused

• onStreamPaused(data: { kind: "video"; reason: string }): void

  • Triggered when a participant’s video, audio, or screen-share stream is paused.

  • This event is triggered only when the Subscription Manager is enabled by calling the enableAdaptiveSubscription() method.

  Parameters

  • data: { kind: "video"; reason: string }

    • kind: "video"

      Type of stream that was paused.

    • reason: string

      Reason why the stream was paused.

      Possible values:

      • "muted" – Stream was paused because it was muted.
      • "leastDominance" – Stream was paused due to bandwidth or dominance rules.

  Returns void

  Example

  function onStreamPaused({ kind, reason }) {
    console.log(kind, reason);
  }
  
  const {
    displayName
    ...
  } = useParticipant(participantId,{
    onStreamPaused,
    ...
  });
  Copy

onStreamResumed

• onStreamResumed(data: { kind: "video"; reason: string }): void

  • Triggered when a participant’s video, audio, or screen-share stream is resumed.

  • This event is triggered only when the Subscription Manager is enabled by calling the enableAdaptiveSubscription() method.

  Parameters

  • data: { kind: "video"; reason: string }

    • kind: "video"

      Type of stream that was resumed.

    • reason: string

      Reason why the stream was resumed.

      Possible values:

      • "adaptiveSubscriptionsDisabled" – Stream resumed after adaptive subscriptions were disabled.
      • "networkStable" – Stream resumed due to stable network conditions.

  Returns void

  Example

  function onStreamResumed({ kind, reason }) {
    console.log(kind, reason);
  }
  
  const {
    displayName
    ...
  } = useParticipant(participantId,{
    onStreamResumed,
    ...
  });
  Copy

onVideoQualityChanged

• onVideoQualityChanged(
      data: {
          currentQuality: "low" | "med" | "high";
          prevQuality: "low" | "med" | "high";
      },
  ): void

  • Triggered when the video quality of a participant changes.

  • The currentQuality and prevQuality values can be HIGH, MEDIUM, or LOW.

  Parameters

  • data: { currentQuality: "low" | "med" | "high"; prevQuality: "low" | "med" | "high" }

    • currentQuality: "low" | "med" | "high"

      The updated video quality level.

    • prevQuality: "low" | "med" | "high"

      The previous video quality level.

  Returns void

  Example

  function onVideoQualityChanged(data) {
    const { currentQuality, prevQuality } = data;
  }
  
  const {
    displayName
    ...
  } = useParticipant(participantId,{
    onVideoQualityChanged,
    ...
  });
  Copy