appium_lib_core 4.1.0 → 5.0.0.rc2

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Appium
+  module Core
+    class Base
+      #
+      # @api private
+      #
+
+      module HasRemoteStatus
+        # Selenium binding has this ability only in Remote Binding,
+        # so this library has this method by own for safe.
+        def remote_status
+          bridge.status
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Appium
+  module Core
+    class Base
+      #
+      # @api private
+      #
+
+      module Rotatable
+        ORIENTATIONS = %i[landscape portrait].freeze
+
+        #
+        # Change the screen orientation
+        #
+        # @param [:landscape, :portrait] orientation
+        #
+        #
+        def rotation=(orientation)
+          unless ORIENTATIONS.include?(orientation)
+            raise ::Appium::Core::Error::ArgumentError, "expected #{ORIENTATIONS.inspect}, got #{orientation.inspect}"
+          end
+
+          bridge.screen_orientation = orientation.to_s.upcase
+        end
+        alias rotate rotation=
+
+        #
+        # Get the current screen orientation
+        #
+        # @return [:landscape, :portrait] orientation
+        #
+        # @api public
+        #
+
+        def orientation
+          bridge.screen_orientation.to_sym.downcase
+        end
+      end
+    end
+  end
+end

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

@@ -15,7 +15,7 @@
 module Appium
   module Core
     class Base
-      module TakeScreenshot
+      module TakesScreenshot
         #
         # Save a PNG screenshot to the given path
         #
@@ -82,11 +82,12 @@ module Appium
         #     @@driver.element_screenshot_as element, :base64 #=> "iVBORw0KGgoAAAANSUhEUgAABDgAAAB+CAIAAABOPDa6AAAAAX"
         #
         def element_screenshot_as(element, format)
+          _, element_id = element.ref
           case format
           when :base64
-            bridge.take_element_screenshot(element)
+            bridge.element_screenshot element_id
           when :png
-            bridge.take_element_screenshot(element).unpack('m')[0]
+            bridge.element_screenshot(element_id).unpack('m')[0]
           else
             raise Core::Error::UnsupportedOperationError, "unsupported format: #{format.inspect}"
           end
@@ -106,7 +107,7 @@ module Appium
             ::Appium::Logger.warn 'name used for saved screenshot does not match file type. '\
                                   'It should end with .png extension'
           end
-          viewport_screenshot_encode64 = bridge.take_viewport_screenshot
+          viewport_screenshot_encode64 = bridge.viewport_screenshot
           File.open(png_path, 'wb') { |f| f << viewport_screenshot_encode64.unpack('m')[0] }
         end
       end

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

@@ -141,6 +141,8 @@ module Appium
         #
         # Find all elements matching the given arguments
         #
+        # @return [Array<Selenium::WebDriver::Element>]
+        #
         # @see SearchContext#find_elements
         #
         def find_elements(*args)
@@ -157,7 +159,10 @@ module Appium
 
         def _set_by_from_finders(how)
           by = FINDERS[how.to_sym]
-          raise ArgumentError, "cannot find element by #{how.inspect}. Available finders are #{FINDERS.keys}." unless by
+          unless by
+            raise ::Appium::Core::Error::ArgumentError,
+                  "cannot find element by #{how.inspect}. Available finders are #{FINDERS.keys}."
+          end
 
           by
         end
@@ -169,16 +174,18 @@ module Appium
           when 1
             arg = args.first
 
-            raise ArgumentError, "expected #{arg.inspect}:#{arg.class} to respond to #shift" unless arg.respond_to?(:shift)
+            unless arg.respond_to?(:shift)
+              raise ::Appium::Core::Error::ArgumentError, "expected #{arg.inspect}:#{arg.class} to respond to #shift"
+            end
 
             # this will be a single-entry hash, so use #shift over #first or #[]
             arr = arg.dup.shift
 
-            raise ArgumentError, "expected #{arr.inspect} to have 2 elements" unless arr.size == 2
+            raise ::Appium::Core::Error::ArgumentError, "expected #{arr.inspect} to have 2 elements" unless arr.size == 2
 
             arr
           else
-            raise ArgumentError, "wrong number of arguments (#{args.size} for 2)"
+            raise ::Appium::Core::Error::ArgumentError, "wrong number of arguments (#{args.size} for 2)"
           end
         end
       end # module SearchContext

data/lib/appium_lib_core/common/base.rb

@@ -29,14 +29,12 @@ require_relative 'device/clipboard_content_type'
 require_relative 'device/device'
 require_relative 'device/touch_actions'
 require_relative 'device/execute_driver'
+require_relative 'device/orientation'
 
 # The following files have selenium-webdriver related stuff.
 require_relative 'base/driver'
 require_relative 'base/bridge'
-require_relative 'base/bridge/mjsonwp'
-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/command.rb

@@ -12,7 +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/mjsonwp'
-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

data/lib/appium_lib_core/common/device/image_comparison.rb

@@ -47,7 +47,7 @@ module Appium
           #                               not available in the default OpenCV installation and have to be enabled manually
           #                               before library compilation. The default detector name is 'ORB'.
           # @param [String] match_func The name of the matching function. The default one is 'BruteForce'.
-          # @param [String] good_matches_factor The maximum count of "good" matches (e. g. with minimal distances).
+          # @param [String, nil] good_matches_factor The maximum count of "good" matches (e. g. with minimal distances).
           #                                     The default one is nil.
           # @param [Bool] visualize Makes the endpoint to return an image, which contains the visualized result of
           #                         the corresponding picture matching operation. This option is disabled by default.
@@ -94,7 +94,12 @@ module Appium
           #                                are supported.
           # @param [Bool] visualize Makes the endpoint to return an image, which contains the visualized result of
           #                         the corresponding picture matching operation. This option is disabled by default.
-          # @param [Float] threshold [0.5] At what normalized threshold to reject
+          # @param [Float, nil] threshold [0.5] At what normalized threshold to reject
+          # @param [bool, nil] multiple Whether to enable the support of multiple image occurrences @since Appium 1.21.0.
+          # @param [integer, nil] match_neighbour_threshold The pixel distance between matches we consider to be part of
+          #                                                 the same template match @since Appium 1.21.0.
+          #                                                 This option is only considered if multiple matches mode is enabled.
+          #                                                 10 pixels by default.
           #
           # @example
           #     @driver.find_image_occurrence full_image: "image data 1", partial_image: "image data 2"
@@ -102,12 +107,15 @@ module Appium
           #     visual = @@driver.find_image_occurrence full_image: image1, partial_image: image2, visualize: true
           #     File.write 'find_result_visual.png', Base64.decode64(visual['visualization']) # if the image is PNG
           #
-          def find_image_occurrence(full_image:, partial_image:, visualize: false, threshold: nil)
+          def find_image_occurrence(full_image:, partial_image:, visualize: false, threshold: nil,
+                                    multiple: nil, match_neighbour_threshold: nil)
             raise "visualize should be #{MATCH_TEMPLATE[:visualize]}" unless MATCH_TEMPLATE[:visualize].member?(visualize)
 
             options = {}
             options[:visualize] = visualize
             options[:threshold] = threshold unless threshold.nil?
+            options[:multiple] = multiple unless multiple.nil?
+            options[:matchNeighbourThreshold] = match_neighbour_threshold unless match_neighbour_threshold.nil?
 
             compare_images(mode: :matchTemplate, first_image: full_image, second_image: partial_image, options: options)
           end
@@ -144,7 +152,7 @@ module Appium
           #                      +:matchFeatures is by default.
           # @param [String] first_image An image data. All image formats, that OpenCV library itself accepts, are supported.
           # @param [String] second_image An image data. All image formats, that OpenCV library itself accepts, are supported.
-          # @param [Hash] options The content of this dictionary depends on the actual +mode+ value.
+          # @param [Hash, nil] options The content of this dictionary depends on the actual +mode+ value.
           #                       See the documentation on +appium-support+ module for more details.
           # @return [Hash] The content of the resulting dictionary depends on the actual +mode+ and +options+ values.
           #                 See the documentation on +appium-support+ module for more details.

data/lib/appium_lib_core/common/device/keyevent.rb

@@ -25,8 +25,8 @@ module Appium
           end
 
           def press_keycode(key, metastate: [], flags: [])
-            raise ArgumentError, 'flags should be Array' unless flags.is_a? Array
-            raise ArgumentError, 'metastates should be Array' unless metastate.is_a? Array
+            raise ::Appium::Core::Error::ArgumentError, 'flags should be Array' unless flags.is_a? Array
+            raise ::Appium::Core::Error::ArgumentError, 'metastates should be Array' unless metastate.is_a? Array
 
             args             = { keycode: key }
             args[:metastate] = metastate.reduce(0) { |acc, meta| acc | meta } unless metastate.empty?
@@ -36,8 +36,8 @@ module Appium
           end
 
           def long_press_keycode(key, metastate: [], flags: [])
-            raise ArgumentError, 'flags should be Array' unless flags.is_a? Array
-            raise ArgumentError, 'metastates should be Array' unless metastate.is_a? Array
+            raise ::Appium::Core::Error::ArgumentError, 'flags should be Array' unless flags.is_a? Array
+            raise ::Appium::Core::Error::ArgumentError, 'metastates should be Array' unless metastate.is_a? Array
 
             args             = { keycode: key }
             args[:metastate] = metastate.reduce(0) { |acc, meta| acc | meta } unless metastate.empty?

data/lib/appium_lib_core/common/{command/mjsonwp.rb → device/orientation.rb}

@@ -14,15 +14,18 @@
 
 module Appium
   module Core
-    module Commands
-      module MJSONWP
-        COMMANDS = ::Appium::Core::Commands::COMMANDS.merge(::Appium::Core::Base::Commands::OSS).merge(
-          {
-            # W3C already has.
-            take_element_screenshot:    [:get, 'session/:session_id/element/:id/screenshot']
-          }
-        ).freeze
-      end # module MJSONWP
-    end # module Commands
+    class Base
+      module Device
+        module Orientation
+          def screen_orientation=(orientation)
+            execute :set_screen_orientation, {}, { orientation: orientation }
+          end
+
+          def screen_orientation
+            execute :get_screen_orientation
+          end
+        end # module Orientation
+      end # module Device
+    end # class Base
   end # module Core
-end # Appium
+end # module Appium

data/lib/appium_lib_core/common/device/value.rb

@@ -17,12 +17,12 @@ module Appium
     class Base
       module Device
         module Value
-          def set_immediate_value(element, *value)
-            execute :set_immediate_value, { id: element.ref }, generate_value_and_text(value)
+          def set_immediate_value(element_id, *value)
+            execute :set_immediate_value, { id: element_id }, generate_value_and_text(value)
           end
 
-          def replace_value(element, *value)
-            execute :replace_value, { id: element.ref }, generate_value_and_text(value)
+          def replace_value(element_id, *value)
+            execute :replace_value, { id: element_id }, generate_value_and_text(value)
           end
 
           private

data/lib/appium_lib_core/common/error.rb

@@ -27,8 +27,11 @@ module Appium
 
       class UnsupportedOperationError < CoreError; end
 
-      # Server side error
+      # Server side errors
       class ServerError < CoreError; end
+
+      # ruby_lib_core library specific errors
+      class ArgumentError < CoreError; end
     end
   end
 end

data/lib/appium_lib_core/common/log.rb

@@ -65,7 +65,10 @@ module Appium
       end
 
       def event=(log_event)
-        raise ArgumentError('log_event should be Hash like { vendor: "appium", event: "funEvent"}') unless log_event.is_a?(Hash)
+        unless log_event.is_a?(Hash)
+          raise ::Appium::Core::Error::ArgumentError,
+                'log_event should be Hash like { vendor: "appium", event: "funEvent"}'
+        end
 
         event vendor: log_event[:vendor], event: log_event[:event]
       end

data/lib/appium_lib_core/common/touch_action/touch_actions.rb

@@ -195,7 +195,10 @@ module Appium
       end
 
       def args_with_ele_ref(args)
-        args[:element] = args[:element].ref if args.key? :element
+        if args.key? :element
+          _, element_id = args[:element].ref
+          args[:element] = element_id
+        end
         args
       end
     end # class TouchAction

data/lib/appium_lib_core/device.rb

@@ -79,11 +79,7 @@ module Appium
         end
 
         def create_bridge_command(method, &block)
-          ::Appium::Core::Base::Bridge::MJSONWP.class_eval do
-            undef_method method if method_defined? method
-            block_given? ? class_eval(&block) : define_method(method) { execute method }
-          end
-          ::Appium::Core::Base::Bridge::W3C.class_eval do
+          ::Appium::Core::Base::Bridge.class_eval do
             undef_method method if method_defined? method
             block_given? ? class_eval(&block) : define_method(method) { execute method }
           end