onkyo_eiscp_ruby 0.0.2 → 2.1.1

data/lib/eiscp/parser/human_readable_parser.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative '../dictionary'
+
+module EISCP
+  module Parser
+    # This module parses a human readable command and returns a Message object
+    #
+    module HumanReadableParser
+      def self.parse(string)
+        array = string.split(' ')
+
+        parsed_zone = if Dictionary.zones.include? array[0]
+                        array.shift
+                      else
+                        Dictionary::DEFAULT_ZONE
+                      end
+
+        command_name = array.shift
+        value_name = array.join(' ')
+        command = Dictionary.command_name_to_command(command_name, parsed_zone)
+        value = Dictionary.command_value_name_to_value(command, value_name)
+        return nil if command.nil? || value.nil?
+
+        Message.new(command: command, value: value)
+      end
+    end
+  end
+end

data/lib/eiscp/parser/iscp_parser.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module EISCP
+  module Parser
+    # This module parses an ISCP string and returns a Message object
+    #
+    module ISCPParser
+      # Regexp for parsing ISCP messages
+      REGEX = /(?<start>!)?(?<unit_type>(\d|x))?(?<command>[A-Z]{3})\s?(?<value>.*?)(?<terminator>[[:cntrl:]]*$)/.freeze
+      def self.parse(string)
+        match = string.match(REGEX)
+
+        # Convert MatchData to Hash
+        hash = Hash[match.names.zip(match.captures)]
+
+        # Remove nil and blank values
+        hash.delete_if { |_, v| v.nil? || v == '' }
+
+        # Convert keys to symbols
+        hash = hash.each_with_object({}) do |(k, v), memo|
+          memo[k.to_sym] = v
+        end
+
+        Message.new(**hash)
+      end
+    end
+  end
+end

data/lib/eiscp/receiver.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require 'resolv'
+require_relative './receiver/discovery'
+require_relative './receiver/command_methods'
+
+module EISCP
+  # The EISCP::Receiver class is used to communicate with one or more
+  # receivers the network. A Receiver can be instantiated automatically
+  # using discovery, or by hostname and port.
+  #
+  #   receiver = EISCP::Receiver.new # find first receiver on LAN
+  #   receiver = EISCP::Receiver.new('192.168.1.12') # default port
+  #   receiver = EISCP::Receiver.new('192.168.1.12', 60129) # non standard port
+  #
+  class Receiver
+    extend Discovery
+    include CommandMethods
+
+    # Receiver's IP address
+    attr_accessor :host
+    # Receiver's model string
+    attr_accessor :model
+    # Receiver's ISCP port
+    attr_accessor :port
+    # Receiver's region
+    attr_accessor :area
+    # Receiver's MAC address
+    attr_accessor :mac_address
+
+    # State object
+    attr_accessor :state
+
+    # Receiver's connection socket
+    attr_reader :socket
+    # Receiver's connection thread
+    attr_reader :thread
+
+    # Default connection timeout value in seconds
+    DEFAULT_TIMEOUT = 0.5
+
+    # Default Onkyo eISCP port
+    ONKYO_PORT = 60_128
+
+    # Create a new EISCP::Receiver object to communicate with a receiver.
+    # If no host is given, use auto discovery and create a
+    # receiver object using the first host to respond.
+    #
+    def initialize(host = nil, info_hash = {}, &block)
+      # Initialize state
+      #
+      @state = {}
+      # This defines the behavior of CommandMethods by telling it what to do
+      # with the Message object that results from a CommandMethod being called.
+      # All we're doing here is calling #send_recv
+      #
+      command_method_proc = proc { |msg| send_recv msg }
+      CommandMethods.generate(&command_method_proc)
+
+      # This proc sets the four ECN attributes and initiates a connection to the
+      # receiver.
+      #
+      set_attrs = lambda do |hash|
+        @model = hash[:model]
+        @port  = hash[:port]
+        @area  = hash[:area]
+        @mac_address = hash[:mac_address]
+        connect(&block) if block_given?
+      end
+
+      # This lambda sets the host IP after resolving it
+      #
+      set_host = lambda do |hostname|
+        @host = Resolv.getaddress hostname
+      end
+
+      # When no host is given, the first discovered host is returned.
+      #
+      # When a host is given without a hash ::discover will be used to find
+      # a receiver that matches.
+      #
+      # Else, use the given host and hash to create a new Receiver object.
+      # This is how ::discover creates Receivers.
+      #
+      if host.nil?
+        first_found = Receiver.discover[0]
+        set_host.call first_found.host
+        set_attrs.call first_found.ecn_hash
+      elsif info_hash.empty?
+        set_host.call host
+        Receiver.discover.each do |receiver|
+          receiver.host == @host && set_attrs.call(receiver.ecn_hash)
+        end
+      else
+        set_host.call host
+        set_attrs.call info_hash
+      end
+    end
+
+    # Manages the thread and uses the same block passed to through #connect.
+    #
+    def update_thread
+      # Kill thread if it exists
+      thread && @thread.kill
+      @thread = Thread.new do
+        loop do
+          message = recv
+          @state[message.command] = message.value
+          yield(message) if block_given?
+        end
+      end
+    end
+    private :update_thread
+
+    # This creates a socket conection to the receiver if one doesn't exist,
+    # and updates or sets the callback block if one is passed.
+    #
+    def connect(&block)
+      @socket ||= TCPSocket.new(@host, @port)
+      update_thread(&block)
+    rescue StandardError => e
+      puts e
+    end
+
+    # Disconnect from the receiver by closing the socket and killing the
+    # connection thread.
+    #
+    def disconnect
+      @thread.kill
+      @socket.close
+    end
+
+    # Sends an EISCP::Message object or string on the network
+    #
+    def send(eiscp)
+      if eiscp.is_a? EISCP::Message
+        @socket.puts(eiscp.to_eiscp)
+      elsif eiscp.is_a? String
+        @socket.puts eiscp
+      end
+    end
+
+    # Reads the socket and returns and EISCP::Message
+    #
+    def recv
+      data = ''
+      data << @socket.gets until data.match(/\r\n$/)
+      message = Parser.parse(data)
+      message
+    end
+
+    # Sends an EISCP::Message object or string on the network and returns recieved data string.
+    #
+    def send_recv(eiscp)
+      eiscp = Parser.parse(eiscp) if eiscp.is_a? String
+      send eiscp
+      sleep DEFAULT_TIMEOUT
+      Parser.parse("#{eiscp.command}#{@state[eiscp.command]}")
+    end
+
+    # Return ECN hash with model, port, area, and MAC address
+    #
+    def ecn_hash
+      { model: @model,
+        port: @port,
+        area: @area,
+        mac_address: @mac_address }
+    end
+
+    # This will return a human-readable represantion of the receiver's state.
+    #
+    def human_readable_state
+      hash = {}
+      @state.each do |c, v|
+        hash[Dictionary.command_to_name(c).to_s] = (Dictionary.command_value_to_value_name(c, v) || v.to_s).to_s
+      end
+      hash
+    end
+
+    # Runs every command that supports the 'QSTN' value. This is a good way to
+    # get the sate of the receiver after connecting.
+    #
+    def update_state
+      Thread.new do
+        Dictionary.commands.each do |zone, _commands|
+          Dictionary.commands[zone].each do |command, info|
+            info[:values].each do |value, _|
+              next unless value == 'QSTN'
+
+              send(Parser.parse(command + 'QSTN'))
+              # If we send any faster we risk making the stereo drop replies.
+              # A dropped reply is not necessarily indicative of the
+              # receiver's failure to receive the command and change state
+              # accordingly. In this case, we're only making queries, so we do
+              # want to capture every reply.
+              sleep DEFAULT_TIMEOUT
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eiscp/receiver/command_methods.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative '../parser'
+require_relative '../dictionary'
+
+module EISCP
+  class Receiver
+    # Iterates through every available command and defines a method to call that
+    # command. It's intended to be used through Receiver and uses methods included
+    # by Receiver::Connection. Each method accepts a string that should match the
+    # human readable name of a valid value for that command.
+    #
+    module CommandMethods
+      def self.generate(&block)
+        Dictionary.zones.each do |zone|
+          Dictionary.commands[zone].each do |command, _values|
+            command_name = Dictionary.command_to_name(command).to_s.gsub(/-/, '_')
+            define_method(command_name) do |v|
+              instance_exec Parser.parse(command_name.gsub(/_/, '-') + ' ' + v), &block
+            end
+          rescue StandardError => e
+            puts e
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eiscp/receiver/discovery.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'socket'
+require_relative '../message'
+require_relative '../parser'
+
+module EISCP
+  class Receiver
+    # This module discovers receivers on the local LAN.
+    #
+    module Discovery
+      # ISCP Magic Packet for Autodiscovery
+      ONKYO_MAGIC = Message.new(command: 'ECN', value: 'QSTN', terminator: "\r\n", unit_type: 'x').to_eiscp
+
+      # Populates Receiver attributes with info from ECNQSTN response.
+      #
+      def ecn_string_to_ecn_array(ecn_string)
+        hash = {}
+        message = Parser.parse(ecn_string)
+        array = message.value.split('/')
+        hash[:model] = array.shift
+        hash[:port] = array.shift.to_i
+        hash[:area] = array.shift
+        hash[:mac_address] = array.shift
+        hash
+      end
+
+      # Returns an array of discovered Receiver objects.
+      #
+      def discover(discovery_port = Receiver::ONKYO_PORT)
+        sock = UDPSocket.new
+        sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_BROADCAST, true)
+        sock.send(ONKYO_MAGIC, 0, '<broadcast>', discovery_port)
+        data = []
+        loop do
+          msg, addr = sock.recvfrom_nonblock(1024)
+          data << Receiver.new(addr[2], ecn_string_to_ecn_array(msg))
+        rescue IO::WaitReadable
+          io = IO.select([sock], nil, nil, 0.5)
+          if io.nil?
+            return data
+          else
+            retry
+          end
+        end
+      end
+    end
+  end
+end

data/onkyo_eiscp_ruby.gemspec

@@ -1,26 +1,29 @@
+# frozen_string_literal: true
+
 Gem::Specification.new do |s|
   s.name         = 'onkyo_eiscp_ruby'
   s.version      = File.read(File.expand_path('VERSION', File.dirname(__FILE__))).strip
+  s.licenses = ['MIT']
   s.platform     = Gem::Platform::RUBY
   s.summary      = 'Manipulate Onkyo stereos with the eISCP protocol'
   s.files        = Dir.glob('{bin,config,lib,test,doc}/**/*') +
-    ["VERSION", "onkyo_eiscp_ruby.gemspec", "eiscp-commands.yaml"]
-  s.extra_rdoc_files = ["README.md"]
+                   ['VERSION', 'onkyo_eiscp_ruby.gemspec', 'eiscp-commands.yaml']
+  s.extra_rdoc_files = ['README.md']
   s.require_path = 'lib'
 
-  s.homepage     = "https://github.com/mikerodrigues/onkyo_eiscp_ruby"
+  s.homepage     = 'https://github.com/mikerodrigues/onkyo_eiscp_ruby'
 
-  s.description  = %q(
-    Use the provided binary script or require the library for use in your scripts.
-  )
+  s.description  = '
+    Control Onkyo receivers over the network.Use the provided binary or
+    require the library for use in your scripts.
+  '
 
-  s.author       = "Michael Rodrigues"
-  s.email        = "mikebrodrigues@gmail.com"
+  s.author       = 'Michael Rodrigues'
+  s.email        = 'mikebrodrigues@gmail.com'
 
-  s.test_files = Dir[ 'test/tc*.rb' ]
-  s.executables = %w(
+  s.test_files = Dir['test/tc*.rb']
+  s.executables = %w[
     onkyo.rb
-    onkyo-server.rb
-  )
-
+    onkyo_server.rb
+  ]
 end

data/test/tc_dictionary.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative '../lib/eiscp/dictionary.rb'
+require 'minitest/autorun'
+
+class TestDictionary < MiniTest::Test
+  def test_zone_from_command
+    assert_equal(EISCP::Dictionary.zone_from_command('PWR'), 'main')
+    assert_equal(EISCP::Dictionary.zone_from_command('ZPW'), 'zone2')
+    assert_equal(EISCP::Dictionary.zone_from_command('CDS'), 'dock')
+  end
+
+  def test_command_to_name
+    assert_equal(EISCP::Dictionary.command_to_name('PWR'), 'system-power')
+    assert_equal(EISCP::Dictionary.command_to_name('ZPW'), 'power2')
+    assert_equal(EISCP::Dictionary.command_to_name('PW3'), 'power3')
+    assert_equal(EISCP::Dictionary.command_to_name('PW4'), 'power4')
+  end
+
+  def test_command_name_to_command
+    assert_equal(EISCP::Dictionary.command_name_to_command('system-power'), 'PWR')
+    assert_equal(EISCP::Dictionary.command_name_to_command('master-volume'), 'MVL')
+    assert_equal(EISCP::Dictionary.command_name_to_command('power2'), 'ZPW')
+  end
+
+  def test_command_value_to_value_name
+    assert_equal(EISCP::Dictionary.command_value_to_value_name('PWR', '01'), 'on')
+    assert_equal(EISCP::Dictionary.command_value_to_value_name('PWR', 'QSTN'), 'query')
+  end
+
+  def test_command_value_name_to_value
+    assert_equal(EISCP::Dictionary.command_value_name_to_value('PWR', 'on'), '01')
+    assert_equal(EISCP::Dictionary.command_value_name_to_value('ZPW', 'on'), '01')
+  end
+
+  def test_description_from_command_name
+    assert_equal(EISCP::Dictionary.description_from_command_name('system-power', 'main'), 'System Power Command')
+    assert_equal(EISCP::Dictionary.description_from_command_name('power2', 'zone2'), 'Zone2 Power Command')
+  end
+
+  def test_description_from_command
+    assert_equal(EISCP::Dictionary.description_from_command('PWR'), 'System Power Command')
+    assert_equal(EISCP::Dictionary.description_from_command('ZPW'), 'Zone2 Power Command')
+  end
+end

data/test/tc_message.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative '../lib/eiscp/message'
+require 'minitest/autorun'
+
+class TestMessage <  MiniTest::Test
+  DISCOVERY_PACKET = EISCP::Message.new(command: 'ECN', value: 'QSTN', terminator: "\r\n", unit_type: 'x', start: '!')
+  DISCOVERY_STRING = DISCOVERY_PACKET.to_eiscp
+
+  def test_create_discovery_iscp_message
+    assert_equal(EISCP::Message.new(command: 'ECN', value: 'QSTN', terminator: "\r\n", unit_type: 'x', start: '!').to_iscp, '!xECNQSTN')
+  end
+
+  def test_create_messages
+    assert_equal(EISCP::Message.new(command: 'PWR', value: '01').to_iscp, '!1PWR01')
+    assert_equal(EISCP::Message.new(command: 'MVL', value: 'QSTN').to_iscp, '!1MVLQSTN')
+  end
+
+  def test_create_discovery_packet_string
+    assert_equal(DISCOVERY_PACKET.to_eiscp, DISCOVERY_STRING)
+  end
+
+  def test_validate_valid_message_with_variable
+    # Commands that return something unexpected like an artist name
+  end
+end