fusuma-plugin-remap 0.10.0 → 0.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 13ff7a06cbeae8f56ebc57ffbc347fe6adf2d7dba7b9fab4977047be9786aebc
-  data.tar.gz: 80a99b69509058b34c58fcea076be99b881a008193bbfb7065134c2d4f75291b
+  metadata.gz: c1a6f601df78486fb3bf89f9c7902fe9fd46e45c33e2807eff9f0c4b5a38ec45
+  data.tar.gz: 50ca1d1da716e62d9ed9cc3973b201f9b8c93b00b5e313559bc5d7d4a73bfd3d
 SHA512:
-  metadata.gz: ed14e66220bb7a483c666f777f2a17cbdd2d0be0ca8b0659f28ca2259d310ac7601f3280f2601ffc4fb809e87d7b37875c352e8cf01d92587e23123fe79f0be6
-  data.tar.gz: 97faa8067e4a49ba9821298a2347d2e3b6ce18a0137f2af1a718ea1a2d5e543a0bb089e081b6544d9375977f498079547d9f657c089730753cf58874a587c808
+  metadata.gz: 881a29098c368a60f0d4469d77b1ffc118d0c9eb2df02d2b7c492ba356f30ab0ad740a73bfa96e229a1fd16d46a7a839139c7b4077e26fb30b092d0c142ca28c
+  data.tar.gz: 50dd4b8c9554ee17e338a5ded7248d1b4f9215d03ca5d19d5e2c8d97731687b42b1edb2105d7ebf7539ac2718bb3d3085db4c800db26cad54426be93fe854643

data/lib/fusuma/plugin/inputs/remap_touchpad_input.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative "../remap/touchpad_remapper"
-# require_relative "../remap/layer_manager"
 
 module Fusuma
   module Plugin
@@ -35,22 +34,7 @@ module Fusuma
 
           gesture = "touch"
           finger = data["finger"]
-
-          # @touch_state ||= {}
-          # @mt_slot ||= 0
-          # @touch_state[@mt_slot] ||= {
-          #   MT_TRACKING_ID: nil,
-          #   X: nil,
-          #   Y: nil,
-          #   valid_touch_point: false
-          # }
-          # TODO: implement update touch_state
-          status =
-            if data["touch_state"].any? { |_, v| v["valid_touch_point"] }
-              "begin"
-            else
-              "end"
-            end
+          status = data["status"]
 
           Events::Records::GestureRecord.new(gesture: gesture, status: status, finger: finger, delta: nil)
         rescue EOFError => e

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

@@ -13,6 +13,14 @@ module Fusuma
 
         VIRTUAL_KEYBOARD_NAME = "fusuma_virtual_keyboard"
 
+        # Key conversion tables for better performance and readability
+        KEYMAP = Revdev.constants.select { |c| c.start_with?("KEY_", "BTN_") }
+          .map { |c| [Revdev.const_get(c), c.to_s.delete_prefix("KEY_")] }
+          .to_h.freeze
+        CODEMAP = Revdev.constants.select { |c| c.start_with?("KEY_", "BTN_") }
+          .map { |c| [c, Revdev.const_get(c)] }
+          .to_h.freeze
+
         # @param layer_manager [Fusuma::Plugin::Remap::LayerManager]
         # @param fusuma_writer [IO]
         # @param config [Hash]
@@ -53,7 +61,7 @@ module Fusuma
             end
 
             input_event = @source_keyboards.find { |kbd| kbd.file == io }.read_input_event
-            input_key = find_key_from_code(input_event.code)
+            input_key = code_to_key(input_event.code)
 
             if input_event.type == EV_KEY
               @emergency_stop.call(old_ie, input_event)
@@ -61,7 +69,13 @@ module Fusuma
               old_ie = input_event
               if input_event.value != 2 # repeat
                 data = {key: input_key, status: input_event.value, layer: layer}
-                @fusuma_writer.write(data.to_msgpack)
+                begin
+                  @fusuma_writer.write(data.to_msgpack)
+                rescue IOError => e
+                  MultiLogger.error("Failed to write to fusuma_writer: #{e.message}")
+                  @destroy&.call(1)
+                  return
+                end
               end
             end
 
@@ -71,7 +85,14 @@ module Fusuma
               next
             end
 
-            remapped_event = InputEvent.new(nil, input_event.type, find_code_from_key(remapped), input_event.value)
+            remapped_code = key_to_code(remapped)
+            if remapped_code.nil?
+              MultiLogger.warn("Invalid remapped key: #{remapped}, skipping...")
+              uinput_keyboard.write_input_event(input_event)
+              next
+            end
+
+            remapped_event = InputEvent.new(nil, input_event.type, remapped_code, input_event.value)
 
             # Workaround to solve the problem that the remapped key remains pressed
             # when the key pressed before remapping is released after remapping
@@ -203,28 +224,30 @@ module Fusuma
           Signal.trap(:TERM) { @destroy.call(1) }
         end
 
+        DEFAULT_EMERGENCY_KEYBIND = "RIGHTCTRL+LEFTCTRL".freeze
+
         # Emergency stop keybind for virtual keyboard
         def set_emergency_ungrab_keys(keybind_string)
           keybinds = keybind_string&.split("+")
           # TODO: Extract to a configuration file or make it optional
           #       it should stop other remappers
           if keybinds&.size != 2
-            MultiLogger.error "Invalid emergency ungrab keybinds: #{keybinds}"
-            MultiLogger.error "Please set two keys separated by '+'"
-            MultiLogger.error <<~YAML
+            MultiLogger.warn "Invalid emergency ungrab keybinds: #{keybinds}, fallback to #{DEFAULT_EMERGENCY_KEYBIND}"
+            MultiLogger.warn "Please set two keys separated by '+'"
+            MultiLogger.warn <<~YAML
               plugin:
                 inputs:
                   remap_keyboard_input:
                     emergency_ungrab_keys: RIGHTCTRL+LEFTCTRL
             YAML
 
-            exit 1
+            keybinds = DEFAULT_EMERGENCY_KEYBIND.split("+")
           end
 
           MultiLogger.info "Emergency ungrab keybind: #{keybinds[0]}+#{keybinds[1]}"
 
-          first_keycode = find_code_from_key(keybinds[0])
-          second_keycode = find_code_from_key(keybinds[1])
+          first_keycode = key_to_code(keybinds[0])
+          second_keycode = key_to_code(keybinds[1])
 
           @emergency_stop = lambda do |prev, current|
             if (prev&.code == first_keycode && prev.value != 0) && (current.code == second_keycode && current.value != 0)
@@ -246,48 +269,45 @@ module Fusuma
         # @param [Integer] code
         # @return [Integer, nil]
         def find_remapped_code(mapping, code)
-          key = find_key_from_code(code) # key = "A"
+          key = code_to_key(code) # key = "A"
           remapped_key = mapping.fetch(key.to_sym, nil) # remapped_key = "b"
           return code unless remapped_key # return original code if key is not found
 
-          find_code_from_key(remapped_key) # remapped_code = 48
+          key_to_code(remapped_key) # remapped_code = 48
         end
 
         # Find key name from key code
         # @example
-        #  find_key_from_code(30) # => "A"
-        #  find_key_from_code(48) # => "B"
+        #  code_to_key(30) # => "A"
+        #  code_to_key(48) # => "B"
+        #  code_to_key(272) # => "BTN_LEFT"
         # @param [Integer] code
         # @return [String]
-        def find_key_from_code(code)
-          # { 30 => :A, 48 => :B, ... }
-          @keys_per_code ||= Revdev.constants.select { |c| c.start_with? "KEY_" }.map { |c| [Revdev.const_get(c), c.to_s.delete_prefix("KEY_")] }.to_h
-          @keys_per_code[code]
+        # @return [nil] when key is not found
+        def code_to_key(code)
+          KEYMAP[code]
         end
 
         # Find key code from key name (e.g. "A", "B", "BTN_LEFT")
         # If key name is not found, return nil
         # @example
-        #  find_code_from_key("A") # => 30
-        #  find_code_from_key("B") # => 48
-        #  find_code_from_key("BTN_LEFT") # => 272
-        #  find_code_from_key("NOT_FOUND") # => nil
+        #  key_to_code("A") # => 30
+        #  key_to_code("B") # => 48
+        #  key_to_code("BTN_LEFT") # => 272
+        #  key_to_code("NOT_FOUND") # => nil
         # @param [String] key
         # @return [Integer] when key is available
         # @return [nil] when key is not available
-        def find_code_from_key(key)
-          # { KEY_A => 30, KEY_B => 48, ... }
-          @codes_per_key ||= Revdev.constants.select { |c| c.start_with?("KEY_", "BTN_") }.map { |c| [c, Revdev.const_get(c)] }.to_h
-
+        def key_to_code(key)
           case key
           when String
             if key.start_with?("BTN_")
-              @codes_per_key[key.upcase.to_sym]
+              CODEMAP[key.upcase.to_sym]
             else
-              @codes_per_key["KEY_#{key}".upcase.to_sym]
+              CODEMAP["KEY_#{key}".upcase.to_sym]
             end
           when Integer
-            @codes_per_key["KEY_#{key}".upcase.to_sym]
+            CODEMAP["KEY_#{key}".upcase.to_sym]
           end
         end
 
@@ -303,7 +323,12 @@ module Fusuma
               break true
             else
               # wait until all keys are released
-              device.read_input_event
+              begin
+                device.read_input_event
+              rescue Errno::ENODEV => e
+                MultiLogger.warn("Device removed while waiting to release keys: #{e.message}")
+                return false
+              end
             end
           end
         end

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

@@ -18,7 +18,6 @@ module Fusuma
           @source_touchpads = source_touchpads # original touchpad
           @fusuma_writer = fusuma_writer # write event to fusuma_input
 
-          # FIXME: PalmDetection should be initialized with each touchpad
           @palm_detectors = @source_touchpads.each_with_object({}) do |source_touchpad, palm_detectors|
             palm_detectors[source_touchpad] = PalmDetection.new(source_touchpad)
           end
@@ -34,6 +33,9 @@ module Fusuma
           touch_state = {}
           mt_slot = 0
           finger_state = nil
+
+          prev_valid_touch = false
+          prev_status = nil
           loop do
             ios = IO.select(@source_touchpads.map(&:file)) # , @layer_manager.reader])
             io = ios&.first&.first
@@ -131,10 +133,29 @@ module Fusuma
             end
 
             if syn_report
+              # Whether any slot is valid (touching)
+              valid_touch = touch_state.any? { |_, st| st[:valid_touch_point] }
+
+              status =
+                if valid_touch
+                  prev_valid_touch ? "update" : "begin"
+                else
+                  prev_valid_touch ? "end" : "cancelled"
+                end
+
+              if status == prev_status
+                next
+              end
+
               # TODO: define format as fusuma_input
               # TODO: Add data to identify multiple touchpads
-              data = {finger: finger_state, touch_state: touch_state}
+              data = {
+                finger: finger_state,
+                status: status
+              }
               @fusuma_writer.write(data.to_msgpack)
+              prev_status = status
+              prev_valid_touch = valid_touch
             end
           end
         rescue => e

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

@@ -3,7 +3,7 @@
 module Fusuma
   module Plugin
     module Remap
-      VERSION = "0.10.0"
+      VERSION = "0.11.1"
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fusuma-plugin-remap
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.1
 platform: ruby
 authors:
 - iberianpig
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-05-11 00:00:00.000000000 Z
+date: 2025-09-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fusuma