new CopayPeer class. Peers working!

js/models/CopayPeer.js

@@ -0,0 +1,256 @@
+
+var imports     = require('soop').imports();
+var EventEmitter= imports.EventEmitter || require('events').EventEmitter;
+
+
+function CopayPeer(opts) {
+  opts = opts || {};
+  this.peerId = opts.peerId;
+  this.apiKey = opts.apiKey || 'lwjd5qra8257b9';
+  this.debug = opts.debug || 3;
+  this.connectedPeers = [];
+}
+
+CopayPeer.parent=EventEmitter;
+
+// Array helpers
+CopayPeer._arrayDiff = function(a, b) {
+  var seen = [];
+  var diff = [];
+
+  for (var i = 0; i < b.length; i++)
+    seen[b[i]] = true;
+
+  for (var j = 0; j < a.length; j++)
+    if (!seen[a[j]])
+      diff.push(a[j]);
+
+  return diff;
+};
+
+CopayPeer._inArray = function(el, array) {
+  return array.indexOf(el) > -1;
+};
+
+CopayPeer._arrayPushOnce = function(el, array) {
+  var ret = false;
+  if (!CopayPeer._inArray(el, array)) {
+    array.push(el);
+    ret = true;
+  }
+  return ret;
+};
+
+CopayPeer._arrayRemove = function(el, array) {
+  var pos = array.indexOf(el);
+  if (pos >= 0) array.splice(pos, 1);
+
+  return array;
+};
+
+// DEBUG
+CopayPeer.prototype._showConnectedPeers = function() {
+  console.log("### CONNECTED PEERS", this.connectedPeers);
+};
+
+CopayPeer.prototype._onClose = function(peerId) {
+  this.connectedPeers = CopayPeer._arrayRemove(peerId, this.connectedPeers);
+  this._notify();
+};
+
+CopayPeer.prototype._connectToPeers = function(peerIds) {
+  var self = this;
+  var ret = false;
+  var arrayDiff1= CopayPeer._arrayDiff(peerIds, this.connectedPeers);
+  var arrayDiff = CopayPeer._arrayDiff(arrayDiff1, [this.peerId]);
+console.log('[CopayPeer.js.65:arrayDiff:] DIFFFFF',arrayDiff, this.connectedPeers); //TODO
+  arrayDiff.forEach(function(peerId) {
+    console.log('### CONNECTING TO:', peerId);
+    self.connectTo(peerId);
+    ret = true;
+  });
+  return ret;
+};
+
+CopayPeer.prototype._onData = function(data, isInbound) {
+  var obj = JSON.parse(data);
+  console.log('### RECEIVED TYPE: %s FROM %s', obj.data.type, obj.sender); 
+
+  switch(obj.data.type) {
+    case 'peerList':
+      var hasChanged = this._connectToPeers(obj.data.peers);
+      // if (hasChanged && !obj.data.isBroadcast) {
+      // };
+      this._notify();
+      break;
+    case 'disconnect':
+      this._onClose(obj.sender);
+    break;
+  }
+};
+
+CopayPeer.prototype._sendPeers = function(peerIds) {
+  var isBroadcast = false;
+  if (!peerIds) {
+    peerIds = this.connectedPeers;
+    isBroadcast = true;
+  };
+
+  console.log('#### SENDING PEER LIST: ', this.connectedPeers, ' TO ', peerIds);
+  this.send(peerIds, {
+    type: 'peerList',
+    peers: this.connectedPeers,
+    isBroadcast: isBroadcast,
+  });
+};
+
+CopayPeer.prototype._addPeer = function(peerId, isInbound) {
+
+  var hasChanged = CopayPeer._arrayPushOnce(peerId, this.connectedPeers);
+
+
+  if (isInbound && hasChanged) {
+    this._sendPeers();              //broadcast peer list
+  }
+  else {
+    if (isInbound) {
+      this._sendPeers(peerId);
+    }
+  }
+};
+
+
+CopayPeer.prototype._setupConnectionHandlers = function(dataConn, isInbound, openCallback) {
+  var self=this;
+
+  dataConn.on('open', function() {
+    if (!CopayPeer._inArray(dataConn.peer, self.connectedPeers)) {
+
+      console.log('### DATA CONNECTION READY TO: ADDING PEER: %s (inbound: %s)',
+        dataConn.peer, isInbound);
+
+      self._addPeer(dataConn.peer, isInbound);
+      self._notify();
+      if (typeof openCallback === 'function') openCallback();
+    }
+  });
+
+  dataConn.on('data', function(data) { 
+    self._onData(data, isInbound);
+  });
+
+  dataConn.on('error', function(e) {
+    console.log('### ## INBOUND DATA ERROR',e ); //TODO
+  });
+
+  dataConn.on('close', function() {
+    self._onClose(dataConn.peer);
+  });
+};
+
+CopayPeer.prototype._notify = function() {
+  this._showConnectedPeers();
+  this.emit('update');
+};
+
+CopayPeer.prototype._setupPeerHandlers = function(openCallback) {
+  var self=this;
+  var p = this.peer;
+
+
+  p.on('open', function(peerId) {
+    console.log('### PEER OPEN. I AM:' + peerId);
+    self.peerId = peerId;
+    self.connectedPeers = [peerId];
+    self._notify();
+    return openCallback(peerId);
+  });
+
+  p.on('error', function(err) {
+    console.log('### PEER ERROR:', err);
+  });
+
+  p.on('connection', function(dataConn) {
+    console.log('### NEW INBOUND CONNECTION'); //TODO
+    self._setupConnectionHandlers(dataConn, true);
+  });
+};
+
+CopayPeer.prototype.start = function(openCallback) {
+  // Start PeerJS Peer
+  this.peer = new Peer(this.peerId, {
+    key: this.apiKey, // TODO: we need our own PeerServer KEY (http://peerjs.com/peerserver)
+    debug: this.debug, 
+  });
+
+  this._setupPeerHandlers(openCallback);
+};
+
+CopayPeer.prototype._sendToOne = function(peerId, data, cb) {
+  if (peerId !== this.peerId) {
+    var conns = this.peer.connections[peerId];
+
+    if (conns) {
+      var str = JSON.stringify({
+        sender: this.peerId,
+        data: data
+      });
+
+      for (var i = 0; i < conns.length; i++) {
+        var conn = conns[i];
+        conn.send(str);
+      }
+    }
+  }
+  if (typeof cb === 'function') cb();
+};
+
+
+CopayPeer.prototype.send = function(peerIds, data, cb) {
+  var self=this;
+
+  if (Array.isArray(peerIds)) {
+    var l = peerIds.length;
+    var i = 0;
+    peerIds.forEach(function(peerId) {
+      self._sendToOne(peerId, data, function () {
+        if (++i === l && typeof cb === 'function') cb();
+      });
+    });
+  }
+  else if (typeof peerIds === 'string')
+    self._sendToOne(peerIds, data, cb);
+};
+
+CopayPeer.prototype.connectTo = function(peerId, cb) {
+  var self = this;
+
+  console.log('### STARTING TO CONNECT TO:' + peerId );
+
+  var dataConn = this.peer.connect(peerId, {
+//    label: 'wallet',
+    serialization: 'none',
+    reliable: true,
+    metadata: { message: 'hi copayer!' }
+  });
+
+  self._setupConnectionHandlers(dataConn, false, cb);
+};
+
+CopayPeer.prototype.disconnect = function(peerId, cb) {
+  var self = this;
+
+  this.send(this.connectedPeers, { type: 'disconnect' }, function() {
+    self.connectedPeers = [];
+    self.peerId = null;
+    if (self.peer) {
+      self.peer.disconnect();
+      self.peer.destroy();
+      self.peer = null;
+    }
+    if (typeof cb === 'function') cb();
+  });
+};
+
+
+module.exports = require('soop')(CopayPeer);

js/models/Peer.js

@@ -0,0 +1,8 @@
+
+
+function Peer(id) {
+  this.id = id;
+};
+
+
+module.exports = require('soop')(Peer);

js/models/Storage.js

@@ -7,12 +7,20 @@ function Storage() {
 }
 
 Storage.prototype.get = function(k) {
-  return this.data[k];
+  return JSON.parse(localStorage.getItem(k));
 };
 
 Storage.prototype.set = function(k,v) {
-  this.data[k]=v;
+  localStorage.setItem(k, JSON.stringify(v));
+};
+ 
+Storage.prototype.remove = function(k) {
+  localStorage.removeItem(k);
 };
 
 
+Storage.prototype.clearAll = function() {
+  localStorage.clear();
+};     
+
 module.exports = require('soop')(Storage);