fusuma-plugin-thumbsense 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1bdd2539bacc9ce3db7375ce445affc2a22fcadfc5a7849243737c8fe028911e
-  data.tar.gz: 4b4b1e40b305ef98b032ae186828dbd69b50fb8d82e978fb02d7a2540f8da517
+  metadata.gz: a991e73e2eace58e3f6732a6a0f39b12b9e968550c613977eeba03ec650dadda
+  data.tar.gz: 8735f0050e321d7171558df00925b94f39ea307e6914f350fdcf69ed805002bc
 SHA512:
-  metadata.gz: e69801eb4e32d544bf7ba7a322b9204683211372e94ef36375e1c2c70a730254638da594fcbf3e13b4c31a7d3a9cba64a25ef3b086696e44bf1dbccb5b145724
-  data.tar.gz: 16d973013a91adc273687a849f48915c6acff2d3bff72ed97aaf44e7b89328051d32c32e1e0a2fb514453cdda80b0989df12bbe039df3209bd69d3d659780e1b
+  metadata.gz: 104fcb225426e2c0310a33277ab82e9a174bfa38dd3212d3b9294f72561b48b8a9ec73860478bc9ab16f53deb6a1272c8d21ca0221c71fe797e571786f6983a8
+  data.tar.gz: d5bf0fba767a5a1d1952cd2fd7f2fd4b9f033ac3c89b76dbfdc31ad5235a5ad0b3727e04437ddd5367eac27ccc256661959859cbd816708ab841588a4a61c524

data/README.md

@@ -3,64 +3,54 @@
 Remapper from key to click only while tapping the touchpad.  
 Implemented as [Fusuma](https://github.com/iberianpig/fusuma) Plugin.
 
-**THIS PLUGIN IS EXPERIMENTAL.**
-
 ## What is ThumbSense?
 [ThumbSense](https://www2.sonycsl.co.jp/person/rekimoto/tsense/soft/index.html) is a tool that lets you control a laptop's touchpad using the keyboard. It assigns certain keyboard keys as mouse buttons and switches between acting as mouse buttons or normal keyboard keys based on whether the user's thumb is touching the touchpad. ThumbSense aims to make it easier to use the touchpad without moving your hand away from the keyboard.
 
 ## Installation
 
-### Requirements
+### Prerequisites
 
 - [fusuma](https://github.com/iberianpig/fusuma#update)  2.0 or later
-- [fusuma-plugin-keypress](https://github.com/iberianpig/fusuma-plugin-keypress) 0.5 or later
-  - fusuma-plugin-keypress is used to get keyboard input and is installed automatically.
-- [fusuma-plugin-remap](https://github.com/iberianpig/fusuma-plugin-remap)
-  - You need to set up udev rules for creating a virtual input device.
-  - fusuma-plugin-remap is installed automatically.
-  - Please refer to [fusuma-plugin-remap's README](https://github.com/iberianpig/fusuma-plugin-remap?tab=readme-ov-file#set-up-udev-rules) for details.
-
-### Install and set up fusuma-plugin-thumbsense
+- [fusuma-plugin-keypress](https://github.com/iberianpig/fusuma-plugin-keypress) 0.5 or later (automatically installed)
+- [fusuma-plugin-remap](https://github.com/iberianpig/fusuma-plugin-remap) (udev rules setup required)
 
-Run the following code in your terminal.
+### Steps to Install and Set Up Fusuma::Plugin::Thumbsense
 
-#### Install ruby-dev and build-essential for installing native extension
+1. Install the necessary packages for native extensions:
 ```sh
 $ sudo apt install ruby-dev build-essential
 ```
 
-#### Install libevdev-dev for building fusuma-plugin-remap
+2. Install the required library for building fusuma-plugin-remap:
 ```sh
 $ sudo apt install libevdev-dev
 ```
 
-#### set up udev rules for creating a virtual input device (fusuma-plugin-remap)
+3. Set up udev rules to create a virtual input device (for fusuma-plugin-remap):
 ```sh
 $ echo 'KERNEL=="uinput", MODE="0660", GROUP="input", OPTIONS+="static_node=uinput"' | sudo tee /etc/udev/rules.d/60-udev-fusuma-remap.rules
 $ sudo udevadm control --reload-rules && sudo udevadm trigger
 ```
 
-
-#### Install fusuma-plugin-thumbsense
+4. Install fusuma-plugin-thumbsense:
 ```sh
 $ sudo gem install fusuma-plugin-thumbsense
 ```
 
-## Properties
+## Configuration
 
-### Thumbsense context
+### Thumbsense Context
 
-First, add the thumbsense `context` to `~/.config/fusuma/config.yml`.
-The `context` is separated by `---` and specified by `context: thumbsense`.
+To add the thumbsense `context`, edit `~/.config/fusuma/config.yml`.
+The `context` section is separated by `---` and specified as `context: thumbsense`.
 Fusuma will switch to the `thumbsense` context while tapping the touchpad.
 
-### Remap key to mouse button
+### Key to Mouse Button Remap
 
 You can remap keys to mouse buttons while tapping the touchpad.
-The `remap` property is specified in the `thumbsense` context.
-
-Available mouse buttons are:
+The `remap` property is configured within the `thumbsense` context.
 
+Available mouse buttons include:
 - `BTN_LEFT`
 - `BTN_MIDDLE`
 - `BTN_RIGHT`
@@ -74,13 +64,12 @@ Available mouse buttons are:
 -   ...
 - `BTN_9`
 
-## Example
+### Example Configuration
 
-Set the following code in `~/.config/fusuma/config.yml`.
+Add the following code to `~/.config/fusuma/config.yml`:
 
 ```yaml
-# add thumbsense context
-
+# Add thumbsense context
 ---
 context: thumbsense
 
@@ -93,17 +82,56 @@ remap:
   K: BTN_RIGHT
 ```
 
-## TODO
+## Pointing Stick Support
+
+### Overview
+Fusuma::Plugin::Thumbsense provides experimental support for pointing stick devices. This functionality is currently limited to the **HHKB Studio** and utilizes HIDRAW. Please note that this feature is still in testing, and improvements may be made in future updates.
+
+see: https://github.com/iberianpig/fusuma-plugin-thumbsense/pull/4
+
+### Setting Up Udev Rules
+
+To use the pointing stick touch support, you need to set up the following Udev rules to ensure that the HHKB Studio device is correctly recognized:
+
+1. **Create the Udev Rule File**:
+   Create a Udev rule file with the following command:
+
+   ```sh
+   sudo nano /etc/udev/rules.d/60-udev-fusuma-thumbsense-hhkb-studio.rules
+   ```
+
+   Add the following content to the file:
+
+   ```plaintext
+   # HHKB Studio (USB)
+   KERNEL=="hidraw*", SUBSYSTEM=="hidraw", ATTRS{idVendor}=="04fe", ATTRS{idProduct}=="0016", MODE="0666"
+   
+   # HHKB Studio (Bluetooth)
+   KERNEL=="hidraw*", SUBSYSTEM=="hidraw", ENV{DEVPATH}=="/devices/virtual/misc/uhid/*:04FE:0016.*/hidraw*", MODE="0666"
+   ```
+
+2. **Reload the Udev Rules**:
+   Execute the following command to reload the Udev rules:
+
+   ```sh
+   sudo udevadm control --reload-rules && sudo udevadm trigger
+   ```
+
+## TODO LIST
 
-- thumbsense
-  - [x] change layer of remap while tapping
-  - [ ] make it possible to execute executor like `command:` `sendkey:`
+- ThumbSense
+  - [x] Change remap layer while tapping
+  - [x] Enable executing commands like `command:` and `sendkey:`
+  - [x] Support pointing stick devices(https://github.com/iberianpig/fusuma-plugin-thumbsense/pull/4)
+    - Now only HHKB Studio is supported using HIDRAW
 
-- remap
-  - [x] remap to single key like `remap: { J: BTN_LEFT }` 
-  - [x] send BTN_LEFT/BTN_MIDDLE/BTN_RIGHT click `remap: { I: BTN_MIDDLE }`
-  - [ ] remap multiple keys like `remap: { H: LEFTCTRL+TAB }`
-  - [ ] remap POINTER_MOTION to POINTER_SCROLL_FINGER `remap: { S: POINTER_SCROLL_FINGER }`
+- Remap
+  - [x] Remap to single key (e.g., `remap: { J: BTN_LEFT }`)
+  - [x] Send mouse clicks with `remap: { I: BTN_MIDDLE }`
+  - [x] Remap multiple keys
+    - Support sending multiple keys with fusuma-plugin-sendkey(https://github.com/iberianpig/fusuma-plugin-sendkey/pull/34)
+      - `remap: { T: { sendkey: [LEFTSHIFT+F10, T, ENTER, ESC] } }`
+  - [ ] Remap POINTER_MOTION to POINTER_SCROLL_FINGER (e.g., `remap: { S: POINTER_SCROLL_FINGER }`)
 
 ## Contributing
 

data/lib/fusuma/plugin/buffers/thumbsense_buffer.rb

@@ -6,6 +6,7 @@ module Fusuma
       # manage events and generate command
       class ThumbsenseBuffer < Buffer
         DEFAULT_SOURCE = "remap_touchpad_input"
+        POINTING_STICK_SOURCE = "pointing_stick_input"
 
         def config_param_types
           {
@@ -26,10 +27,11 @@ module Fusuma
         # @param event [Event]
         # @return [NilClass, ThumbsenseBuffer]
         def buffer(event)
-          return if event&.tag != source
-
-          @events.push(event)
-          self
+          case event.tag
+          when source, POINTING_STICK_SOURCE
+            @events.push(event)
+            self
+          end
         end
 
         # return [Integer]
@@ -37,21 +39,6 @@ module Fusuma
           @events.map { |e| e.record.finger }.max
         end
 
-        def empty?
-          @events.empty?
-        end
-
-        def present?
-          !empty?
-        end
-
-        def select_by_events(&block)
-          return enum_for(:select) unless block
-
-          events = @events.select(&block)
-          self.class.new events
-        end
-
         def ended?(event)
           event.record.status == "end"
         end

data/lib/fusuma/plugin/detectors/thumbsense_detector.rb

@@ -107,11 +107,6 @@ module Fusuma
           codes
         end
 
-        # @return [TrueClass, FalseClass]
-        def touching?
-          !touch_released?(@thumbsense_buffer)
-        end
-
         # @return [TrueClass, FalseClass]
         def touch_released?
           return true if @thumbsense_buffer.empty?
@@ -126,6 +121,8 @@ module Fusuma
           last_keypress = @keypress_buffer.events.last.record
           return if last_keypress.status == "released"
 
+          return if MODIFIER_KEYS.include?(last_keypress.code)
+
           current_layer = last_keypress&.layer
           current_layer && current_layer["thumbsense"]
         end

data/lib/fusuma/plugin/inputs/hidraw/device.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "fusuma/device"
+require "fusuma/multi_logger"
+
+module Fusuma
+  module Plugin
+    module Inputs
+      # Read pointing stick events
+      class Hidraw
+        class Device
+          # Definitions of IOCTL commands
+          HIDIOCGRAWNAME = 0x80804804
+          HIDIOCGRAWPHYS = 0x80404805
+          HIDIOCGRAWINFO = 0x80084803
+          HIDIOCGRDESCSIZE = 0x80044801
+          HIDIOCGRDESC = 0x90044802
+
+          # Definitions of bus types
+          BUS_PCI = 0x01
+          BUS_ISAPNP = 0x02
+          BUS_USB = 0x03
+          BUS_HIL = 0x04
+          BUS_BLUETOOTH = 0x05
+          BUS_VIRTUAL = 0x06
+
+          attr_reader :hidraw_path, :name, :bustype, :vendor_id, :product_id
+
+          def initialize(hidraw_path:)
+            @hidraw_path = hidraw_path
+            load_device_info
+          end
+
+          private
+
+          def load_device_info
+            File.open(@hidraw_path, "rb+") do |file|
+              @name = fetch_ioctl_data(file, HIDIOCGRAWNAME).strip
+
+              info = fetch_ioctl_data(file, HIDIOCGRAWINFO, [0, 0, 0].pack("LSS"))
+              @bustype, vendor, product = info.unpack("LSS")
+              @vendor_id = vendor.to_s(16)
+              @product_id = product.to_s(16)
+            end
+          rescue => e
+            MultiLogger.error "Error loading device info: #{e.message}"
+          end
+
+          def fetch_ioctl_data(file, ioctl_command, buffer = " " * 256)
+            file.ioctl(ioctl_command, buffer)
+            buffer
+          rescue Errno::EIO
+            MultiLogger.warn "Failed to retrieve data with IOCTL command #{ioctl_command}, the device might not support this operation."
+          end
+        end
+
+        class DeviceFinder
+          def find(device_name_pattern)
+            device_name_pattern = Regexp.new(device_name_pattern) if device_name_pattern.is_a?(String)
+            event_path = find_pointer_device_path(device_name_pattern)
+            return nil unless event_path
+
+            hidraw_path = find_hidraw_path(event_path)
+
+            return Device.new(hidraw_path: hidraw_path) if hidraw_path
+
+            nil
+          end
+
+          private
+
+          def find_hidraw_path(event_path)
+            event_abs_path = File.realpath(event_path)
+            parent_path = event_abs_path.gsub(%r{/input/input\d+/.*}, "")
+            locate_hidraw_device(parent_path)
+          end
+
+          def find_pointer_device_path(device_name_pattern)
+            Fusuma::Device.reset
+
+            device = Fusuma::Device.all.find do |device|
+              device.name =~ device_name_pattern && device.capabilities == "pointer"
+            end
+
+            device&.then { |d| "/sys/class/input/#{d.id}" }
+          end
+
+          def locate_hidraw_device(parent_path)
+            Dir.glob("#{parent_path}/hidraw/hidraw*").find do |path|
+              if File.exist?(path)
+                hidraw_device_path = path.gsub(%r{^/.*hidraw/hidraw}, "/dev/hidraw")
+                return hidraw_device_path if File.readable?(hidraw_device_path)
+              end
+            end
+
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fusuma/plugin/inputs/hidraw/hhkb_bluetooth_parser.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module Fusuma
+  module Plugin
+    module Inputs
+      class Hidraw
+        class HhkbBluetoothParser
+          BASE_TIMEOUT = 0.03  # Base timeout value for reading reports
+          MAX_TIMEOUT = 0.2    # Maximum timeout value before failure
+          MULTIPLIER = 1.1     # Multiplier to exponentially increase timeout
+
+          MAX_REPORT_SIZE = 9  # Maximum report size in bytes
+
+          # @param hidraw_device [Hidraw::Device] the HID raw device
+          def initialize(hidraw_device)
+            @hidraw_device = hidraw_device
+          end
+
+          # Parse HID raw device events.
+          def parse
+            File.open(@hidraw_device.hidraw_path, "rb") do |device|
+              timeout = nil
+
+              # Continuously read reports from the device.
+              while (report = read_with_timeout(device, timeout))
+                mouse_state = if report.empty?
+                  # Handle timeout case
+                  :end
+                else
+                  case parse_hid_report(report)
+                  when :mouse
+                    case mouse_state
+                    when :begin, :update
+                      :update
+                    else
+                      :begin
+                    end
+                  when :keyboard
+                    # Continue mouse_state when keyboard operation
+                    mouse_state
+                  else
+                    :end
+                  end
+                end
+
+                case mouse_state
+                when :begin, :update
+                  timeout = update_timeout(timeout)
+                when :end
+                  timeout = nil
+                end
+
+                yield mouse_state
+              end
+            end
+          end
+
+          # Reads the HID report from the device with a timeout.
+          # @param device [File] the opened device file
+          # @param timeout [Float] the timeout duration
+          # @return [String] the HID report as bytes or an empty string on timeout
+          def read_with_timeout(device, timeout)
+            # puts "Timeout: #{timeout}"  # Log timeout for debugging
+            Timeout.timeout(timeout) { device.read(MAX_REPORT_SIZE) }
+          rescue Timeout::Error
+            ""
+          end
+
+          # Update the timeout based on previous value.
+          # @param timeout [Float, nil] previously set timeout
+          # @return [Float] the updated timeout value
+          def update_timeout(timeout)
+            return BASE_TIMEOUT if timeout.nil?
+
+            [timeout * MULTIPLIER, MAX_TIMEOUT].min
+          end
+
+          # Parse the HID report to determine its type.
+          # @param report_bytes [String] the HID report as byte data
+          # @return [Symbol, nil] symbol indicating type of report or nil on error
+          def parse_hid_report(report_bytes)
+            report_id = report_bytes.getbyte(0)
+            case report_id
+            when 1
+              # parse_mouse_report(report_bytes)
+              :mouse
+            when 127
+              # parse_keyboard_report(report_bytes)
+              :keyboard
+            else
+              MultiLogger.warn "Unknown Report ID: #{report_id}"
+              nil
+            end
+          end
+
+          # Parse mouse report data.
+          # @param report_bytes [String] the HID mouse report as byte data
+          def parse_mouse_report(report_bytes)
+            puts "Raw bytes: #{report_bytes.inspect}" # Display raw byte bytes
+
+            report_id, buttons, x, y, wheel, ac_pan = report_bytes.unpack("CCcccc") # Retrieve 6-byte report
+            # - `C`: 1 byte unsigned integer (report ID) (0..255)
+            # - `C`: 1 byte unsigned integer (button state) (0..255)
+            # - `c`: 1 byte signed integer (x-axis) (-128..127)
+            # - `c`: 1 byte signed integer (y-axis) (-128..127)
+            # - `c`: 1 byte signed integer (wheel) (-128..127)
+            # - `c`: 1 byte signed integer (AC pan) (-128..127)
+            button_states = buttons.to_s(2).rjust(8, "0").chars.map(&:to_i)
+
+            puts "# ReportID: #{report_id} / Button: #{button_states.join(" ")} | X: #{x.to_s.rjust(4)} | Y: #{y.to_s.rjust(4)} | Wheel: #{wheel.to_s.rjust(4)} | AC Pan: #{ac_pan.to_s.rjust(4)}"
+          end
+
+          # Parse keyboard report data.
+          # @param report_bytes [String] the HID keyboard report as byte data
+          def parse_keyboard_report(report_bytes)
+            report_id, modifiers, _reserved1, *keys = report_bytes.unpack("CCCC6") # Retrieve 9-byte report
+            # - `C`: 1 byte unsigned integer (report ID) (0..255)
+            # - `C`: 1 byte unsigned integer (modifier keys) (0..255)
+            # - `C`: 1 byte reserved (0)
+            # - `C`: 6 bytes of keycodes (0..255)
+            modifier_states = %w[LeftControl LeftShift LeftAlt LeftGUI RightControl RightShift RightAlt RightGUI].map.with_index { |m, i| "#{m}: #{((modifiers & (1 << i)) != 0) ? 1 : 0}" }
+            keys_output = keys.map { |key| (key == 0) ? "0x70000" : translate_keycode(key) }
+            puts "# ReportID: #{report_id} / #{modifier_states.join(" | ")} | Keyboard #{keys_output}"
+          end
+
+          # Translate keycode to its string representation.
+          # @param keycode [Integer] the keycode to translate
+          # @return [String] the string representation of the keycode
+          def translate_keycode(keycode)
+            # Map of keycodes to their respective characters
+            keycodes = {
+              4 => "a and A", 7 => "d and D", 16 => "s and S", 19 => "w and W",
+              9 => "f and F", 10 => "g and G", 14 => "j and J", 15 => "k and K",
+              33 => "[ and {", 47 => "] and }"
+              # Add more as needed
+            }
+            keycodes[keycode] || "0x#{keycode.to_s(16)}"  # Return hexadecimal if not found
+          end
+        end
+      end
+    end
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  require "timeout"
+
+  require_relative "device"
+  require "fusuma/plugin/inputs/libinput_command_input"
+
+  device = Fusuma::Plugin::Inputs::Hidraw::DeviceFinder.new.find("HHKB-Studio")
+  return if device.nil?
+
+  puts "Device: #{device.name} (#{device.vendor_id}:#{device.product_id})"
+  if device.bustype == Fusuma::Plugin::Inputs::Hidraw::Device::BUS_BLUETOOTH
+    Fusuma::Plugin::Inputs::Hidraw::HhkbBluetoothParser.new(device).parse do |state|
+      puts "Touch state: #{state}"
+    end
+  else
+    puts "Bustype is not BUS_BLUETOOTH"
+  end
+end

data/lib/fusuma/plugin/inputs/hidraw/hhkb_usb_parser.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Fusuma
+  module Plugin
+    module Inputs
+      class Hidraw
+        class HhkbUsbParser
+          BASE_TIMEOUT = 0.03  # Base timeout value for reading reports
+          MAX_TIMEOUT = 0.2    # Maximum timeout value before failure
+          MULTIPLIER = 1.1     # Multiplier to exponentially increase timeout
+
+          MAX_REPORT_SIZE = 5  # Maximum report size in bytes
+
+          # @param hidraw_device [Hidraw::Device] the HID raw device
+          def initialize(hidraw_device)
+            @hidraw_device = hidraw_device
+          end
+
+          # Parse HID raw device events.
+          def parse
+            File.open(@hidraw_device.hidraw_path, "rb") do |device|
+              timeout = nil
+
+              # Continuously read reports from the device.
+              while (report = read_with_timeout(device, timeout))
+                mouse_state = if report.empty?
+                  # Handle timeout case
+                  :end
+                else
+                  # instance.parse_hid_report(report_bytes)
+                  case mouse_state
+                  when :begin, :update
+                    :update
+                  else
+                    :begin
+                  end
+                end
+
+                case mouse_state
+                when :begin, :update
+                  timeout = update_timeout(timeout)
+                when :end
+                  timeout = nil
+                end
+
+                yield mouse_state
+              end
+            end
+          end
+
+          # Reads the HID report from the device with a timeout.
+          # @param device [File] the opened device file
+          # @param timeout [Float] the timeout duration
+          # @return [String] the HID report as bytes or an empty string on timeout
+          def read_with_timeout(device, timeout)
+            # puts "Timeout: #{timeout}"  # Log timeout for debugging
+            Timeout.timeout(timeout) { device.read(MAX_REPORT_SIZE) }
+          rescue Timeout::Error
+            ""
+          end
+
+          # Update the timeout based on previous value.
+          # @param timeout [Float, nil] previously set timeout
+          # @return [Float] the updated timeout value
+          def update_timeout(timeout)
+            return BASE_TIMEOUT if timeout.nil?
+
+            [timeout * MULTIPLIER, MAX_TIMEOUT].min
+          end
+
+          # Parse the HID report to determine its type.
+          # @param report_bytes [String] the HID report as byte data
+          # @return [Symbol, nil] symbol indicating type of report or nil on error
+          def parse_hid_report(report_bytes)
+            return :end if report_bytes.nil?
+
+            # buttons, x, y, wheel, ac_pan = report_bytes.unpack("Ccccc") # Retrieve 5-byte report
+            # - `C`: 1 byte unsigned integer (button state) (0..255)
+            # - `c`: 1 byte signed integer (X-axis) (-127..127)
+            # - `c`: 1 byte signed integer (Y-axis) (-127..127)
+            # - `c`: 1 byte signed integer (Wheel) (-127..127)
+            # - `c`: 1 byte signed integer (AC pan) (-127..127)
+            # button_states = buttons.to_s(2).rjust(8, "0").chars.map(&:to_i)
+
+            # puts "Raw bytes: #{report_bytes.inspect}" # Display raw byte sequence
+            # puts "# Button: #{button_states.join(" ")} | X: #{x.to_s.rjust(4)} | Y: #{y.to_s.rjust(4)} | Wheel: #{wheel.to_s.rjust(4)} | AC Pan: #{ac_pan.to_s.rjust(4)}"
+
+            :begin
+          end
+        end
+      end
+    end
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  require "timeout"
+
+  require_relative "device"
+  require "fusuma/plugin/inputs/libinput_command_input"
+
+  device = Fusuma::Plugin::Inputs::Hidraw::DeviceFinder.new.find("HHKB-Studio")
+  return if device.nil?
+
+  puts "Device: #{device.name} (#{device.vendor_id}:#{device.product_id})"
+  if device.bustype == Fusuma::Plugin::Inputs::Hidraw::Device::BUS_USB
+    Fusuma::Plugin::Inputs::Hidraw::HhkbUsbParser.new(device).parse do |state|
+      puts "Touch state: #{state}"
+    end
+  else
+    puts "Bustype is not USB"
+  end
+end

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "fusuma/device"
+
+require_relative "hidraw/device"
+require_relative "hidraw/hhkb_bluetooth_parser"
+require_relative "hidraw/hhkb_usb_parser"
+
+module Fusuma
+  module Plugin
+    module Inputs
+      # Read pointing stick events
+      class PointingStickInput < Input
+        def config_param_types
+          {
+            device_name_pattern: String
+          }
+        end
+
+        def initialize
+          super
+          @device_name_pattern = config_params(:device_name_pattern)
+        end
+
+        def io
+          @io ||= begin
+            reader, writer = IO.pipe
+            Thread.new do
+              process_device_events(writer)
+              writer.close
+            end
+
+            reader
+          end
+        end
+
+        def process_device_events(writer)
+          hidraw_device = find_hidraw_device(@device_name_pattern, wait: 3)
+          hidraw_parser = select_hidraw_parser(hidraw_device.bustype)
+
+          mouse_state = nil
+
+          hidraw_parser.new(hidraw_device).parse do |new_state|
+            next if mouse_state == new_state
+
+            mouse_state = new_state
+            writer.puts(mouse_state)
+          end
+        rescue Errno::EIO => e
+          MultiLogger.error "#{self.class.name}: #{e}"
+          retry
+        end
+
+        # Override Input#read_from_io
+        def read_from_io
+          status = io.readline(chomp: true)
+          Events::Records::GestureRecord.new(gesture: "touch", status: status, finger: 1, delta: nil)
+        rescue EOFError => e
+          MultiLogger.error "#{self.class.name}: #{e}"
+          MultiLogger.error "Shutdown fusuma process..."
+          Process.kill("TERM", Process.pid)
+        end
+
+        private
+
+        # Retry and wait until hidraw is found
+        def find_hidraw_device(device_name_pattern, wait:)
+          device_finder = Hidraw::DeviceFinder.new
+          logged = false
+          loop do
+            device = device_finder.find(device_name_pattern)
+            if device
+              MultiLogger.info "Found pointing stick device: #{device_name_pattern}"
+
+              return device
+            end
+
+            MultiLogger.warn "No pointing stick device found: #{device_name_pattern}" unless logged
+            logged = true
+
+            sleep wait
+          end
+        end
+
+        # Select parser based on the bus type
+        # @param bustype [Integer]
+        def select_hidraw_parser(bustype)
+          case bustype
+          when Hidraw::Device::BUS_BLUETOOTH
+            Hidraw::HhkbBluetoothParser
+          when Hidraw::Device::BUS_USB
+            Hidraw::HhkbUsbParser
+          else
+            MultiLogger.error "Unsupported bus type: #{bustype}"
+            exit 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fusuma/plugin/inputs/pointing_stick_input.yml

@@ -0,0 +1,4 @@
+plugin:
+  inputs:
+    pointing_stick_input:
+      device_name_pattern:

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

@@ -3,7 +3,7 @@
 module Fusuma
   module Plugin
     module Thumbsense
-      VERSION = "0.8.0"
+      VERSION = "0.9.0"
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fusuma-plugin-thumbsense
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - iberianpig
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-04-15 00:00:00.000000000 Z
+date: 2024-09-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fusuma
@@ -67,6 +67,11 @@ files:
 - lib/fusuma/plugin/buffers/thumbsense_buffer.rb
 - lib/fusuma/plugin/buffers/thumbsense_buffer.yml
 - lib/fusuma/plugin/detectors/thumbsense_detector.rb
+- lib/fusuma/plugin/inputs/hidraw/device.rb
+- lib/fusuma/plugin/inputs/hidraw/hhkb_bluetooth_parser.rb
+- lib/fusuma/plugin/inputs/hidraw/hhkb_usb_parser.rb
+- lib/fusuma/plugin/inputs/pointing_stick_input.rb
+- lib/fusuma/plugin/inputs/pointing_stick_input.yml
 - lib/fusuma/plugin/thumbsense.rb
 - lib/fusuma/plugin/thumbsense/version.rb
 homepage: https://github.com/iberianpig/fusuma-plugin-thumbsense