ruflet_core 0.0.12 → 0.0.14

data/lib/ruflet_ui/ruflet/page.rb

@@ -14,7 +14,132 @@ require "timeout"
 
 module Ruflet
   class Page
-    PAGE_PROP_KEYS = %w[route title vertical_alignment horizontal_alignment scroll].freeze
+    class SharedPreferencesService
+      def initialize(page)
+        @page = page
+      end
+
+      def set(key, value, timeout: 10, on_result: nil)
+        invoke("set", { "key" => key, "value" => value }, timeout: timeout, on_result: on_result)
+      end
+
+      def get(key, timeout: 10, on_result: nil)
+        invoke("get", { "key" => key }, timeout: timeout, on_result: on_result)
+      end
+
+      def contains_key(key, timeout: 10, on_result: nil)
+        invoke("contains_key", { "key" => key }, timeout: timeout, on_result: on_result)
+      end
+
+      def get_keys(key_prefix, timeout: 10, on_result: nil)
+        invoke("get_keys", { "key_prefix" => key_prefix }, timeout: timeout, on_result: on_result)
+      end
+
+      def remove(key, timeout: 10, on_result: nil)
+        invoke("remove", { "key" => key }, timeout: timeout, on_result: on_result)
+      end
+
+      def clear(timeout: 10, on_result: nil)
+        invoke("clear", nil, timeout: timeout, on_result: on_result)
+      end
+
+      private
+
+      def invoke(method_name, args, timeout:, on_result:)
+        @page.__send__(:invoke_shared_preferences, method_name, args: args, timeout: timeout, on_result: on_result)
+      end
+    end
+
+    class WakelockService
+      def initialize(page)
+        @page = page
+      end
+
+      def enable(timeout: 10, on_result: nil)
+        invoke("enable", timeout: timeout, on_result: on_result)
+      end
+
+      def disable(timeout: 10, on_result: nil)
+        invoke("disable", timeout: timeout, on_result: on_result)
+      end
+
+      def is_enabled(timeout: 10, on_result: nil)
+        invoke("is_enabled", timeout: timeout, on_result: on_result)
+      end
+
+      private
+
+      def invoke(method_name, timeout:, on_result:)
+        @page.__send__(:invoke_wakelock, method_name, timeout: timeout, on_result: on_result)
+      end
+    end
+
+    class FlashlightService
+      def initialize(page)
+        @page = page
+      end
+
+      def on(timeout: 10, on_result: nil)
+        invoke("on", timeout: timeout, on_result: on_result)
+      end
+
+      def off(timeout: 10, on_result: nil)
+        invoke("off", timeout: timeout, on_result: on_result)
+      end
+
+      def is_available(timeout: 10, on_result: nil)
+        invoke("is_available", timeout: timeout, on_result: on_result)
+      end
+
+      private
+
+      def invoke(method_name, timeout:, on_result:)
+        @page.__send__(:invoke_flashlight, method_name, timeout: timeout, on_result: on_result)
+      end
+    end
+
+    class ScreenBrightnessService
+      def initialize(page)
+        @page = page
+      end
+
+      %w[
+        can_change_system_screen_brightness
+        get_application_screen_brightness
+        get_system_screen_brightness
+        is_animate
+        is_auto_reset
+        reset_application_screen_brightness
+      ].each do |method_name|
+        define_method(method_name) do |timeout: 10, on_result: nil|
+          invoke(method_name, nil, timeout: timeout, on_result: on_result)
+        end
+      end
+
+      def set_animate(animate, timeout: 10, on_result: nil)
+        invoke("set_animate", { "value" => animate }, timeout: timeout, on_result: on_result)
+      end
+
+      def set_auto_reset(auto_reset, timeout: 10, on_result: nil)
+        invoke("set_auto_reset", { "value" => auto_reset }, timeout: timeout, on_result: on_result)
+      end
+
+      def set_application_screen_brightness(brightness, timeout: 10, on_result: nil)
+        invoke("set_application_screen_brightness", { "value" => brightness }, timeout: timeout, on_result: on_result)
+      end
+
+      def set_system_screen_brightness(brightness, timeout: 10, on_result: nil)
+        invoke("set_system_screen_brightness", { "value" => brightness }, timeout: timeout, on_result: on_result)
+      end
+
+      private
+
+      def invoke(method_name, args, timeout:, on_result:)
+        @page.__send__(:invoke_screen_brightness, method_name, args: args, timeout: timeout, on_result: on_result)
+      end
+    end
+
+    PAGE_PROP_KEYS = %w[dark_theme fonts route rtl show_semantics_debugger theme theme_mode title vertical_alignment horizontal_alignment scroll].freeze
     DIALOG_PROP_KEYS = %w[dialog snack_bar bottom_sheet].freeze
     WIDGET_HELPER_METHODS = (
       Ruflet::UI::MaterialControlMethods.instance_methods(false) +
@@ -35,6 +160,10 @@ module Ruflet
       @root_controls = []
       @views = []
       @dialogs = []
+      @overlay_container_mounted = false
+      @dialogs_container_mounted = false
+      @services_container_mounted = false
+      @visual_service_controls = {}
       @page_event_handlers = {}
       @view_props = {}
       @page_props = { "route" => (client_details["route"] || "/") }
@@ -57,6 +186,10 @@ module Ruflet
       @invoke_waiters = {}
       @invoke_callbacks = {}
       @invoke_waiters_mutex = Mutex.new
+      @shared_preferences_proxy = SharedPreferencesService.new(self)
+      @wakelock_proxy = WakelockService.new(self)
+      @flashlight_proxy = FlashlightService.new(self)
+      @screen_brightness_proxy = ScreenBrightnessService.new(self)
       refresh_overlay_container!
       refresh_services_container!
       refresh_dialogs_container!
@@ -111,15 +244,16 @@ module Ruflet
       @view_props["bgcolor"] = normalize_value("bgcolor", value)
     end
 
-    def add(*controls, appbar: nil, floating_action_button: nil, navigation_bar: nil, dialog: nil, snack_bar: nil, bottom_sheet: nil)
+    def add(*controls, appbar: nil, bottom_appbar: nil, floating_action_button: nil, navigation_bar: nil, dialog: nil, snack_bar: nil, bottom_sheet: nil)
       controls = controls.flatten
       visited = Set.new
       controls.each { |c| register_control_tree(c, visited) }
       @root_controls = controls
 
-      @view_props["appbar"] = appbar if appbar
-      @view_props["floating_action_button"] = floating_action_button if floating_action_button
-      @view_props["navigation_bar"] = navigation_bar if navigation_bar
+      update_view_slot("appbar", appbar)
+      update_view_slot("bottom_appbar", bottom_appbar)
+      update_view_slot("floating_action_button", floating_action_button)
+      update_view_slot("navigation_bar", navigation_bar)
       @dialog = dialog if dialog
       @snack_bar = snack_bar if snack_bar
       @bottom_sheet = bottom_sheet if bottom_sheet
@@ -148,6 +282,50 @@ module Ruflet
       self
     end
 
+    def shared_preferences(**props)
+      return service(:shared_preferences, **props) unless props.empty?
+
+      @shared_preferences_proxy
+    end
+
+    def wakelock(**props)
+      return service(:wakelock, **props) unless props.empty?
+
+      @wakelock_proxy
+    end
+
+    def flashlight(**props)
+      return service(:flashlight, **props) unless props.empty?
+
+      @flashlight_proxy
+    end
+
+    def screen_brightness(**props)
+      return service(:screen_brightness, **props) unless props.empty?
+
+      @screen_brightness_proxy
+    end
+
+    def audio(**props)
+      service(:audio, **props)
+    end
+
+    def audio_recorder(**props)
+      service(:audio_recorder, **props)
+    end
+
+    def browser_context_menu(**props)
+      service(:browser_context_menu, **props)
+    end
+
+    def window(**props)
+      service(:window, **props)
+    end
+
+    def tester(**props)
+      service(:tester, **props)
+    end
+
     def add_service(*value)
       @services_container.props["_services"] = services + value.flatten.compact
       refresh_services_container!
@@ -180,12 +358,25 @@ module Ruflet
       mapped_props = normalize_props(props || {})
       id = mapped_props.delete("id")
       normalized_type = type.to_s.downcase
+      compact_type = normalized_type.delete("_")
+
+      if visual_service_type?(normalized_type)
+        key = id ? "id:#{id}" : normalized_type
+        existing = @visual_service_controls[key]
+        return existing if existing
+
+        svc = Ruflet::UI::ControlFactory.build(type.to_s, id: id&.to_s, **mapped_props)
+        @visual_service_controls[key] = svc
+        return svc
+      end
 
       existing =
         if id
           services.find { |s| s.is_a?(Control) && s.id.to_s == id.to_s }
         else
-          services.find { |s| s.is_a?(Control) && s.type.to_s.downcase == normalized_type }
+          services.find do |s|
+            s.is_a?(Control) && s.type.to_s.downcase.delete("_") == compact_type
+          end
         end
       return existing if existing
 
@@ -201,6 +392,18 @@ module Ruflet
       self
     end
 
+    def navigate(route, **query_params)
+      go(route, **query_params)
+    end
+
+    def push_route(route, **query_params)
+      go(route, **query_params)
+    end
+
+    def query
+      parse_query(route)
+    end
+
     def on_route_change=(handler)
       @page_event_handlers["route_change"] = handler
     end
@@ -224,20 +427,70 @@ module Ruflet
       @view_props["appbar"] = value
     end
 
+    def bottom_appbar=(value)
+      @view_props["bottom_appbar"] = value
+    end
+
+    def bottomappbar=(value)
+      self.bottom_appbar = value
+    end
+
     def floating_action_button=(value)
       @view_props["floating_action_button"] = value
     end
 
+    def drawer
+      @view_props["drawer"]
+    end
+
+    def drawer=(value)
+      @view_props["drawer"] = value
+    end
+
+    def end_drawer
+      @view_props["end_drawer"]
+    end
+
+    def end_drawer=(value)
+      @view_props["end_drawer"] = value
+    end
+
+    def show_drawer(timeout: 10, on_result: nil)
+      raise ArgumentError, "show_drawer requires drawer" unless drawer
+
+      invoke_current_view("show_drawer", timeout: timeout, on_result: on_result)
+      self
+    end
+
+    def close_drawer(timeout: 10, on_result: nil)
+      invoke_current_view("close_drawer", timeout: timeout, on_result: on_result)
+      self
+    end
+
+    def show_end_drawer(timeout: 10, on_result: nil)
+      raise ArgumentError, "show_end_drawer requires end_drawer" unless end_drawer
+
+      invoke_current_view("show_end_drawer", timeout: timeout, on_result: on_result)
+      self
+    end
+
+    def close_end_drawer(timeout: 10, on_result: nil)
+      invoke_current_view("close_end_drawer", timeout: timeout, on_result: on_result)
+      self
+    end
+
     def dialog = @dialog
 
     def dialog=(value)
       @dialog = value
       refresh_dialogs_container!
+      push_dialogs_update! if @dialogs_container_mounted
     end
 
     def snack_bar=(value)
       @snack_bar = value
       refresh_dialogs_container!
+      push_dialogs_update! if @dialogs_container_mounted
     end
 
     def snackbar=(value)
@@ -259,6 +512,7 @@ module Ruflet
       return self if dialog_open?(dialog_control)
 
       dialog_control.props["open"] = true
+      remove_existing_singleton_dialogs(dialog_control)
       @dialogs << dialog_control unless @dialogs.include?(dialog_control)
       refresh_dialogs_container!
       send_view_patch unless @dialogs_container.wire_id
@@ -328,6 +582,30 @@ module Ruflet
       invoke(url_launcher, "can_launch_url", args: { "url" => url }, timeout: timeout)
     end
 
+    def close_in_app_web_view(timeout: 10, on_result: nil)
+      url_launcher = ensure_url_launcher_service
+      invoke(url_launcher, "close_in_app_web_view", timeout: timeout, on_result: on_result)
+    end
+
+    def open_window(url, title: nil, width: nil, height: nil, timeout: 10, on_result: nil)
+      url_launcher = ensure_url_launcher_service
+      args = { "url" => url }
+      args["title"] = title unless title.nil?
+      args["width"] = width unless width.nil?
+      args["height"] = height unless height.nil?
+      invoke(url_launcher, "open_window", args: args, timeout: timeout, on_result: on_result)
+    end
+
+    def supports_launch_mode(mode, timeout: 10, on_result: nil)
+      url_launcher = ensure_url_launcher_service
+      invoke(url_launcher, "supports_launch_mode", args: { "mode" => mode }, timeout: timeout, on_result: on_result)
+    end
+
+    def supports_close_for_launch_mode(mode, timeout: 10, on_result: nil)
+      url_launcher = ensure_url_launcher_service
+      invoke(url_launcher, "supports_close_for_launch_mode", args: { "mode" => mode }, timeout: timeout, on_result: on_result)
+    end
+
     # File picker helpers: create an ephemeral service, invoke method, and dispose it.
     def pick_files(
       dialog_title: nil,
@@ -341,14 +619,14 @@ module Ruflet
     )
       invoke_file_picker(
         "pick_files",
-        {
+        compact_service_args(
           "dialog_title" => dialog_title,
           "initial_directory" => initial_directory,
           "file_type" => file_type,
           "allowed_extensions" => allowed_extensions,
           "allow_multiple" => allow_multiple,
           "with_data" => with_data
-        },
+        ),
         timeout: timeout,
         on_result: on_result
       )
@@ -366,14 +644,14 @@ module Ruflet
     )
       invoke_file_picker(
         "save_file",
-        {
+        compact_service_args(
           "dialog_title" => dialog_title,
           "file_name" => file_name,
           "initial_directory" => initial_directory,
           "file_type" => file_type,
           "allowed_extensions" => allowed_extensions,
           "src_bytes" => src_bytes
-        },
+        ),
         timeout: timeout,
         on_result: on_result
       )
@@ -382,18 +660,212 @@ module Ruflet
     def get_directory_path(dialog_title: nil, initial_directory: nil, timeout: nil, on_result: nil)
       invoke_file_picker(
         "get_directory_path",
-        {
+        compact_service_args(
           "dialog_title" => dialog_title,
           "initial_directory" => initial_directory
-        },
+        ),
+        timeout: timeout,
+        on_result: on_result
+      )
+    end
+
+    def upload(files, timeout: nil, on_result: nil)
+      invoke_file_picker(
+        "upload",
+        { "files" => Array(files).map { |file| normalize_service_value(file) } },
         timeout: timeout,
         on_result: on_result
       )
     end
 
+    def upload_files(files, timeout: nil, on_result: nil)
+      upload(files, timeout: timeout, on_result: on_result)
+    end
+
+    def disable_browser_context_menu(timeout: 10, on_result: nil)
+      invoke_browser_context_menu("disable_menu", timeout: timeout, on_result: on_result)
+    end
+
+    def enable_browser_context_menu(timeout: 10, on_result: nil)
+      invoke_browser_context_menu("enable_menu", timeout: timeout, on_result: on_result)
+    end
+
+    def wait_until_ready_to_show(timeout: 10, on_result: nil)
+      invoke_window("wait_until_ready_to_show", timeout: timeout, on_result: on_result)
+    end
+
+    def window_to_front(timeout: 10, on_result: nil)
+      invoke_window("to_front", timeout: timeout, on_result: on_result)
+    end
+
+    def center_window(timeout: 10, on_result: nil)
+      invoke_window("center", timeout: timeout, on_result: on_result)
+    end
+
+    def close_window(timeout: 10, on_result: nil)
+      invoke_window("close", timeout: timeout, on_result: on_result)
+    end
+
+    def destroy_window(timeout: 10, on_result: nil)
+      invoke_window("destroy", timeout: timeout, on_result: on_result)
+    end
+
+    def start_window_dragging(timeout: 10, on_result: nil)
+      invoke_window("start_dragging", timeout: timeout, on_result: on_result)
+    end
+
+    def start_window_resizing(edge, timeout: 10, on_result: nil)
+      invoke_window(
+        "start_resizing",
+        args: { "edge" => normalize_service_value(edge) },
+        timeout: timeout,
+        on_result: on_result
+      )
+    end
+
+    def tester_pump(options = nil, duration: nil, timeout: 10, on_result: nil)
+      duration = options[:duration] || options["duration"] if options.is_a?(Hash) && duration.nil?
+      invoke_tester("pump", args: compact_service_args("duration" => duration), timeout: timeout, on_result: on_result)
+    end
+
+    def tester_pump_and_settle(options = nil, duration: nil, timeout: 10, on_result: nil)
+      duration = options[:duration] || options["duration"] if options.is_a?(Hash) && duration.nil?
+      invoke_tester("pump_and_settle", args: compact_service_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
+
+    def tap(finder_id = nil, options = nil, finder_index: nil, timeout: 10, on_result: nil)
+      finder_index = options[:finder_index] || options["finder_index"] if options.is_a?(Hash) && finder_index.nil?
+      invoke_tester_finder("tap", finder_id, finder_index: finder_index, timeout: timeout, on_result: on_result)
+    end
+
+    def mouse_click(finder_id = nil, options = nil, finder_index: nil, timeout: 10, on_result: nil)
+      finder_index = options[:finder_index] || options["finder_index"] if options.is_a?(Hash) && finder_index.nil?
+      invoke_tester_finder("mouse_click", finder_id, finder_index: finder_index, timeout: timeout, on_result: on_result)
+    end
+
+    def mouse_double_click(finder_id = nil, options = nil, finder_index: nil, timeout: 10, on_result: nil)
+      finder_index = options[:finder_index] || options["finder_index"] if options.is_a?(Hash) && finder_index.nil?
+      invoke_tester_finder("mouse_double_click", finder_id, finder_index: finder_index, timeout: timeout, on_result: on_result)
+    end
+
+    def right_mouse_click(finder_id = nil, options = nil, finder_index: nil, timeout: 10, on_result: nil)
+      finder_index = options[:finder_index] || options["finder_index"] if options.is_a?(Hash) && finder_index.nil?
+      invoke_tester_finder("right_mouse_click", finder_id, finder_index: finder_index, timeout: timeout, on_result: on_result)
+    end
+
+    def tap_at(offset = nil, timeout: 10, on_result: nil)
+      invoke_tester_at("tap_at", offset, timeout: timeout, on_result: on_result)
+    end
+
+    def mouse_click_at(offset = nil, timeout: 10, on_result: nil)
+      invoke_tester_at("mouse_click_at", offset, timeout: timeout, on_result: on_result)
+    end
+
+    def mouse_double_click_at(offset = nil, timeout: 10, on_result: nil)
+      invoke_tester_at("mouse_double_click_at", offset, timeout: timeout, on_result: on_result)
+    end
+
+    def right_mouse_click_at(offset = nil, timeout: 10, on_result: nil)
+      invoke_tester_at("right_mouse_click_at", offset, timeout: timeout, on_result: on_result)
+    end
+
+    def drag(finder_id, offset, finder_index: nil, timeout: 10, on_result: nil)
+      invoke_tester(
+        "drag",
+        args: compact_service_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_service_args("start" => start, "offset" => offset),
+        timeout: timeout,
+        on_result: on_result
+      )
+    end
+
+    def long_press(finder_id = nil, options = nil, finder_index: nil, timeout: 10, on_result: nil)
+      finder_index = options[:finder_index] || options["finder_index"] if options.is_a?(Hash) && finder_index.nil?
+      invoke_tester_finder("long_press", finder_id, finder_index: finder_index, timeout: timeout, on_result: on_result)
+    end
+
+    def enter_text(finder_id, text, options = nil, finder_index: nil, timeout: 10, on_result: nil)
+      finder_index = options[:finder_index] || options["finder_index"] if options.is_a?(Hash) && finder_index.nil?
+      invoke_tester(
+        "enter_text",
+        args: compact_service_args(
+          "finder_id" => finder_id,
+          "finder_index" => finder_index,
+          "text" => text
+        ),
+        timeout: timeout,
+        on_result: on_result
+      )
+    end
+
+    def mouse_hover(finder_id = nil, options = nil, finder_index: nil, timeout: 10, on_result: nil)
+      finder_index = options[:finder_index] || options["finder_index"] if options.is_a?(Hash) && finder_index.nil?
+      invoke_tester_finder("mouse_hover", finder_id, finder_index: finder_index, timeout: timeout, on_result: on_result)
+    end
+
+    def tester_teardown(timeout: 10, on_result: nil)
+      invoke_tester("teardown", timeout: timeout, on_result: on_result)
+    end
+
+    def heavy_impact(timeout: 10, on_result: nil)
+      invoke_haptic_feedback("heavy_impact", timeout: timeout, on_result: on_result)
+    end
+
+    def medium_impact(timeout: 10, on_result: nil)
+      invoke_haptic_feedback("medium_impact", timeout: timeout, on_result: on_result)
+    end
+
+    def light_impact(timeout: 10, on_result: nil)
+      invoke_haptic_feedback("light_impact", timeout: timeout, on_result: on_result)
+    end
+
+    def selection_click(timeout: 10, on_result: nil)
+      invoke_haptic_feedback("selection_click", timeout: timeout, on_result: on_result)
+    end
+
+    def vibrate(timeout: 10, on_result: nil)
+      invoke_haptic_feedback("vibrate", timeout: timeout, on_result: on_result)
+    end
+
     def set_clipboard(value, timeout: nil, on_result: nil)
       invoke_clipboard_method(
-        "set_data",
+        "set",
         args: { "data" => value.to_s },
         timeout: timeout,
         on_result: on_result
@@ -401,7 +873,7 @@ module Ruflet
     end
 
     def get_clipboard(timeout: nil, on_result: nil)
-      invoke_clipboard_method("get_data", timeout: timeout, on_result: on_result)
+      invoke_clipboard_method("get", timeout: timeout, on_result: on_result)
     end
 
     def set_clipboard_files(files, timeout: nil, on_result: nil)
@@ -442,10 +914,94 @@ module Ruflet
       invoke_battery_method("get_battery_state", timeout: timeout, on_result: on_result)
     end
 
-    def battery_save_mode?(timeout: nil, on_result: nil)
+    def is_in_battery_save_mode(timeout: nil, on_result: nil)
       invoke_battery_method("is_in_battery_save_mode", timeout: timeout, on_result: on_result)
     end
 
+    def battery_save_mode?(timeout: nil, on_result: nil)
+      is_in_battery_save_mode(timeout: timeout, on_result: on_result)
+    end
+
+    def accelerometer(**props)
+      service(:accelerometer, **props)
+    end
+
+    def gyroscope(**props)
+      service(:gyroscope, **props)
+    end
+
+    def user_accelerometer(**props)
+      service(:user_accelerometer, **props)
+    end
+
+    def magnetometer(**props)
+      service(:magnetometer, **props)
+    end
+
+    def barometer(**props)
+      service(:barometer, **props)
+    end
+
+    def shake_detector(**props)
+      service(:shake_detector, **props)
+    end
+
+    def semantics_service(**props)
+      service(:semantics_service, **props)
+    end
+
+    def screenshot(**props)
+      service(:screenshot, **props)
+    end
+
+    def battery(**props)
+      service(:battery, **props)
+    end
+
+    def connectivity(**props)
+      service(:connectivity, **props)
+    end
+
+    def clipboard(**props)
+      service(:clipboard, **props)
+    end
+
+    def file_picker(**props)
+      service(:file_picker, **props)
+    end
+
+    def url_launcher(**props)
+      service(:url_launcher, **props)
+    end
+
+    def storage_paths(**props)
+      service(:storage_paths, **props)
+    end
+
+    def share(**props)
+      service(:share, **props)
+    end
+
+    def camera(**props)
+      service(:camera, **props)
+    end
+
+    def haptic_feedback(**props)
+      service(:haptic_feedback, **props)
+    end
+
+    def geolocator(**props)
+      service(:geolocator, **props)
+    end
+
+    def permission_handler(**props)
+      service(:permission_handler, **props)
+    end
+
+    def secure_storage(**props)
+      service(:secure_storage, **props)
+    end
+
     def get_application_cache_directory(timeout: nil, on_result: nil)
       invoke_storage_paths("get_application_cache_directory", timeout: timeout, on_result: on_result)
     end
@@ -487,7 +1043,7 @@ module Ruflet
     end
 
     def share_text(
-      text:,
+      text = nil,
       title: nil,
       subject: nil,
       preview_thumbnail: nil,
@@ -502,7 +1058,7 @@ module Ruflet
       invoke(
         share,
         "share_text",
-        args: {
+        args: compact_service_args(
           "text" => text,
           "title" => title,
           "subject" => subject,
@@ -511,14 +1067,14 @@ module Ruflet
           "download_fallback_enabled" => download_fallback_enabled,
           "mail_to_fallback_enabled" => mail_to_fallback_enabled,
           "excluded_cupertino_activities" => excluded_cupertino_activities
-        },
+        ),
         timeout: timeout,
         on_result: on_result
       )
     end
 
     def share_uri(
-      uri:,
+      uri = nil,
       share_position_origin: nil,
       excluded_cupertino_activities: nil,
       timeout: nil,
@@ -528,18 +1084,18 @@ module Ruflet
       invoke(
         share,
         "share_uri",
-        args: {
+        args: compact_service_args(
           "uri" => uri,
           "share_position_origin" => share_position_origin,
           "excluded_cupertino_activities" => excluded_cupertino_activities
-        },
+        ),
         timeout: timeout,
         on_result: on_result
       )
     end
 
     def share_files(
-      files:,
+      files = nil,
       text: nil,
       title: nil,
       subject: nil,
@@ -555,17 +1111,17 @@ module Ruflet
       invoke(
         share,
         "share_files",
-        args: {
-          "files" => files,
+        args: compact_service_args(
+          "files" => normalize_share_files(files),
           "text" => text,
           "title" => title,
           "subject" => subject,
-          "preview_thumbnail" => preview_thumbnail,
+          "preview_thumbnail" => normalize_share_file(preview_thumbnail),
           "share_position_origin" => share_position_origin,
           "download_fallback_enabled" => download_fallback_enabled,
           "mail_to_fallback_enabled" => mail_to_fallback_enabled,
           "excluded_cupertino_activities" => excluded_cupertino_activities
-        },
+        ),
         timeout: timeout,
         on_result: on_result
       )
@@ -594,11 +1150,22 @@ module Ruflet
       return nil unless dialog_control
 
       dialog_control.props["open"] = false
-      refresh_dialogs_container!
-      push_dialogs_update!
+      update(dialog_control, open: false)
       dialog_control
     end
 
+    def close_dialog(dialog_control)
+      return self unless dialog_control
+
+      before_dialog_count = @dialogs_container.props["controls"].length
+      dialog_control.props["open"] = false
+      @dialog = nil if @dialog.equal?(dialog_control)
+      remove_dialog_tracking(dialog_control)
+      refresh_dialogs_container!
+      push_dialogs_update!(force_view: @dialogs_container.props["controls"].length < before_dialog_count)
+      self
+    end
+
     def update(control_or_id = nil, **props)
       if control_or_id.nil? && props.empty?
         send_view_patch
@@ -634,6 +1201,7 @@ module Ruflet
 
       visited = Set.new
       patch.each_value { |value| register_embedded_value(value, visited) }
+      patch.each { |k, v| control.props[k] = v }
 
       patch_ops = patch.map { |k, v| [0, 0, k, serialize_patch_value(v)] }
 
@@ -656,8 +1224,6 @@ module Ruflet
       patch = normalize_props(props || {})
       patch.each { |k, v| control.props[k] = v }
 
-      remove_dialog_tracking(control) if patch.key?("open") && patch["open"] == false
-
       self
     end
 
@@ -675,11 +1241,13 @@ module Ruflet
       return unless control
 
       event = Event.new(name: name, target: target, raw_data: data, page: self, control: control)
-      control.emit(name, event)
-
-      if name.to_s == "dismiss" && remove_dialog_tracking(control)
-        push_dialogs_update!
+      apply_event_value_to_control(control, event) if %w[change select select_change].include?(name.to_s)
+      before_dialog_count = @dialogs_container.props["controls"].length
+      if dialog_close_event?(control, name) && remove_dialog_tracking(control)
+        push_dialogs_update!(force_view: @dialogs_container.props["controls"].length < before_dialog_count)
       end
+
+      control.emit(name, event)
     end
 
     def method_missing(name, *args, &block)
@@ -754,10 +1322,56 @@ module Ruflet
 
     def build_widget(type, **props, &block) = WidgetBuilder.new.control(type, **props, &block)
 
+    def compact_service_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|
+          next if item.nil?
+
+          result[key] = key == "data" && byte_array?(item) ? item.pack("C*").b : normalize_service_value(item)
+        end
+      else
+        value
+      end
+    end
+
+    def normalize_share_files(files)
+      return nil if files.nil?
+
+      Array(files).map { |file| normalize_share_file(file) }
+    end
+
+    def normalize_share_file(file)
+      case file
+      when nil
+        nil
+      when String
+        { "path" => file }
+      else
+        normalize_service_value(file)
+      end
+    end
+
+    def byte_array?(value)
+      value.is_a?(Array) && value.all? { |item| item.is_a?(Integer) && item.between?(0, 255) }
+    end
+
     def widget_helper_method?(name)
       WIDGET_HELPER_METHODS.include?(name.to_s)
     end
 
+    def visual_service_type?(type)
+      type.to_s.delete("_") == "camera"
+    end
+
     def text_maps_to_content?(control, patch)
       patch.key?("text") && control.type.end_with?("button")
     end
@@ -772,6 +1386,14 @@ module Ruflet
       @sender.call(action, payload)
     end
 
+    def update_view_slot(name, value)
+      if value.nil?
+        @view_props.delete(name)
+      else
+        @view_props[name] = value
+      end
+    end
+
     def send_view_patch
       refresh_control_indexes!
       view_patches = build_view_patches
@@ -781,10 +1403,13 @@ module Ruflet
         "id" => 1,
         "patch" => [
           [0],
-          [0, 0, "views", view_patches],
-          *page_patch_ops
+          *page_patch_ops,
+          [0, 0, "views", view_patches]
         ]
       })
+      @overlay_container_mounted = true if @overlay_container.wire_id
+      @dialogs_container_mounted = true if @dialogs_container.wire_id
+      @services_container_mounted = true if @services_container.wire_id
     end
 
     def register_control_tree(control, visited = Set.new)
@@ -895,6 +1520,15 @@ module Ruflet
       "#{base}#{separator}#{query}"
     end
 
+    def parse_query(route_value)
+      query_string = route_value.to_s.split("?", 2)[1].to_s
+      return {} if query_string.empty?
+
+      CGI.parse(query_string).each_with_object({}) do |(key, values), result|
+        result[key] = values.size == 1 ? values.first : values
+      end
+    end
+
     def extract_route(data)
       case data
       when String
@@ -910,10 +1544,46 @@ module Ruflet
       handler = @page_event_handlers[name.to_s.sub(/\Aon_/, "")]
       return unless handler.respond_to?(:call)
 
-      event = Event.new(name: name.to_s, target: 1, raw_data: data, page: self, control: nil)
+      event = Ruflet::Event.new(name: name.to_s, target: 1, raw_data: data, page: self, control: nil)
       handler.call(event)
     end
 
+    def apply_event_value_to_control(control, event)
+      return unless event.typed_data && event.typed_data.respond_to?(:value)
+
+      value = event.typed_data.value
+      if control.props.key?("start_value") && control.props.key?("end_value")
+        raw = event.typed_data.respond_to?(:raw) ? event.typed_data.raw : event.data
+        range_value = value.is_a?(Hash) ? value : raw
+        if range_value.is_a?(Hash)
+          start_value = range_value["start_value"] || range_value[:start_value]
+          end_value = range_value["end_value"] || range_value[:end_value]
+          control.props["start_value"] = start_value unless start_value.nil?
+          control.props["end_value"] = end_value unless end_value.nil?
+        end
+        return
+      end
+
+      return if value.nil?
+      return if control.type == "selectionarea"
+
+      prop_name =
+        if event.name == "select"
+          control.props.key?("value") ? "value" : "selected"
+        elsif event.name == "select_change" && control.props.key?("selected")
+          "selected"
+        elsif control.props.key?("expanded")
+          "expanded"
+        elsif control.props.key?("selected")
+          "selected"
+        elsif control.props.key?("selected_index")
+          "selected_index"
+        else
+          "value"
+        end
+      control.props[prop_name] = value
+    end
+
     def page_control_target?(control_or_id)
       control_or_id == 1 || control_or_id.to_s == "1" || control_or_id.to_s == "page"
     end
@@ -927,7 +1597,7 @@ module Ruflet
       when Array
         value.map { |v| serialize_patch_value(v) }
       when Hash
-        value.transform_values { |v| serialize_patch_value(v) }
+        value.each_with_object({}) { |(k, v), result| result[k.to_s] = serialize_patch_value(v) }
       else
         value
       end
@@ -938,7 +1608,7 @@ module Ruflet
     end
 
     def refresh_dialogs_container!
-      dialog_controls = (@dialogs + dialog_slots).uniq
+      dialog_controls = (dialog_slots + @dialogs).uniq
       @dialogs_container.props["controls"] = dialog_controls
       @page_props["_dialogs"] = @dialogs_container
     end
@@ -964,9 +1634,15 @@ module Ruflet
       end
     end
 
-    def push_dialogs_update!
+    def push_dialogs_update!(force_view: false)
       refresh_control_indexes!
 
+      if force_view || @dialogs_container.props["controls"].empty?
+        @dialogs_container_mounted = false
+        send_view_patch
+        return
+      end
+
       if @dialogs_container.wire_id
         send_message(Protocol::ACTIONS[:patch_control], {
           "id" => @dialogs_container.wire_id,
@@ -989,6 +1665,11 @@ module Ruflet
       @dialogs.include?(dialog_control) && dialog_control.props["open"] == true
     end
 
+    def dialog_close_event?(control, name)
+      name = name.to_s
+      name == "dismiss" || (%w[change select select_change].include?(name) && @dialogs.include?(control) && control.props["open"] == false)
+    end
+
     def remove_dialog_tracking(control)
       return false unless @dialogs.include?(control)
 
@@ -997,6 +1678,16 @@ module Ruflet
       true
     end
 
+    def remove_existing_singleton_dialogs(control)
+      return unless singleton_dialog_control?(control)
+
+      @dialogs.delete_if { |dialog| dialog != control && singleton_dialog_control?(dialog) }
+    end
+
+    def singleton_dialog_control?(control)
+      control.type.to_s.tr("_", "").downcase == "snackbar"
+    end
+
     def assign_split_prop(key, value)
       if key == "vertical_alignment" || key == "horizontal_alignment"
         @page_props[key] = value
@@ -1024,202 +1715,233 @@ module Ruflet
         # Keep internal containers stable after initial mount.
         # Re-sending them as full objects can replace Control instances with
         # same IDs and detach service invoke listeners on the Flutter side.
-        next nil if k == "_overlay" && @overlay_container.wire_id
-        next nil if k == "_dialogs" && @dialogs_container.wire_id
+        next nil if k == "_overlay" && @overlay_container_mounted
+        next nil if k == "_dialogs" && @dialogs_container_mounted
+        next nil if k == "_services" && @services_container_mounted
 
         [0, 0, k, serialize_patch_value(v)]
       end
     end
 
-    def ensure_clipboard_service
-      clipboard = services.find { |service| service.is_a?(Control) && service.type == "clipboard" }
-      return [clipboard, false] if clipboard
+    def service_by_type(type)
+      compact_type = type.to_s.downcase.delete("_")
+      services.find do |service|
+        service.is_a?(Control) && service.type.to_s.downcase.delete("_") == compact_type
+      end
+    end
 
-      clipboard = build_widget(:clipboard)
-      add_service(clipboard)
-      [clipboard, true]
+    def service_with_created(type)
+      existing = service_by_type(type)
+      return [existing, false] if existing
+
+      [service(type), true]
+    end
+
+    def ensure_clipboard_service
+      service_with_created(:clipboard)
     end
 
     def invoke_clipboard_method(method_name, args: nil, timeout:, on_result:)
-      clipboard, created = ensure_clipboard_service
-      send_view_patch if created
-      sleep(0.05) if created
+      clipboard, = ensure_clipboard_service
       invoke(
         clipboard,
         method_name,
         args: args,
         timeout: timeout,
-        on_result: lambda { |result, error|
-          message = error.to_s
-          if message.include?("inexistent control")
-            remove_service(clipboard)
-            fresh_clipboard, = ensure_clipboard_service
-            sleep(0.08)
-            invoke(
-              fresh_clipboard,
-              method_name,
-              args: args,
-              timeout: timeout,
-              on_result: on_result
-            )
-          else
-            on_result&.call(result, error)
-          end
-        }
+        on_result: on_result
       )
     rescue StandardError => e
       on_result&.call(nil, e.message)
     end
 
     def ensure_url_launcher_service
-      url_launcher = services.find { |service| service.is_a?(Control) && %w[urllauncher url_launcher].include?(service.type) }
-      return url_launcher if url_launcher
+      service(:url_launcher)
+    end
 
-      url_launcher = build_widget(:url_launcher)
-      add_service(url_launcher)
-      url_launcher
+    def ensure_browser_context_menu_service
+      service(:browser_context_menu)
     end
 
-    def ensure_connectivity_service
-      connectivity = services.find { |service| service.is_a?(Control) && service.type == "connectivity" }
-      return [connectivity, false] if connectivity
+    def invoke_browser_context_menu(method_name, timeout:, on_result:)
+      browser_context_menu = ensure_browser_context_menu_service
+      invoke(browser_context_menu, method_name, timeout: timeout, on_result: on_result)
+    end
+
+    def ensure_window_service
+      service(:window)
+    end
+
+    def invoke_window(method_name, args: nil, timeout:, on_result:)
+      window = ensure_window_service
+      invoke(window, method_name, args: args, timeout: timeout, on_result: on_result)
+    end
+
+    def ensure_tester_service
+      service(:tester)
+    end
+
+    def invoke_tester(method_name, args: nil, timeout:, on_result:)
+      tester = ensure_tester_service
+      invoke(tester, method_name, args: args, timeout: timeout, on_result: on_result)
+    end
 
-      connectivity = build_widget(:connectivity)
-      add_service(connectivity)
-      [connectivity, true]
+    def invoke_tester_finder(method_name, finder_id, finder_index:, timeout:, on_result:)
+      invoke_tester(
+        method_name,
+        args: compact_service_args("finder_id" => finder_id, "finder_index" => finder_index),
+        timeout: timeout,
+        on_result: on_result
+      )
+    end
+
+    def invoke_tester_at(method_name, offset, timeout:, on_result:)
+      invoke_tester(
+        method_name,
+        args: compact_service_args("offset" => offset),
+        timeout: timeout,
+        on_result: on_result
+      )
+    end
+
+    def ensure_haptic_feedback_service
+      service(:haptic_feedback)
+    end
+
+    def invoke_haptic_feedback(method_name, timeout:, on_result:)
+      haptic_feedback = ensure_haptic_feedback_service
+      invoke(haptic_feedback, method_name, timeout: timeout, on_result: on_result)
+    end
+
+    def invoke_current_view(method_name, timeout:, on_result:)
+      target_id = @views.last&.wire_id || @view_id
+      invoke_control_id(target_id, method_name, timeout: timeout, on_result: on_result)
+    end
+
+    def invoke_control_id(control_id, method_name, args: nil, timeout: 10, on_result: nil)
+      call_id = "call_#{Ruflet::Control.generate_id}"
+      if on_result.respond_to?(:call)
+        @invoke_waiters_mutex.synchronize { @invoke_callbacks[call_id] = on_result }
+        unless timeout.nil?
+          Thread.new(call_id, timeout.to_f) do |pending_call_id, invoke_timeout|
+            sleep([invoke_timeout, 0.0].max + 0.1)
+            callback = @invoke_waiters_mutex.synchronize { @invoke_callbacks.delete(pending_call_id) }
+            callback&.call(nil, "execution expired")
+          rescue StandardError => e
+            Kernel.warn("invoke timeout callback error: #{e.class}: #{e.message}")
+          end
+        end
+      end
+
+      payload = {
+        "control_id" => control_id,
+        "call_id" => call_id,
+        "name" => method_name.to_s,
+        "args" => args
+      }
+      payload["timeout"] = timeout unless timeout.nil?
+      send_message(Protocol::ACTIONS[:invoke_control_method], payload)
+
+      call_id
+    end
+
+    def ensure_connectivity_service
+      service_with_created(:connectivity)
     end
 
     def invoke_connectivity_method(method_name, timeout:, on_result:)
-      connectivity, created = ensure_connectivity_service
-      send_view_patch if created
-      sleep(0.05) if created
+      connectivity, = ensure_connectivity_service
       invoke(
         connectivity,
         method_name,
         timeout: timeout,
-        on_result: lambda { |result, error|
-          message = error.to_s
-          if message.include?("inexistent control")
-            remove_service(connectivity)
-            fresh_connectivity, = ensure_connectivity_service
-            sleep(0.08)
-            invoke(
-              fresh_connectivity,
-              method_name,
-              timeout: timeout,
-              on_result: on_result
-            )
-          else
-            on_result&.call(result, error)
-          end
-        }
+        on_result: on_result
       )
     rescue StandardError => e
       on_result&.call(nil, e.message)
     end
 
     def ensure_battery_service
-      battery = services.find { |service| service.is_a?(Control) && service.type == "battery" }
-      return [battery, false] if battery
-
-      battery = build_widget(:battery)
-      add_service(battery)
-      [battery, true]
+      service_with_created(:battery)
     end
 
     def ensure_share_service
-      share = services.find { |service| service.is_a?(Control) && service.type == "share" }
-      return share if share
+      service(:share)
+    end
+
+    def ensure_shared_preferences_service
+      service(:shared_preferences)
+    end
+
+    def invoke_shared_preferences(method_name, args: nil, timeout:, on_result:)
+      shared_preferences = ensure_shared_preferences_service
+      invoke(shared_preferences, method_name, args: args, timeout: timeout, on_result: on_result)
+    end
+
+    def ensure_wakelock_service
+      service(:wakelock)
+    end
+
+    def invoke_wakelock(method_name, timeout:, on_result:)
+      wakelock = ensure_wakelock_service
+      invoke(wakelock, method_name, timeout: timeout, on_result: on_result)
+    end
+
+    def ensure_flashlight_service
+      service(:flashlight)
+    end
 
-      share = build_widget(:share)
-      add_service(share)
-      share
+    def invoke_flashlight(method_name, timeout:, on_result:)
+      flashlight = ensure_flashlight_service
+      invoke(flashlight, method_name, timeout: timeout, on_result: on_result)
+    end
+
+    def ensure_screen_brightness_service
+      service(:screen_brightness)
+    end
+
+    def invoke_screen_brightness(method_name, args: nil, timeout:, on_result:)
+      screen_brightness = ensure_screen_brightness_service
+      invoke(screen_brightness, method_name, args: args, timeout: timeout, on_result: on_result)
     end
 
     def invoke_battery_method(method_name, timeout:, on_result:)
-      battery, created = ensure_battery_service
-      send_view_patch if created
-      sleep(0.05) if created
+      battery, = ensure_battery_service
       invoke(
         battery,
         method_name,
         timeout: timeout,
-        on_result: lambda { |result, error|
-          message = error.to_s
-          if message.include?("inexistent control")
-            remove_service(battery)
-            fresh_battery, = ensure_battery_service
-            sleep(0.08)
-            invoke(
-              fresh_battery,
-              method_name,
-              timeout: timeout,
-              on_result: on_result
-            )
-          else
-            on_result&.call(result, error)
-          end
-        }
+        on_result: on_result
       )
     rescue StandardError => e
       on_result&.call(nil, e.message)
     end
 
     def ensure_storage_paths_service
-      storage_paths = services.find do |service|
-        service.is_a?(Control) && %w[storage_paths storagepaths].include?(service.type.to_s)
-      end
-      return [storage_paths, false] if storage_paths
-
-      storage_paths = build_widget(:storage_paths)
-      add_service(storage_paths)
-      [storage_paths, true]
+      service_with_created(:storage_paths)
     end
 
     def invoke_storage_paths(method_name, timeout:, on_result:)
-      storage_paths, created = ensure_storage_paths_service
-      send_view_patch if created
-      sleep(0.05) if created
+      storage_paths, = ensure_storage_paths_service
       invoke(
         storage_paths,
         method_name,
         timeout: timeout,
-        on_result: lambda { |result, error|
-          message = error.to_s
-          if message.include?("inexistent control")
-            remove_service(storage_paths)
-            fresh_storage_paths, = ensure_storage_paths_service
-            sleep(0.08)
-            invoke(
-              fresh_storage_paths,
-              method_name,
-              timeout: timeout,
-              on_result: on_result
-            )
-          else
-            on_result&.call(result, error)
-          end
-        }
+        on_result: on_result
       )
     rescue StandardError => e
       on_result&.call(nil, e.message)
     end
 
     def invoke_file_picker(method_name, args, timeout:, on_result:)
-      picker = build_widget(:file_picker)
-      add_service(picker)
+      picker = service(:file_picker)
       invoke(
         picker,
         method_name,
         args: args,
         timeout: timeout,
-        on_result: lambda { |result, error|
-          remove_service(picker)
-          on_result&.call(result, error)
-        }
+        on_result: on_result
       )
     rescue StandardError => e
-      remove_service(picker) if picker
       on_result&.call(nil, e.message)
     end
   end