fusuma-plugin-remap 0.3.1 → 0.4.0

data/lib/fusuma/plugin/remap/{remapper.rb → keyboard_remapper.rb}

@@ -2,33 +2,31 @@ require "revdev"
 require "msgpack"
 require "set"
 require_relative "layer_manager"
-
-require_relative "ruinput_device_patched"
+require_relative "uinput_keyboard"
 
 module Fusuma
   module Plugin
     module Remap
-      class Remapper
+      class KeyboardRemapper
         include Revdev
+
+        VIRTUAL_KEYBOARD_NAME = "fusuma_virtual_keyboard"
+
         # @param layer_manager [Fusuma::Plugin::Remap::LayerManager]
-        # @param keyboard_writer [IO]
-        # @param source_keyboards [Array<Revdev::Device>]
-        # @param internal_touchpad [Revdev::Device]
-        def initialize(layer_manager:, keyboard_writer:, source_keyboards:, internal_touchpad:)
+        # @param fusuma_writer [IO]
+        # @param config [Hash]
+        def initialize(layer_manager:, fusuma_writer:, config: {})
           @layer_manager = layer_manager # request to change layer
-          @keyboard_writer = keyboard_writer # write event to original keyboard
-          @source_keyboards = source_keyboards # original keyboard
-          @internal_touchpad = internal_touchpad # internal touchpad
-          @uinput = RuinputDevicePatched.new "/dev/uinput"
-          @pressed_virtual_keys = Set.new
+          @fusuma_writer = fusuma_writer # write event to original keyboard
+          @config = config
         end
 
         def run
           create_virtual_keyboard
-          set_trap
-          grab_keyboards
+          @source_keyboards = reload_keyboards
 
           old_ie = nil
+          layer = nil
           next_mapping = nil
           current_mapping = {}
 
@@ -37,14 +35,12 @@ module Fusuma
             io = ios.first.first
 
             if io == @layer_manager.reader
-              begin
-                @layer_manager.receive_layer
-              rescue EOFError
-                @destroy.call
+              layer = @layer_manager.receive_layer # update @current_layer
+              if layer.nil?
+                next
               end
 
-              MultiLogger.debug "Remapper#run: layer changed to #{@layer_manager.current_layer}"
-              next_mapping = @layer_manager.find_mapping
+              next_mapping = @layer_manager.find_mapping(layer)
               next
             end
 
@@ -59,21 +55,18 @@ module Fusuma
             input_key = find_key_from_code(input_event.code)
 
             if input_event.type == EV_KEY
-              # FIXME: exit when RIGHTCTRL-LEFTCTRL is pressed
-              if (old_ie&.code == KEY_RIGHTCTRL && old_ie.value != 0) && (input_event.code == KEY_LEFTCTRL && input_event.value != 0)
-                @destroy.call
-              end
+              @emergency_stop.call(old_ie, input_event)
 
               old_ie = input_event
               if input_event.value != 2 # repeat
-                packed = {key: input_key, status: input_event.value}.to_msgpack
-                @keyboard_writer.puts(packed)
+                data = {key: input_key, status: input_event.value, layer: layer}
+                @fusuma_writer.write(data.to_msgpack)
               end
             end
 
             remapped = current_mapping.fetch(input_key.to_sym, nil)
             if remapped.nil?
-              @uinput.write_input_event(input_event)
+              uinput_keyboard.write_input_event(input_event)
               next
             end
 
@@ -91,12 +84,42 @@ module Fusuma
             # this is because the command will be executed by fusuma process
             next if remapped_event.code.nil?
 
-            @uinput.write_input_event(remapped_event)
+            uinput_keyboard.write_input_event(remapped_event)
+          rescue Errno::ENODEV => e # device is removed
+            MultiLogger.error "Device is removed: #{e.message}"
+            @source_keyboards = reload_keyboards
           end
+        rescue EOFError => e # device is closed
+          MultiLogger.error "Device is closed: #{e.message}"
+        ensure
+          @destroy.call
         end
 
         private
 
+        def reload_keyboards
+          source_keyboards = KeyboardSelector.new(@config[:keyboard_name_patterns]).select
+
+          MultiLogger.info("Reload keyboards: #{source_keyboards.map(&:device_name)}")
+
+          set_trap(source_keyboards)
+          # TODO: Extract to a configuration file or make it optional
+          #       it should stop other remappers
+          set_emergency_ungrab_keybinds("RIGHTCTRL", "LEFTCTRL")
+          grab_keyboards(source_keyboards)
+        rescue => e
+          MultiLogger.error "Failed to reload keyboards: #{e.message}"
+          MultiLogger.error e.backtrace.join("\n")
+        end
+
+        def uinput_keyboard
+          @uinput_keyboard ||= UinputKeyboard.new("/dev/uinput")
+        end
+
+        def pressed_virtual_keys
+          @pressed_virtual_keys ||= Set.new
+        end
+
         # record virtual keyboard event
         # @param [String] remapped_value remapped key name
         # @param [Integer] event_value event value
@@ -105,9 +128,9 @@ module Fusuma
         def record_virtual_keyboard_event?(remapped_value, event_value)
           case event_value
           when 0
-            @pressed_virtual_keys.delete?(remapped_value)
+            pressed_virtual_keys.delete?(remapped_value)
           when 1
-            @pressed_virtual_keys.add?(remapped_value)
+            pressed_virtual_keys.add?(remapped_value)
             true # Always return true because the remapped key may be the same
           else
             # 2 is repeat
@@ -116,26 +139,38 @@ module Fusuma
         end
 
         def virtual_keyboard_all_key_released?
-          @pressed_virtual_keys.empty?
+          pressed_virtual_keys.empty?
         end
 
         def create_virtual_keyboard
-          @uinput.create "fusuma_virtual_keyboard",
+          touchpad_name_patterns = @config[:touchpad_name_patterns]
+          internal_touchpad = TouchpadSelector.new(touchpad_name_patterns).select.first
+
+          if internal_touchpad.nil?
+            MultiLogger.error("No touchpad found: #{touchpad_name_patterns}")
+            exit
+          end
+
+          MultiLogger.info "Create virtual keyboard: #{VIRTUAL_KEYBOARD_NAME}"
+
+          uinput_keyboard.create VIRTUAL_KEYBOARD_NAME,
             Revdev::InputId.new(
-              # recognized as an internal keyboard on libinput,
-              # touchpad is disabled when typing
-              # see: (https://wayland.freedesktop.org/libinput/doc/latest/palm-detection.html#disable-while-typing)
+              # disable while typing is enabled when
+              # - Both the keyboard and touchpad are BUS_I8042
+              # - The touchpad and keyboard have the same vendor/product
+              # ref: (https://wayland.freedesktop.org/libinput/doc/latest/palm-detection.html#disable-while-typing)
+              #
               {
                 bustype: Revdev::BUS_I8042,
-                vendor: @internal_touchpad.device_id.vendor,
-                product: @internal_touchpad.device_id.product,
-                version: @internal_touchpad.device_id.version
+                vendor: internal_touchpad.device_id.vendor,
+                product: internal_touchpad.device_id.product,
+                version: internal_touchpad.device_id.version
               }
             )
         end
 
-        def grab_keyboards
-          @source_keyboards.each do |keyboard|
+        def grab_keyboards(keyboards)
+          keyboards.each do |keyboard|
             wait_release_all_keys(keyboard)
             begin
               keyboard.grab
@@ -146,16 +181,18 @@ module Fusuma
           end
         end
 
-        def set_trap
+        # @param [Array<Revdev::EventDevice>] keyboards
+        def set_trap(keyboards)
           @destroy = lambda do
-            @source_keyboards.each do |kbd|
+            keyboards.each do |kbd|
               kbd.ungrab
             rescue Errno::EINVAL
+            rescue Errno::ENODEV
               # already ungrabbed
             end
 
             begin
-              @uinput.destroy
+              uinput_keyboard.destroy
             rescue IOError
               # already destroyed
             end
@@ -167,6 +204,20 @@ module Fusuma
           Signal.trap(:TERM) { @destroy.call }
         end
 
+        # Emergency stop keybind for virtual keyboard
+        def set_emergency_ungrab_keybinds(first_key, second_key)
+          first_keycode = find_code_from_key(first_key)
+          second_keycode = find_code_from_key(second_key)
+          MultiLogger.info "Emergency ungrab keybind: #{first_key} + #{second_key}"
+
+          @emergency_stop = lambda do |prev, current|
+            if (prev&.code == first_keycode && prev.value != 0) && (current.code == second_keycode && current.value != 0)
+              MultiLogger.info "Emergency ungrab keybind: #{first_key} + #{second_key}"
+              @destroy.call
+            end
+          end
+        end
+
         # Find remappable key from mapping and return remapped key code
         # If not found, return original key code
         # If the key is found but its value is not valid, return nil
@@ -240,6 +291,52 @@ module Fusuma
             end
           end
         end
+
+        # Devices to detect key presses and releases
+        class KeyboardSelector
+          def initialize(names = ["keyboard", "Keyboard", "KEYBOARD"])
+            @names = names
+          end
+
+          # Select devices that match the name
+          # If no device is found, it will wait for 3 seconds and try again
+          # @return [Array<Revdev::EventDevice>]
+          def select
+            loop do
+              Fusuma::Device.reset # reset cache to get the latest device information
+              devices = Fusuma::Device.all.select { |d| Array(@names).any? { |name| d.name =~ /#{name}/ } }
+              if devices.empty?
+                wait_for_device
+
+                next
+              end
+
+              return devices.map { |d| Revdev::EventDevice.new("/dev/input/#{d.id}") }
+            end
+          end
+
+          def wait_for_device
+            sleep 3
+          end
+        end
+
+        class TouchpadSelector
+          def initialize(names = nil)
+            @names = names
+          end
+
+          # @return [Array<Revdev::EventDevice>]
+          def select
+            devices = if @names
+              Fusuma::Device.all.select { |d| Array(@names).any? { |name| d.name =~ /#{name}/ } }
+            else
+              # available returns only touchpad devices
+              Fusuma::Device.available
+            end
+
+            devices.map { |d| Revdev::EventDevice.new("/dev/input/#{d.id}") }
+          end
+        end
       end
     end
   end

data/lib/fusuma/plugin/remap/layer_manager.rb

@@ -8,28 +8,33 @@ module Fusuma
       class LayerManager
         require "singleton"
         include Singleton
-        attr_reader :reader, :writer, :current_layer
+        attr_reader :reader, :writer, :current_layer, :layers
 
         def initialize
           @layers = {}
           @reader, @writer = IO.pipe
           @current_layer = {} # preserve order
+          @last_layer = nil
+          @last_remove = nil
         end
 
         # @param [Hash] layer
         # @param [Boolean] remove
         def send_layer(layer:, remove: false)
-          # puts "send_layer: #{layer} remove: #{remove}"
-          return if @last_layer == layer && @last_remove == remove
+          return if (@last_layer == layer) && (@last_remove == remove)
 
           @last_layer = layer
           @last_remove = remove
-          @writer.puts({layer: layer, remove: remove}.to_msgpack)
+          @writer.write({layer: layer, remove: remove}.to_msgpack)
         end
 
-        # Read layer from pipe and return remap layer
+        # Read layer from pipe and update @current_layer
+        # @return [Hash] current layer
         # @example
-        # @return [Hash]
+        #  receive_layer
+        #  # => { thumbsense: true }
+        #  receive_layer
+        #  # => { thumbsense: true, application: "Google-chrome" }
         def receive_layer
           @layer_unpacker ||= MessagePack::Unpacker.new(@reader)
 
@@ -41,28 +46,28 @@ module Fusuma
           layer = data[:layer] # e.g { thumbsense: true }
           remove = data[:remove] # e.g true
 
+          # update @current_layer
           if remove
             @current_layer.delete_if { |k, _v| layer.key?(k) }
           else
             # If duplicate keys exist, order of keys is preserved
             @current_layer.merge!(layer)
           end
+          @current_layer
         end
 
         # Find remap layer from config
         # @param [Hash] layer
-        # @return [Hash]
-        def find_mapping(layer = @current_layer)
+        # @return [Hash] remap layer
+        def find_mapping(layer)
           @layers[layer] ||= begin
             result = nil
-            _ = Fusuma::Config::Searcher.find_context(layer) {
+            _ = Fusuma::Config::Searcher.find_context(layer) do
               result = Fusuma::Config.search(Fusuma::Config::Index.new(:remap))
               next unless result
 
-              result = result.deep_transform_keys do |key|
-                key.upcase.to_sym
-              end
-            }
+              result = result.deep_transform_keys { |key| key.upcase.to_sym }
+            end
 
             result || {}
           end

data/lib/fusuma/plugin/remap/touchpad_remapper.rb

@@ -0,0 +1,168 @@
+require "revdev"
+require "msgpack"
+require "set"
+
+require_relative "uinput_touchpad"
+
+module Fusuma
+  module Plugin
+    module Remap
+      class TouchpadRemapper
+        include Revdev
+
+        VIRTUAL_TOUCHPAD_NAME = "fusuma_virtual_touchpad"
+
+        # @param fusuma_writer [IO]
+        # @param source_touchpad [Revdev::Device]
+        def initialize(fusuma_writer:, source_touchpad:)
+          @source_touchpad = source_touchpad # original touchpad
+          @fusuma_writer = fusuma_writer # write event to fusuma_input
+          @palm_detector ||= PalmDetection.new(source_touchpad)
+        end
+
+        # TODO: grab touchpad events and remap them
+        #       send remapped events to virtual touchpad or virtual mouse
+        def run
+          create_virtual_touchpad
+
+          touch_state = {}
+          mt_slot = 0
+          finger_state = nil
+          loop do
+            IO.select([@source_touchpad.file]) # , @layer_manager.reader])
+
+            ## example of input_event
+            # Event: time 1698456258.380027, type 3 (EV_ABS), code 57 (ABS_MT_TRACKING_ID), value 43679
+            # Event: time 1698456258.380027, type 3 (EV_ABS), code 53 (ABS_MT_POSITION_X), value 648
+            # Event: time 1698456258.380027, type 3 (EV_ABS), code 54 (ABS_MT_POSITION_Y), value 209
+            # Event: time 1698456258.380027, type 1 (EV_KEY), code 330 (BTN_TOUCH), value 1
+            # Event: time 1698456258.380027, type 1 (EV_KEY), code 325 (BTN_TOOL_FINGER), value 1
+            # Event: time 1698456258.380027, type 3 (EV_ABS), code 0 (ABS_X), value 648
+            # Event: time 1698456258.380027, type 3 (EV_ABS), code 1 (ABS_Y), value 209
+            # Event: time 1698456258.380027, type 4 (EV_MSC), code 5 (MSC_TIMESTAMP), value 0
+            # Event: time 1698456258.380027, -------------- SYN_REPORT ------------
+            # Event: time 1698456258.382693, type 3 (EV_ABS), code 47 (ABS_MT_SLOT), value 1
+            # Event: time 1698456258.382693, type 3 (EV_ABS), code 57 (ABS_MT_TRACKING_ID), value 43680
+            # Event: time 1698456258.382693, type 3 (EV_ABS), code 53 (ABS_MT_POSITION_X), value 400
+            # Event: time 1698456258.382693, type 3 (EV_ABS), code 54 (ABS_MT_POSITION_Y), value 252
+            # Event: time 1698456258.382693, type 1 (EV_KEY), code 325 (BTN_TOOL_FINGER), value 0
+            # Event: time 1698456258.382693, type 1 (EV_KEY), code 333 (BTN_TOOL_DOUBLETAP), value 1
+            # Event: time 1698456258.382693, type 4 (EV_MSC), code 5 (MSC_TIMESTAMP), value 7100
+            # Event: time 1698456258.382693, -------------- SYN_REPORT ------------
+            input_event = @source_touchpad.read_input_event
+
+            touch_state[mt_slot] ||= {MT_TRACKING_ID: nil, X: nil, Y: nil, valid_touch_point: false}
+            syn_report = nil
+
+            case input_event.type
+            when Revdev::EV_ABS
+              case input_event.code
+              when Revdev::ABS_MT_SLOT
+                mt_slot = input_event.value
+                touch_state[mt_slot] ||= {}
+              when Revdev::ABS_MT_TRACKING_ID
+                touch_state[mt_slot][:MT_TRACKING_ID] = input_event.value
+                if input_event.value == -1
+                  touch_state[mt_slot] = {}
+                end
+              when Revdev::ABS_MT_POSITION_X
+                touch_state[mt_slot][:X] = input_event.value
+              when Revdev::ABS_MT_POSITION_Y
+                touch_state[mt_slot][:Y] = input_event.value
+              when Revdev::ABS_X, Revdev::ABS_Y
+                # ignore
+              when Revdev::ABS_MT_PRESSURE
+                # ignore
+              when Revdev::ABS_MT_TOOL_TYPE
+                # ignore
+              else
+                raise "unhandled event"
+              end
+            when Revdev::EV_KEY
+              case input_event.code
+              when Revdev::BTN_TOUCH
+                # ignore
+              when Revdev::BTN_TOOL_FINGER
+                finger_state = (input_event.value == 1) ? 1 : 0
+              when Revdev::BTN_TOOL_DOUBLETAP
+                finger_state = (input_event.value == 1) ? 2 : 1
+              when Revdev::BTN_TOOL_TRIPLETAP
+                finger_state = (input_event.value == 1) ? 3 : 2
+              when Revdev::BTN_TOOL_QUADTAP
+                finger_state = (input_event.value == 1) ? 4 : 3
+              when 0x148 # define BTN_TOOL_QUINTTAP	0x148	/* Five fingers on trackpad */
+                finger_state = (input_event.value == 1) ? 5 : 4
+              end
+            when Revdev::EV_MSC
+              case input_event.code
+              when 0x05 # define MSC_TIMESTAMP		0x05
+                # ignore
+                # current_timestamp = input_event.value
+              end
+            when Revdev::EV_SYN
+              case input_event.code
+              when Revdev::SYN_REPORT
+                syn_report = input_event.value
+              when Revdev::SYN_DROPPED
+                MultiLogger.error "Dropped: #{input_event.value}"
+              else
+                raise "unhandled event", "#{input_event.hr_type}, #{input_event.hr_code}, #{input_event.value}"
+              end
+            else
+              raise "unhandled event", "#{input_event.hr_type}, #{input_event.hr_code}, #{input_event.value}"
+            end
+
+            # TODO:
+            # Remember the most recent valid touch position and exclude it if it is close to that position
+            # For example, when dragging, it is possible to touch around the edge of the touchpad again after reaching the edge of the touchpad, so in that case, you do not want to execute palm detection
+            if touch_state[mt_slot][:valid_touch_point] != true
+              touch_state[mt_slot][:valid_touch_point] = @palm_detector.palm?(touch_state[mt_slot])
+            end
+
+            if syn_report
+              # TODO: define format as fusuma_input
+              data = {finger: finger_state, touch_state: touch_state}
+              @fusuma_writer.write(data.to_msgpack)
+            end
+          end
+        end
+
+        private
+
+        def uinput
+          @uinput ||= UinputTouchpad.new "/dev/uinput"
+        end
+
+        def create_virtual_touchpad
+          MultiLogger.info "Create virtual keyboard: #{VIRTUAL_TOUCHPAD_NAME}"
+
+          uinput.create_from_device(name: VIRTUAL_TOUCHPAD_NAME, device: @source_touchpad)
+        end
+
+        # Detect palm touch
+        class PalmDetection
+          def initialize(touchpad)
+            @max_x = touchpad.absinfo_for_axis(Revdev::ABS_MT_POSITION_X)[:absmax]
+            @max_y = touchpad.absinfo_for_axis(Revdev::ABS_MT_POSITION_Y)[:absmax]
+          end
+
+          def palm?(touch_state)
+            return false unless touch_state[:X] && touch_state[:Y]
+
+            if 0.8 * @max_y < touch_state[:Y]
+              true
+            else
+              !(
+                # Disable 20% of the touch area on the left, right
+                (touch_state[:X] < 0.2 * @max_x || touch_state[:X] > 0.8 * @max_x) ||
+                # Disable 10% of the touch area on the top edge
+                (touch_state[:Y] < 0.1 * @max_y && (touch_state[:X] < 0.2 * @max_x || touch_state[:X] > 0.8 * @max_x)
+                )
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fusuma/plugin/remap/uinput_keyboard.rb

@@ -0,0 +1,95 @@
+require "ruinput"
+
+class UinputKeyboard < Ruinput::UinputDevice
+  include Ruinput
+
+  # create virtual event divece
+  # _name_ :: device name
+  # _id_ :: InputId ("struct input_id" on input.h)
+  def create name = DEFAULT_DEVICE_NAME, id = DEFAULT_INPUT_ID
+    if !name.is_a? String
+      raise ArgumentError, "1st arg expect String"
+    elsif !id.is_a? Revdev::InputId
+      raise ArgumentError, "2nd arg expect Revdev::InputId"
+    end
+
+    uud = Ruinput::UinputUserDev.new({
+      name: name,
+      id: id,
+      ff_effects_max: 0,
+      absmax: [],
+      absmin: [],
+      absfuzz: [],
+      absflat: []
+    })
+
+    @file.syswrite uud.to_byte_string
+
+    set_all_events
+
+    @file.ioctl UI_DEV_CREATE, nil
+    @is_created = true
+  end
+
+  def set_all_events
+    raise "invalid method call: this uinput is already created" if @is_created
+
+    mouse_btns = [
+      Revdev::BTN_0,
+      Revdev::BTN_MISC,
+      Revdev::BTN_1,
+      Revdev::BTN_2,
+      Revdev::BTN_3,
+      Revdev::BTN_4,
+      Revdev::BTN_5,
+      Revdev::BTN_6,
+      Revdev::BTN_7,
+      Revdev::BTN_8,
+      Revdev::BTN_9,
+      Revdev::BTN_LEFT,
+      Revdev::BTN_MOUSE,
+      Revdev::BTN_MIDDLE,
+      Revdev::BTN_RIGHT,
+      Revdev::BTN_SIDE,
+      Revdev::BTN_EXTRA,
+      Revdev::BTN_FORWARD,
+      Revdev::BTN_BACK,
+      Revdev::BTN_TASK
+      # Revdev::BTN_TRIGGER, # libinput recognized as joystick if set
+    ].freeze
+
+    keyboard_keys = Revdev.constants.select { |c| c.start_with? "KEY_" }.map { |c| Revdev.const_get(c) }.freeze
+
+    @file.ioctl UI_SET_EVBIT, Revdev::EV_KEY
+    @counter = 0
+    Revdev::KEY_CNT.times do |i|
+      # https://github.com/mooz/xkeysnail/pull/101/files
+      if keyboard_keys.include?(i) || mouse_btns.include?(i)
+        # puts "setting #{i} (#{Revdev::REVERSE_MAPS[:KEY][i]})"
+        @file.ioctl UI_SET_KEYBIT, i
+      end
+    end
+
+    # @file.ioctl UI_SET_EVBIT, Revdev::EV_MSC
+    # Revdev::MSC_CNT.times do |i|
+    #   @file.ioctl UI_SET_MSCBIT, i
+    # end
+
+    mouse_rel = [
+      Revdev::REL_X,
+      Revdev::REL_Y,
+      Revdev::REL_WHEEL,
+      Revdev::REL_HWHEEL
+    ].freeze
+
+    @file.ioctl UI_SET_EVBIT, Revdev::EV_REL
+    Revdev::REL_CNT.times do |i|
+      if mouse_rel.include?(i)
+        # puts "setting #{i} (#{Revdev::REVERSE_MAPS[:REL][i]})"
+        @file.ioctl UI_SET_RELBIT, i
+      end
+    end
+
+    @file.ioctl UI_SET_EVBIT, Revdev::EV_REP
+  end
+end