ruku 0.1

data/lib/ruku/clients/web_static/js/ruku.js

@@ -0,0 +1,447 @@
+function RUKU() {}
+
+/**
+ * Creates a remote for a particular box. Calling various methods corresponding to remote
+ * commands (i.e. up(), pause(), home()) will make an AJAX request resulting in the command
+ * being sent to the box with the same IP/hostname as the object.
+ *
+ * Initialize with an object with the following properties: host, name, port (optional)
+ */
+RUKU.createRemote = function(data) {
+	var remote = {
+		host: data.host,
+		name: data.name,
+		port: data.port || 8080
+	};
+
+	// Add methods to our object, for each of the remote commands, that will make AJAX requests
+	// resulting in the server sending the corresponding remote command to the Roku box with
+	// this remote's IP/hostname.
+	var commands = ["home", "up", "down", "left", "right", "select", "pause", "back", "fwd"];
+	for (var i = 0; i < commands.length; i++) {
+		var cmd = commands[i];
+		remote[cmd] = function(theCmd) {
+			return function() {
+				$.ajax({url:"/ajax", data:{command:theCmd, host:data.host}, success:function(resp) {
+					console.log("Successfully sent command: " + cmd);
+				}, error:function() {
+					console.log("Error on command: " + cmd);
+				}});
+			};
+		}(cmd);
+	}
+	return remote;
+};
+
+/**
+ * Creates objects that manage a collection of remote objects. Keeps track of which remote
+ * is the active one, which is the one that commands are to be sent to with the remote interface.
+ *
+ * Initialize with with an object with a remotes property that is an Array of objects suitable
+ * for initializing remote objects and an optional active property that contains the index,
+ * in the remotes Array, of the active remote.
+ */
+RUKU.createRemoteManager = function(data) {
+	var processed = {};
+
+	/**
+	 * Loads data into the remoteManager from an object as described in the createRemoteManager
+	 * top level docs.
+	 */
+	function loadData(remoteData) {
+		this.remotes = [];
+		this.activeIndex = 0;
+		if (remoteData) {
+			for (var i = 0; i < remoteData.remotes.length; i++) {
+				this.remotes.push(RUKU.createRemote(remoteData.remotes[i]));
+			}
+			this.activeIndex = remoteData.active || 0;
+		}
+	}
+
+	loadData.call(processed, data);
+
+	/**
+	 * Loads the remoteManager with data from the server.
+	 */
+	function load(callback) {
+		var that = this;
+		$.ajax({url:"/ajax", dataType:"json", data:{action:"list"}, success:function(data) {
+			that.loadData(data);
+			if (callback) {
+				callback();
+			}
+		}});
+	}
+
+	/**
+	 * Sends the data contained in the remoteManager back to the server for saving.
+	 */
+	function save(callback) {
+		// Just hack together the JSON this one time...
+		var json = "{\"remotes\":[";
+		for (var i = 0; i < this.remotes.length; i++) {
+			var remote = this.remotes[i];
+			json = json + "{\"host\":\"" + remote.host + "\",\"name\":\"" + remote.name +
+				"\",\"port\":\"" + remote.port + "\"}";
+			if (i !== (this.remotes.length - 1)) {
+				json = json + ",";
+			}
+		}
+		json = json + "],\"active\":" + this.activeIndex + "}";
+
+		$.ajax({url:"/ajax", data:{action:"update", data:json}, success:function(resp) {
+			console.log(resp);
+			if (callback) {
+				callback();
+			}
+		}});
+	}
+
+	/**
+	 * Returns the active remote or null if there are no remotes.
+	 */
+	function getActive() {
+		var activeRemote = null;
+		if (this.remotes.length > 0 && this.activeIndex < this.remotes.length) {
+			activeRemote = this.remotes[this.activeIndex];
+		}
+		return activeRemote;
+	}
+
+	/**
+	 * Makes the given remote the active remote. Also accepts a String that is the new active remote's
+	 * IP/hostname. If the remoteManager does not know about a remote with the given hostname then this
+	 * is ignored.
+	 */
+	function setActive(newActive) {
+		var that = this;
+		var newHost = (newActive && newActive.host) ?
+			newActive.host : (typeof newActive === 'string') ? newActive : null;
+		if (newHost) {
+			$.each(this.remotes, function(index, remote) {
+				if (remote.host === newHost) {
+					that.activeIndex = index;
+					that.save();
+					return false;
+				}
+			});
+		}
+	}
+
+	function scanForFirst(callback) {
+		var that = this;
+		$.ajax({url:"/ajax", dataType:"json", data:{action:"scanForFirst"}, success:function(data) {
+			that.loadData(data);
+			if (callback) {
+				callback();
+			}
+		}});
+	}
+
+	function scanForAll(callback) {
+		var that = this;
+		$.ajax({url:"/ajax", dataType:"json", data:{action:"scanForAll"}, success:function(data) {
+			that.loadData(data);
+			if (callback) {
+				callback();
+			}
+		}});
+	}
+
+	return {
+		remotes: processed.remotes,
+		activeIndex: processed.activeIndex,
+		loadData:loadData,
+		getActive:getActive,
+		setActive:setActive,
+		load:load,
+		save:save,
+		scanForFirst:scanForFirst,
+		scanForAll:scanForAll
+	};
+};
+
+/**
+ * Creates an interface for managing remotes. The first parameter is a (jQuery wrapped) element
+ * that holds the main interface components. The second is an element containing the title for
+ * the active remote that needs to be updated when the active remote changes. The third parameter
+ * is the remoteManager to use for remote related operations.
+ */
+RUKU.createRemoteMenu = function(remoteMenu, activeRemoteTitle, remoteManagerToUse) {
+	var remoteManager = remoteManagerToUse || RUKU.createRemoteManager();
+	var container = remoteMenu.parent();
+	var remoteList = remoteMenu.find("#remoteList");
+	var firstBoxInfo = container.find("#firstBoxInfo");
+
+	/** Set the remoteManager for the menu to use for its remote operations */
+	function setRemoteManager(rm) {
+		remoteManager = rm;
+	}
+
+	/** Get the remote that is active according to the remoteManager */
+	function getActiveRemote() {
+		return remoteManager.getActive();
+	}
+
+	/** Returns true if there is at least one remote managed by the remoteManager */
+	function hasRemotes() {
+		return remoteManager &&
+			remoteManager.remotes &&
+			remoteManager.remotes.length > 0;
+	}
+
+	/** Updates the text of the activeRemoteTitle element */
+	function updateActiveRemoteTitle() {
+		var activeRemote;
+		if (remoteManager) {
+			activeRemote = remoteManager.getActive();
+		}
+		if (activeRemote) {
+			var name = ($.trim(activeRemote.name)) === "" ? "(Box with no name)" : activeRemote.name;
+			activeRemoteTitle.text(name);
+			var altText = name + " (" + activeRemote.host + ")";
+			activeRemoteTitle.attr("alt", altText);
+			activeRemoteTitle.attr("title", altText);
+		} else {
+			var text = "(Must set up remote)";
+			activeRemoteTitle.text(text);
+			activeRemoteTitle.attr("alt", text);
+			activeRemoteTitle.attr("title", text);
+		}
+	}
+
+	/** Scan for all remotes on the network and show the results */
+	function scanForAll() {
+		remoteManager.scanForAll(function() {
+			updateActiveRemoteTitle();
+			show();
+		});
+	}
+
+	/**
+	 * Scan for the first remote found on the network (the common case is one remote)
+	 * and show display the result
+	 */
+	function scanForFirst() {
+		remoteManager.scanForFirst(function() {
+			updateActiveRemoteTitle();
+			remoteList.css("display", "none");
+			firstBoxInfo.empty();
+			if (hasRemotes()) {
+				firstBoxInfo
+					.append($("<div>").addClass("message").text("One box found"))
+					.append($("<div>").addClass("boxInfo")
+						.append($("<img>").attr("src", "/images/box-medium.png"))
+						.append(
+							$("<div>").addClass("details")
+								.append($("<div>").addClass("name").text(getActiveRemote().name))
+								.append($("<div>").addClass("host").text(getActiveRemote().host))
+						)
+					)
+					.append(
+						$("<div>").addClass("menu")
+							.append($("<a>").addClass("buttonLink").addClass("doneButton")
+								.text("this is my only box").attr("href", "#")
+								.click(function() {
+									hide();
+									return false;
+								}))
+							.append($("<a>").addClass("buttonLink").addClass("moreButton")
+								.text("scan for more boxes").attr("href", "#")
+								.click(function() {
+									scanForAll();
+									return false;
+								}))
+					);
+			} else {
+				firstBoxInfo.text("Didn't find anything");
+			}
+			firstBoxInfo.css("display", "block");
+		});
+	}
+
+	function addRemote(host, name) {
+		if (host === "") {
+			return;
+		}
+		if (!name) {
+			if (remoteManager.remotes.length === 0) {
+				name = "My Roku Box";
+			} else {
+				name = host;
+			}
+		}
+		remoteManager.remotes.push({host:host, name:name});
+		remoteManager.save(function() {
+			show();
+		});
+	}
+
+	/**
+	 * Updates the name of the remote with the given hostname and causes the remoteManager to save
+	 * the data to the server if the name has changed.
+	 */
+	function updateRemoteName(remoteHost, remoteName) {
+		var changed = false;
+
+		for (var i = 0; i < remoteManager.remotes.length; i++) {
+			var remote = remoteManager.remotes[i];
+			if (remote.host === remoteHost) {
+				if (remote.name !== remoteName) {
+					remote.name = remoteName;
+					changed = true;
+				}
+				break;
+			}
+		}
+
+		if (changed) {
+			remoteManager.save();
+			updateActiveRemoteTitle();
+		}
+	}
+
+	/**
+	 * Changes the active remote to the one with the given hostname. If there are no remotes with the
+	 * given hostname then there is no effect.
+	 */
+	function changeActiveRemote (newActiveRemoteHost) {
+		$.each(remoteManager.remotes, function(index, remote) {
+			if (remote.host === newActiveRemoteHost) {
+				remoteManager.setActive(remote);
+				updateActiveRemoteTitle();
+				return false;
+			}
+		});
+	}
+
+	/** Render a list of available remotes */
+	function show() {
+		remoteList.empty();
+		if (hasRemotes()) {
+			for (var i=0; i < remoteManager.remotes.length; i++) {
+				var remote = remoteManager.remotes[i];
+				var boxDiv = $("<div>").addClass("remote")
+					.append($("<div>")
+						.append($("<input>").addClass("activeRemoteRadio").attr("type", "radio")
+							.attr("name", "activeRemote").val(remote.host))
+							.change(function(host) {
+									return function() {
+										changeActiveRemote(host);
+									};
+								}(remote.host)
+							)
+					)
+					.append($("<div>").append($("<img>").addClass("boxPic").attr("src", "/images/box-small.png")))
+					.append($("<div>").addClass("info")
+						.append($("<input>").addClass("name")
+							.attr("type", "text").val(remote.name || "(no name)")
+							// Add the ability to edit the name of a remote by clicking on it and typing
+							.hover(function() { $(this).addClass("over"); }, function() { $(this).removeClass("over"); })
+							.blur(function(host) {
+								return function() {
+									updateRemoteName(host, $(this).val());
+								};
+							}(remote.host))
+							.keypress(function() {
+								// Make the Return key complete the name edit
+								if (event.which == '13') {
+									event.preventDefault();
+									$(this).blur();
+									$(this).removeClass("over");
+								}
+							}))
+						.append($("<div>").addClass("host").text(remote.host))
+					);
+
+				if (i === remoteManager.activeIndex) {
+					boxDiv.addClass("active");
+					boxDiv.find(".activeRemoteRadio").attr("checked", true);
+				}
+				remoteList.append(boxDiv);
+			}
+		} else {
+			remoteList.append(
+				$("<div>").addClass("noRemotesMessage")
+					.html(
+						"No remotes have been set up yet. Click the <b>scan for boxes</b> button above " +
+						"to find remotes on your network. If you know the IP address or hostname of your " +
+						"box you can add it below instead."
+					)
+			);
+		}
+
+		remoteList.append(
+			$("<div>").attr("id", "manualAddBox")
+				.append("Add a box by IP: ")
+				.append($("<input>").attr("type", "text").attr("id", "manualAddBoxInput"))
+				.append($("<a>").addClass("buttonLink").text("Add")
+					.click(function() {
+						addRemote($("#manualAddBoxInput").val());
+					})
+				)
+		);
+
+		container.css("display", "block");
+		remoteList.css("display", "block");
+		firstBoxInfo.css("display", "none");
+		remoteMenu.fadeIn();
+	}
+
+	/**
+	 * Loads remote data from the server. If no remotes are found this displays
+	 * a 'no remotes' message to the user.
+	 */
+	function load() {
+		remoteManager.load(function() {
+			updateActiveRemoteTitle();
+			if (!hasRemotes()) {
+				// Since we cannot do anything without remotes, go ahead and call the show() method which
+				// will display the 'no remotes' message in this case.
+				show();
+			}
+		});
+	}
+
+	/** Hide the menu */
+	function hide() {
+		remoteMenu.fadeOut("fast", function() {
+			container.css("display", "none");
+		});
+	}
+
+	function listRemotes() {
+		if (hasRemotes()) {
+			// We already have some remotes. Just display them.
+			show();
+		} else {
+			remoteManager.load(function() {
+				updateActiveRemoteTitle();
+				show();
+			});
+		}
+	}
+
+	remoteMenu.find("#closeButton").click(function() {
+		hide();
+		return false;
+	});
+
+	remoteMenu.find("#scanButton").click(function() {
+		scanForFirst();
+		return false;
+	});
+
+	return {
+		remoteManager:remoteManager,
+		setRemoteManager:setRemoteManager,
+		getActiveRemote:getActiveRemote,
+		hasRemotes:hasRemotes,
+		load:load,
+		show:show,
+		hide:hide,
+		listRemotes:listRemotes,
+		updateActiveRemoteTitle:updateActiveRemoteTitle
+	};
+};

data/lib/ruku/remote.rb

@@ -0,0 +1,138 @@
+require 'socket'
+require 'yaml'
+
+module Ruku
+
+  # Class for Remote to extend that removes most instance methods
+  class BlankSlate
+    # Keep a few basics and some YAML related methods
+    KEEPERS = %w[class object_id != inspect to_yaml to_yaml_style to_yaml_properties] +
+      %w[taguri instance_variables instance_variable_get]
+
+    instance_methods.each do |m|
+      # Whack every method except those that start with __ or end with ?, figuring
+      # that those would be unlikely to be tried to use for Roku commands and
+      # possibly useful for other basic stuff.
+      ms = m.to_s
+      undef_method m unless (ms =~ /^__/ || ms =~ /\?$/ || KEEPERS.include?(ms))
+    end
+  end
+
+  # Communicates with a Roku box. Known methods that you can call that correspond with buttons
+  # on the physical Roku remote include: up, down, left, right, select, home, fwd, back, pause
+  #
+  # Calling methods with the name of the command you want to send has the same effect as calling
+  # send_roku_command with the Symbol (or String) representing your command.
+  #
+  # Examples:
+  #
+  #   remote = Remote.new('192.168.1.10') # Use your Roku box IP or hostname
+  #   remote.pause                        # Sends play/pause to the Roku box
+  #   remote.left.down.select             # Can chain commands if you want to
+  #
+  # Actually, all prefixes will work for all commands because they are accepted by the Roku box.
+  # Unless more commands are added to introduce ambiguities, this means only one character is
+  # needed for a command.
+  #
+  # Examples:
+  #
+  #   remote.h           # Registers as 'home'
+  #
+  #   remote.d           # This and the following 3 lines register as 'down'
+  #   remote.do
+  #   remote.dow
+  #   remote.down
+  #
+  # Despite this working now it is not recommended that you use this in case future added commands
+  # create ambiguity and also because it can make code less clear.
+  class Remote < BlankSlate
+    # The port on which the Roku box listens for commands
+    DEFAULT_PORT = 8080
+
+    # Known commands that the Roku box will accept - here mostly for documentation purposes
+    KNOWN_COMMANDS = %w[up down left right select home fwd back pause]
+
+    # Scan for Roku boxes on the local network
+    def self.scan(stop_on_first=false)
+      # TODO: don't just use the typical IP/subnet for a home network; figure it out
+      boxes = []
+      prefix = '192.168.1.'
+      (0..255).each do |host|
+        info = Socket.getaddrinfo(prefix + host.to_s, DEFAULT_PORT)
+        # Is there a better way to identify a Roku box other than looking for a hostname
+        # starting with 'NP-'? There probably is - is the better way also quick?
+        boxes << Remote.new(info[0][3]) if info[0][2] =~ /^NP-/i
+        break if stop_on_first && !boxes.empty?
+      end
+      boxes
+    end
+
+    attr_accessor :host, :name, :port
+
+    def initialize(host, name=nil, port=DEFAULT_PORT)
+      @host, @name, @port = host, name, port
+    end
+
+    # Send a "raw" command to the Roku player that is not formatted in the typical style that
+    # the box is expecting to receive.
+    def send_command(cmd)
+      use_tcp_socket {|s| s.write cmd}
+      self
+    end
+
+    # Send a command to the Roku box in the form "press CMD\n" that is used for known commands.
+    def send_roku_command(cmd)
+      cmd_string = cmd.to_s # In case it's a symbol, basically
+
+      # For some reason the Roku box can be unresponsive with the full 'select' command. It seems
+      # that 'sel' will always work, though, so send that.
+      cmd_string = 'sel' if cmd_string == 'select'
+
+      send_command "press #{cmd_string}\n"
+    end
+
+    # Consider missing methods to be names of commands to send to the box
+    def method_missing(*args)
+      # If more than one argument, assume someone is trying to use a method
+      # that they don't expect will be turned into a Roku command
+      throw 'Roku command takes no arguments' if args.size > 1
+      roku_cmd = args[0]
+      send_roku_command roku_cmd
+    end
+
+    # Overide normal Object select to make it work in the Roku remote sense
+    def select
+      send_roku_command :select
+    end
+
+    # Remotes with the same host are considered equal
+    def ==(other)
+      host == other.host
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def hash
+      host.hash
+    end
+
+    def <=>(other)
+      host <=> other.host
+    end
+
+    def to_s
+      "<Remote host:#{@host}, name:#{@name || '(none)'}>"
+    end
+
+    protected
+
+    # Do something with the TCPSocket in the given block. The socket will be closed afterward.
+    def use_tcp_socket
+      s = TCPSocket.open(@host, @port)
+      yield s
+      s.close
+    end
+  end
+end

data/lib/ruku/remotes.rb

@@ -0,0 +1,78 @@
+module Ruku
+  # A collection of Ruku::Remotes. Keeps track of one or multiple Remotes for Roku
+  # boxes. Manages things like which box is active for use.
+  class Remotes
+    include Enumerable
+
+    attr_reader :active_index
+    attr_accessor :boxes, :storage
+
+    def initialize(boxes=[], storage=SimpleStorage.new)
+      @boxes, @storage = boxes, storage
+      boxes.uniq!
+      @active_index = 0
+    end
+
+    def each(&b)
+      boxes.each &b
+    end
+
+    def size
+      boxes.size
+    end
+
+    def empty?
+      boxes.empty?
+    end
+
+    def [](index)
+      boxes[index]
+    end
+
+    def []=(index, box)
+      boxes[index] = box
+    end
+
+    def active
+      return boxes[@active_index] if !boxes.empty? && boxes.size > active_index
+      nil
+    end
+
+    def set_active(box)
+      new_index = nil
+      boxes.each_with_index {|b,i| new_index = i if b == box} if box.is_a? Remote
+      self.active_index = new_index if new_index and new_index < boxes.size
+    end
+
+    def find_by_host(host)
+      boxes.find {|box| box.host == host}
+    end
+
+    def add(box)
+      boxes << box
+      boxes.sort!.uniq!
+    end
+
+    def remove(box)
+      host = box.is_a?(Remote) ? box.host : box
+      boxes.reject! { |b| b.host == host }
+      self.active_index = 0 if @active_index >= boxes.size
+      boxes.sort!
+    end
+
+    def store
+      storage.store(self)
+    end
+
+    def load
+      loaded = storage.load
+      self.boxes, self.active_index = loaded.boxes, loaded.active_index
+    end
+
+    private
+
+    def active_index=(index)
+      @active_index = index
+    end
+  end
+end