palava-client 2.2.1 → 3.0.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Change Log
 
+## 3.0.0
+
+* Use modern coffee/js modules
+* Add support for WebRTC renegotiation
+* Add support for request local audio/video after the connection is established
+
 ## 2.2.1
 
 * Only catch parsing-related errors with "invalid_format" error

package/README.md

@@ -39,7 +39,7 @@ Use the [yarn link](https://classic.yarnpkg.com/en/docs/cli/link/) feature:
 ### Compile latest source
 
 - Make sure you have Ruby and Bundler installed (and have run `$ bundle install` once)
-- `$ rake build:bundle`
+- `$ rake bundle`
 - Rebuild palava-web, for example, by restarting the yarn dev server
 
 ## Credits

package/dist/browser.js

@@ -0,0 +1,122 @@
+// Generated by CoffeeScript 2.7.0
+import adapter from 'webrtc-adapter';
+
+// Checks whether the browser is a Firefox
+
+// @return [Boolean] `true` if Firefox
+
+export var isMozilla = function() {
+  return adapter.browserDetails.browser === 'firefox';
+};
+
+// Checks whether the browser is a Chrome/Chromium
+
+// @return [Boolean] `true` if Chrome
+
+export var isChrome = function() {
+  return adapter.browserDetails.browser === 'chrome';
+};
+
+// Checks which browser is used
+
+// @return [String] A well defined id of the browser (firefox, chrome, safari, or unknown)
+
+export var getUserAgent = function() {
+  return adapter.browserDetails.browser;
+};
+
+// Checks which browser is used
+
+// @return [Integer] The user agent version
+
+export var getUserAgentVersion = function() {
+  return adapter.browserDetails.version;
+};
+
+// Checks whether the WebRTC support of the browser should be compatible with palava
+
+// Please note: The test requires network connectivity
+
+// @return [Boolean] `true` if the browser is supported by palava
+
+export var checkForWebrtcError = function() {
+  var e;
+  try {
+    new window.RTCPeerConnection({
+      iceServers: []
+    });
+  } catch (error) {
+    e = error;
+    return e;
+  }
+  return !(window.RTCPeerConnection && window.RTCIceCandidate && window.RTCSessionDescription && navigator.mediaDevices && navigator.mediaDevices.getUserMedia);
+};
+
+// Get WebRTC constraints argument
+
+// @return [Object] Appropriate constraints for WebRTC
+
+export var getConstraints = function() {
+  return {
+    optional: [],
+    mandatory: {
+      OfferToReceiveAudio: true,
+      OfferToReceiveVideo: true
+    }
+  };
+};
+
+// Get WebRTC PeerConnection options
+
+// @return [Object] Appropriate options for the PeerConnection
+
+export var getPeerConnectionOptions = function() {
+  if (isChrome()) {
+    return {
+      optional: [
+        {
+          DtlsSrtpKeyAgreement: true
+        }
+      ]
+    };
+  } else {
+    return {};
+  }
+};
+
+// Attaches a media stream to a DOM element
+
+// @param element [DOM Element] The element to attach the stream to
+// @param stream [MediaStream] The stream to attach
+
+export var attachMediaStream = function(element, stream) {
+  if (stream) {
+    return element.srcObject = stream;
+  } else {
+    element.pause();
+    return element.srcObject = null;
+  }
+};
+
+// Attaches a peer's stream to a DOM element
+
+// @param element [DOM Element] The element to attach the stream to
+// @param peer [Peer] The peer whose stream to attach
+
+export var attachPeer = function(element, peer) {
+  var attach;
+  attach = function() {
+    attachMediaStream(element, peer.getStream());
+    if (peer.isLocal()) {
+      element.setAttribute('muted', true);
+    }
+    return element.play();
+  };
+  if (peer.getStream()) {
+    return attach();
+  } else {
+    return peer.on('stream_ready', function() {
+      return attach();
+    });
+  }
+};

package/dist/data_channel.js

@@ -0,0 +1,66 @@
+// Generated by CoffeeScript 2.7.0
+import EventEmitter from 'wolfy87-eventemitter';
+
+export var DataChannel = (function() {
+  class DataChannel extends EventEmitter {
+    constructor(channel) {
+      super();
+      this.channel = channel;
+      this.channel.onmessage = (event) => {
+        return this.emit('message', event.data);
+      };
+      this.channel.onclose = () => {
+        return this.emit('close');
+      };
+      this.channel.onerror = (e) => {
+        return this.emit('error', e);
+      };
+      this.sendBuffer = [];
+    }
+
+    send(data, cb) {
+      this.sendBuffer.push([data, cb]);
+      if (this.sendBuffer.length === 1) {
+        return this.actualSend();
+      }
+    }
+
+    actualSend() {
+      var cb, data, e;
+      if (this.channel.readyState !== 'open') {
+        console.log("Not sending when not open!");
+        return;
+      }
+      while (this.sendBuffer.length) {
+        if (this.channel.bufferedAmount > this.MAX_BUFFER) {
+          setTimeout(this.actualSend.bind(this), 1);
+          return;
+        }
+        [data, cb] = this.sendBuffer[0];
+        try {
+          this.channel.send(data);
+        } catch (error) {
+          e = error;
+          setTimeout(this.actualSend.bind(this), 1);
+          return;
+        }
+        try {
+          if (typeof cb === "function") {
+            cb();
+          }
+        } catch (error) {
+          e = error;
+          // TODO: find a better way to tell the user ...
+          console.log('Exception in write callback:', e);
+        }
+        this.sendBuffer.shift();
+      }
+    }
+
+  };
+
+  DataChannel.prototype.MAX_BUFFER = 1024 * 1024;
+
+  return DataChannel;
+
+}).call(this);

package/dist/distributor.js

@@ -0,0 +1,57 @@
+// Generated by CoffeeScript 2.7.0
+// Distributor supports exchanging direct messages with peers through a channel.
+// The incoming messages are filtered and outgoing messages are are sent within
+// appropriate `send_to_peer` messages.
+
+export var Distributor = class Distributor {
+  // @param channel [palava.Channel] The channel to connect through
+  // @param peerId [String] The id of the peer to connect to or `null` for global messages
+
+  constructor(channel, peerId = null) {
+    // Adds a handler to the Distributor
+
+    // @example
+    //   distributor.on 'peer_left', (msg) => console.log "peer left!"
+
+    // @param event [String] Event id on which the handler is called
+    // @param handler [function] This function is called when the event is received
+
+    this.on = this.on.bind(this);
+    // Sends a message through the Distributor
+
+    // @param msg [Object] The message to send through the distributor
+
+    this.send = this.send.bind(this);
+    this.channel = channel;
+    this.peerId = peerId;
+  }
+
+  on(event, handler) {
+    return this.channel.on('message', (msg) => {
+      if (this.peerId) {
+        if (msg.sender_id === this.peerId && event === msg.event) {
+          return handler(msg);
+        }
+      } else {
+        if (!msg.sender_id && event === msg.event) {
+          return handler(msg);
+        }
+      }
+    });
+  }
+
+  send(msg) {
+    var payload;
+    if (this.peerId) {
+      payload = {
+        event: 'send_to_peer',
+        peer_id: this.peerId,
+        data: msg
+      };
+    } else {
+      payload = msg;
+    }
+    return this.channel.send(payload);
+  }
+
+};

package/dist/gum.js

@@ -0,0 +1,59 @@
+// 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';
+
+export var Gum = class Gum extends EventEmitter {
+  constructor(config) {
+    super();
+    this.changeConfig = this.changeConfig.bind(this);
+    this.requestStream = this.requestStream.bind(this);
+    this.getStream = this.getStream.bind(this);
+    this.releaseStream = this.releaseStream.bind(this);
+    this.config = config || {
+      video: true,
+      audio: true
+    };
+    this.stream = null;
+  }
+
+  changeConfig(config) {
+    boundMethodCheck(this, Gum);
+    this.config = config;
+    this.releaseStream();
+    return this.requestStream();
+  }
+
+  requestStream() {
+    boundMethodCheck(this, Gum);
+    return navigator.mediaDevices.getUserMedia(this.config).then((stream) => {
+      this.stream = stream;
+      return this.emit('stream_ready', stream);
+    }).catch((error) => {
+      return this.emit('stream_error', error);
+    });
+  }
+
+  getStream() {
+    boundMethodCheck(this, Gum);
+    return this.stream;
+  }
+
+  releaseStream() {
+    boundMethodCheck(this, Gum);
+    if (this.stream) {
+      this.stream.getAudioTracks().forEach((track) => {
+        return track.stop();
+      });
+      this.stream.getVideoTracks().forEach((track) => {
+        return track.stop();
+      });
+      this.stream = null;
+      this.emit('stream_released', this);
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+};

package/dist/identity.js

@@ -0,0 +1,27 @@
+// Generated by CoffeeScript 2.7.0
+import {
+  Gum
+} from './gum.js';
+
+export var Identity = class Identity {
+  constructor(o) {
+    this.getName = this.getName.bind(this);
+    this.getStatus = this.getStatus.bind(this);
+    this.userMediaConfig = o.userMediaConfig;
+    this.status = o.status || {};
+    this.status.name = o.name;
+  }
+
+  newUserMedia() {
+    return new Gum(this.userMediaConfig);
+  }
+
+  getName() {
+    return this.name;
+  }
+
+  getStatus() {
+    return this.status;
+  }
+
+};

package/dist/index.js

@@ -0,0 +1,53 @@
+// Generated by CoffeeScript 2.7.0
+import * as browser from './browser.js';
+
+export {
+  browser
+};
+
+export {
+  Gum
+} from './gum.js';
+
+export {
+  Identity
+} from './identity.js';
+
+export {
+  Peer
+} from './peer.js';
+
+export {
+  LocalPeer
+} from './local_peer.js';
+
+export {
+  RemotePeer
+} from './remote_peer.js';
+
+export {
+  Room
+} from './room.js';
+
+export {
+  Session
+} from './session.js';
+
+export {
+  WebSocketChannel
+} from './web_socket_channel.js';
+
+export {
+  Distributor
+} from './distributor.js';
+
+export {
+  DataChannel
+} from './data_channel.js';
+
+// Version info
+export var PROTOCOL_NAME = 'palava';
+
+export var PROTOCOL_VERSION = '1.0.0';
+
+export var LIB_VERSION = '3.0.0';

package/dist/local_peer.js

@@ -0,0 +1,220 @@
+// 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';
+
+// A specialized peer representing the local user in the conference
+export var LocalPeer = class LocalPeer extends Peer {
+  // @param id [String] Unique ID of the local peer in the conference
+  // @param status [Object] An object containing state which is exchanged through the palava machine (see `palava.Peer` for more informations)
+  // @param room [palava.Room] The room in which the peer is present
+  constructor(id, status, room) {
+    super(id, status);
+    // Initializes the events based on the userMedia
+
+    // @nodoc
+
+    this.setupUserMedia = this.setupUserMedia.bind(this);
+    // Initializes the events based on the room
+
+    // @nodoc
+
+    this.setupRoom = this.setupRoom.bind(this);
+    // Returns the local stream
+
+    // @return [MediaStream] The local stream as defined by the WebRTC API
+
+    this.getStream = this.getStream.bind(this);
+    // Updates the status of the local peer. The status is extended or updated with the given items.
+
+    // @param status [Object] Object containing the new items
+
+    this.updateStatus = this.updateStatus.bind(this);
+    // Remove video track and emit event for renegotiation
+
+    this.disableVideo = this.disableVideo.bind(this);
+    // Remove audio track and emit event for renegotiation
+
+    this.disableAudio = this.disableAudio.bind(this);
+    // Request video from getUserMedia and add it to the local stream
+    // Emits 'video_added' event which remote peers listen to for adding the track to their connections
+
+    // @param constraints [Object] Video constraints for getUserMedia (optional, defaults to true)
+    // @return [Promise] Resolves with the video track when added, rejects on error
+
+    this.requestVideo = this.requestVideo.bind(this);
+    // Request audio from getUserMedia and add it to the local stream
+    // Emits 'audio_added' event which remote peers listen to for adding the track to their connections
+
+    // @param constraints [Object] Audio constraints for getUserMedia (optional, defaults to true)
+    // @return [Promise] Resolves with the audio track when added, rejects on error
+
+    this.requestAudio = this.requestAudio.bind(this);
+    // Leave the room
+    this.leave = this.leave.bind(this);
+    this.muted = true;
+    this.local = true;
+    this.room = room;
+    this.userMedia = room.userMedia;
+    this.setupRoom();
+    this.setupUserMedia();
+  }
+
+  setupUserMedia() {
+    boundMethodCheck(this, LocalPeer);
+    this.userMedia.on('stream_released', () => {
+      this.ready = false;
+      return this.emit('stream_removed');
+    });
+    this.userMedia.on('stream_ready', (e) => {
+      this.ready = true;
+      return this.emit('stream_ready', e);
+    });
+    this.userMedia.on('stream_error', (e) => {
+      return this.emit('stream_error', e);
+    });
+    if (this.getStream()) {
+      this.ready = true;
+      return this.emit('stream_ready');
+    }
+  }
+
+  setupRoom() {
+    boundMethodCheck(this, LocalPeer);
+    this.room.peers[this.id] = this.room.localPeer = this;
+    this.on('update', () => {
+      return this.room.emit('peer_update', this);
+    });
+    this.on('stream_ready', () => {
+      return this.room.emit('peer_stream_ready', this);
+    });
+    return this.on('stream_removed', () => {
+      return this.room.emit('peer_stream_removed', this);
+    });
+  }
+
+  getStream() {
+    boundMethodCheck(this, LocalPeer);
+    return this.userMedia.getStream();
+  }
+
+  updateStatus(status) {
+    var base, key;
+    boundMethodCheck(this, LocalPeer);
+    if (!status || !(status instanceof Object) || Object.keys(status).length === 0) {
+      return status;
+    }
+    for (key in status) {
+      this.status[key] = status[key];
+    }
+    (base = this.status).user_agent || (base.user_agent = browser.getUserAgent());
+    this.room.channel.send({
+      event: 'update_status',
+      status: this.status
+    });
+    return this.status;
+  }
+
+  disableVideo() {
+    var i, len, ref, results, stream, track;
+    boundMethodCheck(this, LocalPeer);
+    stream = this.getStream();
+    if (!stream) {
+      return;
+    }
+    ref = stream.getVideoTracks();
+    results = [];
+    for (i = 0, len = ref.length; i < len; i++) {
+      track = ref[i];
+      track.stop();
+      stream.removeTrack(track);
+      results.push(this.emit('video_removed', track, stream));
+    }
+    return results;
+  }
+
+  disableAudio() {
+    var i, len, ref, results, stream, track;
+    boundMethodCheck(this, LocalPeer);
+    stream = this.getStream();
+    if (!stream) {
+      return;
+    }
+    ref = stream.getAudioTracks();
+    results = [];
+    for (i = 0, len = ref.length; i < len; i++) {
+      track = ref[i];
+      track.stop();
+      stream.removeTrack(track);
+      results.push(this.emit('audio_removed', track, stream));
+    }
+    return results;
+  }
+
+  requestVideo(constraints = true) {
+    boundMethodCheck(this, LocalPeer);
+    if (!this.getStream()) {
+      return Promise.reject(new Error('No stream available'));
+    }
+    if (this.hasVideo()) {
+      return Promise.resolve(this.getStream().getVideoTracks()[0]);
+    }
+    return navigator.mediaDevices.getUserMedia({
+      video: constraints,
+      audio: false
+    }).then((stream) => {
+      var videoTrack;
+      videoTrack = stream.getVideoTracks()[0];
+      if (!videoTrack) {
+        return Promise.reject(new Error('No video track received'));
+      }
+      // Add track to our local stream
+      this.getStream().addTrack(videoTrack);
+      // Emit event - remote peers will listen and add the track to their connections
+      this.emit('video_added', videoTrack, this.getStream());
+      return videoTrack;
+    }).catch((error) => {
+      this.emit('video_error', error);
+      return Promise.reject(error);
+    });
+  }
+
+  requestAudio(constraints = true) {
+    boundMethodCheck(this, LocalPeer);
+    if (!this.getStream()) {
+      return Promise.reject(new Error('No stream available'));
+    }
+    if (this.hasAudio()) {
+      return Promise.resolve(this.getStream().getAudioTracks()[0]);
+    }
+    return navigator.mediaDevices.getUserMedia({
+      video: false,
+      audio: constraints
+    }).then((stream) => {
+      var audioTrack;
+      audioTrack = stream.getAudioTracks()[0];
+      if (!audioTrack) {
+        return Promise.reject(new Error('No audio track received'));
+      }
+      // Add track to our local stream
+      this.getStream().addTrack(audioTrack);
+      // Emit event - remote peers will listen and add the track to their connections
+      this.emit('audio_added', audioTrack, this.getStream());
+      return audioTrack;
+    }).catch((error) => {
+      this.emit('audio_error', error);
+      return Promise.reject(error);
+    });
+  }
+
+  leave() {
+    boundMethodCheck(this, LocalPeer);
+    this.ready = false;
+    return this.emit('left');
+  }
+
+};