Options
All
  • Public
  • Public/Protected
  • All
Menu

Class MembraneWebRTC

Main class that is responsible for connecting to the RTC Engine, sending and receiving media.

Hierarchy

  • MembraneWebRTC

Index

Constructors

constructor

Properties

Private Readonly callbacks

callbacks: Callbacks

Private Optional connection

connection: RTCPeerConnection

Private disabledTrackEncodings

disabledTrackEncodings: Map<string, TrackEncoding[]> = ...

Private idToPeer

idToPeer: Map<String, Peer> = ...

Private localPeer

localPeer: Peer = ...

Private localTrackIdToTrack

localTrackIdToTrack: Map<string, TrackContext> = ...

Private localTracksWithStreams

localTracksWithStreams: { stream: MediaStream; track: MediaStreamTrack }[] = []

Private midToTrackId

midToTrackId: Map<string, string> = ...

Private rtcConfig

rtcConfig: RTCConfiguration = ...

Private trackIdToTrack

trackIdToTrack: Map<string, TrackContext> = ...

Methods

Private addPeer

  • addPeer(peer: Peer): void

addTrack

  • addTrack(track: MediaStreamTrack, stream: MediaStream, trackMetadata?: any, simulcastConfig?: SimulcastConfig, maxBandwidth?: number): string
  • Adds track that will be sent to the RTC Engine.

    example
    let localStream: MediaStream = new MediaStream();
    try {
      localAudioStream = await navigator.mediaDevices.getUserMedia(
        AUDIO_CONSTRAINTS
      );
      localAudioStream
        .getTracks()
        .forEach((track) => localStream.addTrack(track));
    } catch (error) {
      console.error("Couldn't get microphone permission:", error);
    }
    
    try {
      localVideoStream = await navigator.mediaDevices.getUserMedia(
        VIDEO_CONSTRAINTS
      );
      localVideoStream
        .getTracks()
        .forEach((track) => localStream.addTrack(track));
    } catch (error) {
     console.error("Couldn't get camera permission:", error);
    }
    
    localStream
     .getTracks()
     .forEach((track) => webrtc.addTrack(track, localStream));
    

    Parameters

    • track: MediaStreamTrack

      Audio or video track e.g. from your microphone or camera.

    • stream: MediaStream

      Stream that this track belongs to.

    • trackMetadata: any = ...

      Any information about this track that other peers will receive in onPeerJoined. E.g. this can source of the track - wheather it's screensharing, webcam or some other media device.

    • simulcastConfig: SimulcastConfig = ...

      Simulcast configuration. For more information refer to SimulcastConfig.

    • maxBandwidth: number = 0

      maximal bandwidth this track can use. Defaults to 0 which is unlimited. This option has no effect for simulcast and audio tracks.

    Returns string

    Returns id of added track

Private addTrackToConnection

Private addTransceiversIfNeeded

  • addTransceiversIfNeeded(serverTracks: Map<string, number>): void

Private checkIfTrackBelongToPeer

  • checkIfTrackBelongToPeer(trackId: string, peer: Peer): boolean

cleanUp

  • cleanUp(): void

Private createAndSendOffer

  • createAndSendOffer(): Promise<void>

Private createAudioTransceiverConfig

  • createAudioTransceiverConfig(_trackContext: TrackContext): RTCRtpTransceiverInit

Private createTransceiverConfig

  • createTransceiverConfig(trackContext: TrackContext): RTCRtpTransceiverInit

Private createVideoTransceiverConfig

  • createVideoTransceiverConfig(trackContext: TrackContext): RTCRtpTransceiverInit

disableTrackEncoding

  • disableTrackEncoding(trackId: string, encoding: TrackEncoding): void
  • Disables track encoding so that it will be no longer sent to the server.

    example
    const trackId = webrtc.addTrack(track, stream, {}, true);
    webrtc.disableTrackEncoding(trackId, "l");
    

    Parameters

    • trackId: string

      id of track

    • encoding: TrackEncoding

      encoding that will be disabled

    Returns void

enableTrackEncoding

  • enableTrackEncoding(trackId: string, encoding: TrackEncoding): void
  • Enables track encoding so that it will be sent to the server.

    example
    const trackId = webrtc.addTrack(track, stream, {}, true);
    webrtc.disableTrackEncoding(trackId, "l");
    // wait some time
    webrtc.enableTrackEncoding(trackId, "l");
    

    Parameters

    • trackId: string

      id of track

    • encoding: TrackEncoding

      encoding that will be enabled

    Returns void

Private erasePeer

  • erasePeer(peer: Peer): void

Private eraseTrack

  • eraseTrack(trackId: string, peerId: string): void

Private findSender

  • findSender(trackId: string): RTCRtpSender

Private getMidToTrackId

  • getMidToTrackId(): any

Private getPeerId

  • getPeerId(): string

Private getTrackId

  • getTrackId(uuid: string): string

Private getTrackIdToMetadata

  • getTrackIdToMetadata(): any

Private handleMediaEvent

  • handleMediaEvent(deserializedMediaEvent: MediaEvent): void

join

  • join(peerMetadata: any): void
  • Tries to join to the RTC Engine. If user is accepted then onJoinSuccess will be called. In other case onJoinError is invoked.

    example
    let webrtc = new MembraneWebRTC(...)
    webrtc.join({displayName: "Bob"})
    

    Parameters

    • peerMetadata: any

      Any information that other peers will receive in onPeerJoined after accepting this peer

    Returns void

leave

  • leave(): void
  • Leaves the room. This function should be called when user leaves the room in a clean way e.g. by clicking a dedicated, custom button disconnect. As a result there will be generated one more media event that should be sent to the RTC Engine. Thanks to it each other peer will be notified that peer left in onPeerLeft,

    Returns void

Private onAnswer

  • onAnswer(answer: RTCSessionDescriptionInit): Promise<void>

Private onLocalCandidate

  • onLocalCandidate(): (event: RTCPeerConnectionIceEvent) => void
  • Returns (event: RTCPeerConnectionIceEvent) => void

      • (event: RTCPeerConnectionIceEvent): void
      • Parameters

        • event: RTCPeerConnectionIceEvent

        Returns void

Private onOfferData

  • onOfferData(offerData: Map<string, number>): Promise<void>

Private onRemoteCandidate

  • onRemoteCandidate(candidate: RTCIceCandidate): void

Private onTrack

  • onTrack(): (event: RTCTrackEvent) => void
  • Returns (event: RTCTrackEvent) => void

      • (event: RTCTrackEvent): void
      • Parameters

        • event: RTCTrackEvent

        Returns void

prioritizeTrack

  • prioritizeTrack(trackId: string): void
  • Prioritizes a track in connection to be always sent to browser.

    Parameters

    • trackId: string

      Id of video track to prioritize.

    Returns void

receiveMediaEvent

  • receiveMediaEvent(mediaEvent: string): void
  • Feeds media event received from RTC Engine to MembraneWebRTC. This function should be called whenever some media event from RTC Engine was received and can result in MembraneWebRTC generating some other media events.

    example

    This example assumes pheonix channels as signalling layer. As phoenix channels require objects, RTC Engine encapsulates binary data into map with one field that is converted to object with one field on the TS side.

    webrtcChannel.on("mediaEvent", (event) => webrtc.receiveMediaEvent(event.data));
    

    Parameters

    • mediaEvent: string

      String data received over custom signalling layer.

    Returns void

removeTrack

  • removeTrack(trackId: string): void
  • Removes a track from connection that was being sent to the RTC Engine.

    example
    // setup camera
    let localStream: MediaStream = new MediaStream();
    try {
      localVideoStream = await navigator.mediaDevices.getUserMedia(
        VIDEO_CONSTRAINTS
      );
      localVideoStream
        .getTracks()
        .forEach((track) => localStream.addTrack(track));
    } catch (error) {
      console.error("Couldn't get camera permission:", error);
    }
    
    let trackId
    localStream
     .getTracks()
     .forEach((track) => trackId = webrtc.addTrack(track, localStream));
    
    // remove track
    webrtc.removeTrack(trackId)
    

    Parameters

    • trackId: string

      Id of audio or video track to remove.

    Returns void

replaceTrack

  • replaceTrack(trackId: string, newTrack: MediaStreamTrack, newTrackMetadata?: any): Promise<boolean>
  • Replaces a track that is being sent to the RTC Engine.

    example
    // setup camera
    let localStream: MediaStream = new MediaStream();
    try {
      localVideoStream = await navigator.mediaDevices.getUserMedia(
        VIDEO_CONSTRAINTS
      );
      localVideoStream
        .getTracks()
        .forEach((track) => localStream.addTrack(track));
    } catch (error) {
      console.error("Couldn't get camera permission:", error);
    }
    let oldTrackId;
    localStream
     .getTracks()
     .forEach((track) => trackId = webrtc.addTrack(track, localStream));
    
    // change camera
    const oldTrack = localStream.getVideoTracks()[0];
    let videoDeviceId = "abcd-1234";
    navigator.mediaDevices.getUserMedia({
         video: {
           ...(VIDEO_CONSTRAINTS as {}),
           deviceId: {
             exact: videoDeviceId,
           },
         }
      })
      .then((stream) => {
        let videoTrack = stream.getVideoTracks()[0];
        webrtc.replaceTrack(oldTrackId, videoTrack);
      })
      .catch((error) => {
        console.error('Error switching camera', error);
      })
    

    Parameters

    • trackId: string

      Id of audio or video track to replace.

    • newTrack: MediaStreamTrack
    • Optional newTrackMetadata: any

    Returns Promise<boolean>

    success

selectTrackEncoding

  • selectTrackEncoding(peerId: string, trackId: string, encoding: TrackEncoding): void
  • Selects track encoding that server should send to the client library.

    example
    webrtc.selectTrackEncoding(incomingTrackCtx.peer.id, incomingTrackCtx.trackId, "l")
    

    Parameters

    • peerId: string

      id of peer that owns track

    • trackId: string

      id of track

    • encoding: TrackEncoding

      encoding to receive

    Returns void

Private sendMediaEvent

  • sendMediaEvent(mediaEvent: MediaEvent): void

setPreferedVideoSizes

  • setPreferedVideoSizes(bigScreens: number, smallScreens: number, mediumScreens?: number, allSameSize?: boolean): void
  • This function allows to adjust resolution and number of video tracks sent by an SFU to a client.

    Parameters

    • bigScreens: number

      number of screens with big size (if simulcast is used this will limit number of tracks sent with highest quality).

    • smallScreens: number

      number of screens with small size (if simulcast is used this will limit number of tracks sent with lowest quality).

    • mediumScreens: number = 0

      number of screens with medium size (if simulcast is used this will limit number of tracks sent with medium quality).

    • allSameSize: boolean = false

      flag that indicates whether all screens should use the same quality

    Returns void

setTrackBandwidth

  • setTrackBandwidth(trackId: string, bandwidth: number): Promise<boolean>
  • Updates maximum bandwidth for the track identified by trackId. This value directly translates to quality of the stream and, in case of video, to the amount of RTP packets being sent. In case trackId points at the simulcast track, bandwidth is split between all of the variant streams proportionally to their resolution.

    Parameters

    • trackId: string
    • bandwidth: number

    Returns Promise<boolean>

    success

Private setTurns

  • setTurns(turnServers: any[]): void

unprioritizeTrack

  • unprioritizeTrack(trackId: string): void
  • Unprioritizes a track.

    Parameters

    • trackId: string

      Id of video track to unprioritize.

    Returns void

updatePeerMetadata

  • updatePeerMetadata(peerMetadata: any): void
  • Updates the metadata for the current peer.

    Parameters

    • peerMetadata: any

      Data about this peer that other peers will receive upon joining.

      If the metadata is different from what is already tracked in the room, the optional callback onPeerUpdated will be triggered for other peers in the room.

    Returns void

updateTrackMetadata

  • updateTrackMetadata(trackId: string, trackMetadata: any): void
  • Updates the metadata for a specific track.

    Parameters

    • trackId: string

      trackId (generated in addTrack) of audio or video track.

    • trackMetadata: any

      Data about this track that other peers will receive upon joining.

      If the metadata is different from what is already tracked in the room, the optional callback onTrackUpdated will be triggered for other peers in the room.

    Returns void

Generated using TypeDoc