Class LocalParticipant

audioTrackPublications

trackPublications

videoTrackPublications

isE2EEEnabled

• get isE2EEEnabled(): boolean

• Returns boolean

isLocal

• get isLocal(): boolean

• Returns boolean

lastCameraError

• get lastCameraError(): undefined | Error

• Returns undefined | Error

lastMicrophoneError

• get lastMicrophoneError(): undefined | Error

• Returns undefined | Error

createScreenTracks

• createScreenTracks(options?: ScreenShareCaptureOptions): Promise<LocalTrack[]>

• Creates a screen capture tracks with getDisplayMedia(). A LocalVideoTrack is always created and returned. If { audio: true }, and the browser supports audio capture, a LocalAudioTrack is also created.

  Parameters

  • Optionaloptions: ScreenShareCaptureOptions

  Returns Promise<LocalTrack[]>

createTracks

• createTracks(options?: CreateLocalTracksOptions): Promise<LocalTrack[]>

• Create local camera and/or microphone tracks

  Parameters

  • Optionaloptions: CreateLocalTracksOptions

  Returns Promise<LocalTrack[]>

editChatMessage

• editChatMessage(
      editText: string,
      originalMessage: ChatMessage,
  ): Promise<
      {
          editTimestamp: number;
          id: string;
          message: string;
          timestamp: number;
      },
  >

• Parameters

  • editText: string
  • originalMessage: ChatMessage

  Returns Promise<
      {
          editTimestamp: number;
          id: string;
          message: string;
          timestamp: number;
      },
  >

enableCameraAndMicrophone

• enableCameraAndMicrophone(): Promise<void>

• Publish both camera and microphone at the same time. This is useful for displaying a single Permission Dialog box to the end user.

  Returns Promise<void>

getTrackPublication

• getTrackPublication(source: Source): undefined | LocalTrackPublication

• Finds the first track that matches the source filter, for example, getting the user's camera track with getTrackBySource(Track.Source.Camera).

  Parameters

  • source: Source

  Returns undefined | LocalTrackPublication

getTrackPublicationByName

• getTrackPublicationByName(name: string): undefined | LocalTrackPublication

• Finds the first track that matches the track's name.

  Parameters

  • name: string

  Returns undefined | LocalTrackPublication

performRpc

• performRpc(params: PerformRpcParams): Promise<string>

• Initiate an RPC call to a remote participant

  Parameters

  • params: PerformRpcParams

    Parameters for initiating the RPC call, see PerformRpcParams

  Returns Promise<string>

  A promise that resolves with the response payload or rejects with an error.

  Throws

  Error on failure. Details in message.

publishData

• publishData(data: Uint8Array, options?: DataPublishOptions): Promise<void>

• Publish a new data payload to the room. Data will be forwarded to each participant in the room if the destination field in publishOptions is empty

  Parameters

  • data: Uint8Array

    Uint8Array of the payload. To send string data, use TextEncoder.encode
  • options: DataPublishOptions = {}

    optionally specify a reliable, topic and destination

  Returns Promise<void>

publishDtmf

• publishDtmf(code: number, digit: string): Promise<void>

• Publish SIP DTMF message to the room.

  Parameters

  • code: number

    DTMF code
  • digit: string

    DTMF digit

  Returns Promise<void>

publishTrack

• publishTrack(
      track: MediaStreamTrack | LocalTrack,
      options?: TrackPublishOptions,
  ): Promise<LocalTrackPublication>

• Publish a new track to the room

  Parameters

  • track: MediaStreamTrack | LocalTrack
  • Optionaloptions: TrackPublishOptions

  Returns Promise<LocalTrackPublication>

registerRpcMethod

• registerRpcMethod(
      method: string,
      handler: (data: RpcInvocationData) => Promise<string>,
  ): void

• Establishes the participant as a receiver for calls of the specified RPC method. Will overwrite any existing callback for the same method.

  Parameters

  • method: string

    The name of the indicated RPC method
  • handler: (data: RpcInvocationData) => Promise<string>

    Will be invoked when an RPC request for this method is received

  Returns void

  A promise that resolves when the method is successfully registered

  Example

  room.localParticipant?.registerRpcMethod(
    'greet',
    async (data: RpcInvocationData) => {
      console.log(`Received greeting from ${data.callerIdentity}: ${data.payload}`);
      return `Hello, ${data.callerIdentity}!`;
    }
  );
  Copy

  The handler should return a Promise that resolves to a string. If unable to respond within responseTimeout, the request will result in an error on the caller's side.

  You may throw errors of type RpcError with a string message in the handler, and they will be received on the caller's side with the message intact. Other errors thrown in your handler will not be transmitted as-is, and will instead arrive to the caller as 1500 ("Application Error").

republishAllTracks

• republishAllTracks(
      options?: TrackPublishOptions,
      restartTracks?: boolean,
  ): Promise<void>

• Parameters

  • Optionaloptions: TrackPublishOptions
  • restartTracks: boolean = true

  Returns Promise<void>

sendChatMessage

• sendChatMessage(text: string): Promise<ChatMessage>

• Parameters

  • text: string

  Returns Promise<ChatMessage>

setAttributes

• setAttributes(attributes: Record<string, string>): Promise<void>

• Set or update participant attributes. It will make updates only to keys that are present in attributes, and will not override others. Note: this requires canUpdateOwnMetadata permission.

  Parameters

  • attributes: Record<string, string>

    attributes to update

  Returns Promise<void>

setCameraEnabled

• setCameraEnabled(
      enabled: boolean,
      options?: VideoCaptureOptions,
      publishOptions?: TrackPublishOptions,
  ): Promise<undefined | LocalTrackPublication>

• Enable or disable a participant's camera track.

  If a track has already published, it'll mute or unmute the track. Resolves with a LocalTrackPublication instance if successful and undefined otherwise

  Parameters

  • enabled: boolean
  • Optionaloptions: VideoCaptureOptions
  • OptionalpublishOptions: TrackPublishOptions

  Returns Promise<undefined | LocalTrackPublication>

setMetadata

• setMetadata(metadata: string): Promise<void>

• Sets and updates the metadata of the local participant. Note: this requires canUpdateOwnMetadata permission. method will throw if the user doesn't have the required permissions

  Parameters

  • metadata: string

  Returns Promise<void>

setMicrophoneEnabled

• setMicrophoneEnabled(
      enabled: boolean,
      options?: AudioCaptureOptions,
      publishOptions?: TrackPublishOptions,
  ): Promise<undefined | LocalTrackPublication>

• Enable or disable a participant's microphone track.

  If a track has already published, it'll mute or unmute the track. Resolves with a LocalTrackPublication instance if successful and undefined otherwise

  Parameters

  • enabled: boolean
  • Optionaloptions: AudioCaptureOptions
  • OptionalpublishOptions: TrackPublishOptions

  Returns Promise<undefined | LocalTrackPublication>

setName

• setName(name: string): Promise<void>

• Sets and updates the name of the local participant. Note: this requires canUpdateOwnMetadata permission. method will throw if the user doesn't have the required permissions

  Parameters

  • name: string

  Returns Promise<void>

setScreenShareEnabled

• setScreenShareEnabled(
      enabled: boolean,
      options?: ScreenShareCaptureOptions,
      publishOptions?: TrackPublishOptions,
  ): Promise<undefined | LocalTrackPublication>

• Start or stop sharing a participant's screen Resolves with a LocalTrackPublication instance if successful and undefined otherwise

  Parameters

  • enabled: boolean
  • Optionaloptions: ScreenShareCaptureOptions
  • OptionalpublishOptions: TrackPublishOptions

  Returns Promise<undefined | LocalTrackPublication>

setTrackSubscriptionPermissions

• setTrackSubscriptionPermissions(
      allParticipantsAllowed: boolean,
      participantTrackPermissions?: ParticipantTrackPermission[],
  ): void

• Control who can subscribe to LocalParticipant's published tracks.

  By default, all participants can subscribe. This allows fine-grained control over who is able to subscribe at a participant and track level.

  Note: if access is given at a track-level (i.e. both [allParticipantsAllowed] and [ParticipantTrackPermission.allTracksAllowed] are false), any newer published tracks will not grant permissions to any participants and will require a subsequent permissions update to allow subscription.

  Parameters

  • allParticipantsAllowed: boolean

    Allows all participants to subscribe all tracks. Takes precedence over [[participantTrackPermissions]] if set to true. By default this is set to true.
  • participantTrackPermissions: ParticipantTrackPermission[] = []

    Full list of individual permissions per participant/track. Any omitted participants will not receive any permissions.

  Returns void

unpublishTrack

• unpublishTrack(
      track: MediaStreamTrack | LocalTrack,
      stopOnUnpublish?: boolean,
  ): Promise<undefined | LocalTrackPublication>

• Parameters

  • track: MediaStreamTrack | LocalTrack
  • OptionalstopOnUnpublish: boolean

  Returns Promise<undefined | LocalTrackPublication>

unpublishTracks

• unpublishTracks(
      tracks: MediaStreamTrack[] | LocalTrack[],
  ): Promise<LocalTrackPublication[]>

• Parameters

  • tracks: MediaStreamTrack[] | LocalTrack[]

  Returns Promise<LocalTrackPublication[]>

unregisterRpcMethod

• unregisterRpcMethod(method: string): void

• Unregisters a previously registered RPC method.

  Parameters

  • method: string

    The name of the RPC method to unregister

  Returns void