palava-client 2.2.1 → 3.0.0

package/dist/room.js

@@ -0,0 +1,213 @@
+// 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';
+
+import {
+  Distributor
+} from './distributor.js';
+
+import {
+  LocalPeer
+} from './local_peer.js';
+
+import {
+  RemotePeer
+} from './remote_peer.js';
+
+// A room connecting multiple participants
+
+export var Room = class Room extends EventEmitter {
+  // @param roomId [String] ID of the room
+  // @param channel [Channel] Channel used for communication
+  // @param userMedia [UserMedia] UserMedia used for local user
+  // @param options [Object] Further objects for the room
+  // @option options joinTimeout [Integer] Timeout for joining
+  // @option options ownStatus [Object] The status of the local user
+
+  constructor(roomId, channel, userMedia, options = {}) {
+    super();
+    // Bind UserMedia events to room events
+
+    // @nodoc
+
+    this.setupUserMedia = this.setupUserMedia.bind(this);
+    // Set default options
+
+    // @nodoc
+
+    this.setupOptions = this.setupOptions.bind(this);
+    // Initialize global distributor and messaging
+
+    // @nodoc
+
+    this.setupDistributor = this.setupDistributor.bind(this);
+    // Join the room
+
+    // @param status [Object] Status of the local user
+
+    this.join = this.join.bind(this);
+    // Send leave room event to server
+
+    this.leave = this.leave.bind(this);
+    // Makes sure room is closed by disconnecting all peer connections and clearing all timeouts
+
+    this.destroy = this.destroy.bind(this);
+    // Find peer with the given id
+
+    // @param id [String] id of the searched peer
+
+    // @return [Peer] The peer with the given id or `undefined`
+
+    this.getPeerById = this.getPeerById.bind(this);
+    // Get local peer
+
+    // @return [Peer] The local peer
+
+    this.getLocalPeer = this.getLocalPeer.bind(this);
+    // Get remote peers
+
+    // @return [Array] All peers except the local peer
+
+    this.getRemotePeers = this.getRemotePeers.bind(this);
+    // Get all peers
+
+    // @return [Array] All peers including the local peer
+
+    this.getAllPeers = this.getAllPeers.bind(this);
+    this.id = roomId;
+    this.userMedia = userMedia;
+    this.channel = channel;
+    this.peers = {};
+    this.options = options;
+    this.setupUserMedia();
+    this.setupDistributor();
+    this.setupOptions();
+  }
+
+  setupUserMedia() {
+    boundMethodCheck(this, Room);
+    this.userMedia.on('stream_ready', (stream) => {
+      return this.emit('local_stream_ready', stream);
+    });
+    this.userMedia.on('stream_error', (error) => {
+      return this.emit('local_stream_error', error);
+    });
+    return this.userMedia.on('stream_released', () => {
+      return this.emit('local_stream_removed');
+    });
+  }
+
+  setupOptions() {
+    var base, base1, base2;
+    boundMethodCheck(this, Room);
+    (base = this.options).joinTimeout || (base.joinTimeout = 1000);
+    (base1 = this.options).ownStatus || (base1.ownStatus = {});
+    return (base2 = this.options).filterIceCandidateTypes || (base2.filterIceCandidateTypes = []);
+  }
+
+  setupDistributor() {
+    boundMethodCheck(this, Room);
+    this.distributor = new Distributor(this.channel);
+    this.distributor.on('joined_room', (msg) => {
+      var i, len, newPeer, offers, peer, ref, turnCredentials;
+      clearTimeout(this.joinCheckTimeout);
+      if (msg.turn_user) {
+        turnCredentials = {
+          user: msg.turn_user,
+          password: msg.turn_password
+        };
+      } else {
+        turnCredentials = null;
+      }
+      new LocalPeer(msg.own_id, this.options.ownStatus, this);
+      ref = msg.peers;
+      for (i = 0, len = ref.length; i < len; i++) {
+        peer = ref[i];
+        offers = !browser.isChrome();
+        newPeer = new RemotePeer(peer.peer_id, peer.status, this, offers, turnCredentials);
+      }
+      return this.emit("joined");
+    });
+    this.distributor.on('new_peer', (msg) => {
+      var newPeer, offers;
+      offers = msg.status.user_agent === 'chrome';
+      newPeer = new RemotePeer(msg.peer_id, msg.status, this, offers);
+      return this.emit('peer_joined', newPeer);
+    });
+    this.distributor.on('error', (msg) => {
+      return this.emit('signaling_error', 'server', msg.description);
+    });
+    return this.distributor.on('shutdown', (msg) => {
+      return this.emit('signaling_shutdown', msg.seconds);
+    });
+  }
+
+  join(status = {}) {
+    var base, i, key, len;
+    boundMethodCheck(this, Room);
+    this.joinCheckTimeout = setTimeout((() => {
+      return this.emit('join_error');
+    }), this.options.joinTimeout);
+    for (i = 0, len = status.length; i < len; i++) {
+      key = status[i];
+      this.options.ownStatus[key] = status[key];
+    }
+    (base = this.options.ownStatus).user_agent || (base.user_agent = browser.getUserAgent());
+    return this.distributor.send({
+      event: 'join_room',
+      room_id: this.id,
+      status: this.options.ownStatus
+    });
+  }
+
+  leave() {
+    boundMethodCheck(this, Room);
+    if (this.channel) {
+      this.distributor.send({
+        event: 'leave_room'
+      });
+    }
+    return this.emit('left');
+  }
+
+  destroy() {
+    boundMethodCheck(this, Room);
+    this.getRemotePeers().forEach((peer) => {
+      return peer.closePeerConnection();
+    });
+    return clearTimeout(this.joinCheckTimeout);
+  }
+
+  getPeerById(id) {
+    boundMethodCheck(this, Room);
+    return this.peers[id];
+  }
+
+  getLocalPeer() {
+    boundMethodCheck(this, Room);
+    return this.localPeer;
+  }
+
+  getRemotePeers() {
+    boundMethodCheck(this, Room);
+    return this.getAllPeers(false);
+  }
+
+  getAllPeers(allowLocal = true) {
+    var id, peer, peers, ref;
+    boundMethodCheck(this, Room);
+    peers = [];
+    ref = this.peers;
+    for (id in ref) {
+      peer = ref[id];
+      if (allowLocal || !peer.local) {
+        peers.push(peer);
+      }
+    }
+    return peers;
+  }
+
+};

package/dist/session.js

@@ -0,0 +1,319 @@
+// 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';
+
+import {
+  Gum
+} from './gum.js';
+
+import {
+  Room
+} from './room.js';
+
+import {
+  WebSocketChannel
+} from './web_socket_channel.js';
+
+// Session is a wrapper around a concrete room, channel and userMedia
+export var Session = class Session extends EventEmitter {
+  // Creates the session object
+
+  // @param o [Object] See Session#connect for available options
+
+  constructor(o = {}) {
+    super();
+    // Initializes the websocket channel, retrieves user media and joins room when stream ready
+
+    // @param o [Object] Options for the session
+    // @option o webSocketAddress [WebSocket] The websocket endpoint to connect to
+    // @option o userMediaConfig [Object] getUserMedia constraints
+    // @option o stun [String] Address of stun server
+    // @option o turn [String] Turn address and credentials
+    // @option o joinTimeout [Integer] Milliseconds till joining is canceled by throwing
+    //           the "join_error" event
+
+    this.connect = this.connect.bind(this);
+    // Reconnect the session
+
+    this.reconnect = this.reconnect.bind(this);
+    // Reset channel and room
+
+    // @param o [Object] Also release user media
+
+    this.tearDown = this.tearDown.bind(this);
+    // Moves options into inner state
+
+    // @nodoc
+
+    this.assignOptions = this.assignOptions.bind(this);
+    // Checks whether the inner state of the session is valid. Emits events otherwise
+
+    // @return [Boolean] `true` if options are correct and webrtc support is given
+
+    this.checkRequirements = this.checkRequirements.bind(this);
+    // Get the channel of the session
+
+    // @return [Channel] The channel of the session
+
+    this.getChannel = this.getChannel.bind(this);
+    // Get the UserMedia of the session
+
+    // @return [UserMedia] UserMedia of the session
+
+    this.getUserMedia = this.getUserMedia.bind(this);
+    // Get the room of the session
+
+    // @return [Room] Room of the session
+
+    this.getRoom = this.getRoom.bind(this);
+    // Build connection to websocket endpont
+
+    // @return [Room] Room of the session
+
+    this.createChannel = this.createChannel.bind(this);
+    // Maps signals from room to session signals
+
+    // @nodoc
+
+    this.createRoom = this.createRoom.bind(this);
+    // Destroys the session
+    this.destroy = this.destroy.bind(this);
+    this.roomOptions = {};
+    this.assignOptions(o);
+  }
+
+  connect(o) {
+    boundMethodCheck(this, Session);
+    this.assignOptions(o);
+    if (!this.checkRequirements()) {
+      return;
+    }
+    this.createChannel();
+    this.createRoom();
+    if (this.userMedia.stream) {
+      return this.room.join();
+    } else {
+      return this.userMedia.requestStream().then(() => {
+        return this.room.join();
+      });
+    }
+  }
+
+  reconnect() {
+    boundMethodCheck(this, Session);
+    this.emit('session_reconnect');
+    this.tearDown();
+    this.createChannel();
+    this.createRoom();
+    return this.room.join();
+  }
+
+  tearDown(resetUserMedia = false) {
+    var ref, ref1, ref2, ref3, ref4, ref5;
+    boundMethodCheck(this, Session);
+    if ((ref = this.room) != null) {
+      ref.removeAllListeners();
+    }
+    if ((ref1 = this.channel) != null) {
+      ref1.removeAllListeners();
+    }
+    if ((ref2 = this.channel) != null ? ref2.isConnected() : void 0) {
+      if ((ref3 = this.room) != null) {
+        ref3.leave();
+      }
+    }
+    if ((ref4 = this.channel) != null) {
+      ref4.close();
+    }
+    this.channel = null;
+    if ((ref5 = this.room) != null) {
+      ref5.destroy();
+    }
+    this.room = null;
+    if (resetUserMedia && this.userMedia) {
+      return this.userMedia.releaseStream();
+    }
+  }
+
+  assignOptions(o) {
+    boundMethodCheck(this, Session);
+    if (o.roomId) {
+      this.roomId = o.roomId;
+    }
+    if (o.webSocketAddress) {
+      this.webSocketAddress = o.webSocketAddress;
+    }
+    if (o.identity) {
+      this.userMedia = o.identity.newUserMedia();
+      this.roomOptions.ownStatus = o.identity.getStatus();
+    }
+    if (o.userMediaConfig) {
+      this.userMedia = new Gum(o.userMediaConfig);
+    }
+    if (o.dataChannels) {
+      this.roomOptions.dataChannels = o.dataChannels;
+    }
+    if (o.stun) {
+      this.roomOptions.stun = o.stun;
+    }
+    if (o.turnUrls) {
+      this.roomOptions.turnUrls = o.turnUrls;
+    }
+    if (o.joinTimeout) {
+      this.roomOptions.joinTimeout = o.joinTimeout;
+    }
+    if (o.filterIceCandidateTypes) {
+      return this.roomOptions.filterIceCandidateTypes = o.filterIceCandidateTypes;
+    }
+  }
+
+  checkRequirements() {
+    var e;
+    boundMethodCheck(this, Session);
+    if (!this.webSocketAddress) {
+      this.emit('argument_error', 'no web socket address given');
+      return false;
+    }
+    if (!this.userMedia) {
+      this.emit('argument_error', 'no user media given');
+      return false;
+    }
+    if (!this.roomId) {
+      this.emit('argument_error', 'no room id given');
+      return false;
+    }
+    if (!this.roomOptions.stun) {
+      this.emit('argument_error', 'no stun server given');
+      return false;
+    }
+    if (this.roomOptions.turnUrls && !Array.isArray(this.roomOptions.turnUrls)) {
+      this.emit('argument_error', 'turnUrls must be an array');
+      return false;
+    }
+    if (!navigator.onLine) {
+      this.emit('signaling_not_reachable');
+      return false;
+    }
+    if (e = browser.checkForWebrtcError()) {
+      this.emit('webrtc_no_support', 'WebRTC is not supported by your browser', e);
+      return false;
+    }
+    return true;
+  }
+
+  getChannel() {
+    boundMethodCheck(this, Session);
+    return this.channel;
+  }
+
+  getUserMedia() {
+    boundMethodCheck(this, Session);
+    return this.userMedia;
+  }
+
+  getRoom() {
+    boundMethodCheck(this, Session);
+    return this.room;
+  }
+
+  createChannel() {
+    boundMethodCheck(this, Session);
+    this.channel = new WebSocketChannel(this.webSocketAddress);
+    this.channel.on('open', () => {
+      return this.emit('signaling_open');
+    });
+    this.channel.on('error', (t, e) => {
+      return this.emit('signaling_error', t, e);
+    });
+    this.channel.on('close', (e) => {
+      return this.emit('signaling_close', e);
+    });
+    return this.channel.on('not_reachable', () => {
+      return this.emit('signaling_not_reachable');
+    });
+  }
+
+  createRoom() { // TODO move some more stuff away from the room? eg signaling
+    boundMethodCheck(this, Session);
+    this.room = new Room(this.roomId, this.channel, this.userMedia, this.roomOptions);
+    this.room.on('local_stream_ready', (s) => {
+      return this.emit('local_stream_ready', s);
+    });
+    this.room.on('local_stream_error', (e) => {
+      return this.emit('local_stream_error', e);
+    });
+    this.room.on('local_stream_removed', () => {
+      return this.emit('local_stream_removed');
+    });
+    this.room.on('join_error', () => {
+      this.tearDown(true);
+      return this.emit('room_join_error', this.room);
+    });
+    this.room.on('full', () => {
+      return this.emit('room_full', this.room);
+    });
+    this.room.on('joined', () => {
+      return this.emit('room_joined', this.room);
+    });
+    this.room.on('left', () => {
+      return this.emit('room_left', this.room);
+    });
+    this.room.on('peer_joined', (p) => {
+      return this.emit('peer_joined', p);
+    });
+    this.room.on('peer_offer', (p) => {
+      return this.emit('peer_offer', p);
+    });
+    this.room.on('peer_answer', (p) => {
+      return this.emit('peer_answer', p);
+    });
+    this.room.on('peer_update', (p) => {
+      return this.emit('peer_update', p);
+    });
+    this.room.on('peer_stream_ready', (p) => {
+      return this.emit('peer_stream_ready', p);
+    });
+    this.room.on('peer_stream_removed', (p) => {
+      return this.emit('peer_stream_removed', p);
+    });
+    this.room.on('peer_connection_pending', (p) => {
+      return this.emit('peer_connection_pending', p);
+    });
+    this.room.on('peer_connection_established', (p) => {
+      return this.emit('peer_connection_established', p);
+    });
+    this.room.on('peer_connection_failed', (p) => {
+      return this.emit('peer_connection_failed', p);
+    });
+    this.room.on('peer_connection_disconnected', (p) => {
+      return this.emit('peer_connection_disconnected', p);
+    });
+    this.room.on('peer_connection_closed', (p) => {
+      return this.emit('peer_connection_closed', p);
+    });
+    this.room.on('peer_left', (p) => {
+      return this.emit('peer_left', p);
+    });
+    this.room.on('peer_channel_ready', (p, n, c) => {
+      return this.emit('peer_channel_ready', p, n, c);
+    });
+    this.room.on('signaling_shutdown', (p) => {
+      return this.emit('signaling_shutdown', p);
+    });
+    this.room.on('signaling_error', (t, e) => {
+      return this.emit('signaling_error', t, e);
+    });
+    return true;
+  }
+
+  destroy() {
+    boundMethodCheck(this, Session);
+    this.emit('session_before_destroy');
+    this.tearDown(true);
+    return this.emit('session_after_destroy');
+  }
+
+};

package/dist/web_socket_channel.js

@@ -0,0 +1,132 @@
+// 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';
+
+// Channel implementation using websockets
+
+// Events: open -> (), message -> (msg), error -> (), close -> ()
+
+export var WebSocketChannel = class WebSocketChannel extends EventEmitter {
+  // @param address [String] Address of the websocket. Should start with `ws://` for web sockets or `wss://` for secure web sockets.
+  constructor(address, retries = 2) {
+    super();
+    // Returns true if socket is in a good state
+    this.isConnected = this.isConnected.bind(this);
+    this.sendDeliverOnConnectMessages = this.sendDeliverOnConnectMessages.bind(this);
+    // Connects websocket events with the events of this object
+
+    // @nodoc
+
+    this.setupWebsocket = this.setupWebsocket.bind(this);
+    this.startClientPings = this.startClientPings.bind(this);
+    // Sends the given data through the websocket
+
+    // @param data [Object] Object to send through the channel
+
+    this.send = this.send.bind(this);
+    // Closes the websocket
+
+    this.close = this.close.bind(this);
+    this.address = address;
+    this.retries = retries;
+    this.messagesToDeliverOnConnect = [];
+    this.setupWebsocket();
+    this.startClientPings();
+  }
+
+  isConnected() {
+    var ref;
+    boundMethodCheck(this, WebSocketChannel);
+    return ((ref = this.socket) != null ? ref.readyState : void 0) === 1;
+  }
+
+  sendDeliverOnConnectMessages() {
+    var i, len, msg, ref;
+    boundMethodCheck(this, WebSocketChannel);
+    ref = this.messagesToDeliverOnConnect;
+    for (i = 0, len = ref.length; i < len; i++) {
+      msg = ref[i];
+      this.socket.send(msg);
+    }
+    return this.messagesToDeliverOnConnect = [];
+  }
+
+  setupWebsocket() {
+    boundMethodCheck(this, WebSocketChannel);
+    this.socket = new WebSocket(this.address);
+    this.socket.onopen = (handshake) => {
+      this.retries = 0;
+      this.sendDeliverOnConnectMessages();
+      return this.emit('open', handshake);
+    };
+    this.socket.onmessage = (msg) => {
+      var error, parsedMsg;
+      try {
+        parsedMsg = JSON.parse(msg.data);
+      } catch (error1) {
+        error = error1;
+        this.emit('error', 'invalid_format', {
+          error: error,
+          data: msg.data
+        });
+        return;
+      }
+      if (parsedMsg.event === "pong") {
+        return this.outstandingPongs = 0;
+      } else {
+        return this.emit('message', parsedMsg);
+      }
+    };
+    this.socket.onerror = (msg) => {
+      clearInterval(this.pingInterval);
+      if (this.retries > 0) {
+        this.retries -= 1;
+        this.setupWebsocket();
+        return this.startClientPings();
+      } else {
+        return this.emit('error', 'socket', msg);
+      }
+    };
+    return this.socket.onclose = () => {
+      clearInterval(this.pingInterval);
+      return this.emit('close');
+    };
+  }
+
+  startClientPings() {
+    boundMethodCheck(this, WebSocketChannel);
+    this.outstandingPongs = 0;
+    return this.pingInterval = setInterval(() => {
+      if (this.outstandingPongs >= 6) {
+        clearInterval(this.pingInterval);
+        this.socket.close();
+        this.emit('error', "missing_pongs");
+      }
+      this.socket.send(JSON.stringify({
+        event: "ping"
+      }));
+      return this.outstandingPongs += 1;
+    }, 5000);
+  }
+
+  send(data) {
+    boundMethodCheck(this, WebSocketChannel);
+    if (this.socket.readyState === 1) { // successful connection
+      if (this.messagesToDeliverOnConnect.length !== 0) {
+        this.sendDeliverOnConnectMessages();
+      }
+      return this.socket.send(JSON.stringify(data));
+    } else if (this.socket.readyState > 1) { // connection closing or closed
+      return this.emit('not_reachable'); // connection still to be established
+    } else {
+      return this.messagesToDeliverOnConnect.push(JSON.stringify(data));
+    }
+  }
+
+  close() {
+    boundMethodCheck(this, WebSocketChannel);
+    return this.socket.close();
+  }
+
+};

package/package.json

@@ -1,18 +1,26 @@
 {
   "name": "palava-client",
   "description": "Signaling client for WebRTC video-/audio conferencing using the palava protocol",
-  "version": "2.2.1",
+  "version": "3.0.0",
   "author": {
     "name": "palava e. V.",
     "email": "contact@palava.tv",
     "homepage": "https://palava.tv"
   },
   "license": "LGPL-3.0",
+  "type": "module",
+  "exports": "./dist/index.js",
+  "scripts": {
+    "build": "coffee -c -o dist/ coffee/",
+    "watch": "coffee -c -w -o dist/ coffee/"
+  },
   "dependencies": {
     "webrtc-adapter": "^7.7.0",
-    "wolfy87-eventemitter": "~5.2.9"
+    "wolfy87-eventemitter": "^5.2.9"
+  },
+  "devDependencies": {
+    "coffeescript": "^2.7.0"
   },
-  "browser": "./palava.js",
   "keywords": [
     "webrtc",
     "websocket",
@@ -22,6 +30,6 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/palavatv/palava-client.git"
+    "url": "git+https://github.com/palavatv/palava-client.git"
   }
 }

package/Gemfile

@@ -1,8 +0,0 @@
-source 'https://rubygems.org'
-
-gem 'sprockets'
-gem 'coffee-script'
-gem 'rake'
-gem 'paint'
-gem 'json'
-gem 'uglifier'