Options
All
  • Public
  • Public/Protected
  • All
Menu

Class MembraneWebRTC

Main class that is responsible for connecting to the SFU server, sending and receiving media.

Hierarchy

  • MembraneWebRTC

Index

Constructors

constructor

Properties

Private Readonly callbacks

callbacks: Callbacks

Private Optional connection

connection: RTCPeerConnection

Private Optional id

id: string

Private idToPeer

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

Private localTrackIdToMetadata

localTrackIdToMetadata: Map<string, any> = ...

Private localTracksWithStreams

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

Private midToPeer

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

Private midToStream

midToStream: Map<String, MediaStream> = ...

Private midToTrackMetadata

midToTrackMetadata: Map<string, any> = ...

Private receiveMedia

receiveMedia: boolean

Private Readonly rtcConfig

rtcConfig: RTCConfiguration = ...

Methods

Private addPeer

  • addPeer(peer: Peer): void

addTrack

  • addTrack(track: MediaStreamTrack, stream: MediaStream, trackMetadata?: any): void
  • Adds track that will be sent to the SFU server. At this moment only one audio and one video track can be added.

    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 void

cleanUp

  • cleanUp(): void

join

  • join(peerMetadata: any): void
  • Tries to join to the SFU server. 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 SFU server. Thanks to it each other peer will be notified that peer left in onPeerLeft,

    Returns void

Private onLocalCandidate

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

      • (event: RTCPeerConnectionIceEvent): void
      • Parameters

        • event: RTCPeerConnectionIceEvent

        Returns void

Private onOffer

  • onOffer(offer: RTCSessionDescriptionInit): 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 SFU server to MembraneWebRTC. This function should be called whenever some media event from SFU server was received and can result in MembraneWebRTC generating some other media events.

    example

    This example assumes pheonix channels as signalling layer. As pheonix channels require objects, SFU server 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

Private removePeer

  • removePeer(peer: Peer): void

replaceTrack

  • replaceTrack(oldTrackId: string, newTrack: MediaStreamTrack): Promise<any>
  • Replaces a track that is being sent to the SFU server. At the moment this assumes that only one video and one audio track is being sent.

    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);
    }
    
    localStream
     .getTracks()
     .forEach((track) => webrtc.addTrack(track, localStream));
    
    // change camera
    const oldTrackId = localStream.getVideoTracks()[0].id;
    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

    • oldTrackId: string
    • newTrack: MediaStreamTrack

    Returns Promise<any>

Private sendMediaEvent

  • sendMediaEvent(mediaEvent: MediaEvent): void

Generated using TypeDoc