fusuma-plugin-touchscreen 0.0.1.alpha → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 382351b2d3d10f48ec04e2c6615805d8dbc1861ca22521728104a223077864e1
-  data.tar.gz: ec9eb76e6b29b083eb6e43d94876251bc8326eba145ea338ed314bc76a324ce8
+  metadata.gz: 34475baf5bb86b2a999b1d4184e07207f6cd9b978c9c593650cfb3198b7431c6
+  data.tar.gz: f83b7d67b09d75403f1aa1232ea24980d34faf6a09f1dfd38b5ea3f441f8d101
 SHA512:
-  metadata.gz: 3052cd87167d7db34cf511302472765b33d0956a66477068a271d8c525c75fe35281ea83db6172bcb22cd11e032e3ee447813affc7a70a84390369f55c26d127
-  data.tar.gz: ec2bd3533144d81b222a57ab82b982cf625a8dfdcaf4416d00845b2ce0456edbb93e44fbe96117426e71ad73154d2906354cec357fccdbae1ae39f0df1a41f55
+  metadata.gz: 9d62633fd2feeacd1bcb880919b4665381d804bf0b80526ecb0b985488ad8be71fbbc6a41bf43ebf2c2b2d668c92856d529e9a99ef6a8e95dc2a9c6a2ede24e0
+  data.tar.gz: 8a411319e9ad71cdcf7d97c79c80d72a668c1858fa2c67bd8b0ae081733926157451a25da9a4805ab5d68e3c0d33c309b94ad25539e47267abdae12715632a43

data/README.md

@@ -1,2 +1,71 @@
-# fusuma-plugin-touchscreen
-The Fusuma plugin for touchscreens
+# Fusuma::Plugin::Touchscreen
+
+The Fusuma plugin for touchscreens.
+
+## Fusuma
+
+Fusuma is a multitouch gesture recognizer for Linux desktops.
+You can read more about it on [the Fusuma GitHub page](https://github.com/iberianpig/fusuma).
+
+This plugin adds support for touchscreens.
+
+## Installation
+
+First you need to [install Fusuma](https://github.com/iberianpig/fusuma#installation).
+
+Then the plugin can be installed as [any other Fusuma plugin](https://github.com/iberianpig/fusuma#fusuma-plugins):
+
+```bash
+sudo gem install fusuma-plugin-touchscreen
+```
+
+## Configuration
+
+If your Fusuma is already configured, you don't need to do anything else.
+The plugin uses the very same configuration file / entries.
+
+(So yes, your touchpad and your touchscreen will share the same gestures.)
+
+Read more [how to configure Fusuma](https://github.com/iberianpig/fusuma#customize-gesture-mapping).
+
+## Supported features
+
+Tap, Hold, Swipe, Pinch, Rotate.
+
+One or more fingers, as many as your device supports (through libinput).
+
+begin / update / end events (for all but Tap of course). 
+
+## Known issues
+
+As Fusuma itself, this plugin depends on the output of the `libinput debug-events`
+command which may be unstable.
+
+It is a plan to write some code to interact with libinput directly,
+but that's a task for the future.
+
+Threshold options are hard-coded and not configurable yet. That would be the next step.
+
+## Possible issues
+
+This plugin is tested on Microsoft Surface Pro 3 only.
+If you can test it on other devices, please share your experience.
+
+## Contributing
+
+Bug reports and pull requests are welcome
+on GitHub at https://github.com/Phaengris/fusuma-plugin-touchscreen
+
+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::Touchscreen project’s codebases,
+issue trackers, chat rooms and mailing lists is expected to follow
+the [code of conduct](https://github.com/iberianpig/fusuma-plugin-tap/blob/master/CODE_OF_CONDUCT.md).

data/fusuma-plugin-touchscreen.gemspec

@@ -22,7 +22,8 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.required_ruby_version = '>= 2.3' # https://packages.ubuntu.com/search?keywords=ruby&searchon=names&exact=1&suite=all&section=main
-
+  spec.required_ruby_version = ">= 2.5.1" # https://packages.ubuntu.com/search?keywords=ruby&searchon=names&exact=1&suite=all&section=main
+  # support bionic (18.04LTS) 2.5.1
+  
   spec.add_dependency 'fusuma', '~> 2.0'
 end

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

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'fusuma/plugin/buffers/buffer'
+require 'fusuma/plugin/touchscreen/math'
+
 module Fusuma
   module Plugin
     module Buffers
@@ -34,24 +37,12 @@ module Fusuma
         end
 
         def events
-          raise "Not supported, use finger_events_map instead"
+          raise NoMethodError, "Not supported, use finger_events_map instead"
         end
 
         def clear_expired(current_time: Time.now)
           @seconds_to_keep ||= (config_params(:seconds_to_keep) || DEFAULT_SECONDS_TO_KEEP)
 
-          # @finger_events_map.each do |finger, events|
-          #   next if events.empty?
-          #
-          #   if events.last.record.status == "end"
-          #     @finger_events_map.delete finger
-          #   else
-          #     @finger_events_map[finger].select! do |e|
-          #       current_time - e.time < @seconds_to_keep
-          #     end
-          #     @finger_events_map.delete finger if @finger_events_map[finger].empty?
-          #   end
-          # end
           clear if ended?
           @finger_events_map.each do |finger, events|
             next if events.empty?
@@ -89,11 +80,13 @@ module Fusuma
 
         def moved?
           # TODO: a quicker way to do this?
-          @mem[:moved] ||= finger_movements.any? && finger_movements.all? { |finger, movement| movement[:distance] > jitter_threshold }
+          @mem[:moved] ||= @finger_events_map.any? && @finger_events_map.keys.all? { |finger| finger_movements.key?(finger) }
         end
 
         def duration
-          @mem[:duration] ||= if ended?
+          @mem[:duration] ||= if @finger_events_map.empty?
+                                0
+                              elsif ended?
                                 end_time - begin_time
                               else
                                 Time.now - begin_time
@@ -113,78 +106,21 @@ module Fusuma
             position_events = events.select { |e| e.record.position? }
             next if position_events.size < 2 # we need at least first and last position
 
-            first_position = position_events.first
-            last_position = position_events.last
-
-            case
-            when (first_position.record.x_mm - last_position.record.x_mm).abs < axis_threshold
-              orientation = :vertical
-              direction = (last_position.record.y_mm - first_position.record.y_mm) <=> 0
-              x_axis = (first_position.record.x_mm + last_position.record.x_mm) / 2.0
-            when (first_position.record.y_mm - last_position.record.y_mm).abs < axis_threshold
-              orientation = :horizontal
-              direction = (last_position.record.x_mm - first_position.record.x_mm) <=> 0
-              y_axis = (first_position.record.y_mm + last_position.record.y_mm) / 2.0
-            else
-              orientation = :diagonal
-              k = (first_position.record.y_mm - last_position.record.y_mm) / (first_position.record.x_mm - last_position.record.x_mm)
-              b = first_position.record.y_mm - k * first_position.record.x_mm
-              direction_x = (last_position.record.x_mm - first_position.record.x_mm) <=> 0
-              direction_y = (last_position.record.y_mm - first_position.record.y_mm) <=> 0
-            end
+            first_position = { x: position_events.first.record.x_mm, y: position_events.first.record.y_mm }
+            last_position = { x: position_events.last.record.x_mm, y: position_events.last.record.y_mm }
+            distance = Touchscreen::Math.distance(first_position, last_position)
+            next if distance < movement_threshold
 
-            prev_position = first_position
-            catch(:interrupted_movement) do
-              position_events.each do |position|
-                delta_x = position.record.x_mm - prev_position.record.x_mm
-                delta_y = position.record.y_mm - prev_position.record.y_mm
-
-                jitter_x = delta_x.abs < jitter_threshold
-                jitter_y = delta_y.abs < jitter_threshold
-                next if jitter_x && jitter_y
-
-                case orientation
-                when :vertical
-                  throw(:interrupted_movement) unless jitter_y || (delta_y <=> 0) == direction
-                  throw(:interrupted_movement) unless (position.record.x_mm - x_axis).abs < jitter_threshold
-                when :horizontal
-                  throw(:interrupted_movement) unless jitter_x || (delta_x <=> 0) == direction
-                  throw(:interrupted_movement) unless (position.record.y_mm - y_axis).abs < jitter_threshold
-                else
-                  throw(:interrupted_movement) unless jitter_x || (delta_x <=> 0) == direction_x
-                  throw(:interrupted_movement) unless jitter_y || (delta_y <=> 0) == direction_y
-                  throw(:interrupted_movement) unless (position.record.y_mm - k * position.record.x_mm - b).abs < jitter_threshold
-                end
-                prev_position = position
-              end
-
-              case orientation
-              when :vertical
-                angle = direction == 1 ? 90 : 270
-                distance = (last_position.record.y_mm - first_position.record.y_mm).abs
-              when :horizontal
-                angle = direction == 1 ? 0 : 180
-                distance = (last_position.record.x_mm - first_position.record.x_mm).abs
-              else
-                angle = (Math.atan(k) * 180 / Math::PI).round
-                angle += 360 if angle < 0
-                distance = Math.sqrt((last_position.record.x_mm - first_position.record.x_mm)**2 + (last_position.record.y_mm - first_position.record.y_mm)**2)
-              end
-              next if distance < jitter_threshold
-
-              [finger, { angle: angle, distance: distance }]
-            end
+            # TODO: check if there were trajectory changes in between?
+
+            [finger, { first_position: first_position, last_position: last_position }]
           end.compact.to_h
         end
 
         private
 
-        def axis_threshold
-          2.0 # TODO: make it configurable
-        end
-
-        def jitter_threshold
-          5.0 # TODO: configurable
+        def movement_threshold
+          0.5 # TODO: configurable
         end
 
         def reset_memoized

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'fusuma/plugin/detectors/detector'
+
 require_relative './touch_detectors/tap_detector'
 require_relative './touch_detectors/hold_detector'
 require_relative './touch_detectors/swipe_detector'
@@ -16,13 +18,13 @@ module Fusuma
         def initialize(*)
           super
           @detectors = [
-            Fusuma::Plugin::Detectors::TouchDetectors::TapDetector,
-            Fusuma::Plugin::Detectors::TouchDetectors::SwipeDetector,
-          # Fusuma::Plugin::Detectors::TouchDetectors::PinchDetector,
-          # Fusuma::Plugin::Detectors::TouchDetectors::RotateDetector,
-          # Fusuma::Plugin::Detectors::TouchDetectors::EdgeDetector
-          ].map(&:new)
-          @detectors << (@hold_detector = Fusuma::Plugin::Detectors::TouchDetectors::HoldDetector.new)
+            Fusuma::Plugin::Detectors::TouchDetectors::TapDetector.new,
+            (@hold_detector = Fusuma::Plugin::Detectors::TouchDetectors::HoldDetector.new),
+            Fusuma::Plugin::Detectors::TouchDetectors::SwipeDetector.new,
+            Fusuma::Plugin::Detectors::TouchDetectors::PinchDetector.new,
+            # Fusuma::Plugin::Detectors::TouchDetectors::RotateDetector.new,
+            # Fusuma::Plugin::Detectors::TouchDetectors::EdgeDetector.new
+          ]
           @last_known_gesture = nil
         end
 
@@ -51,10 +53,11 @@ module Fusuma
             return events if touch_buffer.nil? || touch_buffer.empty?
           end
 
-          if @touch_buffer.ended? && @last_known_gesture
-            events << create_event(record: @last_known_gesture.record.create_index_record(status: 'end', trigger: :repeat)) if @last_known_gesture.record.repeatable?
-            @last_known_gesture = nil
-          end
+          # current gesture ended or even new gesture began
+          # if (@touch_buffer.ended? || @touch_buffer.began?) && @last_known_gesture
+          #   events << create_event(record: @last_known_gesture.record.create_index_record(status: 'end', trigger: :repeat)) if @last_known_gesture.record.repeatable?
+          #   @last_known_gesture = nil
+          # end
 
           gesture_record = nil
           if touch_buffer
@@ -68,16 +71,30 @@ module Fusuma
           end
 
           if gesture_record
-            @touch_buffer.clear
+            # repeat previous gesture
             if gesture_record.repeatable? && @last_known_gesture&.record == gesture_record
               @last_known_gesture = create_event(record: gesture_record)
-              events << create_event(record: gesture_record.create_index_record(status: 'update', trigger: :repeat))
+              if touch_buffer.ended?
+                events << create_event(record: gesture_record.create_index_record(status: 'end', trigger: :repeat))
+              else
+                events << create_event(record: gesture_record.create_index_record(status: 'update', trigger: :repeat))
+              end
+            # new gesture (repeatable or not)
             else
               events << create_event(record: @last_known_gesture.record.create_index_record(status: 'end', trigger: :repeat)) if @last_known_gesture&.record&.repeatable?
               @last_known_gesture = create_event(record: gesture_record)
               events << create_event(record: gesture_record.create_index_record)
-              events << create_event(record: gesture_record.create_index_record(status: 'begin', trigger: :repeat)) if gesture_record.repeatable?
+              if gesture_record.repeatable?
+                events << create_event(record: gesture_record.create_index_record(status: 'begin', trigger: :repeat))
+                # already ended? (in this very same tick)
+                events << create_event(record: gesture_record.create_index_record(status: 'end', trigger: :repeat)) if touch_buffer.ended?
+              end
             end
+            @touch_buffer.clear
+          # no new gesture, but may be the previous one ended?
+          elsif @touch_buffer&.ended? && @last_known_gesture
+            events << create_event(record: @last_known_gesture.record.create_index_record(status: 'end', trigger: :repeat)) if @last_known_gesture.record.repeatable?
+            @last_known_gesture = nil
           end
 
           events

data/lib/fusuma/plugin/detectors/touch_detectors/base.rb

@@ -3,6 +3,9 @@ module Fusuma
     module Detectors
       module TouchDetectors
         class Base
+          def detect
+            raise NotImplementedError, "override #{self.class.name}##{__method__}"
+          end
 
           protected
 
@@ -10,6 +13,10 @@ module Fusuma
             0.5 # TODO: configurable
           end
 
+          def jitter_threshold
+            5.0 # TODO: configurable
+          end
+
         end
       end
     end

data/lib/fusuma/plugin/detectors/touch_detectors/hold_detector.rb

@@ -1,16 +1,24 @@
-require_relative './base'
+require_relative './tap_hold_base'
 
 module Fusuma
   module Plugin
     module Detectors
       module TouchDetectors
-        class HoldDetector < Base
+        class HoldDetector < TapHoldBase
 
           def detect(touch_buffer)
             MultiLogger.debug('> hold detector')
 
             MultiLogger.debug('  no movement?')
-            return if touch_buffer.moved?
+            if touch_buffer.moved?
+              touch_buffer.finger_movements.each do |finger, movement|
+                distance = Touchscreen::Math.distance(movement[:first_position], movement[:last_position])
+                if distance > jitter_threshold
+                  MultiLogger.debug("  finger #{finger} moved too much: #{distance} > #{jitter_threshold}")
+                  return
+                end
+              end
+            end
 
             MultiLogger.debug("  tap / hold threshold? (duration #{touch_buffer.duration})")
             return unless touch_buffer.duration > tap_hold_threshold

data/lib/fusuma/plugin/detectors/touch_detectors/pinch_detector.rb

@@ -1,4 +1,5 @@
 require_relative './base'
+require 'fusuma/plugin/touchscreen/math'
 
 module Fusuma
   module Plugin
@@ -6,7 +7,64 @@ module Fusuma
       module TouchDetectors
         class PinchDetector < Base
 
-        end
+          def detect(touch_buffer)
+            MultiLogger.debug('> pinch detector')
+
+            MultiLogger.debug('  movement?')
+            return unless touch_buffer.moved?
+
+            MultiLogger.debug('  at least 2 fingers?')
+            return unless touch_buffer.finger_movements.size >= 2
+
+            MultiLogger.debug('  distance change between first 2 fingers?')
+            first_finger, second_finger = touch_buffer.finger_movements.values[0..1]
+            begin_distance = Touchscreen::Math.distance(first_finger[:first_position], second_finger[:first_position])
+            end_distance = Touchscreen::Math.distance(first_finger[:last_position], second_finger[:last_position])
+            distance = end_distance - begin_distance
+            return unless distance.abs > jitter_threshold
+
+            direction = distance <=> 0
+            MultiLogger.debug("  assuming direction is #{direction}, testing all pairs of fingers")
+            is_pinch = catch(:not_a_pinch) do
+              pairs = touch_buffer.finger_movements.keys.combination(2).to_a
+              pairs.each do |finger1, finger2|
+                begin_distance = Touchscreen::Math.distance(
+                  touch_buffer.finger_movements[finger1][:first_position],
+                  touch_buffer.finger_movements[finger2][:first_position]
+                )
+                end_distance = Touchscreen::Math.distance(
+                  touch_buffer.finger_movements[finger1][:last_position],
+                  touch_buffer.finger_movements[finger2][:last_position]
+                )
+                MultiLogger.debug("  fingers #{finger1} and #{finger2} moved from #{begin_distance} to #{end_distance}")
+                this_distance = end_distance - begin_distance
+                if this_distance.abs < jitter_threshold
+                  MultiLogger.debug("  !distance between fingers #{finger1} and #{finger2} is not changed enough (#{this_distance.abs}), not a pinch")
+                  throw(:not_a_pinch)
+                end
+                this_direction = this_distance <=> 0
+                if this_direction != direction
+                  MultiLogger.debug("  !fingers #{finger1} and #{finger2} moved in direction #{this_direction}, not a pinch")
+                  throw(:not_a_pinch)
+                end
+              end
+              true
+            end
+            return unless is_pinch
+
+            direction = direction == -1 ? :in : :out
+            MultiLogger.debug("  pinch #{direction} detected!")
+
+            Plugin::Events::Records::TouchRecords::PinchRecord.new(finger: touch_buffer.finger, direction: direction)
+          end
+
+          private
+
+          def jitter_threshold
+            5.0 # TODO: configurable
+          end
+
+        end # class PinchDetector
       end
     end
   end

data/lib/fusuma/plugin/detectors/touch_detectors/rotate_detector.rb

@@ -1,4 +1,5 @@
 require_relative './base'
+require 'fusuma/plugin/touchscreen/math'
 
 module Fusuma
   module Plugin
@@ -6,7 +7,70 @@ module Fusuma
       module TouchDetectors
         class RotateDetector < Base
 
-        end
+          def detect(touch_buffer)
+            MultiLogger.debug('> rotate detector')
+
+            MultiLogger.debug('  movement?')
+            return unless touch_buffer.moved?
+
+            MultiLogger.debug('  at least 2 fingers?')
+            return unless touch_buffer.finger_movements.size >= 2
+
+            # MultiLogger.debug('  center is static?')
+            # begin_center = Touchscreen::Math.center(touch_buffer.finger_movements.map { |_, v| v[:first_position] })
+            # end_center = Touchscreen::Math.center(touch_buffer.finger_movements.map { |_, v| v[:last_position] })
+            # return unless Touchscreen::Math.distance(begin_center, end_center) <= center_jitter_threshold
+
+            MultiLogger.debug('  angle change for the first finger?')
+            center = Touchscreen::Math.center(touch_buffer.finger_movements.map { |_, v| v[:first_position] })
+            first_finger = touch_buffer.finger_movements.values.first
+            begin_angle = Touchscreen::Math.angle_between(center, first_finger[:first_position])
+            end_angle = Touchscreen::Math.angle_between(center, first_finger[:last_position])
+            angle_change = Touchscreen::Math.angles_difference(end_angle, begin_angle)
+            MultiLogger.debug("    (#{angle_change})")
+            return unless angle_change.abs > angle_threshold
+
+            direction = angle_change <=> 0
+            MultiLogger.debug("  assuming direction is #{direction} (from #{begin_angle} to #{end_angle}), testing all fingers")
+
+            is_rotate = catch(:not_a_rotate) do
+              touch_buffer.finger_movements.except(0).each do |finger, movement|
+                begin_angle = Touchscreen::Math.angle_between(center, movement[:first_position])
+                end_angle = Touchscreen::Math.angle_between(center, movement[:last_position])
+                this_angle_change = Touchscreen::Math.angles_difference(end_angle, begin_angle)
+                if this_angle_change.abs < angle_threshold
+                  MultiLogger.debug("  !angle for finger #{finger} is not changed enough (#{this_angle_change.abs}), not a rotate")
+                  throw(:not_a_rotate)
+                end
+                this_direction = this_angle_change <=> 0
+                if this_direction != direction
+                  MultiLogger.debug("  !finger #{finger} moved in direction #{this_direction} (from #{begin_angle} to #{end_angle}, not a rotate")
+                  throw(:not_a_rotate)
+                end
+              end
+              true
+            end
+            return unless is_rotate
+
+            direction = direction == -1 ? :clockwise : :counterclockwise
+            MultiLogger.debug("  rotate #{direction} detected!")
+
+            Plugin::Events::Records::TouchRecords::RotateRecord.new(finger: touch_buffer.finger, direction: direction)
+          end
+
+          private
+
+          def angle_threshold
+            # such low value is because of how a human usually rotates fingers
+            # it is barely possible to draw a geometrically perfect circle
+            # in reality one finger can move very little, and another can move a lot
+            # so for the "base" finger the angle change will be very small, and for the "moving" finger it will be big
+            # if we increase the threshold, we will get a lot of false negatives
+            # which will make continuous rotate gestures very bulky
+            0.1 # TODO: make configurable
+          end
+
+        end # class RotateDetector
       end
     end
   end

data/lib/fusuma/plugin/detectors/touch_detectors/swipe_detector.rb

@@ -1,11 +1,11 @@
 require_relative './base'
-require_relative '../../../utils/angle'
+require 'fusuma/plugin/touchscreen/math'
 
 module Fusuma
   module Plugin
     module Detectors
       module TouchDetectors
-        class SwipeDetector
+        class SwipeDetector < Base
 
           def detect(touch_buffer)
             MultiLogger.debug('> swipe detector')
@@ -14,24 +14,26 @@ module Fusuma
             return unless touch_buffer.moved?
 
             MultiLogger.debug('  angles?')
-            angles = touch_buffer.finger_movements.map { |_, movement| movement[:angle] }
+            angles = touch_buffer.finger_movements.map do |_, movement|
+              Touchscreen::Math.angle_between(movement[:first_position], movement[:last_position])
+            end
             angles.combination(2).each do |angle1, angle2|
-              if Utils::Angle.difference(angle1, angle2) > movement_angle_threshold
+              if Touchscreen::Math.angles_difference(angle1, angle2).abs > movement_angle_threshold
                 MultiLogger.debug("  !too much difference between #{angle1} and #{angle2}, not a swipe")
                 return
               end
             end
-            angle = angles.inject(:+).to_f / angles.size
+            angle = Touchscreen::Math.angles_average(angles)
 
             MultiLogger.debug('  direction?')
             case angle
-            when 0...(direction_angle_width / 2), (360 - (direction_angle_width / 2))...360
+            when 0..(direction_angle_width / 2), (360 - (direction_angle_width / 2))..360
               direction = :right
-            when (90 - (direction_angle_width / 2))...(90 + (direction_angle_width / 2))
+            when (90 - (direction_angle_width / 2))..(90 + (direction_angle_width / 2))
               direction = :down
-            when (180 - (direction_angle_width / 2))...(180 + (direction_angle_width / 2))
+            when (180 - (direction_angle_width / 2))..(180 + (direction_angle_width / 2))
               direction = :left
-            when (270 - (direction_angle_width / 2))...(270 + (direction_angle_width / 2))
+            when (270 - (direction_angle_width / 2))..(270 + (direction_angle_width / 2))
               direction = :up
             else
               MultiLogger.debug("  !gesture angle of #{angle} does not fall into any direction")

data/lib/fusuma/plugin/detectors/touch_detectors/tap_detector.rb

@@ -1,10 +1,10 @@
-require_relative './base'
+require_relative './tap_hold_base'
 
 module Fusuma
   module Plugin
     module Detectors
       module TouchDetectors
-        class TapDetector < Base
+        class TapDetector < TapHoldBase
 
           def detect(touch_buffer)
             MultiLogger.debug('> tap detector')

data/lib/fusuma/plugin/detectors/touch_detectors/tap_hold_base.rb

@@ -0,0 +1,21 @@
+module Fusuma
+  module Plugin
+    module Detectors
+      module TouchDetectors
+        class TapHoldBase
+
+          protected
+
+          def tap_hold_threshold
+            0.5 # TODO: configurable
+          end
+
+          def jitter_threshold
+            5.0 # TODO: configurable
+          end
+
+        end # class TapHoldBase
+      end
+    end
+  end
+end

data/lib/fusuma/plugin/events/records/touch_record.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: true
+require 'fusuma/plugin/events/records/record'
 
 require_relative './touch_records/tap_record'
 require_relative './touch_records/hold_record'
@@ -31,6 +31,19 @@ module Fusuma
           def position?
             @x_px || @y_px
           end
+
+          def inspect
+            s = "#{self.class} status: #{status} finger: #{finger} time offset: #{time_offset}"
+            s << " x_px: #{x_px}" if x_px
+            s << " y_px: #{y_px}" if y_px
+            s << " x_mm: #{x_mm}" if x_mm
+            s << " y_mm: #{y_mm}" if y_mm
+            s
+          end
+
+          def to_s
+            inspect
+          end
         end
       end
     end

data/lib/fusuma/plugin/events/records/touch_records/base.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'fusuma/plugin/events/records/record'
+
 module Fusuma
   module Plugin
     module Events