onkyo_eiscp_ruby 0.0.3 → 2.1.2

data/lib/eiscp/parser.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative './parser/eiscp_parser'
+require_relative './parser/iscp_parser'
+require_relative './parser/human_readable_parser'
+
+module EISCP
+  # This module provides an interface to the other parser modules.
+  #
+  module Parser
+    # Passes the string to the proper parser module's #parse method.
+    #
+    def self.parse(string)
+      case string
+      when /^ISCP/
+        EISCPParser.parse(string)
+      when ISCPParser::REGEX
+        ISCPParser.parse(string)
+      else
+        HumanReadableParser.parse(string)
+      end
+    end
+  end
+end

data/lib/eiscp/parser/dynamic_value_parser.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module EISCP
+  module Parser
+    module DynamicValueParser
+      # Still trying to sort this out.
+    end
+  end
+end

data/lib/eiscp/parser/eiscp_parser.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative './iscp_parser'
+
+module EISCP
+  module Parser
+    # This module parses an eISCP string and returns a Message object
+    #
+    module EISCPParser
+      def self.parse(string)
+        array = string.unpack('A4NNCa3A*')
+        msg = ISCPParser.parse(array[5])
+        packet = Message.new(
+          command: msg.command,
+          value: msg.value,
+          terminator: msg.terminator,
+          unit_type: msg.unit_type,
+          start: msg.start
+        )
+        packet.header = {
+          magic: array[0],
+          header_size: array[1],
+          data_size: array[2],
+          version: array[3],
+          reserved: array[4]
+        }
+        packet
+      end
+
+      def self.validate(packet)
+        packet.header.header_size.size == packet.command.size
+      end
+    end
+
+    class EISCPParserException < RuntimeError; end
+  end
+end

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

@@ -1,180 +1,203 @@
-require 'socket'
-require 'eiscp/message'
+# 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
 
-    ONKYO_MAGIC = Message.new("ECN", "QSTN", "x").to_eiscp
-    ONKYO_PORT = 60128
+    # 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
 
-    # Create a new EISCP object to communicate with a receiver.
+    # 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, port = ONKYO_PORT)
-      if host == nil
-        if first_rec = self.class.discover[0]
-          host = first_rec[1]
-          set_info first_rec[0]
-        else
-          raise Exception
-        end
-      end
-      @host = Resolv.getaddress host
-      @port = port
-      unless @model
-        set_info get_ecn
+    #
+    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
-    end
 
-    def set_info(ecn_string)
-      array = self.class.parse_ecn(ecn_string)
-      @model = array.shift
-      @port = array.shift.to_i
-      @area = array.shift
-      @mac_address = array.shift.split("\x19")[0]
-      return self
-    end
+      # This lambda sets the host IP after resolving it
+      #
+      set_host = lambda do |hostname|
+        @host = Resolv.getaddress hostname
+      end
 
-    def get_ecn
-      self.class.discover.each do |entry|
-        if @host == entry[1]
-          return entry[0]
+      # 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
 
-    # Gets the ECNQSTN response of self using @host
-    # then parses it with parse_ecn, returning an array
-    # with receiver info
-
-    def get_ecn_array
-      self.class.discover.each do |entry|
-        if @host == entry[1]
-          array = self.class.parse_ecn(entry[0])
+    # 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
-        return array
       end
     end
+    private :update_thread
 
-    # Returns array containing @model, @port, @area, and @mac_address
-    # from ECNQSTN response
-
-    def self.parse_ecn(ecn_string)
-      message = EISCP::Message.parse(ecn_string)
-      message.parameter.split("/")
+    # 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
 
-    # Internal method for receiving data with a timeout
-
-    def self.recv(sock, timeout = 0.5)
-      data = []
-      while true
-        ready = IO.select([sock], nil, nil, timeout)
-        if ready != nil
-          then readable = ready[0]
-        else
-          return data
-        end
-
-
-        readable.each do |socket|
-          begin
-            if socket == sock
-              data << sock.recv_nonblock(1024).chomp
-            end
-          rescue IO::WaitReadable
-            retry
-          end
-        end
-
-      end
+    # Disconnect from the receiver by closing the socket and killing the
+    # connection thread.
+    #
+    def disconnect
+      @thread.kill
+      @socket.close
     end
 
-    # Returns an array of arrays consisting of a discovery response packet string
-    # and the source ip address of the reciever.
-
-    def self.discover
-      sock = UDPSocket.new
-      sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_BROADCAST, true)
-      sock.send(ONKYO_MAGIC, 0, '<broadcast>', ONKYO_PORT)
-      data = []
-      while true
-        ready = IO.select([sock], nil, nil, 0.5)
-        if ready != nil
-          then readable = ready[0]
-        else
-          return data
-        end
-
-
-        readable.each do |socket|
-          begin
-            if socket == sock
-              msg, addr = sock.recvfrom_nonblock(1024)
-              data << [msg, addr[2]]
-            end
-          rescue IO::WaitReadable
-            retry
-          end
-        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
 
-    # Sends a packet string on the network
-
-    def send(eiscp_packet)
-      sock = TCPSocket.new @host, @port
-      sock.puts eiscp_packet
-      sock.close
+    # Reads the socket and returns and EISCP::Message
+    #
+    def recv
+      data = String.new
+      data << @socket.gets until data.match(/\r\n$/)
+      message = Parser.parse(data)
+      message
     end
 
-    # Send a packet string and return recieved data string.
-
-    def send_recv(eiscp_packet)
-      sock = TCPSocket.new @host, @port
-      sock.puts eiscp_packet
-      return Receiver.recv(sock, 0.5)
+    # 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
 
-    # Open a TCP connection to the host and print all received messages until
-    # killed.
+    # Return ECN hash with model, port, area, and MAC address
+    #
+    def ecn_hash
+      { model: @model,
+        port: @port,
+        area: @area,
+        mac_address: @mac_address }
+    end
 
-    def connect(&block)
-      sock = TCPSocket.new @host, @port
-      while true
-        ready = IO.select([sock], nil, nil, nil)
-        if ready != nil
-          then readable = ready[0]
-        else
-          return
-        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
 
-        readable.each do |socket|
-          begin
-            if socket == sock
-              data = sock.recv_nonblock(1024).chomp
-              if block_given?
-                yield data
-              else
-                puts data
-              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
-          rescue IO::WaitReadable
-            retry
           end
         end
-
       end
     end
-
   end
 end