appium_lib_core 5.0.0.beta1 → 5.0.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd462f64262abe99f03dd5a421f2a2dd9c8064f1d44eff47bc1872a834793d27
-  data.tar.gz: 1a1ca492c3551d8c992e9f2b740460e67239887400602351423062e49912b73f
+  metadata.gz: 53abadd3b91fdcaac0c23f62bbc83b0e21ea08a50da28394a504d6839d36d2e7
+  data.tar.gz: 9bc2cda2b1fa8be1d602cd7ab9943594f9b4a1fce0ea5a4527491563c3687fd2
 SHA512:
-  metadata.gz: d9e4977dfb93ce734c59af5053a6331bfc2038bd3a03757a31fd7e48c3cdcc810204fb6f3027a1120afe91eda31ad61aa504fa25fdf2a2a21d36638c27982f8e
-  data.tar.gz: 3e23c561984a3ad4bf4214aad79fc730f8673d0bc29c81d26ff5143c0dbeb38d6eacc9278ba0caa11e4dfc51f82267f79b97efe6937ad8315c837e64876df162
+  metadata.gz: 313ae53035edd0273b8d122325c77d031a186c5a9f60b57956ad0f204165cc8ca60420ce2a910dc28d9e0b5000fa9131262fbe4a2b796e4e4d7bd09d9e40e941
+  data.tar.gz: deb1d0d9c9aba7cc7a9b6040dbdbcf76896d5a0ce786a8ac419b436a11a90e1960893e2f6683a78efee7d3a8044d5eb19414d527123778cebd088a437b6a4215

data/appium_lib_core.gemspec

@@ -31,7 +31,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'minitest', '~> 5.0'
   spec.add_development_dependency 'minitest-reporters', '~> 1.1'
   spec.add_development_dependency 'webmock', '~> 3.12.1'
-  spec.add_development_dependency 'rubocop', '1.11.0'
+  spec.add_development_dependency 'rubocop', '1.12.0'
   spec.add_development_dependency 'appium_thor', '~> 1.0'
   spec.add_development_dependency 'pry'
   spec.add_development_dependency 'pry-byebug'

data/lib/appium_lib_core.rb

@@ -17,11 +17,8 @@ require 'selenium-webdriver'
 require_relative 'appium_lib_core/version'
 require_relative 'appium_lib_core/common'
 require_relative 'appium_lib_core/driver'
-
 require_relative 'appium_lib_core/device'
-
-# Call patch after requiring other files
-require_relative 'appium_lib_core/patch'
+require_relative 'appium_lib_core/element'
 
 module Appium
   # convert all keys (including nested) to symbols

data/lib/appium_lib_core/common/base.rb

@@ -34,9 +34,7 @@ require_relative 'device/orientation'
 # The following files have selenium-webdriver related stuff.
 require_relative 'base/driver'
 require_relative 'base/bridge'
-require_relative 'base/bridge/w3c'
 require_relative 'base/capabilities'
 require_relative 'base/http_default'
 require_relative 'base/search_context'
-require_relative 'base/command'
 require_relative 'base/platform'

data/lib/appium_lib_core/common/base/bridge.rb

@@ -16,11 +16,36 @@ module Appium
   module Core
     class Base
       class Bridge < ::Selenium::WebDriver::Remote::Bridge
-        # TODO: Move W3C module to here
+        include Device::DeviceLock
+        include Device::Keyboard
+        include Device::ImeActions
+        include Device::Setting
+        include Device::Context
+        include Device::Value
+        include Device::FileManagement
+        include Device::KeyEvent
+        include Device::ImageComparison
+        include Device::AppManagement
+        include Device::AppState
+        include Device::ScreenRecord::Command
+        include Device::Device
+        include Device::TouchActions
+        include Device::ExecuteDriver
+        include Device::Orientation
 
         # Prefix for extra capability defined by W3C
         APPIUM_PREFIX = 'appium:'
 
+        # Returns 'unknown' if no specific browser name
+        def browser
+          @browser ||= begin
+            name = @capabilities.browser_name
+            name ? name.tr(' ', '_').downcase.to_sym : 'unknown'
+          rescue KeyError
+            'unknown'
+          end
+        end
+
         # Override
         # Creates session handling both OSS and W3C dialects.
         #
@@ -99,6 +124,241 @@ module Appium
         def json_create(value)
           ::Selenium::WebDriver::Remote::Capabilities.json_create(value)
         end
+
+        public
+
+        def commands(command)
+          ::Appium::Core::Commands::COMMANDS[command]
+        end
+
+        # Returns all available sessions on the Appium server instance
+        def sessions
+          execute :get_all_sessions
+        end
+
+        def status
+          execute :status
+        end
+
+        # Perform touch actions for W3C module.
+        # Generate +touch+ pointer action here and users can use this via +driver.action+
+        # - https://seleniumhq.github.io/selenium/docs/api/rb/Selenium/WebDriver/W3CActionBuilder.html
+        # - https://seleniumhq.github.io/selenium/docs/api/rb/Selenium/WebDriver/PointerActions.html
+        # - https://seleniumhq.github.io/selenium/docs/api/rb/Selenium/WebDriver/KeyActions.html
+        #
+        # 'mouse' action is by default in the Ruby client. Appium server force the +mouse+ action to +touch+ once in
+        # the server side. So we don't consider the case.
+        #
+        # @example
+        #
+        #     element = @driver.find_element(:id, "some id")
+        #     @driver.action.click(element).perform # The 'click' is a part of 'PointerActions'
+        #
+        def action(async = false)
+          # Used for default duration of each touch actions
+          # Override from 250 milliseconds to 50 milliseconds
+          action_builder = super
+          action_builder.default_move_duration = 0.05
+          action_builder
+        end
+
+        # Port from MJSONWP
+        def get_timeouts
+          execute :get_timeouts
+        end
+
+        # Port from MJSONWP
+        def session_capabilities
+          ::Selenium::WebDriver::Remote::Capabilities.json_create execute(:get_capabilities)
+        end
+
+        # Port from MJSONWP
+        def send_keys_to_active_element(key)
+          text = ::Selenium::WebDriver::Keys.encode(key).join('')
+          execute :send_keys_to_active_element, {}, { value: text.split(//) }
+        end
+
+        # For Appium
+        # override
+        def page_source
+          # For W3C
+          # execute_script('var source = document.documentElement.outerHTML;' \
+          # 'if (!source) { source = new XMLSerializer().serializeToString(document); }' \
+          # 'return source;')
+          execute :get_page_source
+        end
+
+        # For Appium
+        # override
+        def element_displayed?(element)
+          # For W3C
+          # https://github.com/SeleniumHQ/selenium/commit/b618499adcc3a9f667590652c5757c0caa703289
+          # execute_atom :isDisplayed, element
+          execute :is_element_displayed, id: element.ref
+        end
+
+        # For Appium
+        # override
+        def element_attribute(element, name)
+          # For W3C in Selenium Client
+          # execute_atom :getAttribute, element, name
+          execute :get_element_attribute, id: element.ref, name: name
+        end
+
+        # For Appium
+        # override
+        def active_element
+          ::Appium::Core::Element.new self, element_id_from(execute(:get_active_element))
+        end
+        alias switch_to_active_element active_element
+
+        # For Appium
+        # override
+        def find_element_by(how, what, parent = nil)
+          how, what = convert_locators(how, what)
+
+          id = if parent
+                 execute :find_child_element, { id: parent }, { using: how, value: what }
+               else
+                 execute :find_element, {}, { using: how, value: what }
+               end
+          ::Appium::Core::Element.new self, element_id_from(id)
+        end
+
+        # For Appium
+        # override
+        def find_elements_by(how, what, parent = nil)
+          how, what = convert_locators(how, what)
+
+          ids = if parent
+                  execute :find_child_elements, { id: parent }, { using: how, value: what }
+                else
+                  execute :find_elements, {}, { using: how, value: what }
+                end
+
+          ids.map { |id| ::Appium::Core::Element.new self, element_id_from(id) }
+        end
+
+        # For Appium
+        # @param [Hash] id The id which can get as a response from server
+        # @return [::Appium::Core::Element]
+        def convert_to_element(id)
+          ::Appium::Core::Element.new self, element_id_from(id)
+        end
+
+        # For Appium
+        # override
+        # called in 'extend DriverExtensions::HasNetworkConnection'
+        def network_connection
+          execute :get_network_connection
+        end
+
+        # For Appium
+        # override
+        # called in 'extend DriverExtensions::HasNetworkConnection'
+        def network_connection=(type)
+          execute :set_network_connection, {}, { parameters: { type: type } }
+        end
+
+        # For Appium
+        # No implementation for W3C webdriver module
+        # called in 'extend DriverExtensions::HasLocation'
+        def location
+          obj = execute(:get_location) || {}
+          ::Selenium::WebDriver::Location.new obj['latitude'], obj['longitude'], obj['altitude']
+        end
+
+        # For Appium
+        # No implementation for W3C webdriver module
+        def set_location(lat, lon, alt = 0.0, speed: nil)
+          loc = { latitude: lat, longitude: lon, altitude: alt }
+          loc[:speed] = speed unless speed.nil?
+          execute :set_location, {}, { location: loc }
+        end
+
+        #
+        # logs
+        #
+        # For Appium
+        # No implementation for W3C webdriver module
+        def available_log_types
+          types = execute :get_available_log_types
+          Array(types).map(&:to_sym)
+        end
+
+        # For Appium
+        # No implementation for W3C webdriver module
+        def log(type)
+          data = execute :get_log, {}, { type: type.to_s }
+
+          Array(data).map do |l|
+            begin
+              ::Selenium::WebDriver::LogEntry.new l.fetch('level', 'UNKNOWN'), l.fetch('timestamp'), l.fetch('message')
+            rescue KeyError
+              next
+            end
+          end
+        end
+
+        # For Appium
+        def log_event(vendor, event)
+          execute :post_log_event, {}, { vendor: vendor, event: event }
+        end
+
+        # For Appium
+        def log_events(type = nil)
+          args = {}
+          args['type'] = type unless type.nil?
+
+          execute :get_log_events, {}, args
+        end
+
+        def take_viewport_screenshot
+          execute_script('mobile: viewportScreenshot')
+        end
+
+        def take_element_screenshot(element)
+          execute :take_element_screenshot, id: element.ref
+        end
+
+        private
+
+        def unwrap_script_result(arg)
+          case arg
+          when Array
+            arg.map { |e| unwrap_script_result(e) }
+          when Hash
+            element_id = element_id_from(arg)
+            return ::Appium::Core::Element.new(self, element_id) if element_id
+
+            arg.each { |k, v| arg[k] = unwrap_script_result(v) }
+          else
+            arg
+          end
+        end
+
+        def element_id_from(id)
+          id['ELEMENT'] || id['element-6066-11e4-a52e-4f735466cecf']
+        end
+
+        # Don't convert locators for Appium Client
+        # TODO: Only for Appium. Ideally, we'd like to keep the selenium-webdriver
+        def convert_locators(how, what)
+          # case how
+          # when 'class name'
+          #   how = 'css selector'
+          #   what = ".#{escape_css(what)}"
+          # when 'id'
+          #   how = 'css selector'
+          #   what = "##{escape_css(what)}"
+          # when 'name'
+          #   how = 'css selector'
+          #   what = "*[name='#{escape_css(what)}']"
+          # when 'tag name'
+          #   how = 'css selector'
+          # end
+          [how, what]
+        end
       end # class Bridge
     end # class Base
   end # module Core

data/lib/appium_lib_core/common/base/driver.rb

@@ -36,6 +36,8 @@ module Appium
         include ::Appium::Core::Base::HasLocation
         include ::Appium::Core::Base::HasNetworkConnection
 
+        private
+
         # Private API.
         # Do not use this for general use. Used by flutter driver to get bridge for creating a new element
         attr_reader :bridge
@@ -48,9 +50,8 @@ module Appium
         #   2. Sniffs response.
         #   3. Based on the response, understands which dialect we should use.
         #
-        # @return [Bridge::W3C]
+        # @return [::Appium::Core::Base::Bridge]
         #
-        # TODO: Fixme
         def create_bridge(**opts)
           opts[:url] ||= service_url(opts)
           caps = opts.delete(:capabilities)
@@ -73,17 +74,13 @@ module Appium
           bridge_opts = { http_client: opts.delete(:http_client), url: opts.delete(:url) }
           raise ArgumentError, "Unable to create a driver with parameters: #{opts}" unless opts.empty?
 
-          bridge = ::Appium::Core::Base::Bridge::W3C.new(**bridge_opts)
+          bridge = ::Appium::Core::Base::Bridge.new(**bridge_opts)
 
           bridge.create_session(capabilities)
           bridge
         end
 
-        # Get the dialect value
-        # @return [:oss|:w3c]
-        def dialect
-          @bridge.dialect
-        end
+        public
 
         # Update +server_url+ and HTTP clients following this arguments, protocol, host, port and path.
         # After this method, +@bridge.http+ will be a new instance following them instead of +server_url+ which is
@@ -1074,7 +1071,7 @@ module Appium
         #
         # @param [String] img_path A path to a partial image you'd like to find
         #
-        # @return [::Selenium::WebDriver::Element]
+        # @return [::Appium::Core::Element]
         #
         # @example
         #
@@ -1144,14 +1141,14 @@ module Appium
           @bridge.execute_driver(script: script, type: type, timeout_ms: timeout_ms)
         end
 
-        # Convert vanilla element response to ::Selenium::WebDriver::Element
+        # Convert vanilla element response to ::Appium::Core::Element
         #
         # @param [Hash] id The id which can get as a response from server
-        # @return [::Selenium::WebDriver::Element]
+        # @return [::Appium::Core::Element]
         #
         # @example
         #     response = {"element-6066-11e4-a52e-4f735466cecf"=>"xxxx", "ELEMENT"=>"xxxx"}
-        #     ele = @driver.convert_to_element(response) #=> ::Selenium::WebDriver::Element
+        #     ele = @driver.convert_to_element(response) #=> ::Appium::Core::Element
         #     ele.rect #=> Can get the rect of the element
         #
         def convert_to_element(id)

data/lib/appium_lib_core/common/command.rb

@@ -12,6 +12,262 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require_relative 'base/command'
-require_relative 'command/common'
-require_relative 'command/w3c'
+module Appium
+  module Core
+    # ref: https://github.com/appium/appium-base-driver/blob/master/lib/mjsonwp/routes.js
+    module Commands
+      # Some commands differ for each driver.
+      COMMAND = {
+        ###
+        # W3C
+        ###
+        status: [:get, 'status'],
+
+        #
+        # session handling
+        #
+
+        new_session: [:post, 'session'],
+        delete_session: [:delete, 'session/:session_id'],
+
+        #
+        # basic driver
+        #
+
+        get: [:post, 'session/:session_id/url'],
+        get_current_url: [:get, 'session/:session_id/url'],
+        back: [:post, 'session/:session_id/back'],
+        forward: [:post, 'session/:session_id/forward'],
+        refresh: [:post, 'session/:session_id/refresh'],
+        get_title: [:get, 'session/:session_id/title'],
+
+        #
+        # window and Frame handling
+        #
+
+        get_window_handle: [:get, 'session/:session_id/window'],
+        new_window: [:post, 'session/:session_id/window/new'],
+        close_window: [:delete, 'session/:session_id/window'],
+        switch_to_window: [:post, 'session/:session_id/window'],
+        get_window_handles: [:get, 'session/:session_id/window/handles'],
+        fullscreen_window: [:post, 'session/:session_id/window/fullscreen'],
+        minimize_window: [:post, 'session/:session_id/window/minimize'],
+        maximize_window: [:post, 'session/:session_id/window/maximize'],
+        set_window_size: [:post, 'session/:session_id/window/size'],
+        get_window_size: [:get, 'session/:session_id/window/size'],
+        set_window_position: [:post, 'session/:session_id/window/position'],
+        get_window_position: [:get, 'session/:session_id/window/position'],
+        set_window_rect: [:post, 'session/:session_id/window/rect'],
+        get_window_rect: [:get, 'session/:session_id/window/rect'],
+        switch_to_frame: [:post, 'session/:session_id/frame'],
+        switch_to_parent_frame: [:post, 'session/:session_id/frame/parent'],
+
+        #
+        # element
+        #
+
+        find_element: [:post, 'session/:session_id/element'],
+        find_elements: [:post, 'session/:session_id/elements'],
+        find_child_element: [:post, 'session/:session_id/element/:id/element'],
+        find_child_elements: [:post, 'session/:session_id/element/:id/elements'],
+        get_active_element: [:get, 'session/:session_id/element/active'],
+        is_element_selected: [:get, 'session/:session_id/element/:id/selected'],
+        get_element_attribute: [:get, 'session/:session_id/element/:id/attribute/:name'],
+        get_element_property: [:get, 'session/:session_id/element/:id/property/:name'],
+        get_element_css_value: [:get, 'session/:session_id/element/:id/css/:property_name'],
+        get_element_text: [:get, 'session/:session_id/element/:id/text'],
+        get_element_tag_name: [:get, 'session/:session_id/element/:id/name'],
+        get_element_rect: [:get, 'session/:session_id/element/:id/rect'],
+        is_element_enabled: [:get, 'session/:session_id/element/:id/enabled'],
+
+        #
+        # document handling
+        #
+
+        get_page_source: [:get, 'session/:session_id/source'],
+        execute_script: [:post, 'session/:session_id/execute/sync'],
+        execute_async_script: [:post, 'session/:session_id/execute/async'],
+
+        #
+        # cookies
+        #
+
+        get_all_cookies: [:get, 'session/:session_id/cookie'],
+        get_cookie: [:get, 'session/:session_id/cookie/:name'],
+        add_cookie: [:post, 'session/:session_id/cookie'],
+        delete_cookie: [:delete, 'session/:session_id/cookie/:name'],
+        delete_all_cookies: [:delete, 'session/:session_id/cookie'],
+
+        #
+        # timeouts
+        #
+
+        set_timeout: [:post, 'session/:session_id/timeouts'],
+
+        #
+        # actions
+        #
+
+        actions: [:post, 'session/:session_id/actions'],
+        release_actions: [:delete, 'session/:session_id/actions'],
+        print_page: [:post, 'session/:session_id/print'],
+
+        #
+        # Element Operations
+        #
+
+        element_click: [:post, 'session/:session_id/element/:id/click'],
+        element_tap: [:post, 'session/:session_id/element/:id/tap'],
+        element_clear: [:post, 'session/:session_id/element/:id/clear'],
+        element_send_keys: [:post, 'session/:session_id/element/:id/value'],
+
+        #
+        # alerts
+        #
+
+        dismiss_alert: [:post, 'session/:session_id/alert/dismiss'],
+        accept_alert: [:post, 'session/:session_id/alert/accept'],
+        get_alert_text: [:get, 'session/:session_id/alert/text'],
+        send_alert_text: [:post, 'session/:session_id/alert/text'],
+
+        #
+        # screenshot
+        #
+
+        take_screenshot: [:get, 'session/:session_id/screenshot'],
+        take_element_screenshot: [:get, 'session/:session_id/element/:id/screenshot'],
+
+        #
+        # server extensions
+        #
+
+        upload_file: [:post, 'session/:session_id/se/file'],
+
+        ###
+        # Used by Appium, but no in W3C
+        ###
+
+        # ::Appium::Core::Base::Commands::OSS has the following commands and Appium also use them.
+        # Delegated to ::Appium::Core::Base::Commands::OSS commands
+        is_element_displayed: [:get, 'session/:session_id/element/:id/displayed'], # hint: https://w3c.github.io/webdriver/#element-displayedness
+
+        get_timeouts: [:get, 'session/:session_id/timeouts'], # https://w3c.github.io/webdriver/#get-timeouts
+
+        # Add OSS commands to W3C commands. We can remove them if we would like to remove them from W3C module.
+        ### Session capability
+        get_capabilities: [:get, 'session/:session_id'],
+
+        ### rotatable
+        get_screen_orientation: [:get, 'session/:session_id/orientation'],
+        set_screen_orientation: [:post, 'session/:session_id/orientation'],
+
+        get_location: [:get, 'session/:session_id/location'],
+        set_location: [:post, 'session/:session_id/location'],
+
+        ### For IME
+        ime_get_available_engines: [:get, 'session/:session_id/ime/available_engines'],
+        ime_get_active_engine: [:get, 'session/:session_id/ime/active_engine'],
+        ime_is_activated: [:get, 'session/:session_id/ime/activated'],
+        ime_deactivate: [:post, 'session/:session_id/ime/deactivate'],
+        ime_activate_engine: [:post, 'session/:session_id/ime/activate'],
+
+        send_keys_to_active_element: [:post, 'session/:session_id/keys'],
+
+        ### Logs
+        get_available_log_types: [:get, 'session/:session_id/log/types'],
+        get_log: [:post, 'session/:session_id/log'],
+
+        ###
+        # Appium own
+        ###
+
+        # common
+        get_all_sessions: [:get, 'sessions'],
+        available_contexts: [:get, 'session/:session_id/contexts'],
+        set_context: [:post, 'session/:session_id/context'],
+        current_context: [:get, 'session/:session_id/context'],
+
+        touch_actions: [:post, 'session/:session_id/touch/perform'],
+        multi_touch: [:post, 'session/:session_id/touch/multi/perform'],
+
+        set_immediate_value: [:post, 'session/:session_id/appium/element/:id/value'],
+        replace_value: [:post, 'session/:session_id/appium/element/:id/replace_value'],
+
+        launch_app: [:post, 'session/:session_id/appium/app/launch'],
+        close_app: [:post, 'session/:session_id/appium/app/close'],
+        reset: [:post, 'session/:session_id/appium/app/reset'],
+        background_app: [:post, 'session/:session_id/appium/app/background'],
+        app_strings: [:post, 'session/:session_id/appium/app/strings'],
+
+        device_locked?: [:post, 'session/:session_id/appium/device/is_locked'],
+        unlock: [:post, 'session/:session_id/appium/device/unlock'],
+        lock: [:post, 'session/:session_id/appium/device/lock'],
+        device_time: [:get, 'session/:session_id/appium/device/system_time'],
+        install_app: [:post, 'session/:session_id/appium/device/install_app'],
+        remove_app: [:post, 'session/:session_id/appium/device/remove_app'],
+        app_installed?: [:post, 'session/:session_id/appium/device/app_installed'],
+        activate_app: [:post, 'session/:session_id/appium/device/activate_app'],
+        terminate_app: [:post, 'session/:session_id/appium/device/terminate_app'],
+        app_state: [:post, 'session/:session_id/appium/device/app_state'],
+        shake: [:post, 'session/:session_id/appium/device/shake'],
+        hide_keyboard: [:post, 'session/:session_id/appium/device/hide_keyboard'],
+        press_keycode: [:post, 'session/:session_id/appium/device/press_keycode'],
+        long_press_keycode: [:post, 'session/:session_id/appium/device/long_press_keycode'],
+        # keyevent is only for Selendroid
+        keyevent: [:post, 'session/:session_id/appium/device/keyevent'],
+        push_file: [:post, 'session/:session_id/appium/device/push_file'],
+        pull_file: [:post, 'session/:session_id/appium/device/pull_file'],
+        pull_folder: [:post, 'session/:session_id/appium/device/pull_folder'],
+        get_clipboard: [:post, 'session/:session_id/appium/device/get_clipboard'],
+        set_clipboard: [:post, 'session/:session_id/appium/device/set_clipboard'],
+        finger_print: [:post, 'session/:session_id/appium/device/finger_print'],
+        get_settings: [:get, 'session/:session_id/appium/settings'],
+        update_settings: [:post, 'session/:session_id/appium/settings'],
+        stop_recording_screen: [:post, 'session/:session_id/appium/stop_recording_screen'],
+        start_recording_screen: [:post, 'session/:session_id/appium/start_recording_screen'],
+        compare_images: [:post, 'session/:session_id/appium/compare_images'],
+        is_keyboard_shown: [:get, 'session/:session_id/appium/device/is_keyboard_shown'],
+        execute_driver: [:post, 'session/:session_id/appium/execute_driver'],
+        post_log_event: [:post, 'session/:session_id/appium/log_event'],
+        get_log_events: [:post, 'session/:session_id/appium/events']
+      }.freeze
+
+      COMMAND_ANDROID = {
+        open_notifications: [:post, 'session/:session_id/appium/device/open_notifications'],
+        toggle_airplane_mode: [:post, 'session/:session_id/appium/device/toggle_airplane_mode'],
+        start_activity: [:post, 'session/:session_id/appium/device/start_activity'],
+        current_activity: [:get, 'session/:session_id/appium/device/current_activity'],
+        current_package: [:get, 'session/:session_id/appium/device/current_package'],
+        get_system_bars: [:get, 'session/:session_id/appium/device/system_bars'],
+        get_display_density: [:get, 'session/:session_id/appium/device/display_density'],
+        toggle_wifi: [:post, 'session/:session_id/appium/device/toggle_wifi'],
+        toggle_data: [:post, 'session/:session_id/appium/device/toggle_data'],
+        toggle_location_services: [:post, 'session/:session_id/appium/device/toggle_location_services'],
+        end_coverage: [:post, 'session/:session_id/appium/app/end_test_coverage'],
+        get_performance_data_types: [:post, 'session/:session_id/appium/performanceData/types'],
+        get_performance_data: [:post, 'session/:session_id/appium/getPerformanceData'],
+        get_network_connection: [:get, 'session/:session_id/network_connection'], # defined also in OSS
+        set_network_connection: [:post, 'session/:session_id/network_connection'], # defined also in OSS
+
+        # only emulator
+        send_sms: [:post, 'session/:session_id/appium/device/send_sms'],
+        gsm_call: [:post, 'session/:session_id/appium/device/gsm_call'],
+        gsm_signal: [:post, 'session/:session_id/appium/device/gsm_signal'],
+        gsm_voice: [:post, 'session/:session_id/appium/device/gsm_voice'],
+        set_network_speed: [:post, 'session/:session_id/appium/device/network_speed'],
+        set_power_capacity: [:post, 'session/:session_id/appium/device/power_capacity'],
+        set_power_ac: [:post, 'session/:session_id/appium/device/power_ac'],
+
+        # For chromium: https://chromium.googlesource.com/chromium/src/+/master/chrome/test/chromedriver/server/http_handler.cc
+        chrome_send_command: [:post, 'session/:session_id/goog/cdp/execute']
+      }.freeze
+
+      COMMAND_IOS = {
+        touch_id: [:post, 'session/:session_id/appium/simulator/touch_id'],
+        toggle_touch_id_enrollment: [:post, 'session/:session_id/appium/simulator/toggle_touch_id_enrollment']
+      }.freeze
+
+      COMMANDS = {}.merge(COMMAND).merge(COMMAND_ANDROID).merge(COMMAND_IOS).freeze
+    end # module Commands
+  end # module Core
+end # module Appium