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 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): 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.

    Returns string

    Returns id of added track

Private addTransceiversIfNeeded

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

cleanUp

  • cleanUp(): void

Private createAndSendOffer

  • createAndSendOffer(): Promise<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

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
  • Remove 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

Private sendMediaEvent

  • sendMediaEvent(mediaEvent: MediaEvent): void

Private setTurns

  • setTurns(turnServers: any[], iceTransportPolicy: "relay" | "all"): void
  • Parameters

    • turnServers: any[]
    • iceTransportPolicy: "relay" | "all"

    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