dial_a_device_node 0.0.153

data/app/assets/javascripts/dial_a_device_node/systemstatus.js

@@ -0,0 +1,124 @@
+(function (exports) {
+
+    var status_model = {
+
+        deviceconnection: false,
+        devicesimulation: false,
+        devicewebconnection: false,
+        webconnection: false,
+        webchannel: ""
+
+    }
+
+    var deviceendpoint = false;
+
+    exports.init = function (eventbus) {
+        localeventbus = eventbus;
+
+        localeventbus.on("status.deviceendpoint", function (data) {
+
+            deviceendpoint = data;
+
+        });
+
+
+        localeventbus.on("status.incoming", function (data) {
+
+            status_model_device = data;
+
+            status_model.devicewebconnection = status_model_device.devicewebconnection;
+            status_model.deviceconnection = status_model_device.deviceconnection;
+            status_model.devicesimulation = status_model_device.devicesimulation;
+
+            localeventbus.emit("ui.status", status_model);
+        });
+
+        localeventbus.on("serial.portopened", function () {
+
+            status_model.deviceconnection = true;
+            localeventbus.emit("ui.status", status_model);
+        });
+
+        localeventbus.on("device.assumeconnected", function () {
+
+                status_model.deviceconnection = true;
+                localeventbus.emit("ui.status", status_model);
+
+        });
+
+        localeventbus.on("serial.simulation", function () {
+
+            status_model.devicesimulation = true;
+
+            localeventbus.emit("ui.status", status_model);
+        });
+
+        localeventbus.on("serial.openfailed", function () {
+
+            status_model.deviceconnection = false;
+            localeventbus.emit("ui.status", status_model);
+
+            setTimeout(function () {
+                localeventbus.emit("serial.connect");
+            }, 1000);
+
+        });
+
+
+        localeventbus.on("webconnection.connected", function (url) {
+
+            if (deviceendpoint) {
+                status_model.devicewebconnection = true;
+            } else {
+                status_model.webconnection = true;
+            }
+            status_model.webchannel = "";
+            localeventbus.emit("ui.status", status_model);
+
+        });
+
+        localeventbus.on("webconnection.closed", function () {
+
+            if (deviceendpoint) {
+                status_model.devicewebconnection = false;
+            } else {
+                status_model.webconnection = false;
+            }
+            status_model.webchannel = "";
+            localeventbus.emit("ui.status", status_model);
+
+            setTimeout(function () {
+                localeventbus.emit("webconnection.connect");
+            }, 1000);
+        });
+
+        localeventbus.on("channel.subscription", function (channelname, channel) {
+
+            status_model.webchannel = channelname;
+
+            if (deviceendpoint) {
+                status_model.devicewebconnection = true;
+            } else {
+                status_model.webconnection = true;
+            }
+
+            localeventbus.emit("ui.status", status_model);
+        });
+
+        localeventbus.on("channel.dev_disconnected", function () {
+
+            if (deviceendpoint) {
+                status_model.devicewebconnection = false;
+                status_model.deviceconnection = false;
+            } else {
+                status_model.devicewebconnection = false;
+                status_model.deviceconnection = false;
+            }
+
+            localeventbus.emit("ui.status", status_model);
+        });
+
+        localeventbus.emit("status.initialized");
+    };
+
+})(typeof exports == 'undefined' ? this['systemstatus'] = {} : exports);

data/app/assets/javascripts/dial_a_device_node/webconnection.js

@@ -0,0 +1,197 @@
+(function (exports) {
+
+    var websockets;
+
+    var localeventbus;
+
+    var channel;
+
+    var deviceendpoint = false;
+
+    var simulation = false;
+
+    var device_info = {
+
+        deviceid: "",
+        operationid: "",
+        devicetype: ""
+
+    }
+
+    var channelname = "";
+    var url = "";
+
+
+    exports.websockets = websockets;
+
+    exports.halt = function () {
+
+        if (!(typeof websockets === "undefined")) {
+            websockets.close();
+        }
+
+    }
+
+    exports.init = function (eventbus, de) {
+        localeventbus = eventbus;
+
+        deviceendpoint = de;
+
+
+
+        localeventbus.emit("initialized");
+
+        localeventbus.emit("status.deviceendpoint", deviceendpoint);
+
+        localeventbus.on("serial.simulation", function () {
+
+            simulation = true;
+
+        });
+
+        localeventbus.on("device.announce.deviceid", function (data) {
+            device_info.deviceid = data;
+        });
+
+        localeventbus.on("device.announce.operationid", function (data) {
+            device_info.operationid = data;
+        });
+
+        localeventbus.on("device.announce.devicetype", function (data) {
+            device_info.devicetype = data;
+        });
+
+        localeventbus.on("webconnection.set.channelname", function (data) {
+            channelname = data;
+        });
+
+        localeventbus.on("webconnection.set.url", function (data) {
+            url = data;
+        });
+
+        localeventbus.on("webconnection.set.deviceendpoint", function (data) {
+            (typeof data == 'object' ? deviceendpoint = data[0] : deviceendpoint = data);
+        });
+
+        localeventbus.on("webconnection.connect", function (data) {
+
+            localeventbus.emit('connecting', url);
+
+            websockets = new WebSocketRails(url, true);
+
+            websockets.bind("connection_closed", function (data) {
+                localeventbus.emit('webconnection.closed');
+            });
+
+            websockets.bind("connection_error", function (data) {
+                localeventbus.emit('webconnection.closed');
+            });
+
+
+            localeventbus.on("device.snapshot", function (model) {
+
+                websockets.trigger("device.log", {
+
+                        "device_info": device_info,
+                        "model": model
+                    
+                });
+            });
+
+            websockets.on_open = function (data) {
+                localeventbus.emit('webconnection.connected', url);
+
+                localeventbus.emit('channel.subscribing', channelname);
+
+                channel = websockets.subscribe(channelname);
+
+                if (simulation) {
+
+                    // create a local loop for ui updates
+
+                    localeventbus.on("ui.command", function (data) {
+
+                        localeventbus.emit("device.command", data);
+
+                    });
+
+                }
+
+
+                if (deviceendpoint) {
+
+                    localeventbus.on("ui.status", function (data) {
+                        channel.trigger("device.status", data);
+                    });
+
+                    // device-local loop
+
+                    localeventbus.on("device.requestheartbeat", function (data) {
+                        localeventbus.emit("device.heartbeat");
+                    });
+
+
+                    // new commands
+
+                    localeventbus.on("ui.update", function (data) {
+                        channel.trigger("ui.update", data);
+                    });
+
+                    channel.bind('subscriber_join', function (data) {
+                        localeventbus.emit("channel.ui_connected", data);
+                    });
+
+                    channel.bind('subscriber_part', function (data) {
+                        localeventbus.emit("channel.ui_disconnected", data);
+                    });
+
+                    channel.bind('device.command', function (data) {
+                        localeventbus.emit("device.command", data);
+                    });
+
+
+                } else {
+
+                    channel.bind("device.status", function (data) {
+                        localeventbus.emit("status.incoming", data);
+                    });
+
+                    // new commands
+
+                    channel.bind("ui.update", function (data) {
+                        localeventbus.emit("ui.update", data);
+                    });
+
+                    channel.bind("ui.status", function (data) {
+                        localeventbus.emit("status.incoming", data);
+                    });
+
+                    localeventbus.on("ui.command", function (data) {
+                        channel.trigger("device.command", data);
+                    });
+
+                    channel.bind('subscriber_join', function (data) {
+                        localeventbus.emit("channel.dev_connected", data);
+                    });
+
+                    channel.bind('subscriber_part', function (data) {
+                        localeventbus.emit("channel.dev_disconnected", data);
+                    });
+
+                }
+
+                localeventbus.emit('channel.subscription', channelname, channel);
+            }
+
+        });
+
+    };
+
+    exports.webconnect = function (url) {
+
+
+    };
+
+
+
+})(typeof exports == 'undefined' ? this['webconnection'] = {} : exports);

data/app/assets/javascripts/dial_a_device_node/websocket_rails/abstract_connection.js.coffee

@@ -0,0 +1,45 @@
+###
+ Abstract Interface for the WebSocketRails client.
+###
+class WebSocketRails.AbstractConnection
+
+  constructor: (url, @dispatcher) ->
+    @message_queue   = []
+
+  close: ->
+
+  trigger: (event) ->
+    if @dispatcher.state != 'connected'
+      @message_queue.push event
+    else
+      @send_event event
+
+  send_event: (event) ->
+    # Events queued before connecting do not have the correct
+    # connection_id set yet. We need to update it before dispatching.
+    event.connection_id = @connection_id if @connection_id?
+
+    # ...
+    
+  on_close: (event) ->
+    if @dispatcher && @dispatcher._conn == @
+      close_event = new WebSocketRails.Event(['connection_closed', event])
+      @dispatcher.state = 'disconnected'
+      @dispatcher.dispatch close_event
+
+  on_error: (event) ->
+    if @dispatcher && @dispatcher._conn == @
+      error_event = new WebSocketRails.Event(['connection_error', event])
+      @dispatcher.state = 'disconnected'
+      @dispatcher.dispatch error_event
+
+  on_message: (event_data) ->
+    if @dispatcher && @dispatcher._conn == @
+      @dispatcher.new_message event_data
+
+  setConnectionId: (@connection_id) ->
+
+  flush_queue: ->
+    for event in @message_queue
+      @trigger event
+    @message_queue = []

data/app/assets/javascripts/dial_a_device_node/websocket_rails/channel.js.coffee

@@ -0,0 +1,70 @@
+###
+The channel object is returned when you subscribe to a channel.
+
+For instance:
+  var dispatcher = new WebSocketRails('localhost:3000/websocket');
+  var awesome_channel = dispatcher.subscribe('awesome_channel');
+  awesome_channel.bind('event', function(data) { console.log('channel event!'); });
+  awesome_channel.trigger('awesome_event', awesome_object);
+
+If you want to unbind an event, you can use the unbind function :
+  awesome_channel.unbind('event')
+###
+class WebSocketRails.Channel
+
+  constructor: (@name, @_dispatcher, @is_private = false, @on_success, @on_failure) ->
+    @_callbacks = {}
+    @_token = undefined
+    @_queue = []
+    if @is_private
+      event_name = 'websocket_rails.subscribe_private'
+    else
+      event_name = 'websocket_rails.subscribe'
+
+    @connection_id = @_dispatcher._conn?.connection_id
+    event = new WebSocketRails.Event( [event_name, {data: {channel: @name}}, @connection_id], @_success_launcher, @_failure_launcher)
+    @_dispatcher.trigger_event event
+
+  destroy: ->
+    if @connection_id == @_dispatcher._conn?.connection_id
+      event_name = 'websocket_rails.unsubscribe'
+      event =  new WebSocketRails.Event( [event_name, {data: {channel: @name}}, @connection_id] )
+      @_dispatcher.trigger_event event
+    @_callbacks = {}
+
+  bind: (event_name, callback) ->
+    @_callbacks[event_name] ?= []
+    @_callbacks[event_name].push callback
+
+  unbind: (event_name) ->
+    delete @_callbacks[event_name]
+
+  trigger: (event_name, message) ->
+    event = new WebSocketRails.Event( [event_name, {channel: @name, data: message, token: @_token}, @connection_id] )
+    if !@_token
+      @_queue.push event
+    else
+      @_dispatcher.trigger_event event
+
+  dispatch: (event_name, message) ->
+    if event_name == 'websocket_rails.channel_token'
+      @connection_id = @_dispatcher._conn?.connection_id
+      @_token = message['token']
+      @flush_queue()
+    else
+      return unless @_callbacks[event_name]?
+      for callback in @_callbacks[event_name]
+        callback message
+
+  # using this method because @on_success will not be defined when the constructor is executed
+  _success_launcher: (data) =>
+    @on_success(data) if @on_success?
+
+  # using this method because @on_failure will not be defined when the constructor is executed
+  _failure_launcher: (data) =>
+    @on_failure(data) if @on_failure?
+
+  flush_queue: ->
+    for event in @_queue
+      @_dispatcher.trigger_event event
+    @_queue = []

data/app/assets/javascripts/dial_a_device_node/websocket_rails/event.js.coffee

@@ -0,0 +1,42 @@
+###
+The Event object stores all the relevant event information.
+###
+
+class WebSocketRails.Event
+
+  constructor: (data, @success_callback, @failure_callback) ->
+    @name    = data[0]
+    attr     = data[1]
+    if attr?
+      @id      = if attr['id']? then attr['id'] else (((1+Math.random())*0x10000)|0)
+      @channel = if attr.channel? then attr.channel
+      @data    = if attr.data? then attr.data else attr
+      @token   = if attr.token? then attr.token
+      @connection_id = data[2]
+      if attr.success?
+        @result  = true
+        @success = attr.success
+
+  is_channel: ->
+    @channel?
+
+  is_result: ->
+    typeof @result != 'undefined'
+
+  is_ping: ->
+    @name == 'websocket_rails.ping'
+
+  serialize: ->
+      JSON.stringify [@name, @attributes()]
+
+  attributes: ->
+    id: @id,
+    channel: @channel,
+    data: @data
+    token: @token
+
+  run_callbacks: (@success, @result) ->
+    if @success == true
+      @success_callback?(@result)
+    else
+      @failure_callback?(@result)