fusuma-plugin-remap 0.11.0 → 0.11.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b55e5ef616cbf48bc0a8c3a4c0b9b91dbed01c3b4dc87f53f09fa51ab6c34227
-  data.tar.gz: 1e34c8882e52d3191092576ab5d056d74c1ea0d130963a37304ce2a8bc6b0fdf
+  metadata.gz: 5eb6be3cd4ee3e56a0fa412b29381e336c0b25207ca42d716a8a124cf907a5f8
+  data.tar.gz: d3b19a185e0cc03b7abcb00be6a8d7f63340827dafd1136adc941671457b2a80
 SHA512:
-  metadata.gz: bb30877c6629814e6aff80127aa63045e4901d416a568d1a6f0e7f268254509903df5df8d90382a7d739ea3b2a6b666a461f57d9af0ce00941152d2296953efd
-  data.tar.gz: f11178d8bf7c553a1568b67e1a62b4cb747d51c0b67008330b98b17228b82a5d41cecd5b4de2f259d2d572f539e4f55daaa75f79fdd7c3a2608ac4013a2473f7
+  metadata.gz: 593c365c6ef1ffc67a3865e188baeb8c59fa69a37aaaa3f75bad64b251d77d9abd9f914f2b90739f59dffc40b94dbb29c50fb894b8a524ba5820980ba364d8e6
+  data.tar.gz: 4cbd18fda7bfa3a05622f82cb4d558e7d00ea4b6d1a97c7c6617003eec64e1b6cb6caabd3fcfff91ef9c6c5c957b7681004c4a234f5c3a5e75a6878ba05526ca

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

@@ -12,6 +12,15 @@ module Fusuma
         include Revdev
 
         VIRTUAL_KEYBOARD_NAME = "fusuma_virtual_keyboard"
+        DEFAULT_EMERGENCY_KEYBIND = "RIGHTCTRL+LEFTCTRL".freeze
+
+        # 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]
@@ -53,7 +62,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,23 +70,50 @@ 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
 
             remapped = current_mapping.fetch(input_key.to_sym, nil)
-            if remapped.nil?
+            case remapped
+            when String, Symbol
+              # Remapped to another key - continue processing below
+            when Hash
+              # Command execution (e.g., {:SENDKEY=>"LEFTCTRL+BTN_LEFT", :CLEARMODIFIERS=>true})
+              # Skip input event processing and let Fusuma's Executor handle this
+              next
+            when nil
+              # Not remapped - write original key event as-is
+              uinput_keyboard.write_input_event(input_event)
+              next
+            else
+              # Invalid remapping configuration
+              MultiLogger.warn("Invalid remapped value - type: #{remapped.class}, key: #{input_key}")
+              next
+            end
+
+            remapped_code = key_to_code(remapped)
+            if remapped_code.nil?
+              MultiLogger.warn("Invalid remapped value - unknown key: #{remapped}, input: #{input_key}")
               uinput_keyboard.write_input_event(input_event)
               next
             end
 
-            remapped_event = InputEvent.new(nil, input_event.type, find_code_from_key(remapped), input_event.value)
+            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
-            unless record_virtual_keyboard_event?(remapped, remapped_event.value)
-              # set original key before remapping
+            # Workaround: If a key was pressed before remapping started and is being released,
+            # use the original key code to ensure proper key release
+            if should_use_original_key?(remapped, remapped_event.value)
               remapped_event.code = input_event.code
+            else
+              # Only update virtual key state if we're using the remapped key
+              update_virtual_key_state(remapped, remapped_event.value)
             end
 
             # remap to command will be nil
@@ -119,21 +155,34 @@ module Fusuma
           @pressed_virtual_keys ||= Set.new
         end
 
-        # record virtual keyboard event
+        # Update virtual keyboard key state
+        # @param [String] remapped_value remapped key name
+        # @param [Integer] event_value event value (0: release, 1: press, 2: repeat)
+        # @return [void]
+        def update_virtual_key_state(remapped_value, event_value)
+          case event_value
+          when 0 # key release
+            pressed_virtual_keys.delete(remapped_value)
+          when 1 # key press
+            pressed_virtual_keys.add(remapped_value)
+            # when 2 is repeat - no state change needed
+          end
+        end
+
+        # Check if we should use the original key code instead of remapped key
+        # This handles the case where a key was pressed before remapping started
+        # and is released after remapping
         # @param [String] remapped_value remapped key name
-        # @param [Integer] event_value event value
-        # @return [Boolean] false if the key was pressed before remapping started and was released
-        # @return [Boolean] true if the key was not pressed before remapping started
-        def record_virtual_keyboard_event?(remapped_value, event_value)
+        # @param [Integer] event_value event value (0: release, 1: press, 2: repeat)
+        # @return [Boolean] true if we should use original key code
+        def should_use_original_key?(remapped_value, event_value)
           case event_value
-          when 0
-            pressed_virtual_keys.delete?(remapped_value)
-          when 1
-            pressed_virtual_keys.add?(remapped_value)
-            true # Always return true because the remapped key may be the same
-          else
-            # 2 is repeat
-            true
+          when 0 # key release
+            # If the key was not in our pressed set, it means it was pressed
+            # before remapping started, so we should use original key
+            !pressed_virtual_keys.include?(remapped_value)
+          when 1, 2 # key press or repeat
+            false # Always use remapped key for press/repeat events
           end
         end
 
@@ -209,22 +258,22 @@ module Fusuma
           # 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 +295,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 +349,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/version.rb

@@ -3,7 +3,7 @@
 module Fusuma
   module Plugin
     module Remap
-      VERSION = "0.11.0"
+      VERSION = "0.11.2"
     end
   end
 end

metadata

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