fusuma-plugin-remap 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0cb6b77fe516b413998fa4e025528e5532e620fd7c7693c613d6cc3a02b9a8c0
+  data.tar.gz: bfb505583972722526bb56e5d8056fa1445b36e37bce3de3fe54cc824c44a2c2
+SHA512:
+  metadata.gz: e3e93232d8b457bed61e3e3d0cc5edca4a16277ec7064280920c026398df36de31ec4c8673113d79517c8d8e19c64feb2f938ce5f3e85c1735ab639b781c981f
+  data.tar.gz: 21c9eee15afcf106d5935e2b6aec029adafa953cbc1d3bc6160afb6abe42ccb4a395130c88a7fe52f9c506f4f1995ad55714a6a43d5cebd3ce15b04f06b83bc4

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 iberianpig
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,98 @@
+# Fusuma::Plugin::Remap [![Gem Version](https://badge.fury.io/rb/fusuma-plugin-remap.svg)](https://badge.fury.io/rb/fusuma-plugin-remap) [![Build Status](https://github.com/iberianpig/fusuma-plugin-remap/actions/workflows/ubuntu.yml/badge.svg)](https://github.com/iberianpig/fusuma-plugin-remap/actions/workflows/ubuntu.yml)
+
+## Installation
+
+**THIS PLUGIN IS EXPERIMENTAL.**
+
+A Fusuma plugin for remapping keyboard events into virtual input devices. Compatible with other Fusuma plugins.
+
+This plugin empowers users to manipulate keyboard events and convert them into virtual input devices. It is designed to integrate seamlessly with other Fusuma plugins, thus enabling users to construct sophisticated input configurations and achieve distinctive functionalities. A key feature is the dynamic alteration of remapping layers within the Fusuma process, thereby enabling users to adapt their keyboard inputs to suit specific tasks or applications.
+
+This plugin requires [fusuma](https://github.com/iberianpig/fusuma#update) 2.0
+
+### Install dependencies
+
+**NOTE: If you have installed ruby by apt, you must install ruby-dev.**
+```sh
+$ sudo apt-get install libevdev-dev ruby-dev build-essential
+```
+
+### Set up udev rules
+
+fusuma-plugin-remap create virtual input device(`fusuma_virtual_keyboard`) by uinput. So you need to set up udev rules.
+
+```sh
+$ echo 'KERNEL=="uinput", MODE="0660", GROUP="input", OPTIONS+="static_node=uinput"' | sudo tee /etc/udev/rules.d/60-udev-fusuma-remap.rules
+```
+
+Then, reload udev rules.
+
+```sh
+$ sudo udevadm control --reload-rules && sudo udevadm trigger
+```
+
+### Install fusuma-plugin-remap
+
+```sh
+$ sudo gem install fusuma-plugin-remap
+```
+
+### Set plugin properties
+
+Open `~/.config/fusuma/config.yml` and add the following code at the bottom in primary context(first section separated by `---`).
+
+```yaml
+plugin:
+  inputs:
+    remap_keyboard_input:
+      keyboard_name_patterns: xremap # (optional) specifiy other source keyboard name
+  buffers:
+    keypress_buffer:
+      source: remap_keyboard_input # (required) use buffer of fusuma-plugin-keypress
+  executors:
+    sendkey_executor:
+      device_name: fusuma_virtual_keyboard # (optional) when you use fusuma-plugin-sendkey
+
+---
+
+```
+
+## Properties
+
+### Remap
+
+Currently, remapping is only possible in the thumbsense context.
+Please install [fusuma-plugin-thumbsense](https://github.com/iberianpig/fusuma-plugin-thumbsense)
+
+First, add the 'thumbsense' context to `~/.config/fusuma/config.yml`.
+The context is separated by `---` and specified by `context: { thumbsense: true }`.
+
+### Example
+
+Set the following code in `~/.config/fusuma/config.yml`.
+
+```yaml
+
+---
+context: 
+  thumbsense: true
+
+remap:
+  J: BTN_LEFT
+  K: BTN_RIGHT
+  F: BTN_LEFT
+  D: BTN_RIGHT
+  SPACE: BTN_LEFT
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/iberianpig/fusuma-plugin-remap. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Fusuma::Plugin::Remap project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/iberianpig/fusuma-plugin-remap/blob/master/CODE_OF_CONDUCT.md).

data/bin/console

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "fusuma/plugin/manager"
+Fusuma::Plugin::Manager.require_base_plugins
+
+require "fusuma/plugin/remap"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/fusuma-remap

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/fusuma/plugin/remap/version"
+require_relative "../lib/fusuma/plugin/remap/remapper"
+require_relative "../lib/fusuma/plugin/remap/layer_manager"
+require "fusuma/config"
+require "revdev"
+require "msgpack"
+
+include Revdev
+
+if ARGV.length > 1
+  source_keyboards = [Revdev::EventDevice.new(ARGV.shift)]
+  internal_touchpad = Revdev::EventDevice.new(ARGV.shift)
+else
+  warn "Usage: #{$PROGRAM_NAME} /dev/input/KEYBOARD /dev/input/TOUCHPAD"
+  exit false
+end
+
+Fusuma::Config.instance.custom_path = "~/.config/fusuma/config.yml"
+
+layer_manager = Fusuma::Plugin::Remap::LayerManager.instance
+
+_keyboard_reader, keyboard_writer = IO.pipe
+Thread.new do
+  layer_manager.send_layer(layer: {foo: "bar"})
+  sleep 3
+  layer_manager.send_layer(layer: {thumbsense: true})
+  sleep 3
+  layer_manager.send_layer(layer: {thumbsense: true}, remove: true)
+
+  # u = MessagePack::Unpacker.new(keyboard_reader)
+  # loop do
+  #   puts "unpack: #{u.unpack}"
+  # end
+end
+
+Fusuma::Plugin::Remap::Remapper.new(
+  layer_manager: layer_manager,
+  keyboard_writer: keyboard_writer,
+  source_keyboards: source_keyboards,
+  internal_touchpad: internal_touchpad
+).run

data/fusuma-plugin-remap.gemspec

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "fusuma/plugin/remap/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "fusuma-plugin-remap"
+  spec.version = Fusuma::Plugin::Remap::VERSION
+  spec.authors = ["iberianpig"]
+  spec.email = ["yhkyky@gmail.com"]
+
+  spec.summary = "A Fusuma plugin for remapping keyboard events into virtual input devices."
+  spec.description = "This plugin empowers users to manipulate keyboard events and convert them into virtual input devices. It is designed to integrate seamlessly with other Fusuma plugins, thus enabling users to construct sophisticated input configurations and achieve distinctive functionalities. A key feature is the dynamic alteration of remapping layers within the Fusuma process, thereby enabling users to adapt their keyboard inputs to suit specific tasks or applications."
+  spec.homepage = "https://github.com/iberianpig/fusuma-plugin-remap"
+  spec.license = "MIT"
+
+  spec.files = Dir["{bin,lib,exe}/**/*", "LICENSE*", "README*", "*.gemspec"]
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = ">= 2.5.1"
+  spec.add_dependency "fusuma", "~> 2.0"
+  spec.add_dependency "fusuma-plugin-keypress", "~> 0.5"
+  spec.add_dependency "msgpack"
+  spec.add_dependency "revdev"
+  spec.add_dependency "ruinput"
+  spec.metadata = {
+    "rubygems_mfa_required" => "true"
+  }
+end

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "fusuma/device"
+require "fusuma/plugin/remap/remapper"
+require "fusuma/plugin/remap/layer_manager"
+
+module Fusuma
+  module Plugin
+    module Inputs
+      # Get keyboard events from remapper
+      class RemapKeyboardInput < Input
+        def config_param_types
+          {
+            keyboard_name_patterns: [Array, String],
+            touchpad_name_patterns: [Array, String]
+          }
+        end
+
+        attr_reader :pid
+
+        def initialize
+          super
+          setup_remapper
+        end
+
+        def io
+          @keyboard_reader
+        end
+
+        # @param record [String]
+        # @return [Event]
+        def create_event(record:)
+          data = MessagePack.unpack(record) # => {"key"=>"J", "status"=>1}
+
+          unless data.is_a? Hash
+            MultiLogger.error("Invalid record: #{record}", data: data)
+            return
+          end
+
+          code = data["key"]
+          status = (data["status"] == 1) ? "pressed" : "released"
+          record = Events::Records::KeypressRecord.new(status: status, code: code)
+
+          e = Events::Event.new(tag: tag, record: record)
+          MultiLogger.debug(input_event: e)
+          e
+        end
+
+        private
+
+        def setup_remapper
+          layer_manager = Remap::LayerManager.instance
+
+          # physical keyboard input event
+          @keyboard_reader, keyboard_writer = IO.pipe
+
+          source_keyboards = KeyboardSelector.new(config_params(:keyboard_name_patterns)).select
+          internal_touchpad = TouchpadSelector.new(config_params(:touchpad_name_patterns)).select.first
+          MultiLogger.info(source_keyboards: source_keyboards.map(&:device_name), internal_touchpad: internal_touchpad.device_name)
+
+          @pid = fork do
+            layer_manager.writer.close
+            @keyboard_reader.close
+            remapper = Remap::Remapper.new(
+              layer_manager: layer_manager,
+              source_keyboards: source_keyboards,
+              keyboard_writer: keyboard_writer,
+              internal_touchpad: internal_touchpad
+            )
+            remapper.run
+          end
+          layer_manager.reader.close
+          keyboard_writer.close
+        end
+
+        # Devices to detect key presses and releases
+        class KeyboardSelector
+          def initialize(names = ["keyboard", "Keyboard", "KEYBOARD"])
+            @names = names
+          end
+
+          # @return [Array<Revdev::EventDevice>]
+          def select
+            devices = Fusuma::Device.all.select { |d| Array(@names).any? { |name| d.name =~ /#{name}/ } }
+            devices.map { |d| Revdev::EventDevice.new("/dev/input/#{d.id}") }
+          end
+        end
+
+        class TouchpadSelector
+          def initialize(names)
+            @names = names
+          end
+
+          # @return [Array<Revdev::EventDevice>]
+          def select
+            devices = if @names
+              Fusuma::Device.all.select do |d|
+                Array(@names).any? do |name|
+                  d.name =~ /#{name}/
+                end
+              end
+            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
+end

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

@@ -0,0 +1,73 @@
+require "fusuma/config"
+require "msgpack"
+
+module Fusuma
+  module Plugin
+    module Remap
+      # Set layer sent from pipe
+      class LayerManager
+        require "singleton"
+        include Singleton
+        attr_reader :reader, :writer, :current_layer
+
+        def initialize
+          @layers = {}
+          @reader, @writer = IO.pipe
+          @current_layer = {} # preserve order
+        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
+
+          @last_layer = layer
+          @last_remove = remove
+          @writer.puts({layer: layer, remove: remove}.to_msgpack)
+        end
+
+        # Read layer from pipe and return remap layer
+        # @example
+        # @return [Hash]
+        def receive_layer
+          @layer_unpacker ||= MessagePack::Unpacker.new(@reader)
+
+          data = @layer_unpacker.unpack
+
+          return unless data.is_a? Hash
+
+          data = data.deep_symbolize_keys
+          layer = data[:layer] # e.g { thumbsense: true }
+          remove = data[:remove] # e.g true
+
+          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
+        end
+
+        # Find remap layer from config
+        # @param [Hash] layer
+        # @return [Hash]
+        def find_mapping(layer = @current_layer)
+          @layers[layer] ||= begin
+            result = nil
+            _ = Fusuma::Config::Searcher.find_context(layer) {
+              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 || {}
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,232 @@
+require "revdev"
+require "msgpack"
+require "set"
+require_relative "./layer_manager"
+
+require_relative "./ruinput_device_patched"
+
+module Fusuma
+  module Plugin
+    module Remap
+      class Remapper
+        include Revdev
+        # @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:)
+          @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
+        end
+
+        def run
+          create_virtual_keyboard
+          set_trap
+          grab_keyboards
+
+          old_ie = nil
+          next_mapping = nil
+          current_mapping = {}
+
+          loop do
+            ios = IO.select([*@source_keyboards.map(&:file), @layer_manager.reader])
+            io = ios.first.first
+
+            if io == @layer_manager.reader
+              begin
+                @layer_manager.receive_layer
+              rescue => e
+                MultiLogger.error "#{e.class}: #{e.message}, #{e.backtrace.first}"
+                raise
+              end
+
+              MultiLogger.debug "Remapper#run: layer changed to #{@layer_manager.current_layer}"
+              next_mapping = @layer_manager.find_mapping
+              next
+            end
+
+            if next_mapping && virtual_keyboard_all_key_released?
+              if current_mapping != next_mapping
+                current_mapping = next_mapping
+              end
+              next_mapping = nil
+            end
+
+            input_event = @source_keyboards.find { |kbd| kbd.file == io }.read_input_event
+            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
+
+              old_ie = input_event
+              if input_event.value != 2 # repeat
+                packed = {key: input_key, status: input_event.value}.to_msgpack
+                @keyboard_writer.puts(packed)
+              end
+            end
+
+            remapped = current_mapping.fetch(input_key.to_sym, nil)
+            if remapped.nil?
+              @uinput.write_input_event(input_event)
+              next
+            end
+
+            remapped_event = InputEvent.new(nil, input_event.type, find_code_from_key(remapped), input_event.value)
+
+            # When Set.delete? fails, it means that the key was pressed before remapping started and was released.
+            unless record_virtual_keyboard_event?(remapped, remapped_event.value)
+              # set original key before remapping
+              remapped_event.code = input_event.code
+            end
+
+            # remap to command will be nil
+            # e.g) remap: { X: { command: echo 'foo' } }
+            # this is because the command will be executed by fusuma process
+            next if remapped_event.code.nil?
+
+            @uinput.write_input_event(remapped_event)
+          end
+        end
+
+        # @param [Revdev::InputEvent] event
+        # @return [void]
+        def record_virtual_keyboard_event?(remapped_value, event_value)
+          case event_value
+          when 0
+            @pressed_virtual_keys.delete?(remapped_value)
+          when 1
+            @pressed_virtual_keys.add?(remapped_value)
+          else
+            # 2 is repeat
+            true
+          end
+        end
+
+        def virtual_keyboard_all_key_released?
+          @pressed_virtual_keys.empty?
+        end
+
+        def create_virtual_keyboard
+          @uinput.create "fusuma_virtual_keyboard",
+            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)
+              {
+                bustype: Revdev::BUS_I8042,
+                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|
+            wait_release_all_keys(keyboard) && keyboard.grab
+          end
+        end
+
+        def set_trap
+          @destroy = lambda do
+            begin
+              @source_keyboards.each { |kbd| kbd.ungrab }
+            rescue => e
+              puts e.message
+            end
+            begin
+              @uinput.destroy
+            rescue => e
+              puts e.message
+            end
+            exit 0
+          end
+
+          Signal.trap(:INT) { @destroy.call }
+          Signal.trap(:TERM) { @destroy.call }
+        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
+        # @example
+        #  find_remapped_code({ "A" => "b" }, 30) # => 48
+        #  find_remapped_code({ "A" => "b" }, 100) # => 100
+        #  find_remapped_code({ "A" => {command: 'echo foobar'}  }, 30) # => nil
+        #
+        # @param [Hash] mapping
+        # @param [Integer] code
+        # @return [Integer, nil]
+        def find_remapped_code(mapping, code)
+          key = find_key_from_code(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
+        end
+
+        # Find key name from key code
+        # @example
+        #  find_key_from_code(30) # => "A"
+        #  find_key_from_code(48) # => "B"
+        # @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]
+        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
+        # @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
+
+          case key
+          when String
+            if key.start_with?("BTN_")
+              @codes_per_key[key.upcase.to_sym]
+            else
+              @codes_per_key["KEY_#{key}".upcase.to_sym]
+            end
+          when Integer
+            @codes_per_key["KEY_#{key}".upcase.to_sym]
+          end
+        end
+
+        def released_all_keys?(device)
+          # key status if all bytes are 0, the key is not pressed
+          bytes = device.read_ioctl_with(Revdev::EVIOCGKEY)
+          bytes.unpack("C*").all? { |byte| byte == 0 }
+        end
+
+        def wait_release_all_keys(device, &block)
+          loop do
+            if released_all_keys?(device)
+              break true
+            else
+              # wait until all keys are released
+              device.read_input_event
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+require "ruinput"
+
+class RuinputDevicePatched < Ruinput::UinputDevice
+  include Ruinput
+  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
+    ].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
+    (Revdev::KEY_RESERVED...Revdev::KEY_CNT).each do |n|
+      # https://github.com/mooz/xkeysnail/pull/101/files
+      next unless keyboard_keys.include?(n) || mouse_btns.include?(n)
+
+      @file.ioctl UI_SET_KEYBIT, n
+    end
+
+    # @file.ioctl UI_SET_EVBIT, Revdev::EV_MSC
+    # Revdev::MSC_CNT.times do |i|
+    #   @file.ioctl UI_SET_MSCBIT, i
+    # end
+
+    # kernel bug: device has min == max on ABS_Y
+    # @file.ioctl UI_SET_EVBIT, Revdev::EV_ABS
+    # Revdev::ABS_CNT.times do |i|
+    #   @file.ioctl UI_SET_ABSBIT, i
+    # end
+
+    @file.ioctl UI_SET_EVBIT, Revdev::EV_REP
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Fusuma
+  module Plugin
+    module Remap
+      VERSION = "0.1.0"
+    end
+  end
+end

data/lib/fusuma/plugin/remap.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "remap/version"
+
+module Fusuma
+  module Plugin
+    module Remap
+    end
+  end
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: fusuma-plugin-remap
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- iberianpig
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2023-05-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fusuma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: fusuma-plugin-keypress
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: msgpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: revdev
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ruinput
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This plugin empowers users to manipulate keyboard events and convert
+  them into virtual input devices. It is designed to integrate seamlessly with other
+  Fusuma plugins, thus enabling users to construct sophisticated input configurations
+  and achieve distinctive functionalities. A key feature is the dynamic alteration
+  of remapping layers within the Fusuma process, thereby enabling users to adapt their
+  keyboard inputs to suit specific tasks or applications.
+email:
+- yhkyky@gmail.com
+executables:
+- fusuma-remap
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- bin/console
+- bin/setup
+- exe/fusuma-remap
+- fusuma-plugin-remap.gemspec
+- lib/fusuma/plugin/inputs/remap_keyboard_input.rb
+- lib/fusuma/plugin/remap.rb
+- lib/fusuma/plugin/remap/layer_manager.rb
+- lib/fusuma/plugin/remap/remapper.rb
+- lib/fusuma/plugin/remap/ruinput_device_patched.rb
+- lib/fusuma/plugin/remap/version.rb
+homepage: https://github.com/iberianpig/fusuma-plugin-remap
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.22
+signing_key: 
+specification_version: 4
+summary: A Fusuma plugin for remapping keyboard events into virtual input devices.
+test_files: []