hacky_hal 0.2.0

data/lib/hacky_hal/device_controllers/roku.rb

@@ -0,0 +1,121 @@
+require "net/http"
+require "uri"
+require "cgi"
+require "rexml/document"
+require_relative "base"
+require_relative "../util"
+
+# Docs: http://sdkdocs.roku.com/display/sdkdoc/External+Control+Guide
+
+module HackyHAL
+  module DeviceControllers
+    class Roku < Base
+      KEY_HOME = "Home"
+      KEY_REVERSE = "Rev"
+      KEY_FORWARD = "Fwd"
+      KEY_PLAY = "Play"
+      KEY_SELECT = "Select"
+      KEY_LEFT = "Left"
+      KEY_RIGHT = "Right"
+      KEY_DOWN = "Down"
+      KEY_UP = "Up"
+      KEY_BACK = "Back"
+      KEY_INSTANT_REPLAY = "InstantReplay"
+      KEY_INFO = "Info"
+      KEY_BACKSPACE = "Backspace"
+      KEY_SEARCH = "Search"
+      KEY_ENTER = "Enter"
+
+      NAMED_KEYS = Set.new([
+        KEY_HOME, KEY_REVERSE, KEY_FORWARD, KEY_PLAY,
+        KEY_SELECT, KEY_LEFT, KEY_RIGHT, KEY_DOWN,
+        KEY_UP, KEY_BACK, KEY_INSTANT_REPLAY, KEY_INFO,
+        KEY_BACKSPACE, KEY_SEARCH, KEY_ENTER
+      ])
+
+      attr_reader :host_uri
+
+      def initialize(options)
+        super(options)
+        ensure_option(:device_resolver)
+
+        resolver = Util.object_from_hash(options[:device_resolver], DeviceResolvers)
+        @host_uri = resolver.uri
+
+        log("Host found at: #{@host_uri.to_s}", :debug)
+      end
+
+      def channel_list
+        response = get_request("/query/apps")
+        response_document = REXML::Document.new(response.body)
+        
+        response_document.elements.to_a("apps/app").map do |app|
+          id = app.attributes["id"]
+          version = app.attributes["version"]
+          name = app.text
+
+          {id: id, version: version, name: name}
+        end
+      end
+
+      def launch(channel_id, query_params = nil)
+        post_request("/launch/#{channel_id}", query_params)
+      end
+
+      def icon(channel_id)
+        response = get_request("/query/icon/#{channel_id}")
+        {type: response["content-type"], body: response.body}
+      end
+
+      def key_down(key)
+        post_request("/keydown/#{key_code(key)}")
+      end
+
+      def key_up(key)
+        post_request("/keyup/#{key_code(key)}")
+      end
+      
+      def key_press(key)
+        post_request("/keypress/#{key_code(key)}")
+      end
+
+      def key_press_string(string)
+        string.chars.each do |char|
+          key_press(char)
+        end
+      end
+
+      private
+
+      def key_code(key)
+        if NAMED_KEYS.include?(key)
+          key
+        else
+          "Lit_#{CGI::escape(key)}"
+        end
+      end
+
+      def get_request(path, query_params = nil)
+        http_request(Net::HTTP::Get, path, query_params)
+      end
+
+      def post_request(path, query_params = nil)
+        http_request(Net::HTTP::Post, path, query_params)
+      end
+
+      def request_uri(path, query_params)
+        uri = @host_uri.dup
+        uri.path = path
+        uri.query = URI.encode_www_form(query_params) if query_params
+        uri
+      end
+
+      def http_request(request_type, path, query_params)
+        uri = request_uri(path, query_params)
+        http = Net::HTTP.new(uri.host, uri.port)
+        request = request_type.new(uri.request_uri)
+        http.request(request)
+      end
+    end
+  end
+end

data/lib/hacky_hal/device_controllers/yamaha_av_receiver.rb

@@ -0,0 +1,202 @@
+require "net/http"
+require "rexml/document"
+require_relative "base"
+require_relative "../util"
+
+module HackyHAL
+  module DeviceControllers
+    class YamahaAvReceiver < Base
+      CONTROL_PATH = "/YamahaRemoteControl/ctrl"
+      CONTROL_PORT = 80
+
+      attr_reader :host_uri
+
+      def initialize(options)
+        super(options)
+        ensure_option(:device_resolver)
+
+        resolver = Util.object_from_hash(options[:device_resolver], DeviceResolvers)
+
+        @host_uri = resolver.uri
+        @host_uri.path = CONTROL_PATH
+        @host_uri.port = CONTROL_PORT
+
+        log("Host found at: #{@host_uri.to_s}", :debug)
+      end
+
+      def basic_status
+        response = get_request('<Main_Zone><Basic_Status>GetParam</Basic_Status></Main_Zone>')
+
+        basic_settings = response.elements["YAMAHA_AV/Main_Zone/Basic_Status"]
+        power_settings = basic_settings.elements["Power_Control"]
+        volume_settings = basic_settings.elements["Volume"]
+        input_settings = basic_settings.elements["Input/Input_Sel_Item_Info"]
+        sound_video_settings = basic_settings.elements["Sound_Video"]
+        hdmi_settings = sound_video_settings.elements["HDMI"]
+        tone_settings = sound_video_settings.elements["Tone"]
+        dialog_adjust_settings = sound_video_settings.elements["Dialogue_Adjust"]
+        surround_settings = basic_settings.elements["Surround/Program_Sel/Current"]
+
+        hdmi_output_values = []
+        hdmi_settings.elements.each("Output") do |output_element|
+          if output_element.name =~ /^OUT_(\d)$/
+            hdmi_output_values << {
+              name: output_element.name,
+              enabled: element_on?(output_element)
+            }
+          end
+        end
+
+        {
+          power: element_on?(power_settings.elements["Power"]),
+          sleep: element_on?(power_settings.elements["Sleep"]),
+          mute: element_on?(volume_settings.elements["Mute"]),
+          volume: element_volume_value(volume_settings.elements["Lvl/Val"]),
+          subwoofer_trim: element_volume_value(volume_settings.elements["Subwoofer_Trim/Val"]),
+          tone: {
+            base: element_volume_value(tone_settings.elements["Bass/Val"]),
+            treble: element_volume_value(tone_settings.elements["Treble/Val"])
+          },
+          input: {
+            name: input_settings.elements["Param"].text,
+            title: input_settings.elements["Title"].text
+          },
+          surround: {
+            straight: element_on?(surround_settings.elements["Straight"]),
+            enhancer: element_on?(surround_settings.elements["Enhancer"]),
+            sound_program: surround_settings.elements["Sound_Program"].text,
+            cinema_dsp_3d_mode: element_on?(basic_settings.elements["Surround/_3D_Cinema_DSP"])
+          },
+          hdmi: {
+            standby_through: element_on?(hdmi_settings.elements["Standby_Through_Info"]),
+            outputs: hdmi_output_values
+          },
+          party_mode: element_on?(basic_settings.elements["Party_Info"]),
+          pure_direct_mode: element_on?(sound_video_settings.elements["Pure_Direct/Mode"]),
+          adaptive_drc: element_on?(sound_video_settings.elements["Adaptive_DRC"]),
+          dialog_adjust: {
+            level: dialog_adjust_settings.elements["Dialogue_Lvl"].text.to_i,
+            lift: dialog_adjust_settings.elements["Dialogue_Lift"].text.to_i
+          }
+        }
+      end
+
+      def inputs
+        response = get_request('<Main_Zone><Input><Input_Sel_Item>GetParam</Input_Sel_Item></Input></Main_Zone>')
+
+        inputs = []
+        response.elements["YAMAHA_AV/Main_Zone/Input/Input_Sel_Item"].each do |input_element|
+          if input_element.name =~ /^Item_\d+$/
+            inputs << {
+              name: input_element.elements["Param"].text,
+              title: input_element.elements["Title"].text,
+              source_name: input_element.elements["Src_Name"].text,
+              source_number: input_element.elements["Src_Number"].text.to_i,
+            }
+          end
+        end
+
+        inputs
+      end
+
+      def input
+        response = get_request('<Main_Zone><Input><Input_Sel>GetParam</Input_Sel></Input></Main_Zone>')
+        response.elements["YAMAHA_AV/Main_Zone/Input/Input_Sel"].text
+      end
+
+      def input=(input_name)
+        put_request(%|<Main_Zone><Input><Input_Sel>#{input_name}</Input_Sel></Input></Main_Zone>|)
+      end
+
+      def hdmi_output(output_name)
+        response = get_request(%|<System><Sound_Video><HDMI><Output><#{output_name}>GetParam</#{output_name}></Output></HDMI></Sound_Video></System>|)
+        element_on?(response.elements["YAMAHA_AV/System/Sound_Video/HDMI/Output/#{output_name}"])
+      end
+
+      def set_hdmi_output(output_name, enabled)
+        value = enabled ? "On" : "Off"
+        put_request(%|<System><Sound_Video><HDMI><Output><#{output_name}>#{value}</#{output_name}></Output></HDMI></Sound_Video></System>|)
+      end
+
+      def on
+        response = get_request("<Main_Zone><Power_Control><Power>GetParam</Power></Power_Control></Main_Zone>")
+        response.elements["YAMAHA_AV/Main_Zone/Power_Control/Power"].text == "On"
+      end
+
+      def on=(value)
+        value = value ? "On" : "Standby"
+        put_request("<Main_Zone><Power_Control><Power>#{value}</Power></Power_Control></Main_Zone>")
+      end
+
+      def volume
+        response = get_request("<Main_Zone><Volume><Lvl>GetParam</Lvl></Volume></Main_Zone>")
+        element_volume_value(response.elements["YAMAHA_AV/Main_Zone/Volume/Lvl/Val"])
+      end
+
+      def volume=(value)
+        value = (value * 10.0).to_i.to_s
+        response = put_request("<Main_Zone><Volume><Lvl><Val>#{value}</Val><Exp>1</Exp><Unit>dB</Unit></Lvl></Volume></Main_Zone>")
+      end
+      
+      def mute
+        response = get_request("<Main_Zone><Volume><Mute>GetParam</Mute></Volume></Main_Zone>")
+        element_on?(response.elements["YAMAHA_AV/Main_Zone/Volume/Mute"])
+      end
+      
+      def mute=(value)
+        value = case value
+                when true then "On"
+                when false then "Off"
+                else value
+                end
+
+        put_request("<Main_Zone><Volume><Mute>#{value}</Mute></Volume></Main_Zone>")
+      end
+
+      private
+
+      def request(body)
+        http = Net::HTTP.new(@host_uri.host, @host_uri.port)
+
+        request = Net::HTTP::Post.new(@host_uri.request_uri)
+        request["Content-Type"] = "text/xml"
+        request.body = body
+
+        response = http.request(request)
+        log("Response: #{response.body}", :debug)
+
+        response_xml = REXML::Document.new(response.body)
+
+        if response_xml.root.attributes["RC"] == "0"
+          response_xml
+        else
+          false
+        end
+      end
+
+      def get_request(body)
+        command = %|<YAMAHA_AV cmd="GET">#{body}</YAMAHA_AV>| 
+        log("GET Request: #{command.inspect}", :debug)
+        request(command)
+      end
+
+      def put_request(body)
+        command = %|<YAMAHA_AV cmd="PUT">#{body}</YAMAHA_AV>|
+        log("POST Request: #{command.inspect}", :debug)
+        request(command)
+      end
+
+      def element_on?(element)
+        case element.text
+        when "On" then true
+        when "Off" then false
+        else element.text
+        end
+      end
+
+      def element_volume_value(element)
+        element.text.to_f / 10.0
+      end
+    end
+  end
+end

data/lib/hacky_hal/device_resolvers/base.rb

@@ -0,0 +1,9 @@
+require_relative "../options"
+
+module HackyHAL
+  module DeviceResolvers
+    class Base
+      include Options
+    end
+  end
+end

data/lib/hacky_hal/device_resolvers/ssdp.rb

@@ -0,0 +1,36 @@
+require_relative "base"
+require "uri"
+require "upnp/ssdp"
+
+module HackyHAL
+  module DeviceResolvers
+    class SsdpUnresolvedDevice < Exception; end
+
+    DEFAULT_OPTIONS = {
+      search: "upnp:rootdevice"
+    }
+
+    class SSDP < Base
+      def initialize(options)
+        super(DEFAULT_OPTIONS.merge(options))
+        ensure_option(:usn)
+      end
+
+      def uri
+        @uri ||= (
+          old_upnp_log_value = UPnP.log?
+          UPnP.log = false
+
+          device = UPnP::SSDP.search(options[:search]).find do |device|
+            device[:usn] == options[:usn]
+          end
+
+          UPnP.log = old_upnp_log_value
+
+          raise SsdpUnresolvedDevice unless device
+          URI.parse(device[:location])
+        )
+      end
+    end
+  end
+end

data/lib/hacky_hal/device_resolvers/static_uri.rb

@@ -0,0 +1,17 @@
+require_relative "base"
+require "uri"
+
+module HackyHAL
+  module DeviceResolvers
+    class StaticURI < Base
+      attr_reader :uri
+
+      def initialize(options)
+        super(options)
+        ensure_option(:uri)
+
+        @uri = URI.parse(options[:uri])
+      end
+    end
+  end
+end

data/lib/hacky_hal/log.rb

@@ -0,0 +1,33 @@
+require "logger"
+require "singleton"
+
+module HackyHAL
+  class Log < Logger
+    include Singleton
+
+    attr_accessor :enabled
+
+    class Formatter
+      def call(severity, time, progname, message)
+        time = time.strftime("%d/%b/%Y %H:%M:%S")
+        "[#{time}] #{severity}: #{message}\n"
+      end
+    end
+
+    def initialize
+      super($stdout)
+      self.enabled = true
+      self.formatter = Formatter.new
+    end
+
+    alias_method :add_without_enabled_switch, :add
+    def add(severity, message = nil, progname = nil, &block)
+      add_without_enabled_switch(severity, message, progname, &block) if enabled
+    end
+
+    # for compatibility with Rack logger
+    def write(string)
+      self << string
+    end
+  end
+end

data/lib/hacky_hal/options.rb

@@ -0,0 +1,21 @@
+module HackyHAL
+  module Options
+    attr_reader :options
+
+    def initialize(options)
+      @options = options
+    end
+
+    def [](value)
+      @options[value]
+    end
+
+    protected
+
+    def ensure_option(option_name)
+      unless options[option_name]
+        raise ArgumentError, "#{self.class.name} must set #{option_name} option."
+      end
+    end
+  end
+end

data/lib/hacky_hal/registry.rb

@@ -0,0 +1,22 @@
+require "singleton"
+require_relative "util"
+
+module HackyHAL
+  class Registry
+    include Singleton
+
+    attr_reader :devices
+
+    def load_yaml_file(path)
+      devices = YAML.load(File.read(File.expand_path(path)))
+      devices = Util.symbolize_keys_deep(devices)
+
+      @devices = {}
+      devices.each do |name, config|
+        config = config.dup
+        config[:name] = name
+        @devices[name] = Util.object_from_hash(config, HackyHAL::DeviceControllers)
+      end
+    end
+  end
+end

data/lib/hacky_hal/util.rb

@@ -0,0 +1,23 @@
+module HackyHAL
+  module Util
+    def self.object_from_hash(hash, context_module)
+      hash = hash.dup
+      type = hash.delete(:type)
+
+      unless type
+        raise ArgumentError, "Must specify type to build object from hash.  Given: #{hash}"
+      end
+
+      context_module.const_get(type).new(hash)
+    end
+
+    def self.symbolize_keys_deep(h)
+      h.keys.each do |k|
+        ks = k.respond_to?(:to_sym) ? k.to_sym : k
+        h[ks] = h.delete(k)
+        symbolize_keys_deep(h[ks]) if h[ks].kind_of?(Hash)
+      end
+      h
+    end
+  end
+end

data/lib/hacky_hal.rb

@@ -0,0 +1,17 @@
+require_relative "hacky_hal/registry"
+require_relative "hacky_hal/log"
+
+module HackyHAL
+  DEVICE_CONTROLLERS_DIR = "hacky_hal/device_controllers"
+  DEVICE_RESOLVERS_DIR = "hacky_hal/device_resolvers"
+
+  controllers_dir = File.expand_path(DEVICE_CONTROLLERS_DIR, File.dirname(__FILE__))
+  Dir["#{controllers_dir}/*"].each do |file|
+    require_relative file
+  end
+
+  resolvers_dir = File.expand_path(DEVICE_RESOLVERS_DIR, File.dirname(__FILE__))
+  Dir["#{resolvers_dir}/*"].each do |file|
+    require_relative file
+  end
+end

data/spec/hacky_hal/device_controllers/base_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+require "hacky_hal/device_controllers/base"
+
+describe HackyHAL::DeviceControllers::Base do
+  it "should include Options" do
+    described_class.ancestors.should include(HackyHAL::Options)
+  end
+
+  describe "#log" do
+    it "should log to HackyHAL::Log with device name" do
+      controller = described_class.new(name: "dummy device")
+      HackyHAL::Log.instance.should_receive(:info).with("dummy device: dummy message")
+      controller.log("dummy message", :info)
+    end
+  end
+end

data/spec/hacky_hal/device_controllers/generic_serial_port_spec.rb

@@ -0,0 +1,167 @@
+require "spec_helper"
+require "hacky_hal/device_controllers/generic_serial_port"
+
+describe HackyHAL::DeviceControllers::GenericSerialPort do
+  before(:each) do
+    @serial_port = double("serial port")
+    @serial_port.stub(:read_timeout=)
+    @serial_port.stub(:baud=)
+    @serial_port.stub(:data_bits=)
+    @serial_port.stub(:stop_bits=)
+    @serial_port.stub(:parity=)
+    @serial_port.stub(:flow_control=)
+
+    @serial_device_path = "/dev/foo0"
+    @generic_serial_port = described_class.new(serial_device_path: @serial_device_path)
+
+    SerialPort.stub(:new).and_return(@serial_port)
+  end
+
+  describe "#write_command" do
+    before(:each) do
+      @serial_port.stub(:flush)
+    end
+
+    it "should write to the serial port" do
+      @serial_port.should_receive(:write).with("foobar\r\n")
+      @generic_serial_port.write_command("foobar")
+    end
+
+    it "should return true on successful run" do
+      @serial_port.should_receive(:write)
+      @generic_serial_port.write_command("foobar").should be_true
+    end
+
+    it "should retry after rescuing from an Errno::EIO" do
+      @generic_serial_port.should_receive(:disconnect)
+
+      retries = 0
+      @serial_port.stub(:write) do
+        if retries < HackyHAL::DeviceControllers::GenericSerialPort::MAX_READ_WRITE_RETRIES
+          retries += 1
+          raise Errno::EIO
+        end
+      end
+
+      @generic_serial_port.write_command("foobar").should be_true
+    end
+
+    it "should raise Errno::EIO if retry failed" do
+      @serial_port.stub(:write) { raise Errno::EIO }
+      @serial_port.stub(:close)
+
+      expect {
+        @generic_serial_port.write_command("foobar")
+      }.to raise_error(Errno::EIO)
+    end
+
+    it "should log debug message" do
+      @serial_port.stub(:write)
+      @generic_serial_port.should_receive(:log).with("Wrote: \"foobar\\r\\n\"", :debug)
+      @generic_serial_port.write_command("foobar")
+    end
+  end
+
+  describe "#read_command" do
+    it "should return read string on successful run" do
+      @serial_port.stub(:readline).and_return("a return string")
+      @generic_serial_port.read_command.should == "a return string"
+    end
+
+    it "should set the serial port read timeout to given value" do
+      @serial_port.stub(:readline)
+      @serial_port.should_receive(:read_timeout=).with(12000)
+      @generic_serial_port.read_command(12)
+    end
+
+    it "should call handle_error if error_response?(response) is true" do
+      @serial_port.stub(:readline)
+      @generic_serial_port.stub(:error_response?).and_return(true)
+      @generic_serial_port.should_receive(:handle_error)
+      @generic_serial_port.read_command
+    end
+
+    it "should rescue EOFError and return nil" do
+      @serial_port.stub(:readline) { raise EOFError }
+      @generic_serial_port.read_command.should be_nil
+    end
+
+    it "should rescue EOFError and log warn message" do
+      @serial_port.stub(:readline) { raise EOFError }
+      @generic_serial_port.should_receive(:log).with("Read EOFError", :warn)
+      @generic_serial_port.read_command
+    end
+
+    it "should retry after rescuing from an Errno::EIO" do
+      @generic_serial_port.should_receive(:disconnect)
+
+      retries = 0
+      @serial_port.stub(:readline) do
+        if retries < HackyHAL::DeviceControllers::GenericSerialPort::MAX_READ_WRITE_RETRIES
+          retries += 1
+          raise Errno::EIO
+        else
+          "a return string"
+        end
+      end
+
+      @generic_serial_port.read_command.should == "a return string"
+    end
+
+    it "should raise Errno::EIO if retry failed" do
+      @serial_port.stub(:readline) { raise Errno::EIO }
+      @serial_port.stub(:close)
+
+      expect {
+        @generic_serial_port.read_command
+      }.to raise_error(Errno::EIO)
+    end
+
+    it "should log debug message" do
+      @serial_port.stub(:readline).and_return("response")
+      @generic_serial_port.should_receive(:log).with("Read: \"response\"", :debug)
+      @generic_serial_port.read_command
+    end
+  end
+
+  describe "#disconnect" do
+    it "should close serial port if serial port is set" do
+      @generic_serial_port.serial_port # make sure serial port is set
+      @serial_port.should_receive(:close)
+      @generic_serial_port.disconnect
+    end
+
+    it "should not attempt to close serial port if serial port is not set" do
+      @generic_serial_port.stub(:serial_port).and_return(nil)
+      @generic_serial_port.disconnect
+    end
+
+    it "should set serial_port to nil" do
+      @generic_serial_port.serial_port # make sure serial port is set
+      @serial_port.should_receive(:close)
+      @generic_serial_port.disconnect
+      SerialPort.should_receive(:new)
+      @generic_serial_port.serial_port
+    end
+  end
+
+  describe "#serial_port" do
+    it "should create new SerialPort" do
+      SerialPort.should_receive(:new).with(@serial_device_path).and_return(@serial_port)
+      @generic_serial_port.stub(:serial_options).and_return(
+        baud_rate: 50,
+        data_bits: 5,
+        stop_bits: 2,
+        parity: SerialPort::EVEN,
+        flow_control: SerialPort::HARD
+      )
+      @serial_port.should_receive(:baud=).with(50)
+      @serial_port.should_receive(:data_bits=).with(5)
+      @serial_port.should_receive(:stop_bits=).with(2)
+      @serial_port.should_receive(:parity=).with(SerialPort::EVEN)
+      @serial_port.should_receive(:flow_control=).with(SerialPort::HARD)
+
+      @generic_serial_port.serial_port.should == @serial_port
+    end
+  end
+end