sony_camera_remote_api 0.1.1

data/lib/sony_camera_remote_api/logging.rb

@@ -0,0 +1,76 @@
+require 'logger'
+
+# Logging function module
+module Logging
+  # Generic delegator class
+  class MultiDelegator
+    def initialize(*targets)
+      @targets = targets
+    end
+
+    def self.delegate(*methods)
+      methods.each do |m|
+        define_method(m) do |*args|
+          @targets.map { |t| t.send(m, *args) }
+        end
+      end
+      self
+    end
+
+    class <<self
+      alias to new
+    end
+  end
+
+  #--------------------PUBLIC METHODS BEGIN--------------------
+
+  # Get Logger class instance for the user class.
+  # @return [Logger] Logging class instance
+  def log
+    @logger ||= Logging.logger_for(self.class.name)
+  end
+
+
+  # Set file name or stream to output log.
+  # Log file is common in each user class.
+  # @param [String, IO, Array<String, IO>] log_file file name or stream to output log.
+  # @return [void]
+  def output_to(*log_file)
+    Logging.log_file self.class.name, log_file
+  end
+
+  #--------------------PUBLIC METHODS END----------------------
+
+
+  # Log files and streams shared in user classes.
+  @log_file = []
+  # Use a hash class-ivar to cache a unique Logger per class.
+  @loggers = {}
+
+  # These module class methods are private to user class.
+  class << self
+    # Set log files and streams. Logger class instance is re-created.
+    def log_file(classname, log_file)
+      @log_file = Array(log_file)
+      @loggers[classname] = nil
+    end
+
+    # Get Logger class instance or create it for the user class
+    def logger_for(classname)
+      @loggers[classname] ||= configure_logger_for(classname)
+    end
+
+    # Configure Logger instance for the user class.
+    # 1. create Logger instance with given log file and sterams
+    # 2. set progname to user class name
+    def configure_logger_for(classname)
+      @log_file.compact!
+      fios = @log_file.map do |f|
+        f.is_a?(String) ? File.open(f, 'a') : f
+      end
+      logger = Logger.new MultiDelegator.delegate(:write, :close).to(*fios)
+      logger.progname = classname.split('::')[-1]
+      logger
+    end
+  end
+end

data/lib/sony_camera_remote_api/packet.rb

@@ -0,0 +1,109 @@
+require 'bindata'
+
+module SonyCameraRemoteAPI
+
+  # The payload of Liveview image packet
+  # @private
+  class LiveviewImagePayload < BinData::Record
+    endian :big
+    # Payload header part
+    uint32 :start_code, assert: 0x24356879
+    uint24 :payload_data_size_wo_padding
+    uint8  :padding_size
+    uint32
+    uint8 :flag
+    uint920
+    # Payload data part
+    string :jpeg_data, :length => lambda { payload_data_size_wo_padding }
+    string :padding_data, :length => lambda { padding_size }
+  end
+
+  # Liveview frame information data version
+  # @private
+  class DataVersion < BinData::Record
+    endian :big
+    uint8 :major
+    uint8 :minor
+  end
+
+  # Point of liveview frame data
+  class Point < BinData::Record
+    endian :big
+    uint16 :x
+    uint16 :y
+  end
+
+  # The payload of Liveview frame information packet
+  # @private
+  class LiveviewFrameInformationPayload < BinData::Record
+    endian :big
+    # Payload header part
+    uint32 :start_code, assert: 0x24356879
+    uint24 :payload_data_size_wo_padding
+    uint8  :padding_size
+    data_version :frame_information_data_version
+    uint16 :frame_count
+    uint16 :single_frame_data_size
+    uint912
+    # Payload data part
+    array :frame_data, :initial_length => lambda { frame_count } do
+      point  :top_left
+      point  :bottom_right
+      uint8  :category
+      uint8  :status
+      uint8  :additional_status
+      uint40
+      string :padding_data, :length => lambda { padding_size }
+    end
+  end
+
+  # Liveview packet definition
+  # @private
+  class LiveviewPacket < BinData::Record
+    endian :big
+    uint8  :start_byte, assert: 0xFF
+    uint8  :payload_type, assert: -> { value == 0x01 || value == 0x02 }
+    uint16 :sequence_number
+    uint32 :time_stamp
+    choice :payload, selection: :payload_type do
+      liveview_image_payload 0x01
+      liveview_frame_information_payload 0x02
+    end
+  end
+
+
+  # Liveview image class
+  class LiveviewImage
+    attr_reader :sequence_number, :time_stamp, :jpeg_data
+    def initialize(packet)
+      @sequence_number = packet.sequence_number
+      @time_stamp = packet.time_stamp
+      @jpeg_data = packet.payload.jpeg_data
+    end
+  end
+
+  # Liveview frame information class
+  class LiveviewFrameInformation
+    # Frame class
+    class Frame
+      attr_reader :top_left, :bottom_right, :category, :status, :additional_status
+
+      def initialize(frame)
+        @top_left = frame.top_left
+        @bottom_right = frame.bottom_right
+        @category = frame.category
+        @status = frame.status
+        @additional_status = frame.additional_status
+      end
+    end
+
+    attr_reader :sequence_number, :time_stamp, :data_version, :frames
+    def initialize(packet)
+      @sequence_number = packet.sequence_number
+      @time_stamp = packet.time_stamp
+      @data_version = "#{packet.payload.frame_information_data_version.major}.#{packet.payload.frame_information_data_version.minor}"
+      @frames = packet.payload.frame_data.map { |f| Frame.new(f) }
+    end
+  end
+end
+

data/lib/sony_camera_remote_api/raw_api.rb

@@ -0,0 +1,196 @@
+require 'sony_camera_remote_api/error'
+require 'httpclient'
+
+module SonyCameraRemoteAPI
+
+  # Raw API layer class, which call APIs by HTTP POST to endpoint URLs and recieve the response.
+  class RawAPIManager
+    include Logging
+
+    # API Information class
+    class APIInfo
+      attr_accessor :name, :versions, :service_types
+
+      def initialize(name, versions, service_types)
+        @name = name
+        @versions = [versions]
+        @service_types = [service_types]
+      end
+
+      def multi_versions?
+        @versions.length > 1
+      end
+
+      def multi_service_types?
+        @service_types.length > 1
+      end
+    end
+
+    attr_reader :apis
+
+
+    # @param [Hash] endpoints Endpoint URIs
+    def initialize(endpoints)
+      @endpoints = endpoints
+      @cli = HTTPClient.new
+      @cli.connect_timeout  = @cli.send_timeout = @cli.receive_timeout = 30
+
+      unless call_api('camera', 'getApplicationInfo', [], 1, '1.0').result[1] >= '2.0.0'
+        raise ServerNotCompatible, 'API version of the server < 2.0.0.'
+      end
+      @apis = make_api_list
+    end
+
+
+    # Make supported API list
+    # @return [Hash<Symbol, APIInfo>] API list
+    def make_api_list
+      apis = {}
+      @endpoints.keys.each do |s|
+        versions = call_api(s, 'getVersions', [], 1, '1.0')['result'][0].sort.reverse
+        versions.each do |v|
+          results = call_api(s, 'getMethodTypes', [v], 1, '1.0')['results']
+          next unless results
+          results.each do |r|
+            name = r[0].to_sym
+            if apis.key?(name)
+              apis[name].versions << v unless apis[name].versions.index(v)
+              apis[name].service_types << s unless apis[name].service_types.index(s)
+            else
+              apis[name] = APIInfo.new(r[0], v, s)
+            end
+          end
+        end
+      end
+      apis
+    end
+
+
+    # Call API by HTTP POST.
+    # @param [String] service_type
+    # @param [String] method
+    # @param [Array, String] params
+    # @param [Fixnum] id
+    # @param [String] version
+    # @return [Hash]  Response of API
+    def call_api(service_type, method, params, id, version)
+      params = [params] unless params.is_a? Array
+      request = {
+        'method' => method,
+        'params' => params,
+        'id' => id,
+        'version' => version
+      }
+      # log.debug request
+      begin
+        raw_response = @cli.post_content(@endpoints[service_type], request.to_json)
+      rescue HTTPClient::BadResponseError => e
+        if e.res.status_code == 403
+          raise APIForbidden.new, "Method '#{method}' returned 403 Forbidden error. Maybe this method is not allowed to general users."
+        else
+          raise e
+        end
+      end
+      response = JSON.parse(raw_response)
+      if response.key? 'error'
+        raise APIExecutionError.new(method, request, response), "Request:#{request}, Response:#{response}"
+      end
+      # log.debug response
+      response
+    end
+
+
+    # Asynchronous call API by HTTP POST.
+    # Currently only used by 'getEvent' API with long polling.
+    # @param [String] service_type
+    # @param [String] method
+    # @param [Array, String] params
+    # @param [Fixnum] id
+    # @param [String] version
+    # @param [Fixnum] timeout Timeout in seconds for waiting response
+    # @return [Hash]  Response of API
+    def call_api_async(service_type, method, params, id, version, timeout = nil)
+      request = {
+        'method' => method,
+        'params' => params,
+        'id' => id,
+        'version' => version
+      }
+      conn = @cli.post_async(@endpoints[service_type], request.to_json)
+      start_time = Time.now if timeout
+      loop do
+        break if conn.finished?
+        if timeout
+          raise EventTimeoutError, "Timeout expired: #{timeout} sec." if Time.now - start_time > timeout
+        end
+        sleep 0.1
+      end
+      raw_response = conn.pop.content.read
+      response = JSON.parse(raw_response)
+      if response.key? 'error'
+        raise APIExecutionError.new(method, request, response), "Request:#{request}, Response:#{response}"
+      end
+      response
+    end
+
+
+    # Search given API from API list.
+    # @param [Symbol] method  The method name
+    # @param [String] service
+    # @param [Fixnum] id
+    # @param [String] version
+    def search_method(method, **opts)
+      if @apis && @apis.key?(method)
+        api_info = @apis[method]
+        # use ID=1 if not given
+        id = opts.key?(:id) ? opts[:id] : 1
+        if opts.key? :version
+          if api_info.versions.include? opts[:version]
+            version = opts[:version]
+          else
+            raise APIVersionInvalid, "The version '#{opts[:version]}' is invalid for method '#{method}'."
+          end
+        else
+          # use newest version if not given
+          if api_info.multi_versions?
+            # log.debug "Using newest version '#{api_info.versions[0]}' for method '#{method}'."
+          end
+          version = api_info.versions[0]
+        end
+        if opts.key? :service
+          service = opts[:service]
+          if api_info.service_types.include? opts[:service]
+            service = opts[:service]
+          else
+            raise ServiceTypeInvalid, "The service type '#{opts[:service]}' is invalid for method '#{method}'."
+          end
+        else
+          # raise error if service type is not given for method having multi service types
+          if api_info.multi_service_types?
+            strs = api_info.service_types.map { |item| "'#{item}'" }
+            raise ServiceTypeNotGiven, "The method '#{method}' must be specified service type from #{strs.join(' or ')}."
+          end
+          service = api_info.service_types[0]
+        end
+        return api_info.name, service, id, version
+      else
+        raise APINotSupported.new, "The method '#{method}' is not supported by this camera."
+      end
+    end
+
+
+    # @param [Symbol] method The method name
+    # @return [Boolean] +true+ if the API is supported by this camera. +false+ otherwise.
+    def support?(method)
+      @apis.key? method
+    end
+
+
+    # Reset HTTPClient.
+    # @return [void]
+    def reset_connection
+      @cli.reset_all
+    end
+
+  end
+end

data/lib/sony_camera_remote_api/scripts.rb

@@ -0,0 +1,64 @@
+require 'open3'
+
+module SonyCameraRemoteAPI
+  # Helper module for connecting to camera by wi-fi.
+  module Scripts
+
+    module_function
+
+    # Connects to camera by Wi-Fi.
+    # This method does nothing if already connected, which is judged by ifconfig command.
+    # @param [String] interface Interface name, e.g. wlan0
+    # @param [String] ssid SSID of the camera to connect
+    # @param [String] pass Password of the camera to connect
+    # @return [Boolean] +true+ if succeeded, +false+ otherwise.
+    def connect(interface, ssid, pass)
+      run_external_command "sudo bash #{connection_script} #{interface} #{ssid} #{pass}"
+    end
+
+    # Restart the interface and connect to camera by Wi-Fi.
+    # @param [String] interface Interface name, e.g. wlan0
+    # @param [String] ssid SSID of the camera to connect
+    # @param [String] pass Password of the camera to connect
+    # @return [Boolean] +true+ if succeeded, +false+ otherwise.
+    def restart_and_connect(interface, ssid, pass)
+      run_external_command "sudo bash #{connection_script} -r #{interface} #{ssid} #{pass}"
+    end
+
+
+    # Run shell command.
+    # Command output are written to stdout witout buffering.
+    # @param [String] command Command to execute
+    # @return [Boolean] +true+ if succeeded, +false+ otherwise.
+    def run_external_command(command)
+      puts command
+      Open3.popen2e(command) do |_i, oe, w|
+        oe.each do |line|
+          puts line
+        end
+        # Return code
+        if w.value != 0
+          return false
+        else
+          return true
+        end
+      end
+    end
+
+    # Get gem root path (not smart)
+    def root
+      File.expand_path '../../..', __FILE__
+    end
+
+    # Path where scripts are located
+    def path
+      File.join root, 'scripts'
+    end
+
+    # Full path of connection script
+    def connection_script
+      File.join path, 'connect.sh'
+    end
+
+  end
+end

data/lib/sony_camera_remote_api/ssdp.rb

@@ -0,0 +1,72 @@
+require 'frisky/ssdp'
+require 'httpclient'
+require 'nokogiri'
+require 'json'
+
+module SonyCameraRemoteAPI
+  # Module providing SSDP function to discover camera (Device discovery)
+  module SSDP
+
+    # Cannot find camera
+    class DeviceNotFound < StandardError;
+    end
+    # Failed to Parse device description
+    class DeviceDescriptionInvalid < StandardError;
+    end
+
+    # The search target for Sony camera (fixed)
+    SSDP_SEARCH_TARGET = 'urn:schemas-sony-com:service:ScalarWebAPI:1'.freeze
+    # Retrying limit for SSDP search
+    SSDP_SEARCH_RETRY = 4
+    # Retrying interval for SSDP search
+    SSDP_RETRY_INTERVAL = 5
+
+    # Perform SSDP discover to find camera on network.
+    # @return [Hash] Endpoint URLs
+    def ssdp_search
+      log.info 'Trying SSDP discover...'
+      try = 1
+      while true do
+        response = Frisky::SSDP.search SSDP_SEARCH_TARGET
+        if response.present?
+          break
+        elsif try < SSDP_SEARCH_RETRY
+          try += 1
+          log.warn "SSDP discover failed, retrying... (#{try}/#{SSDP_SEARCH_RETRY})"
+          sleep(SSDP_RETRY_INTERVAL)
+        else
+          raise DeviceNotFound, 'Cannot find camera API server. Please confirm network connection is correct.'
+        end
+      end
+      log.info 'SSDP discover succeeded.'
+
+      # get device description
+      dd = HTTPClient.new.get_content(response[0][:location])
+      # puts dd
+      parse_device_description(dd)
+    end
+
+
+    # Parse device description and get endpoint URLs
+    def parse_device_description(dd)
+      dd_xml = Nokogiri::XML(dd)
+      raise DeviceDescriptionInvalid if dd_xml.nil?
+      dd_xml.remove_namespaces!
+      camera_name = dd_xml.css('device friendlyName').inner_text
+      services = dd_xml.css('device X_ScalarWebAPI_Service')
+      endpoints = {}
+      services.each do |sv|
+        service_type = sv.css('X_ScalarWebAPI_ServiceType').inner_text
+        endpoints[service_type] = File.join(sv.css('X_ScalarWebAPI_ActionList_URL').inner_text, service_type)
+      end
+      # endpoints['liveview'] = dd_xml.css('device X_ScalarWebAPI_LiveView_URL').inner_text
+      # endpoints.delete_if { |k, v| v.blank? }
+      log.info "model-name: #{camera_name}"
+      log.debug 'endpoints:'
+      endpoints.each do |e|
+        log.debug "  #{e}"
+      end
+      endpoints
+    end
+  end
+end

data/lib/sony_camera_remote_api/utils.rb

@@ -0,0 +1,98 @@
+module SonyCameraRemoteAPI
+  # Module providing utility methods
+  module Utils
+
+    module_function
+
+    # Get file name in the format of <prefix>_<num>.<ext>
+    # If there are files that matches this format, get the next number of it.
+    # @param [String] prefix
+    # @param [String] ext
+    # @param [Fixnum] start
+    # @param [Fixnum] num
+    # @param [String] dir
+    def generate_sequencial_filenames(prefix, ext, start: nil, num: nil, dir: nil)
+      if start
+        count = start
+      else
+        count = get_next_file_number prefix, ext, dir: dir
+      end
+      gen = Enumerator.new do |y|
+        loop do
+          y << "#{prefix}_#{count}.#{ext}"
+          count += 1
+        end
+      end
+      if num
+        return (0..(num-1)).map { gen.next }
+      else
+        return gen
+      end
+    end
+
+
+    # Get the next file number by searching files with format '<prefix>_\d+.<ext>' in <dir>.
+    # @param [String] prefix
+    # @param [String] ext
+    # @param [String] dir
+    def get_next_file_number(prefix, ext, dir: nil)
+      numbers = []
+      Dir["#{dir}/*"].map do |f|
+        begin
+          num = f[/#{dir}\/#{prefix}_(\d+).#{ext}/, 1]
+          numbers << num.to_i if num.present?
+        rescue
+          nil
+        end
+      end
+      if numbers.empty?
+        0
+      else
+        numbers.sort[-1] + 1
+      end
+    end
+
+
+    # Search pattern in candidates.
+    # @param [String] pattern Pattern
+    # @param [Array<String>] candidates Candidates
+    # @return [Array<String, Fixnum>] matched candidate and the number of matched candidates.
+    def partial_and_unique_match(pattern, candidates)
+      result = candidates.find { |c| c == pattern }
+      return result, 1 if result
+      result = candidates.select { |c| c =~ /#{pattern}/i }
+      return result[0], 1 if result.size == 1
+      result = candidates.select { |c| c =~ /#{pattern}/ }
+      return result[0], 1 if result.size == 1
+      return nil, result.size
+    end
+
+    # Print array.
+    # @param [Array] array
+    # @param [Fixnum] horizon
+    # @param [Fixnum] space
+    # @param [Fixnum] threshold
+    def print_array_in_columns(array, horizon, space, threshold)
+      if array.size >= threshold
+        longest = array.map { |s| s.size }.max
+        num_columns = (horizon + space ) / (longest + space)
+        num_rows = array.size / num_columns + 1
+        array += [''] * ((num_columns * num_rows) - array.size)
+        array_2d = array.each_slice(num_rows).to_a
+        longests = array_2d.map { |column| column.map { |e| e.size }.max }
+        array_2d = array_2d.transpose
+        array_2d.each do |row|
+          row.zip(longests).each do |e, len|
+            print e + ' ' * (len - e.size) + ' ' * space
+          end
+          puts ''
+        end
+      else
+        array.each do |e|
+            puts e
+        end
+      end
+    end
+  end
+end
+

data/lib/sony_camera_remote_api/version.rb

@@ -0,0 +1,3 @@
+module SonyCameraRemoteAPI
+  VERSION = '0.1.1'.freeze
+end