fusuma-plugin-thumbsense 0.7.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30004fbb68724dafdc6cdafc0b8ab756ed1f3104c505327adb2a4435617c6400
-  data.tar.gz: bbdd89545b405e673e87e61cae5c9fb3052c4b8a788c28e889664618cbd95a4b
+  metadata.gz: a991e73e2eace58e3f6732a6a0f39b12b9e968550c613977eeba03ec650dadda
+  data.tar.gz: 8735f0050e321d7171558df00925b94f39ea307e6914f350fdcf69ed805002bc
 SHA512:
-  metadata.gz: af54a3831c6b69e9449efde47bad16be777902eaf65492edd7cf2291cbfc30202b16cbe63e5632707f253ff5eb445ed3a54654618a409783629ae3168547bfde
-  data.tar.gz: afdb2ed48a5f1629875a77c282606c0460a7dc6664561ffb4b12e2d947281a0988d2c2af78ad662818c85a14f12f128130bc8c853beaf68cf484f6e99bb1f1fb
+  metadata.gz: 104fcb225426e2c0310a33277ab82e9a174bfa38dd3212d3b9294f72561b48b8a9ec73860478bc9ab16f53deb6a1272c8d21ca0221c71fe797e571786f6983a8
+  data.tar.gz: d5bf0fba767a5a1d1952cd2fd7f2fd4b9f033ac3c89b76dbfdc31ad5235a5ad0b3727e04437ddd5367eac27ccc256661959859cbd816708ab841588a4a61c524

data/README.md

@@ -3,54 +3,135 @@
 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.
-  - 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.
+- [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)
+
+### Steps to Install and Set Up Fusuma::Plugin::Thumbsense
+
+1. Install the necessary packages for native extensions:
+```sh
+$ sudo apt install ruby-dev build-essential
+```
 
-### Install fusuma-plugin-thumbsense
+2. Install the required library for building fusuma-plugin-remap:
+```sh
+$ sudo apt install libevdev-dev
+```
 
-Run the following code in your terminal.
+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
+```
 
+4. Install fusuma-plugin-thumbsense:
 ```sh
 $ sudo gem install fusuma-plugin-thumbsense
 ```
 
-## Properties
+## Configuration
+
+### Thumbsense Context
+
+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.
+
+### Key to Mouse Button Remap
 
-### Thumbsense
+You can remap keys to mouse buttons while tapping the touchpad.
+The `remap` property is configured within the `thumbsense` context.
 
-First, add the `thumbsense` context to `~/.config/fusuma/config.yml`.
-The context is separated by `---` and specified by `context: thumbsense`.
+Available mouse buttons include:
+- `BTN_LEFT`
+- `BTN_MIDDLE`
+- `BTN_RIGHT`
+- `BTN_SIDE`
+- `BTN_EXTRA`
+- `BTN_FORWARD`
+- `BTN_BACK`
+- `BTN_TASK`
+- `BTN_0`
+- `BTN_1`
+-   ...
+- `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
 ---
 context: thumbsense
 
 remap:
+  F: BTN_LEFT
+  E: BTN_MIDDLE
+  D: BTN_RIGHT
+  SPACE: BTN_LEFT
   J: BTN_LEFT
   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 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
 
-- Using the fusuma-plugin-sendkey to emulate mouse buttons
-- Creating a simple key remapper using evdev and uinput to prevent the pressing of J/K keys on the physical keyboard from being sent.
+- 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/fusuma-plugin-thumbsense.gemspec

@@ -25,8 +25,8 @@ Gem::Specification.new do |spec|
   # https://packages.ubuntu.com/search?keywords=ruby&searchon=names&exact=1&suite=all&section=main
   # support focal (20.04LTS) 2.7
   spec.add_dependency "fusuma", ">= 3.2"
-  spec.add_dependency "fusuma-plugin-keypress", ">= 0.5"
-  spec.add_dependency "fusuma-plugin-remap"
+  spec.add_dependency "fusuma-plugin-keypress", ">= 0.11"
+  spec.add_dependency "fusuma-plugin-remap", ">= 0.4"
   spec.metadata = {
     "rubygems_mfa_required" => "true"
   }

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

@@ -5,7 +5,8 @@ module Fusuma
     module Buffers
       # manage events and generate command
       class ThumbsenseBuffer < Buffer
-        DEFAULT_SOURCE = "thumbsense_parser"
+        DEFAULT_SOURCE = "remap_touchpad_input"
+        POINTING_STICK_SOURCE = "pointing_stick_input"
 
         def config_param_types
           {
@@ -20,17 +21,17 @@ module Fusuma
           # skip palm/begin record
           return if !ended?(@events.last)
 
-          released_finger = @events.last.record.finger
-          @events.delete_if { |e| e.record.finger == released_finger }
+          clear
         end
 
         # @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]
@@ -38,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/buffers/thumbsense_buffer.yml

@@ -0,0 +1,4 @@
+plugin:
+  buffers:
+    thumbsense_buffer:
+      source: remap_touchpad_input

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

@@ -10,8 +10,8 @@ module Fusuma
     module Detectors
       # Detect Thumbsense context and change remap layer of fusuma-plugin-remap
       class ThumbsenseDetector < Detector
+        # keypress buffer is used to detect modifier keys
         SOURCES = %w[thumbsense keypress].freeze
-        BUFFER_TYPE = "thumbsense"
 
         MODIFIER_KEYS = Set.new(%w[
           CAPSLOCK
@@ -28,51 +28,74 @@ module Fusuma
         LAYER_CONTEXT = {thumbsense: true}.freeze
 
         # Detect Context event and change remap layer of fusuma-plugin-remap
-        # @param buffers [Array<Buffer>]
+        # @param buffers [Array<Buffer>] ThumbsenseBuffer, KeypressBuffer
         # @return [Event] if Thumbsense context is detected
+        # @return [Array<Event>] if Thumbsense context and Remap index when keypress is detected
         # @return [NilClass] if event is NOT detected
         def detect(buffers)
-          thumbsense_buffer = buffers.find { |b| b.type == BUFFER_TYPE }
-
-          return if thumbsense_buffer.empty?
-
-          MultiLogger.debug("thumbsense_buffer: #{thumbsense_buffer.events.map(&:record).map { |r| "#{r.finger} #{r.gesture} #{r.status}" }}")
+          @thumbsense_buffer ||= find_buffer(buffers, "thumbsense")
+          @keypress_buffer ||= find_buffer(buffers, "keypress")
 
           layer_manager = Fusuma::Plugin::Remap::LayerManager.instance
 
-          if touch_released?(thumbsense_buffer)
+          # layer is thumbsense => create thumbsense context and remap index
+          # touch is touching   => create thumbsense context and remap index
+          # touch is released   => remove thumbsense context
+          # keypress -> touch   => remove thumbsense context
+          if touch_released? && !thumbsense_layer?
+            MultiLogger.debug("thumbsense layer removed")
             layer_manager.send_layer(layer: LAYER_CONTEXT, remove: true)
             return
           end
 
-          keypress_buffer = buffers.find { |b| b.type == "keypress" }
+          # When keypress event is first:
+          # If current layer is thumbsense, the layer should not be changed
+          # If current layer is not thumbsense, it should remain a normal key
+          # In other words, if the key event comes first, do nothing
+          if keypress_first?
+            MultiLogger.debug("keypress event is first")
 
-          # If only modifier keys are pressed or no key is pressed
-          if pressed_codes(keypress_buffer).all? { |code| MODIFIER_KEYS.include?(code) }
-
-            # Even if the palm is detected, keep the thumbsense layer until `:end` event
-            if palm_detected?(thumbsense_buffer)
-              layer_manager.send_layer(layer: LAYER_CONTEXT, remove: true)
-              return
-            end
+            return
+          end
 
-            layer_manager.send_layer(layer: LAYER_CONTEXT)
+          MultiLogger.debug("thumbsense context created") unless thumbsense_layer?
+          layer_manager.send_layer(layer: LAYER_CONTEXT)
 
-            # create thumbsense context
-            record = Events::Records::ContextRecord.new(
+          # create thumbsense context
+          context = create_event(
+            record: Events::Records::ContextRecord.new(
               name: :thumbsense,
               value: true
             )
-            return create_event(record: record)
+          )
+
+          # TODO: Threshold
+          # create remap index
+          index = if (keys = pressed_codes) && !keys.empty?
+            MultiLogger.debug("thumbsense remap index created: #{keys}")
+            combined_keys = keys.join("+")
+            create_event(
+              record: Events::Records::IndexRecord.new(
+                index: Config::Index.new([:remap, combined_keys])
+              )
+            )
           end
 
-          nil
+          [context, index].compact
         end
 
         private
 
-        def pressed_codes(keypress_buffer)
-          records = keypress_buffer.events.map(&:record)
+        # @param buffers [Array<Buffer>]
+        # @param type [String]
+        # @return [Buffer]
+        def find_buffer(buffers, type)
+          buffers.find { |b| b.type == type }
+        end
+
+        # @return [Array<String>]
+        def pressed_codes
+          records = @keypress_buffer.events.map(&:record)
           codes = []
           records.each do |r|
             if r.status == "pressed"
@@ -84,45 +107,40 @@ module Fusuma
           codes
         end
 
-        def touching?(thumbsense_buffer)
-          !touch_released?(thumbsense_buffer)
+        # @return [TrueClass, FalseClass]
+        def touch_released?
+          return true if @thumbsense_buffer.empty?
+
+          @thumbsense_buffer.events.map(&:record).last&.status == "end"
         end
 
         # @return [TrueClass, FalseClass]
-        def touch_released?(thumbsense_buffer)
-          thumbsense_events = thumbsense_buffer.events
-          touch_num = thumbsense_events.count { |e| (e.record.status == "begin") }
-          release_num = thumbsense_events.count { |e| e.record.status == "end" }
+        def thumbsense_layer?
+          return if @keypress_buffer.empty?
+
+          last_keypress = @keypress_buffer.events.last.record
+          return if last_keypress.status == "released"
+
+          return if MODIFIER_KEYS.include?(last_keypress.code)
 
-          touch_num <= release_num
+          current_layer = last_keypress&.layer
+          current_layer && current_layer["thumbsense"]
         end
 
-        # Detect palm, except when there is another touch
+        # Check if keypress event is first, before thumbsense event
+        # If last keypress event is modifier key, return false
+        # @param keypress_buffer [Buffer]
         # @param thumbsense_buffer [Buffer]
-        # @return [TrueClass, FalseClass]
-        def palm_detected?(thumbsense_buffer)
-          # finger is a number to distinguish different touches and palms
-          # If the count remains, it is judged as a touch state
-          touch_state_per_finger = {}
-          thumbsense_buffer.events.each do |e|
-            f = e.record.finger
-            touch_state_per_finger[f] ||= 0
-
-            case e.record.status
-            when "begin"
-              touch_state_per_finger[f] += 1
-            when "palm"
-              if touch_state_per_finger[f] < 0
-                # NOTE: If Palm continues, it is equivalent to end
-                touch_state_per_finger[f] = 0
-              else
-                touch_state_per_finger[f] -= 1
-              end
-            when "end"
-              touch_state_per_finger[f] = 0
-            end
+        # @return [TrueClass] if keypress event is first
+        # @return [FalseClass] if keypress event is NOT first or buffers are empty
+        def keypress_first?
+          return false if @thumbsense_buffer.empty? || @keypress_buffer.empty?
+
+          if (keys = pressed_codes) && !keys.empty?
+            return false if MODIFIER_KEYS.include?(keys.first)
           end
-          touch_state_per_finger.values.all? { |count| count <= 0 }
+
+          @keypress_buffer.events.first.time < @thumbsense_buffer.events.first.time
         end
       end
     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.7.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.7.0
+  version: 0.9.0
 platform: ruby
 authors:
 - iberianpig
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-09-24 00:00:00.000000000 Z
+date: 2024-09-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fusuma
@@ -30,28 +30,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.5'
+        version: '0.11'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.5'
+        version: '0.11'
 - !ruby/object:Gem::Dependency
   name: fusuma-plugin-remap
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.4'
 description: fusuma-plugin-thumbsense is Fusuma plugin for thumbsense.
 email:
 - yhkyky@gmail.com
@@ -65,10 +65,13 @@ files:
 - bin/setup
 - fusuma-plugin-thumbsense.gemspec
 - lib/fusuma/plugin/buffers/thumbsense_buffer.rb
+- lib/fusuma/plugin/buffers/thumbsense_buffer.yml
 - lib/fusuma/plugin/detectors/thumbsense_detector.rb
-- lib/fusuma/plugin/filters/thumbsense_filter.rb
-- lib/fusuma/plugin/filters/thumbsense_filter.yml
-- lib/fusuma/plugin/parsers/thumbsense_parser.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
@@ -91,7 +94,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.4.19
 signing_key: 
 specification_version: 4
 summary: Thumbsense plugin for Fusuma

data/lib/fusuma/plugin/filters/thumbsense_filter.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require "fusuma/device"
-
-module Fusuma
-  module Plugin
-    module Filters
-      # Filter keyboard events from libinput_command_input
-      class ThumbsenseFilter < Filter
-        DEFAULT_SOURCE = "libinput_command_input"
-
-        # @return [TrueClass] when keeping it
-        # @return [FalseClass] when discarding it
-        def keep?(record)
-          case record.to_s
-          when %r{\sevent\d+\s+-\sbutton state: touch (?<finger>[[:digit:]])}
-            true
-          when %r{\sevent\d+\s+-\spalm: touch (?<finger>[[:digit:]])}
-            true
-          else
-            false
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fusuma/plugin/filters/thumbsense_filter.yml

@@ -1,5 +0,0 @@
-plugin:
-  inputs:
-    libinput_command_input:
-      verbose: true
-      disable-dwt: true

data/lib/fusuma/plugin/parsers/thumbsense_parser.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-# require 'fusuma/plugin/parsers/parser.rb'
-# require 'fusuma/plugin/events/event.rb'
-
-module Fusuma
-  module Plugin
-    module Parsers
-      # parse libinput and generate event
-      class ThumbsenseParser < Parser
-        DEFAULT_SOURCE = "libinput_command_input"
-
-        #    ... event7  - button state: touch 3 from BUTTON_STATE_AREA    event BUTTON_EVENT_UP          to BUTTON_STATE_NONE
-        # 10766: event7  - button state: touch 1 from BUTTON_STATE_AREA    event BUTTON_EVENT_UP          to BUTTON_STATE_NONE
-        # 10768: event7  - button state: touch 0 from BUTTON_STATE_AREA    event BUTTON_EVENT_UP          to BUTTON_STATE_NONE
-
-        # @param record [String]
-        # @return [Records::Gesture, nil]
-        def parse_record(record)
-          gesture = "touch"
-
-          case record.to_s
-
-          # touched
-          when %r{\sevent\d+\s+-\sbutton state: touch (?<finger>[[:digit:]]) from BUTTON_STATE_NONE}
-            status = "begin"
-            finger = $~[:finger].to_i + 1
-          # released
-          when %r{\sevent\d+\s+-\sbutton state: touch (?<finger>[[:digit:]]) .* to BUTTON_STATE_NONE}
-            status = "end"
-            finger = $~[:finger].to_i + 1
-
-          # palm
-          when %r{\sevent\d+\s+-\spalm: touch (?<finger>[[:digit:]]) .*}
-            status = "palm"
-            finger = $~[:finger].to_i + 1
-          else
-            return
-          end
-
-          Events::Records::GestureRecord.new(status: status, gesture: gesture, finger: finger, delta: nil)
-        end
-
-        def tag
-          "thumbsense_parser"
-        end
-      end
-    end
-  end
-end