appium_lib_core 0.1.0

data/lib/appium_lib_core/common/error.rb

@@ -0,0 +1,18 @@
+module Appium
+  module Core
+    module Error
+      class CoreError < StandardError; end
+
+      # Capability related errors
+      class NoCapabilityError < CoreError; end
+      class CapabilityStructureError < CoreError; end
+
+      # Appium related errors
+      class NotSupportedAppiumServer < CoreError; end
+      class NoSuchElementError < CoreError; end
+
+      # Server side error
+      class ServerError; end
+    end
+  end
+end

data/lib/appium_lib_core/common/log.rb

@@ -0,0 +1,30 @@
+module Appium
+  module Core
+    class Logs
+      def initialize(bridge)
+        @bridge = bridge
+      end
+
+      # @param [String|Hash] type You can get particular type's logs.
+      # @return [[Selenium::WebDriver::LogEntry]] A list of logs data.
+      #
+      # @example
+      #   Appium::Core::Logs.new(driver).get("syslog") #=> [[Selenium::WebDriver::LogEntry]]
+      #   Appium::Core::Logs.new(driver).get(:syslog)  #=> [[Selenium::WebDriver::LogEntry]]
+      #
+      def get(type)
+        @bridge.get type
+      end
+
+      # Get a list of available log types
+      #
+      # @return [[Hash]] A list of available log types.
+      # @example
+      #   Appium::Core::Logs.new(driver).available_types #=>  [:syslog, :crashlog, :performance]
+      #
+      def available_types
+        @bridge.available_types
+      end
+    end
+  end # module Core
+end # module Appium

data/lib/appium_lib_core/common/logger.rb

@@ -0,0 +1,30 @@
+require 'forwardable'
+require 'logger'
+
+module Appium
+  module Logger
+    #
+    # @example Use logger manually
+    #   Appium::Logger.debug('This is info message')
+    #   Appium::Logger.warn('This is warning message')
+    #
+    class << self
+      extend Forwardable
+      def_delegators :logger, :fatal, :error, :warn, :info, :debug, :level, :level=, :formatter, :formatter=
+
+      attr_writer :logger
+
+      private
+
+      def logger
+        @logger ||= begin
+          logger = ::Logger.new($stdout)
+          logger.progname = 'ruby_lib'
+          logger.level = ::Logger::WARN
+          logger.formatter = proc { |_severity, _datetime, _progname, msg| "#{msg}\n" }
+          logger
+        end
+      end
+    end # class << self
+  end # module Logger
+end # module Appium

data/lib/appium_lib_core/device/multi_touch.rb

@@ -0,0 +1,48 @@
+module Appium
+  module Core
+    # MultiTouch actions allow for multiple touches to happen at the same time,
+    # for instance, to simulate multiple finger swipes.
+    #
+    # Create a series of touch actions by themselves (without a `prepare()`), then
+    # add to a new MultiTouch action.  When ready, call `prepare()` and all
+    # actions will be executed simultaneously.
+    #
+    # @example
+    #
+    #   action_1 = TouchAction.new.press(x: 45, y: 100).wait(5).release
+    #   action_2 = TouchAction.new.tap(element: el, x: 50, y:5, count: 3)
+    #
+    #   multi_touch_action = MultiTouch.new
+    #   multi_touch_action.add action_1
+    #   multi_touch_action.add action_2
+    #   multi_touch_action.perform
+    #
+    #   # with an arbitrary driver
+    #   driver = Appium::Driver.new(opts, false).start_driver
+    #   multi_touch_action = MultiTouch.new(driver)
+    #   multi_touch_action.add action_1
+    #   multi_touch_action.add action_2
+    #   multi_touch_action.perform
+    #
+    class MultiTouch
+      attr_reader :driver
+
+      def initialize(driver)
+        @actions = []
+        @driver = driver
+      end
+
+      # Add a touch_action to be performed
+      # @param chain (TouchAction) The action to add to the chain
+      def add(chain)
+        @actions << chain.actions
+      end
+
+      # Ask Appium to perform the actions
+      def perform
+        @driver.multi_touch @actions
+        @actions.clear
+      end
+    end # class MultiTouch
+  end # module Core
+end # module Appium

data/lib/appium_lib_core/device/touch_actions.rb

@@ -0,0 +1,191 @@
+module Appium
+  # Perform a series of gestures, one after another.  Gestures are chained
+  # together and only performed when `perform()` is called. Default is conducted by global driver.
+  #
+  # Each method returns the object itself, so calls can be chained.
+  #
+  # ```ruby
+  # action = TouchAction(@driver).new.press(x: 45, y: 100).wait(5).release
+  # action.perform
+  # action = TouchAction.new.swipe(....)
+  # action.perform
+  # ```
+  module Core
+    class TouchAction
+      ACTIONS         = [:move_to, :long_press, :double_tap, :two_finger_tap, :press, :release, :tap, :wait, :perform].freeze
+      COMPLEX_ACTIONS = [:swipe].freeze
+
+      attr_reader :actions, :driver
+
+      def initialize(driver)
+        @actions = []
+        @driver = driver
+      end
+
+      # Move to the given co-ordinates.
+      #
+      # `move_to`'s `x` and `y` have two case. One is working as coordinate, the other is working as offset.
+      #
+      # @option opts [integer] :x x co-ordinate to move to if element isn't set. Works as an offset if x is set with Element.
+      # @option opts [integer] :y y co-ordinate to move to if element isn't set. Works as an offset if y is set with Element.
+      # @option opts [WebDriver::Element] Element to scope this move within.
+      def move_to(opts)
+        opts = args_with_ele_ref(opts)
+        chain_method(:moveTo, opts)
+      end
+
+      # Press down for a specific duration.
+      # Alternatively, you can use `press(...).wait(...).release()` instead of `long_press` if duration doesn't work well.
+      # https://github.com/appium/ruby_lib/issues/231#issuecomment-269895512
+      # e.g. Appium::TouchAction.new.press(x: 280, y: 530).wait(2000).release.perform
+      #
+      # @option element [WebDriver::Element] the element to press.
+      # @option x [integer] x co-ordinate to press on.
+      # @option y [integer] y co-ordinate to press on.
+      # @option duration [integer] Number of milliseconds to press.
+      def long_press(opts)
+        args = opts.select { |k, _v| [:element, :x, :y, :duration].include? k }
+        args = args_with_ele_ref(args)
+        chain_method(:longPress, args) # longPress is what the appium server expects
+      end
+
+      # Press a finger onto the screen.  Finger will stay down until you call
+      # `release`.
+      #
+      # @option opts [WebDriver::Element] :element (Optional) Element to press within.
+      # @option opts [integer] :x x co-ordinate to press on
+      # @option opts [integer] :y y co-ordinate to press on
+      def press(opts)
+        args = opts.select { |k, _v| [:element, :x, :y].include? k }
+        args = args_with_ele_ref(args)
+        chain_method(:press, args)
+      end
+
+      # Remove a finger from the screen.
+      #
+      # @option opts [WebDriver::Element] :element (Optional) Element to release from.
+      # @option opts [integer] :x x co-ordinate to release from
+      # @option opts [integer] :y y co-ordinate to release from
+      def release(opts = nil)
+        args = args_with_ele_ref(opts) if opts
+        chain_method(:release, args)
+      end
+
+      # Touch a point on the screen.
+      # Alternatively, you can use `press(...).release.perform` instead of `tap(...).perform`.
+      #
+      # @option opts [WebDriver::Element] :element (Optional) Element to restrict scope too.
+      # @option opts [integer] :x x co-ordinate to tap
+      # @option opts [integer] :y y co-ordinate to tap
+      # @option opts [integer] :fingers how many fingers to tap with (Default 1)
+      def tap(opts)
+        opts[:count] = opts.delete(:fingers) if opts[:fingers]
+        opts[:count] ||= 1
+        args = args_with_ele_ref opts
+        chain_method(:tap, args)
+      end
+
+      # Double tap an element on the screen
+      #
+      # @option opts [WebDriver::Element] :element (Optional) Element to restrict scope too.
+      # @option opts [integer] :x x co-ordinate to tap
+      # @option opts [integer] :y y co-ordinate to tap
+
+      def double_tap(opts)
+        args = opts.select { |k, _v| [:element, :x, :y].include? k }
+        args = args_with_ele_ref(args)
+        chain_method(:doubleTap, args) # doubleTap is what the appium server expects
+      end
+
+      # Two finger tap an element on the screen
+      #
+      # @option opts [WebDriver::Element] :element (Optional) Element to restrict scope too.
+      # @option opts [integer] :x x co-ordinate to tap
+      # @option opts [integer] :y y co-ordinate to tap
+      def two_finger_tap(opts)
+        args = opts.select { |k, _v| [:element, :x, :y].include? k }
+        args = args_with_ele_ref(args)
+        chain_method(:twoFingerTap, args) # twoFingerTap is what the appium server expects
+      end
+
+      # Pause for a number of milliseconds before the next action
+      # @param milliseconds [integer] Number of milliseconds to pause for
+      def wait(milliseconds)
+        args = { ms: milliseconds }
+        chain_method(:wait, args)
+      end
+
+      # Convenience method to peform a swipe.
+      #
+      # Note that iOS 7 simulators have broken swipe.
+      #
+      # For iOS: Use `offset_x` and `offset_y` to define the end point.
+      #
+      # For Android: Use `end_x` and `end_y` to define the end point.
+      #
+      # If you'd like more details, please read tests and its log samples in
+      # `ios_tests/lib/ios/specs/device/touch_actions.rb` and `ios_tests/lib/ios/specs/device/touch_actions.rb`
+      #
+      # @option opts [int] :start_x Where to start swiping, on the x axis.  Default 0.
+      # @option opts [int] :start_y Where to start swiping, on the y axis.  Default 0.
+      # @option opts [int] :offset_x Offset, on the x axis.  Default 0.
+      # @option opts [int] :offset_y Offset, on the y axis.  Default 0.
+      # @option opts [int] :duration How long the actual swipe takes to complete in milliseconds. Default 200.
+      def swipe(opts, ele = nil)
+        start_x  = opts.fetch :start_x, 0
+        start_y  = opts.fetch :start_y, 0
+        offset_x = opts.fetch :offset_x, 0
+        offset_y = opts.fetch :offset_y, 0
+        duration = opts.fetch :duration, 200
+
+        coordinates = swipe_coordinates(start_x: start_x, start_y: start_y, offset_x: offset_x, offset_y: offset_y)
+
+        if ele # pinch/zoom for XCUITest
+          press x: start_x, y: start_y, element: ele
+          move_to x: coordinates[:offset_x], y: coordinates[:offset_y], element: ele
+        else
+          press x: start_x, y: start_y
+          wait(duration) if duration
+          move_to x: coordinates[:offset_x], y: coordinates[:offset_y]
+        end
+        release
+
+        self
+      end
+
+      # Ask the driver to perform all actions in this action chain.
+      def perform
+        @driver.touch_actions @actions
+        @actions.clear
+        self
+      end
+
+      # Does nothing, currently.
+      def cancel
+        @actions << { action: cancel }
+        @driver.touch_actions @actions
+        self
+      end
+
+      # Visible for testing
+      # @private
+      def swipe_coordinates(start_x: 0, start_y: 0, offset_x: 0, offset_y: 0)
+        Appium::Logger.info "start_x: #{start_x}, start_y: #{start_y}, offset_x: #{offset_x}, offset_y: #{offset_y}"
+        { offset_x: offset_x, offset_y: offset_y }
+      end
+
+      private
+
+      def chain_method(method, args = nil)
+        action = args ? { action: method, options: args } : { action: method }
+        @actions << action
+        self
+      end
+
+      def args_with_ele_ref(args)
+        args[:element] = args[:element].ref if args.key? :element
+        args
+      end
+    end # class TouchAction
+  end # module Core
+end # module Appium

data/lib/appium_lib_core/driver.rb

@@ -0,0 +1,459 @@
+module Appium
+  module Core
+    class Driver
+      # Selenium webdriver capabilities
+      # @return [Core::Base::Capabilities]
+      attr_reader :caps
+
+      # Return http client called in start_driver()
+      # @return [Appium::Core::Base::Http::Default] the http client
+      attr_reader :http_client
+
+      # Device type to request from the appium server
+      # @return [Symbol] :android and :ios, for example
+      attr_reader :device
+
+      # Automation name sent to appium server or received from server
+      # If automation_name is nil, it is not set both client side and server side.
+      # @return [Hash]
+      attr_reader :automation_name
+
+      # Custom URL for the selenium server. If set this attribute, ruby_lib try to handshake to the custom url.
+      # @return [String]
+      attr_reader :custom_url
+
+      # Export session id to textfile in /tmp for 3rd party tools
+      # @return [Boolean]
+      attr_reader :export_session
+      # @return [String] By default, session id is exported in '/tmp/appium_lib_session'
+      attr_reader :export_session_path
+
+      # Default wait time for elements to appear
+      # Returns the default client side wait.
+      # This value is independent of what the server is using
+      # Provide Appium::Drive like { appium_lib: { wait: 20 } }
+      # @return [Integer]
+      attr_reader :default_wait
+
+      # Appium's server port
+      # Provide Appium::Drive like { appium_lib: { port: 8080 } }
+      # @return [Integer]
+      attr_reader :port
+
+      # Return a time wait timeout
+      # Wait time for ::Appium::Core::Base::Wait, wait and wait_true
+      # Provide Appium::Drive like { appium_lib: { wait_timeout: 20 } }
+      # @return [Integer]
+      attr_reader :wait_timeout
+
+      # Return a time wait timeout
+      # Wait interval time for ::Appium::Core::Base::Wait, wait and wait_true
+      # Provide Appium::Drive like { appium_lib: { wait_interval: 20 } }
+      # @return [Integer]
+      attr_reader :wait_interval
+
+      # instance of AbstractEventListener for logging support
+      attr_reader :listener
+
+      # @return [Appium::Core::Base::Driver]
+      attr_reader :driver
+
+      # Creates a new global driver and extend particular methods to `target`
+      # @param [Class] target Extend particular methods to this target.
+      # @param [Hash] opts A options include capabilities for the Appium Server and for the client.
+      # @return [Driver]
+      #
+      # @example
+      #
+      #     require 'rubygems'
+      #     require 'appium_lib'
+      #
+      #     # Start iOS driver
+      #     opts = {
+      #              caps: {
+      #                platformName: :ios,
+      #                app: '/path/to/MyiOS.app'
+      #              },
+      #              appium_lib: {
+      #                server_url: "http://custom-host:8080/wd/hub.com",
+      #                export_session: false,
+      #                port: 8080,
+      #                wait: 0,
+      #                wait_timeout: 20,
+      #                wait_interval: 0.3,
+      #                listener: nil,
+      #              }
+      #            }
+      #     @core_driver = Appium::Core.for(self, opts) # create a core driver with `opts` and extend methods into `self`
+      #     @core_driver.start_driver(server_url: server_url, http_client_ops: http_client_ops) # start driver
+      #
+      def self.for(target, opts = {})
+        new(target, opts)
+      end
+
+      # @private
+      def initialize(target, opts = {})
+        opts = Appium.symbolize_keys opts
+        validate_keys(opts)
+
+        @caps = get_caps(opts)
+
+        set_appium_lib_specific_values(get_appium_lib_opts(opts))
+        set_app_path
+        set_appium_device
+        set_automation_name
+
+        extend_for(device: @device, automation_name: @automation_name, target: target)
+
+        self
+      end
+
+      # Creates a new global driver and quits the old one if it exists.
+      # You can customise http_client as the following
+      #
+      # @param [String] server_url Custom server url to send to requests. Default is "http://127.0.0.1:4723/wd/hub".
+      # @option http_client_ops [Hash] :http_client Custom HTTP Client
+      # @option http_client_ops [Hash] :open_timeout Custom open timeout for http client.
+      # @option http_client_ops [Hash] :read_timeout Custom read timeout for http client.
+      # @return [Selenium::WebDriver] the new global driver
+      #
+      # @example
+      #
+      #     require 'rubygems'
+      #     require 'appium_lib'
+      #
+      #     # platformName takes a string or a symbol.
+      #
+      #     # Start iOS driver
+      #     opts = {
+      #              caps: {
+      #                platformName: :ios,
+      #                app: '/path/to/MyiOS.app'
+      #              },
+      #              appium_lib: {
+      #                server_url: "http://custom-host:8080/wd/hub.com",
+      #                export_session: false,
+      #                port: 8080,
+      #                wait: 0,
+      #                wait_timeout: 20,
+      #                wait_interval: 0.3,
+      #                listener: nil,
+      #              }
+      #            }
+      #     @core = Appium::Driver.new(opts)
+      #     @driver = @core.start_driver
+      #
+      def start_driver(server_url: nil,
+                       http_client_ops: { http_client: nil, open_timeout: 999_999, read_timeout: 999_999 })
+        server_url = server_url ? server_url : "http://127.0.0.1:#{@port}/wd/hub"
+
+        # open_timeout and read_timeout are explicit wait.
+        open_timeout = http_client_ops.delete(:open_timeout)
+        read_timeout = http_client_ops.delete(:read_timeout)
+
+        http_client = http_client_ops.delete(:http_client)
+        @http_client ||= http_client ? http_client : Appium::Core::Base::Http::Default.new
+
+        @http_client.open_timeout = open_timeout if open_timeout
+        @http_client.read_timeout = read_timeout if read_timeout
+
+        begin
+          # included https://github.com/SeleniumHQ/selenium/blob/43f8b3f66e7e01124eff6a5805269ee441f65707/rb/lib/selenium/webdriver/remote/driver.rb#L29
+          @driver = ::Appium::Core::Base::Driver.new(http_client: @http_client,
+                                                     desired_capabilities: @caps,
+                                                     url: server_url,
+                                                     listener: @listener)
+
+          # export session
+          write_session_id(@driver.session_id, @export_session_path) if @export_session
+        rescue Errno::ECONNREFUSED
+          raise "ERROR: Unable to connect to Appium. Is the server running on #{server_url}?"
+        end
+
+        # If "automationName" is set only server side, this method set "automationName" attribute into @automation_name.
+        # Since @automation_name is set only client side before start_driver is called.
+        set_automation_name_if_nil
+
+        set_implicit_wait_by_default(@default_wait)
+
+        @driver
+      end
+
+      private
+
+      # Ignore setting default wait if the target driver has no implementation
+      def set_implicit_wait_by_default(wait)
+        @driver.manage.timeouts.implicit_wait = wait
+      rescue Selenium::WebDriver::Error::UnknownError => e
+        unless e.message.include?('The operation requested is not yet implemented')
+          raise e.message, ::Appium::Core::Error::ServerError
+        end
+
+        Appium::Logger.debug(e.message)
+        {}
+      end
+
+      public
+
+      # Quits the driver
+      # @return [void]
+      #
+      # @example
+      #
+      #   @core.quit_driver
+      #
+      def quit_driver
+        @driver.quit
+      rescue
+        nil
+      end
+
+      # Returns the server's version info
+      # @return [Hash]
+      #
+      # @example
+      #
+      #   @core.appium_server_version
+      #     {
+      #         "build" => {
+      #             "version" => "0.18.1",
+      #             "revision" => "d242ebcfd92046a974347ccc3a28f0e898595198"
+      #         }
+      #     }
+      #
+      # Returns blank hash for Selenium Grid since `remote_status` gets 500 error
+      #
+      # @example
+      #
+      #   @core.appium_server_version #=> {}
+      #
+      def appium_server_version
+        @driver.remote_status
+      rescue Selenium::WebDriver::Error::ServerError => e
+        raise ::Appium::Core::Error::ServerError unless e.message.include?('status code 500')
+        # driver.remote_status returns 500 error for using selenium grid
+        {}
+      end
+
+      # Return the platform version as an array of integers
+      # @return [Array<Integer>]
+      #
+      # @example
+      #
+      #     @core.platform_version #=> [10.1.1]
+      #
+      def platform_version
+        p_version = @driver.capabilities['platformVersion']
+        p_version.split('.').map(&:to_i)
+      end
+
+      # Takes a png screenshot and saves to the target path.
+      #
+      # @param png_save_path [String] the full path to save the png
+      # @return [File]
+      #
+      # @example
+      #
+      #   @core.screenshot '/tmp/hi.png' #=> nil
+      #   # same as `@driver.save_screenshot png_save_path`
+      #
+      def screenshot(png_save_path)
+        warn '[DEPRECATION] screenshot will be removed. Please use driver.save_screenshot instead.'
+        @driver.save_screenshot png_save_path
+      end
+
+      # Check every interval seconds to see if yield returns a truthy value.
+      # Note this isn't a strict boolean true, any truthy value is accepted.
+      # false and nil are considered failures.
+      # Give up after timeout seconds.
+      #
+      # Wait code from the selenium Ruby gem
+      # https://github.com/SeleniumHQ/selenium/blob/cf501dda3f0ed12233de51ce8170c0e8090f0c20/rb/lib/selenium/webdriver/common/wait.rb
+      #
+      # If only a number is provided then it's treated as the timeout value.
+      #
+      # @param [Hash] opts Options
+      # @option opts [Numeric] :timeout Seconds to wait before timing out. Set default by `appium_wait_timeout` (30).
+      # @option opts [Numeric] :interval Seconds to sleep between polls. Set default by `appium_wait_interval` (0.5).
+      # @option opts [String] :message Exception message if timed out.
+      # @option opts [Array, Exception] :ignore Exceptions to ignore while polling (default: Exception)
+      #
+      # @example
+      #
+      #   @core.wait_true { @driver.find_element :accessibility_id, 'something' }
+      #
+      def wait_true(opts = {})
+        opts = process_wait_opts(opts).merge(return_if_true: true)
+
+        opts[:timeout]  ||= @wait_timeout
+        opts[:interval] ||= @wait_interval
+
+        wait = ::Appium::Core::Base::Wait.new opts
+        wait.until { yield }
+      end
+
+      # Check every interval seconds to see if yield doesn't raise an exception.
+      # Give up after timeout seconds.
+      #
+      # Wait code from the selenium Ruby gem
+      # https://github.com/SeleniumHQ/selenium/blob/cf501dda3f0ed12233de51ce8170c0e8090f0c20/rb/lib/selenium/webdriver/common/wait.rb
+      #
+      # If only a number is provided then it's treated as the timeout value.
+      #
+      # @param [Hash] opts Options
+      # @option opts [Numeric] :timeout Seconds to wait before timing out. Set default by `appium_wait_timeout` (30).
+      # @option opts [Numeric] :interval Seconds to sleep between polls. Set default by `appium_wait_interval` (0.5).
+      # @option opts [String] :message Exception message if timed out.
+      # @option opts [Array, Exception] :ignore Exceptions to ignore while polling (default: Exception)
+      #
+      # @example
+      #
+      #   @core.wait { @driver.find_element :accessibility_id, 'something' }
+      #
+      def wait(opts = {})
+        opts = process_wait_opts(opts).merge(return_if_true: false)
+
+        opts[:timeout] ||= @wait_timeout
+        opts[:interval] ||= @wait_interval
+
+        wait = ::Appium::Core::Base::Wait.new opts
+        wait.until { yield }
+      end
+
+      private
+
+      # @private
+      def process_wait_opts(opts)
+        opts = { timeout: opts } if opts.is_a?(Numeric)
+        raise 'opts must be a hash' unless opts.is_a? Hash
+        opts
+      end
+
+      # @private
+      def extend_for(device:, automation_name:, target:)
+        target.extend Appium::Core
+        target.extend Appium::Core::Device
+
+        case device
+        when :android
+          case automation_name
+          when :espresso
+            ::Appium::Core::Android::Espresso::Bridge.for(self)
+          when :uiautomator2
+            ::Appium::Core::Android::Uiautomator2::Bridge.for(self)
+          else # default and UiAutomator
+            ::Appium::Core::Android::Uiautomator1::Bridge.for(self)
+          end
+        when :ios
+          case automation_name
+          when :xcuitest
+            ::Appium::Core::Ios::Xcuitest::Bridge.for(self)
+          else # default and UIAutomation
+            ::Appium::Core::Ios::Uiautomation::Bridge.for(self)
+          end
+        when :mac
+          # no Mac specific extentions
+          Appium::Logger.debug('mac')
+        when :windows
+          # no windows specific extentions
+          Appium::Logger.debug('windows')
+        else
+          Appium::Logger.warn('no device matched')
+        end
+
+        target
+      end
+
+      # @private
+      def validate_keys(opts)
+        flatten_ops = flatten_hash_keys(opts)
+
+        raise Error::NoCapabilityError unless opts.member?(:caps)
+        if !opts.member?(:appium_lib) && flatten_ops.member?(:appium_lib)
+          raise Error::CapabilityStructureError, 'Please check the value of appium_lib in the capability'
+        end
+
+        true
+      end
+
+      # @private
+      def flatten_hash_keys(hash, flatten_keys_result = [])
+        hash.each do |key, value|
+          flatten_keys_result << key
+          flatten_hash_keys(value, flatten_keys_result) if value.is_a?(Hash)
+        end
+
+        flatten_keys_result
+      end
+
+      # @private
+      def get_caps(opts)
+        Core::Base::Capabilities.create_capabilities(opts[:caps] || {})
+      end
+
+      # @private
+      def get_appium_lib_opts(opts)
+        opts[:appium_lib] || {}
+      end
+
+      # @private
+      # Path to the .apk, .app or .app.zip.
+      # The path can be local or remote for Sauce.
+      def set_app_path
+        return unless @caps && @caps[:app] && !@caps[:app].empty?
+        @caps[:app] = File.expand_path(@caps[:app])
+      end
+
+      # @private
+      def set_appium_lib_specific_values(appium_lib_opts)
+        @custom_url = appium_lib_opts.fetch :server_url, false
+        @default_wait = appium_lib_opts.fetch :wait, 0
+
+        # bump current session id into a particular file
+        @export_session = appium_lib_opts.fetch :export_session, false
+        @export_session_path = appium_lib_opts.fetch :export_session_path, '/tmp/appium_lib_session'
+
+        @port = appium_lib_opts.fetch :port, 4723
+
+        # timeout and interval used in ::Appium::Comm.wait/wait_true
+        @wait_timeout  = appium_lib_opts.fetch :wait_timeout, 30
+        @wait_interval = appium_lib_opts.fetch :wait_interval, 0.5
+
+        # to pass it in Selenium.new.
+        # `listener = opts.delete(:listener)` is called in Selenium::Driver.new
+        @listener = appium_lib_opts.fetch :listener, nil
+      end
+
+      # @private
+      def set_appium_device
+        # https://code.google.com/p/selenium/source/browse/spec-draft.md?repo=mobile
+        @device = @caps[:platformName]
+        return @device unless @device
+
+        @device = @device.is_a?(Symbol) ? @device : @device.downcase.strip.intern
+      end
+
+      # @private
+      def set_automation_name
+        @automation_name = @caps[:automationName] if @caps[:automationName]
+        @automation_name = if @automation_name
+                             @automation_name.is_a?(Symbol) ? @automation_name : @automation_name.downcase.strip.intern
+                           end
+      end
+
+      # @private
+      def set_automation_name_if_nil
+        return unless @automation_name.nil?
+        @automation_name = @driver.capabilities['automationName']
+      end
+
+      # @private
+      def write_session_id(session_id, export_path = '/tmp/appium_lib_session')
+        File.open(export_path, 'w') { |f| f.puts session_id }
+      rescue IOError => e
+        ::Appium::Logger.warn e
+        nil
+      end
+    end # class Driver
+  end # module Core
+end # module Appium