palava-client 2.2.1 → 3.0.0

package/dist/peer.js

@@ -0,0 +1,150 @@
+// Generated by CoffeeScript 2.7.0
+var boundMethodCheck = function(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new Error('Bound instance method accessed before binding'); } };
+
+import EventEmitter from 'wolfy87-eventemitter';
+
+import * as browser from './browser.js';
+
+// Class representing a participant in a room
+
+export var Peer = class Peer extends EventEmitter {
+  // @param id [String] ID of the participant
+  // @param status [Object] An object conataining state which is exchanged through the palava machine
+  // @option staus name [String] The chosen name of the participant
+
+  constructor(id, status) {
+    var base;
+    super();
+    // Checks whether the participant is sending audio
+
+    // @return [Boolean] `true` if participant is sending audio
+
+    this.transmitsAudio = this.transmitsAudio.bind(this);
+    // Checks whether the participant is could send audio (but maybe has it muted)
+
+    // @return [Boolean] `true` if participant has audio tracks
+
+    this.hasAudio = this.hasAudio.bind(this);
+    // Checks whether the participant is sending audio
+
+    // @return [Boolean] `true` if participant is sending audio
+
+    this.transmitsVideo = this.transmitsVideo.bind(this);
+    // Checks whether the participant is could send video (but maybe put in on hold)
+
+    // @return [Boolean] `true` if participant has audio tracks
+
+    this.hasVideo = this.hasVideo.bind(this);
+    // Checks whether the peer connection is somewhat erroneous
+
+    // @return [Boolean] `true` if participant connection has an error
+
+    this.hasError = this.hasError.bind(this);
+    // Returns the error message of the peer
+
+    // @return [String] error message
+
+    this.getError = this.getError.bind(this);
+    // Checks whether the participant is muted
+
+    // @return [Boolean] `true` if participant is muted
+
+    this.isMuted = this.isMuted.bind(this);
+    // Checks whether the peer is ready
+
+    // @return [Boolean] `true` if participant is ready, that they have a stream
+
+    this.isReady = this.isReady.bind(this);
+    // Checks whether the participant is local
+
+    // @return [Boolean] `true` if participant is the local peer
+
+    this.isLocal = this.isLocal.bind(this);
+    // Checks whether the participant is remote
+
+    // @return [Boolean] `true` if participant is the remote peer
+
+    this.isRemote = this.isRemote.bind(this);
+    this.id = id;
+    this.status = status || {};
+    (base = this.status).user_agent || (base.user_agent = browser.getUserAgent());
+    this.joinTime = (new Date()).getTime();
+    this.ready = false;
+    this.error = null;
+  }
+
+  transmitsAudio() {
+    var ref, ref1, ref2;
+    boundMethodCheck(this, Peer);
+    return !!((ref = this.getStream()) != null ? (ref1 = ref.getAudioTracks()) != null ? (ref2 = ref1[0]) != null ? ref2.enabled : void 0 : void 0 : void 0);
+  }
+
+  hasAudio() {
+    var ref, ref1;
+    boundMethodCheck(this, Peer);
+    return !!((ref = this.getStream()) != null ? (ref1 = ref.getAudioTracks()) != null ? ref1[0] : void 0 : void 0);
+  }
+
+  transmitsVideo() {
+    var ref, ref1, ref2;
+    boundMethodCheck(this, Peer);
+    return !!((ref = this.getStream()) != null ? (ref1 = ref.getVideoTracks()) != null ? (ref2 = ref1[0]) != null ? ref2.enabled : void 0 : void 0 : void 0);
+  }
+
+  hasVideo() {
+    var ref, ref1;
+    boundMethodCheck(this, Peer);
+    return !!((ref = this.getStream()) != null ? (ref1 = ref.getVideoTracks()) != null ? ref1[0] : void 0 : void 0);
+  }
+
+  hasError() {
+    boundMethodCheck(this, Peer);
+    if (this.error) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  getError() {
+    boundMethodCheck(this, Peer);
+    return this.error;
+  }
+
+  isMuted() {
+    boundMethodCheck(this, Peer);
+    if (this.muted) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  isReady() {
+    boundMethodCheck(this, Peer);
+    if (this.ready) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  isLocal() {
+    boundMethodCheck(this, Peer);
+    if (this.local) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  isRemote() {
+    boundMethodCheck(this, Peer);
+    if (this.local) {
+      return false;
+    } else {
+      return true;
+    }
+  }
+
+};

package/dist/remote_peer.js

@@ -0,0 +1,484 @@
+// Generated by CoffeeScript 2.7.0
+var boundMethodCheck = function(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new Error('Bound instance method accessed before binding'); } };
+
+import * as browser from './browser.js';
+
+import {
+  Peer
+} from './peer.js';
+
+import {
+  Distributor
+} from './distributor.js';
+
+import {
+  DataChannel
+} from './data_channel.js';
+
+// A remote participant in a room
+
+export var RemotePeer = class RemotePeer extends Peer {
+  // @param id [String] ID of the participant
+  // @param status [Object] Status object of the participant
+  // @param room [Room] Room the participant is in
+  // @param hasOfferPriority [Boolean] If true, we send the initial offer and win offer collisions (impolite)
+  // @param turnCredentials [Object] username and password for the turn server (optional)
+
+  constructor(id, status, room, hasOfferPriority, turnCredentials) {
+    super(id, status);
+    // Get the stream
+
+    // @return [MediaStream] Remote stream as defined by WebRTC
+
+    this.getStream = this.getStream.bind(this);
+    // Toggle the mute state of the peer
+
+    this.toggleMute = this.toggleMute.bind(this);
+    // Generates the STUN and TURN options for a peer connection
+
+    // @return [Object] ICE options for the peer connections
+
+    this.generateIceOptions = this.generateIceOptions.bind(this);
+    // Sets up the peer connection and its events
+
+    // @nodoc
+
+    this.setupPeerConnection = this.setupPeerConnection.bind(this);
+    // Queues a negotiation task to ensure sequential execution
+    // Each task is a function that returns a Promise
+
+    // @param task [Function] Function returning a Promise
+
+    this.queueNegotiation = this.queueNegotiation.bind(this);
+    // Creates and sends an offer
+    // This is queued via queueNegotiation to prevent race conditions
+
+    // @nodoc
+
+    this.createAndSendOffer = this.createAndSendOffer.bind(this);
+    // Handles an incoming offer
+    // This is queued via queueNegotiation to prevent race conditions
+
+    // @param sdp [RTCSessionDescription] The remote offer
+    // @nodoc
+
+    this.handleOffer = this.handleOffer.bind(this);
+    // Handles an incoming answer
+    // This is queued via queueNegotiation to prevent race conditions
+
+    // @param sdp [RTCSessionDescription] The remote answer
+    // @nodoc
+
+    this.handleAnswer = this.handleAnswer.bind(this);
+    // Adds a new track to this peer connection
+    // Used when the local user enables video/audio after initially joining without it
+    // Triggers renegotiation via onnegotiationneeded
+
+    // @param track [MediaStreamTrack] The track to add
+    // @param stream [MediaStream] The stream the track belongs to
+
+    this.addTrack = this.addTrack.bind(this);
+    // Removes a track from this peer connection
+    // Used when the local user disables video/audio
+    // Triggers renegotiation via onnegotiationneeded
+
+    // @param track [MediaStreamTrack] The track to remove
+
+    this.removeTrack = this.removeTrack.bind(this);
+    // Sets up the distributor connecting to the participant
+
+    // @nodoc
+
+    this.setupDistributor = this.setupDistributor.bind(this);
+    // Forward events to the room and listen for local peer events
+
+    // @nodoc
+
+    this.setupRoom = this.setupRoom.bind(this);
+    // Listen for video_added and audio_added events from the local peer
+    // and add those tracks to this peer connection
+
+    // @nodoc
+
+    this.setupLocalPeerListeners = this.setupLocalPeerListeners.bind(this);
+    this.sendMessage = this.sendMessage.bind(this);
+    // End peer connection
+
+    this.closePeerConnection = this.closePeerConnection.bind(this);
+    this.muted = false;
+    this.local = false;
+    this.room = room;
+    this.remoteStream = null;
+    this.turnCredentials = turnCredentials;
+    this.hasOfferPriority = hasOfferPriority;
+    // Queue to ensure negotiation operations happen sequentially
+    this.negotiationQueue = Promise.resolve();
+    this.dataChannels = {};
+    this.setupRoom();
+    this.setupPeerConnection();
+    this.setupDistributor();
+    if (this.hasOfferPriority) {
+      this.queueNegotiation(this.createAndSendOffer);
+    }
+  }
+
+  getStream() {
+    boundMethodCheck(this, RemotePeer);
+    return this.remoteStream;
+  }
+
+  toggleMute() {
+    boundMethodCheck(this, RemotePeer);
+    return this.muted = !this.muted;
+  }
+
+  generateIceOptions() {
+    var options;
+    boundMethodCheck(this, RemotePeer);
+    options = [];
+    if (this.room.options.stun) {
+      options.push({
+        urls: [this.room.options.stun]
+      });
+    }
+    if (this.room.options.turnUrls && this.turnCredentials) {
+      options.push({
+        urls: this.room.options.turnUrls,
+        username: this.turnCredentials.user,
+        credential: this.turnCredentials.password
+      });
+    }
+    return {
+      iceServers: options
+    };
+  }
+
+  setupPeerConnection() {
+    var channel, i, label, len, localStream, options, ref, ref1, registerChannel, track;
+    boundMethodCheck(this, RemotePeer);
+    this.peerConnection = new RTCPeerConnection(this.generateIceOptions(), browser.getPeerConnectionOptions());
+    this.peerConnection.onicecandidate = (event) => {
+      if (event.candidate) {
+        return this.distributor.send({
+          event: 'ice_candidate',
+          sdpmlineindex: event.candidate.sdpMLineIndex,
+          sdpmid: event.candidate.sdpMid,
+          candidate: event.candidate.candidate
+        });
+      }
+    };
+    this.peerConnection.ontrack = (event) => {
+      var stream, track;
+      stream = event.streams[0];
+      track = event.track;
+      if (!this.remoteStream) {
+        this.remoteStream = stream;
+        this.ready = true;
+        this.emit('stream_ready');
+        // Listen for tracks being added/removed from the remote stream
+        this.remoteStream.onaddtrack = (e) => {
+          if (e.track.kind === 'video') {
+            return this.emit('video_added', e.track, this.remoteStream);
+          } else if (e.track.kind === 'audio') {
+            return this.emit('audio_added', e.track, this.remoteStream);
+          }
+        };
+        return this.remoteStream.onremovetrack = (e) => {
+          if (e.track.kind === 'video') {
+            return this.emit('video_removed', e.track, this.remoteStream);
+          } else if (e.track.kind === 'audio') {
+            return this.emit('audio_removed', e.track, this.remoteStream);
+          }
+        };
+      } else {
+        // Additional track added to existing stream
+        if (track.kind === 'video') {
+          return this.emit('video_added', track, this.remoteStream);
+        } else if (track.kind === 'audio') {
+          return this.emit('audio_added', track, this.remoteStream);
+        }
+      }
+    };
+    this.peerConnection.onremovestream = (event) => {
+      this.remoteStream = null;
+      this.ready = false;
+      return this.emit('stream_removed');
+    };
+    this.peerConnection.oniceconnectionstatechange = (event) => {
+      var connectionState;
+      connectionState = event.target.iceConnectionState;
+      switch (connectionState) {
+        case 'connecting':
+          this.error = null;
+          return this.emit('connection_pending');
+        case 'connected':
+          this.error = null;
+          return this.emit('connection_established');
+        case 'failed':
+          this.error = "connection_failed";
+          return this.emit('connection_failed');
+        case 'disconnected':
+          this.error = "connection_disconnected";
+          return this.emit('connection_disconnected');
+        case 'closed':
+          this.error = "connection_closed";
+          return this.emit('connection_closed');
+      }
+    };
+    // Handle negotiationneeded event - queue an offer
+    this.peerConnection.onnegotiationneeded = () => {
+      return this.queueNegotiation(this.createAndSendOffer);
+    };
+    // Add local tracks if we have a stream
+    localStream = this.room.localPeer.getStream();
+    if (localStream) {
+      ref = localStream.getTracks();
+      for (i = 0, len = ref.length; i < len; i++) {
+        track = ref[i];
+        this.peerConnection.addTrack(track, localStream);
+      }
+    }
+    // data channel setup
+    if (this.room.options.dataChannels != null) {
+      registerChannel = (channel) => {
+        var name, wrapper;
+        name = channel.label;
+        wrapper = new DataChannel(channel);
+        this.dataChannels[name] = wrapper;
+        return this.emit('channel_ready', name, wrapper);
+      };
+      if (this.hasOfferPriority) {
+        ref1 = this.room.options.dataChannels;
+        for (label in ref1) {
+          options = ref1[label];
+          channel = this.peerConnection.createDataChannel(label, options);
+          channel.onopen = function() {
+            return registerChannel(this);
+          };
+        }
+      } else {
+        this.peerConnection.ondatachannel = (event) => {
+          return registerChannel(event.channel);
+        };
+      }
+    }
+    return this.peerConnection;
+  }
+
+  queueNegotiation(task) {
+    boundMethodCheck(this, RemotePeer);
+    return this.negotiationQueue = this.negotiationQueue.then(task).catch((error) => {
+      return this.emit('oaerror', error);
+    });
+  }
+
+  createAndSendOffer() {
+    boundMethodCheck(this, RemotePeer);
+    return this.peerConnection.createOffer(browser.getConstraints()).then((offer) => {
+      return this.peerConnection.setLocalDescription(offer);
+    }).then(() => {
+      this.distributor.send({
+        event: 'offer',
+        sdp: this.peerConnection.localDescription
+      });
+      return this.emit('offer');
+    });
+  }
+
+  handleOffer(sdp) {
+    boundMethodCheck(this, RemotePeer);
+    // Check for offer collision: both peers sent offers at the same time
+    // If we're impolite (hasOfferPriority) and we have a pending local offer, ignore incoming offer
+    if (this.hasOfferPriority && this.peerConnection.signalingState === 'have-local-offer') {
+      return Promise.resolve();
+    }
+    // If we're polite and have a pending local offer, implicit rollback will happen
+    // when we call setRemoteDescription with the incoming offer
+    return this.peerConnection.setRemoteDescription(sdp).then(() => {
+      return this.peerConnection.createAnswer(browser.getConstraints());
+    }).then((answer) => {
+      return this.peerConnection.setLocalDescription(answer);
+    }).then(() => {
+      this.distributor.send({
+        event: 'answer',
+        sdp: this.peerConnection.localDescription
+      });
+      return this.emit('answer');
+    });
+  }
+
+  handleAnswer(sdp) {
+    boundMethodCheck(this, RemotePeer);
+    // Only process answer if we're expecting one
+    if (this.peerConnection.signalingState !== 'have-local-offer') {
+      return Promise.resolve();
+    }
+    return this.peerConnection.setRemoteDescription(sdp);
+  }
+
+  addTrack(track, stream) {
+    boundMethodCheck(this, RemotePeer);
+    if (!this.peerConnection) {
+      return;
+    }
+    return this.peerConnection.addTrack(track, stream);
+  }
+
+  removeTrack(track) {
+    var sender;
+    boundMethodCheck(this, RemotePeer);
+    if (!this.peerConnection) {
+      return;
+    }
+    // Find the sender for this track and remove it
+    sender = this.peerConnection.getSenders().find(function(s) {
+      return s.track === track;
+    });
+    if (sender) {
+      return this.peerConnection.removeTrack(sender);
+    }
+  }
+
+  setupDistributor() {
+    boundMethodCheck(this, RemotePeer);
+    this.distributor = new Distributor(this.room.channel, this.id);
+    this.distributor.on('peer_left', (msg) => {
+      if (this.ready) {
+        this.remoteStream = null;
+        this.emit('stream_removed');
+        this.ready = false;
+      }
+      this.peerConnection.close();
+      return this.emit('left');
+    });
+    this.distributor.on('ice_candidate', (msg) => {
+      var candidate;
+      // empty msg.candidate causes error messages in firefox, so let RTCPeerConnection deal with it and return here
+      if (msg.candidate === "") {
+        return;
+      }
+      candidate = new RTCIceCandidate({
+        candidate: msg.candidate,
+        sdpMLineIndex: msg.sdpmlineindex,
+        sdpMid: msg.sdpmid
+      });
+      if (!this.room.options.filterIceCandidateTypes.includes(candidate.type)) {
+        return this.peerConnection.addIceCandidate(candidate);
+      }
+    });
+    this.distributor.on('offer', (msg) => {
+      var sdp;
+      sdp = new RTCSessionDescription(msg.sdp);
+      return this.queueNegotiation(() => {
+        return this.handleOffer(sdp);
+      });
+    });
+    this.distributor.on('answer', (msg) => {
+      var sdp;
+      sdp = new RTCSessionDescription(msg.sdp);
+      return this.queueNegotiation(() => {
+        return this.handleAnswer(sdp);
+      });
+    });
+    this.distributor.on('peer_updated_status', (msg) => {
+      this.status = msg.status;
+      return this.emit('update');
+    });
+    this.distributor.on('message', (msg) => {
+      return this.emit('message', msg.data);
+    });
+    return this.distributor;
+  }
+
+  setupRoom() {
+    boundMethodCheck(this, RemotePeer);
+    this.room.peers[this.id] = this;
+    this.on('left', () => {
+      delete this.room.peers[this.id];
+      return this.room.emit('peer_left', this);
+    });
+    this.on('offer', () => {
+      return this.room.emit('peer_offer', this);
+    });
+    this.on('answer', () => {
+      return this.room.emit('peer_answer', this);
+    });
+    this.on('update', () => {
+      return this.room.emit('peer_update', this);
+    });
+    this.on('stream_ready', () => {
+      return this.room.emit('peer_stream_ready', this);
+    });
+    this.on('stream_removed', () => {
+      return this.room.emit('peer_stream_removed', this);
+    });
+    this.on('connection_pending', () => {
+      return this.room.emit('peer_connection_pending', this);
+    });
+    this.on('connection_established', () => {
+      return this.room.emit('peer_connection_established', this);
+    });
+    this.on('connection_failed', () => {
+      return this.room.emit('peer_connection_failed', this);
+    });
+    this.on('connection_disconnected', () => {
+      return this.room.emit('peer_connection_disconnected', this);
+    });
+    this.on('connection_closed', () => {
+      return this.room.emit('peer_connection_closed', this);
+    });
+    this.on('oaerror', (e) => {
+      return this.room.emit('peer_oaerror', this, e);
+    });
+    this.on('channel_ready', (n, c) => {
+      return this.room.emit('peer_channel_ready', this, n, c);
+    });
+    // Listen for local peer adding new tracks (when user enables video/audio after joining)
+    return this.setupLocalPeerListeners();
+  }
+
+  setupLocalPeerListeners() {
+    boundMethodCheck(this, RemotePeer);
+    this.localPeerVideoAddedHandler = (track, stream) => {
+      return this.addTrack(track, stream);
+    };
+    this.localPeerAudioAddedHandler = (track, stream) => {
+      return this.addTrack(track, stream);
+    };
+    this.localPeerVideoRemovedHandler = (track, stream) => {
+      return this.removeTrack(track);
+    };
+    this.localPeerAudioRemovedHandler = (track, stream) => {
+      return this.removeTrack(track);
+    };
+    this.room.localPeer.on('video_added', this.localPeerVideoAddedHandler);
+    this.room.localPeer.on('audio_added', this.localPeerAudioAddedHandler);
+    this.room.localPeer.on('video_removed', this.localPeerVideoRemovedHandler);
+    this.room.localPeer.on('audio_removed', this.localPeerAudioRemovedHandler);
+    // Clean up listeners when this peer leaves
+    return this.on('left', () => {
+      this.room.localPeer.off('video_added', this.localPeerVideoAddedHandler);
+      this.room.localPeer.off('audio_added', this.localPeerAudioAddedHandler);
+      this.room.localPeer.off('video_removed', this.localPeerVideoRemovedHandler);
+      return this.room.localPeer.off('audio_removed', this.localPeerAudioRemovedHandler);
+    });
+  }
+
+  sendMessage(data) {
+    boundMethodCheck(this, RemotePeer);
+    return this.distributor.send({
+      event: 'message',
+      data: data
+    });
+  }
+
+  closePeerConnection() {
+    var ref;
+    boundMethodCheck(this, RemotePeer);
+    if ((ref = this.peerConnection) != null) {
+      ref.close();
+    }
+    return this.peerConnection = null;
+  }
+
+};