ruflet_core 0.0.12 → 0.0.13

data/lib/ruflet_ui/ruflet/ui/services/ruflet/audio_recorder_control.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Ruflet
+  module UI
+    module Services
+      module RufletServicesComponents
+        class AudioRecorderControl < Ruflet::Control
+          TYPE = "audiorecorder".freeze
+          WIRE = "AudioRecorder".freeze
+
+          def initialize(id: nil, configuration: nil, data: nil, key: nil, on_state_change: nil, on_stream: nil, on_upload: nil)
+            props = {}
+            props[:configuration] = configuration unless configuration.nil?
+            props[:data] = data unless data.nil?
+            props[:key] = key unless key.nil?
+            props[:on_state_change] = on_state_change unless on_state_change.nil?
+            props[:on_stream] = on_stream unless on_stream.nil?
+            props[:on_upload] = on_upload unless on_upload.nil?
+            super(type: TYPE, id: id, **props)
+          end
+
+          %w[
+            cancel_recording
+            get_input_devices
+            has_permission
+            is_paused
+            is_recording
+            pause_recording
+            resume_recording
+            stop_recording
+          ].each do |method_name|
+            define_method(method_name) do |timeout: 10, on_result: nil|
+              invoke_audio_recorder(method_name, timeout: timeout, on_result: on_result)
+            end
+          end
+
+          def is_supported_encoder(encoder, timeout: 10, on_result: nil)
+            invoke_audio_recorder(
+              "is_supported_encoder",
+              args: { "encoder" => normalize_service_value(encoder) },
+              timeout: timeout,
+              on_result: on_result
+            )
+          end
+
+          def start_recording(output_path: nil, configuration: nil, upload: nil, timeout: 10, on_result: nil)
+            invoke_audio_recorder(
+              "start_recording",
+              args: compact_args(
+                "output_path" => output_path,
+                "configuration" => configuration,
+                "upload" => upload
+              ),
+              timeout: timeout,
+              on_result: on_result
+            )
+          end
+
+          private
+
+          def invoke_audio_recorder(method_name, args: nil, timeout:, on_result:)
+            runtime_page&.invoke(self, method_name, args: args, timeout: timeout, on_result: on_result)
+          end
+
+          def compact_args(hash)
+            hash.each_with_object({}) do |(key, value), result|
+              result[key] = normalize_service_value(value) unless value.nil?
+            end
+          end
+
+          def normalize_service_value(value)
+            case value
+            when Array
+              value.map { |item| normalize_service_value(item) }
+            when Hash
+              value.transform_keys(&:to_s).each_with_object({}) do |(key, item), result|
+                result[key] = normalize_service_value(item) unless item.nil?
+              end
+            else
+              value.respond_to?(:to_h) ? normalize_service_value(value.to_h) : value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruflet_ui/ruflet/ui/services/ruflet/geolocator_control.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Ruflet
+  module UI
+    module Services
+      module RufletServicesComponents
+        class GeolocatorControl < Ruflet::Control
+          TYPE = "geolocator".freeze
+          WIRE = "Geolocator".freeze
+
+          def initialize(id: nil, configuration: nil, data: nil, key: nil, on_error: nil, on_position_change: nil)
+            props = {}
+            props[:configuration] = configuration unless configuration.nil?
+            props[:data] = data unless data.nil?
+            props[:key] = key unless key.nil?
+            props[:on_error] = on_error unless on_error.nil?
+            props[:on_position_change] = on_position_change unless on_position_change.nil?
+            super(type: TYPE, id: id, **props)
+          end
+
+          %w[
+            get_last_known_position
+            get_permission_status
+            is_location_service_enabled
+            open_app_settings
+            open_location_settings
+            request_permission
+          ].each do |method_name|
+            define_method(method_name) do |timeout: 10, on_result: nil|
+              invoke_geolocator(method_name, timeout: timeout, on_result: on_result)
+            end
+          end
+
+          def distance_between(start_latitude, start_longitude, end_latitude, end_longitude, timeout: 10, on_result: nil)
+            invoke_geolocator(
+              "distance_between",
+              args: {
+                "start_latitude" => start_latitude,
+                "start_longitude" => start_longitude,
+                "end_latitude" => end_latitude,
+                "end_longitude" => end_longitude
+              },
+              timeout: timeout,
+              on_result: on_result
+            )
+          end
+
+          def get_current_position(configuration: nil, timeout: 10, on_result: nil)
+            invoke_geolocator(
+              "get_current_position",
+              args: compact_args("configuration" => configuration),
+              timeout: timeout,
+              on_result: on_result
+            )
+          end
+
+          private
+
+          def invoke_geolocator(method_name, args: nil, timeout:, on_result:)
+            runtime_page&.invoke(self, method_name, args: args, timeout: timeout, on_result: on_result)
+          end
+
+          def compact_args(hash)
+            hash.each_with_object({}) do |(key, value), result|
+              result[key] = normalize_service_value(value) unless value.nil?
+            end
+          end
+
+          def normalize_service_value(value)
+            case value
+            when Array
+              value.map { |item| normalize_service_value(item) }
+            when Hash
+              value.transform_keys(&:to_s).each_with_object({}) do |(key, item), result|
+                result[key] = normalize_service_value(item) unless item.nil?
+              end
+            else
+              value.respond_to?(:to_h) ? normalize_service_value(value.to_h) : value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruflet_ui/ruflet/ui/services/ruflet/permissionhandler_control.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Ruflet
+  module UI
+    module Services
+      module RufletServicesComponents
+        class PermissionHandlerControl < Ruflet::Control
+          TYPE = "permissionhandler".freeze
+          WIRE = "PermissionHandler".freeze
+
+          def initialize(id: nil, data: nil, key: nil)
+            props = {}
+            props[:data] = data unless data.nil?
+            props[:key] = key unless key.nil?
+            super(type: TYPE, id: id, **props)
+          end
+
+          def get_status(permission, timeout: 10, on_result: nil)
+            invoke_permission_handler(
+              "get_status",
+              args: { "permission" => normalize_service_value(permission) },
+              timeout: timeout,
+              on_result: on_result
+            )
+          end
+
+          def request(permission, timeout: 10, on_result: nil)
+            invoke_permission_handler(
+              "request",
+              args: { "permission" => normalize_service_value(permission) },
+              timeout: timeout,
+              on_result: on_result
+            )
+          end
+
+          def open_app_settings(timeout: 10, on_result: nil)
+            invoke_permission_handler("open_app_settings", timeout: timeout, on_result: on_result)
+          end
+
+          private
+
+          def invoke_permission_handler(method_name, args: nil, timeout:, on_result:)
+            runtime_page&.invoke(self, method_name, args: args, timeout: timeout, on_result: on_result)
+          end
+
+          def normalize_service_value(value)
+            value.respond_to?(:to_h) ? value.to_h.transform_keys(&:to_s) : value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruflet_ui/ruflet/ui/services/ruflet/securestorage_control.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Ruflet
+  module UI
+    module Services
+      module RufletServicesComponents
+        class SecureStorageControl < Ruflet::Control
+          TYPE = "securestorage".freeze
+          WIRE = "SecureStorage".freeze
+          OPTION_KEYS = %w[web ios macos android windows].freeze
+
+          def initialize(id: nil, android_options: nil, data: nil, ios_options: nil, key: nil, macos_options: nil, web_options: nil, windows_options: nil, on_change: nil)
+            props = {}
+            props[:android_options] = android_options unless android_options.nil?
+            props[:data] = data unless data.nil?
+            props[:ios_options] = ios_options unless ios_options.nil?
+            props[:key] = key unless key.nil?
+            props[:macos_options] = macos_options unless macos_options.nil?
+            props[:web_options] = web_options unless web_options.nil?
+            props[:windows_options] = windows_options unless windows_options.nil?
+            props[:on_change] = on_change unless on_change.nil?
+            super(type: TYPE, id: id, **props)
+          end
+
+          def set(key, value, **options)
+            invoke_secure_storage("set", args: option_args(options).merge("key" => key, "value" => value), **invoke_options(options))
+          end
+
+          def get(key, **options)
+            invoke_secure_storage("get", args: option_args(options).merge("key" => key), **invoke_options(options))
+          end
+
+          def contains_key(key, **options)
+            invoke_secure_storage("contains_key", args: option_args(options).merge("key" => key), **invoke_options(options))
+          end
+
+          def get_all(**options)
+            invoke_secure_storage("get_all", args: option_args(options), **invoke_options(options))
+          end
+
+          def remove(key, **options)
+            invoke_secure_storage("remove", args: option_args(options).merge("key" => key), **invoke_options(options))
+          end
+
+          def clear(**options)
+            invoke_secure_storage("clear", args: option_args(options), **invoke_options(options))
+          end
+
+          def get_availability(timeout: 10, on_result: nil)
+            invoke_secure_storage("get_availability", timeout: timeout, on_result: on_result)
+          end
+
+          private
+
+          def invoke_secure_storage(method_name, args: nil, timeout:, on_result:)
+            runtime_page&.invoke(self, method_name, args: args, timeout: timeout, on_result: on_result)
+          end
+
+          def invoke_options(options)
+            {
+              timeout: options.fetch(:timeout, 10),
+              on_result: options[:on_result]
+            }
+          end
+
+          def option_args(options)
+            OPTION_KEYS.each_with_object({}) do |key, result|
+              value = options[key.to_sym] || options[key]
+              result[key] = normalize_service_value(value) unless value.nil?
+            end
+          end
+
+          def normalize_service_value(value)
+            case value
+            when Array
+              value.map { |item| normalize_service_value(item) }
+            when Hash
+              value.transform_keys(&:to_s).each_with_object({}) do |(key, item), result|
+                result[key] = normalize_service_value(item) unless item.nil?
+              end
+            else
+              value.respond_to?(:to_h) ? normalize_service_value(value.to_h) : value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruflet_ui/ruflet/ui/services/ruflet/semanticsservice_control.rb

@@ -14,6 +14,34 @@ module Ruflet
             props[:key] = key unless key.nil?
             super(type: TYPE, id: id, **props)
           end
+
+          def announce_message(message, rtl: false, assertiveness: "polite", timeout: 10, on_result: nil)
+            runtime_page&.invoke(
+              self,
+              "announce_message",
+              args: {
+                "message" => message,
+                "rtl" => rtl,
+                "assertiveness" => assertiveness
+              },
+              timeout: timeout,
+              on_result: on_result
+            )
+          end
+
+          def announce_tooltip(message, timeout: 10, on_result: nil)
+            runtime_page&.invoke(
+              self,
+              "announce_tooltip",
+              args: { "message" => message },
+              timeout: timeout,
+              on_result: on_result
+            )
+          end
+
+          def get_accessibility_features(timeout: 10, on_result: nil)
+            runtime_page&.invoke(self, "get_accessibility_features", timeout: timeout, on_result: on_result)
+          end
         end
       end
     end

data/lib/ruflet_ui/ruflet/ui/services/ruflet/tester_control.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Ruflet
+  module UI
+    module Services
+      module RufletServicesComponents
+        class TesterControl < Ruflet::Control
+          TYPE = "tester".freeze
+          WIRE = "Tester".freeze
+
+          def initialize(id: nil, data: nil, key: nil)
+            props = {}
+            props[:data] = data unless data.nil?
+            props[:key] = key unless key.nil?
+            super(type: TYPE, id: id, **props)
+          end
+
+          def pump(duration: nil, timeout: 10, on_result: nil)
+            invoke_tester("pump", args: compact_args("duration" => duration), timeout: timeout, on_result: on_result)
+          end
+
+          def pump_and_settle(duration: nil, timeout: 10, on_result: nil)
+            invoke_tester("pump_and_settle", args: compact_args("duration" => duration), timeout: timeout, on_result: on_result)
+          end
+
+          def find_by_text(text, timeout: 10, on_result: nil)
+            invoke_tester("find_by_text", args: { "text" => text }, timeout: timeout, on_result: on_result)
+          end
+
+          def find_by_text_containing(pattern, timeout: 10, on_result: nil)
+            invoke_tester("find_by_text_containing", args: { "pattern" => pattern }, timeout: timeout, on_result: on_result)
+          end
+
+          def find_by_key(key, timeout: 10, on_result: nil)
+            invoke_tester("find_by_key", args: { "key" => key }, timeout: timeout, on_result: on_result)
+          end
+
+          def find_by_tooltip(value, timeout: 10, on_result: nil)
+            invoke_tester("find_by_tooltip", args: { "value" => value }, timeout: timeout, on_result: on_result)
+          end
+
+          def find_by_icon(icon, timeout: 10, on_result: nil)
+            invoke_tester("find_by_icon", args: { "icon" => normalize_service_value(icon) }, timeout: timeout, on_result: on_result)
+          end
+
+          def take_screenshot(name, timeout: 10, on_result: nil)
+            invoke_tester("take_screenshot", args: { "name" => name }, timeout: timeout, on_result: on_result)
+          end
+
+          %w[tap mouse_click mouse_double_click right_mouse_click long_press mouse_hover].each do |method_name|
+            define_method(method_name) do |finder_id = nil, finder_index: nil, timeout: 10, on_result: nil|
+              invoke_tester(
+                method_name,
+                args: compact_args("finder_id" => finder_id, "finder_index" => finder_index),
+                timeout: timeout,
+                on_result: on_result
+              )
+            end
+          end
+
+          %w[tap_at mouse_click_at mouse_double_click_at right_mouse_click_at].each do |method_name|
+            define_method(method_name) do |offset = nil, timeout: 10, on_result: nil|
+              invoke_tester(method_name, args: compact_args("offset" => offset), timeout: timeout, on_result: on_result)
+            end
+          end
+
+          def drag(finder_id, offset, finder_index: nil, timeout: 10, on_result: nil)
+            invoke_tester(
+              "drag",
+              args: compact_args("finder_id" => finder_id, "finder_index" => finder_index, "offset" => offset),
+              timeout: timeout,
+              on_result: on_result
+            )
+          end
+
+          def drag_from(start, offset, timeout: 10, on_result: nil)
+            invoke_tester(
+              "drag_from",
+              args: compact_args("start" => start, "offset" => offset),
+              timeout: timeout,
+              on_result: on_result
+            )
+          end
+
+          def enter_text(finder_id, text, finder_index: nil, timeout: 10, on_result: nil)
+            invoke_tester(
+              "enter_text",
+              args: compact_args("finder_id" => finder_id, "finder_index" => finder_index, "text" => text),
+              timeout: timeout,
+              on_result: on_result
+            )
+          end
+
+          def teardown(timeout: 10, on_result: nil)
+            invoke_tester("teardown", timeout: timeout, on_result: on_result)
+          end
+
+          private
+
+          def invoke_tester(method_name, args: nil, timeout:, on_result:)
+            runtime_page&.invoke(self, method_name, args: args, timeout: timeout, on_result: on_result)
+          end
+
+          def compact_args(hash)
+            hash.each_with_object({}) do |(key, value), result|
+              result[key] = normalize_service_value(value) unless value.nil?
+            end
+          end
+
+          def normalize_service_value(value)
+            case value
+            when Array
+              value.map { |item| normalize_service_value(item) }
+            when Hash
+              value.transform_keys(&:to_s).each_with_object({}) do |(key, item), result|
+                result[key] = normalize_service_value(item) unless item.nil?
+              end
+            else
+              value.respond_to?(:to_h) ? normalize_service_value(value.to_h) : value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruflet_ui/ruflet/ui/services/ruflet_services.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "ruflet/accelerometer_control"
+require_relative "ruflet/audio_recorder_control"
 require_relative "ruflet/barometer_control"
 require_relative "ruflet/battery_control"
 require_relative "ruflet/camera_control"
@@ -8,16 +9,20 @@ require_relative "ruflet/clipboard_control"
 require_relative "ruflet/connectivity_control"
 require_relative "ruflet/filepicker_control"
 require_relative "ruflet/flashlight_control"
+require_relative "ruflet/geolocator_control"
 require_relative "ruflet/gyroscope_control"
 require_relative "ruflet/hapticfeedback_control"
 require_relative "ruflet/magnetometer_control"
+require_relative "ruflet/permissionhandler_control"
 require_relative "ruflet/screenbrightness_control"
 require_relative "ruflet/screenshot_control"
+require_relative "ruflet/securestorage_control"
 require_relative "ruflet/semanticsservice_control"
 require_relative "ruflet/shakedetector_control"
 require_relative "ruflet/share_control"
 require_relative "ruflet/sharedpreferences_control"
 require_relative "ruflet/storagepaths_control"
+require_relative "ruflet/tester_control"
 require_relative "ruflet/urllauncher_control"
 require_relative "ruflet/useraccelerometer_control"
 require_relative "ruflet/wakelock_control"
@@ -30,21 +35,30 @@ module Ruflet
 
         CLASS_MAP = {
           "accelerometer" => RufletServicesComponents::AccelerometerControl,
+          "audio_recorder" => RufletServicesComponents::AudioRecorderControl,
+          "audiorecorder" => RufletServicesComponents::AudioRecorderControl,
           "barometer" => RufletServicesComponents::BarometerControl,
           "battery" => RufletServicesComponents::BatteryControl,
+          "browser_context_menu" => Ruflet::UI::Controls::RufletComponents::BrowserContextMenuControl,
+          "browsercontextmenu" => Ruflet::UI::Controls::RufletComponents::BrowserContextMenuControl,
           "camera" => RufletServicesComponents::CameraControl,
           "clipboard" => RufletServicesComponents::ClipboardControl,
           "connectivity" => RufletServicesComponents::ConnectivityControl,
           "file_picker" => RufletServicesComponents::FilePickerControl,
           "filepicker" => RufletServicesComponents::FilePickerControl,
           "flashlight" => RufletServicesComponents::FlashlightControl,
+          "geolocator" => RufletServicesComponents::GeolocatorControl,
           "gyroscope" => RufletServicesComponents::GyroscopeControl,
           "haptic_feedback" => RufletServicesComponents::HapticFeedbackControl,
           "hapticfeedback" => RufletServicesComponents::HapticFeedbackControl,
           "magnetometer" => RufletServicesComponents::MagnetometerControl,
+          "permission_handler" => RufletServicesComponents::PermissionHandlerControl,
+          "permissionhandler" => RufletServicesComponents::PermissionHandlerControl,
           "screen_brightness" => RufletServicesComponents::ScreenBrightnessControl,
           "screenbrightness" => RufletServicesComponents::ScreenBrightnessControl,
           "screenshot" => RufletServicesComponents::ScreenshotControl,
+          "secure_storage" => RufletServicesComponents::SecureStorageControl,
+          "securestorage" => RufletServicesComponents::SecureStorageControl,
           "semantics_service" => RufletServicesComponents::SemanticsServiceControl,
           "semanticsservice" => RufletServicesComponents::SemanticsServiceControl,
           "shake_detector" => RufletServicesComponents::ShakeDetectorControl,
@@ -54,11 +68,13 @@ module Ruflet
           "sharedpreferences" => RufletServicesComponents::SharedPreferencesControl,
           "storage_paths" => RufletServicesComponents::StoragePathsControl,
           "storagepaths" => RufletServicesComponents::StoragePathsControl,
+          "tester" => RufletServicesComponents::TesterControl,
           "url_launcher" => RufletServicesComponents::UrlLauncherControl,
           "urllauncher" => RufletServicesComponents::UrlLauncherControl,
           "user_accelerometer" => RufletServicesComponents::UserAccelerometerControl,
           "useraccelerometer" => RufletServicesComponents::UserAccelerometerControl,
           "wakelock" => RufletServicesComponents::WakelockControl,
+          "window" => Ruflet::UI::Controls::RufletComponents::WindowControl,
         }.freeze
       end
     end