fusuma-plugin-touchscreen 0.0.1.alpha

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 382351b2d3d10f48ec04e2c6615805d8dbc1861ca22521728104a223077864e1
+  data.tar.gz: ec9eb76e6b29b083eb6e43d94876251bc8326eba145ea338ed314bc76a324ce8
+SHA512:
+  metadata.gz: 3052cd87167d7db34cf511302472765b33d0956a66477068a271d8c525c75fe35281ea83db6172bcb22cd11e032e3ee447813affc7a70a84390369f55c26d127
+  data.tar.gz: ec2bd3533144d81b222a57ab82b982cf625a8dfdcaf4416d00845b2ce0456edbb93e44fbe96117426e71ad73154d2906354cec357fccdbae1ae39f0df1a41f55

data/LICENSE

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

data/README.md

@@ -0,0 +1,2 @@
+# fusuma-plugin-touchscreen
+The Fusuma plugin for touchscreens

data/fusuma-plugin-touchscreen.gemspec

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'fusuma/plugin/touchscreen/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'fusuma-plugin-touchscreen'
+  spec.version       = Fusuma::Plugin::Touchscreen::VERSION
+  spec.authors       = ['Mikhail Fedotov']
+  spec.email         = ['myf.ivm@gmail.com']
+
+  spec.summary       = ' Touchscreen support plugin for Fusuma '
+  spec.description   = ' fusuma-plugin-touchscreen is Fusuma plugin for support touchscreen devices. '
+  spec.homepage      = 'https://github.com/Phaengris/fusuma-plugin-touchscreen'
+  spec.license       = 'MIT'
+
+  # Specify which files should be added to the gem when it is released.
+  spec.files          = Dir['{bin,lib,exe}/**/*', 'LICENSE*', 'README*', '*.gemspec']
+  spec.test_files     = Dir['{test,spec,features}/**/*']
+  spec.bindir        = 'exe'
+  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.add_dependency 'fusuma', '~> 2.0'
+end

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

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module Fusuma
+  module Plugin
+    module Buffers
+      class TouchBuffer < Buffer
+        DEFAULT_SOURCE = "libinput_touch_parser"
+        DEFAULT_SECONDS_TO_KEEP = 100
+
+        attr_reader :finger_events_map
+
+        def initialize(*args)
+          super()
+          @finger_events_map = {}
+          @mem = {}
+          @last_event_time = nil
+        end
+
+        def config_param_types
+          {
+            source: [String],
+            seconds_to_keep: [Float, Integer]
+          }
+        end
+
+        def buffer(event)
+          return if event&.tag != source
+
+          @finger_events_map[event.record.finger] ||= []
+          @finger_events_map[event.record.finger].push(event)
+          reset_memoized
+
+          self
+        end
+
+        def events
+          raise "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?
+
+            @finger_events_map[finger].select! do |e|
+              current_time - e.time < @seconds_to_keep
+            end
+          end
+          @finger_events_map.delete_if { |_, events| events.empty? }
+
+          reset_memoized
+        end
+
+        def clear
+          super
+          @finger_events_map = {}
+          reset_memoized
+        end
+
+        def empty?
+          @finger_events_map.empty?
+        end
+
+        def finger
+          @mem[:finger] ||= @finger_events_map.keys.count
+        end
+
+        def began?
+          @mem[:began] ||= @finger_events_map.any? && @finger_events_map.all? { |_, events| events.first&.record.status == "begin" }
+        end
+
+        def ended?
+          @mem[:ended] ||= @finger_events_map.any? && @finger_events_map.all? { |_, events| events.last&.record.status == "end" }
+        end
+
+        def moved?
+          # TODO: a quicker way to do this?
+          @mem[:moved] ||= finger_movements.any? && finger_movements.all? { |finger, movement| movement[:distance] > jitter_threshold }
+        end
+
+        def duration
+          @mem[:duration] ||= if ended?
+                                end_time - begin_time
+                              else
+                                Time.now - begin_time
+                              end
+        end
+
+        def begin_time
+          @mem[:begin_time] ||= @finger_events_map.values.map { |events| events.first.time }.min
+        end
+
+        def end_time
+          @mem[:end_time] ||= @finger_events_map.values.map { |events| events.last.time }.max
+        end
+
+        def finger_movements
+          @mem[:finger_movements] ||= @finger_events_map.map do |finger, events|
+            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
+
+            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
+          end.compact.to_h
+        end
+
+        private
+
+        def axis_threshold
+          2.0 # TODO: make it configurable
+        end
+
+        def jitter_threshold
+          5.0 # TODO: configurable
+        end
+
+        def reset_memoized
+          @mem = {} if @mem.any?
+        end
+
+      end # class TouchBuffer
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative './touch_detectors/tap_detector'
+require_relative './touch_detectors/hold_detector'
+require_relative './touch_detectors/swipe_detector'
+require_relative './touch_detectors/pinch_detector'
+require_relative './touch_detectors/rotate_detector'
+require_relative './touch_detectors/edge_detector'
+
+module Fusuma
+  module Plugin
+    module Detectors
+      class TouchDetector < Detector
+        SOURCES = %w[touch timer].freeze
+
+        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)
+          @last_known_gesture = nil
+        end
+
+        def detect(buffers)
+          events = []
+
+          timer_buffer = buffers.find { |b| b.type == 'timer' }
+          touch_buffer = buffers.find { |b| b.type == 'touch' }
+          @touch_buffer = touch_buffer || @touch_buffer
+
+          if timer_buffer &&
+            timer_buffer.events.any? &&
+            @last_known_gesture &&
+            (timer_buffer.events.last.time - @last_known_gesture.time) > event_expire_time
+
+            # TODO: should we also clear the touch buffer?
+            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
+
+          if timer_buffer
+            # if this is a timer tick, we have to have saved touch buffer to work with
+            return events if @touch_buffer.nil? || @touch_buffer.empty?
+          else
+            # if not, we have to have a new touch buffer events
+            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
+
+          gesture_record = nil
+          if touch_buffer
+            @detectors.each do |detector|
+              gesture_record = detector.detect(@touch_buffer)
+              break if gesture_record
+            end
+          else
+            return events if @touch_buffer.empty?
+            gesture_record = @hold_detector.detect(@touch_buffer)
+          end
+
+          if gesture_record
+            @touch_buffer.clear
+            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))
+            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?
+            end
+          end
+
+          events
+        end
+
+        private
+
+        def event_expire_time
+          2.0 # TODO: make configurable
+        end
+
+      end # class TouchDetector
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Fusuma
+  module Plugin
+    module Detectors
+      module TouchDetectors
+        class Base
+
+          protected
+
+          def tap_hold_threshold
+            0.5 # TODO: configurable
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+require_relative './base'
+
+module Fusuma
+  module Plugin
+    module Detectors
+      module TouchDetectors
+        class EdgeDetector < Base
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require_relative './base'
+
+module Fusuma
+  module Plugin
+    module Detectors
+      module TouchDetectors
+        class HoldDetector < Base
+
+          def detect(touch_buffer)
+            MultiLogger.debug('> hold detector')
+
+            MultiLogger.debug('  no movement?')
+            return if touch_buffer.moved?
+
+            MultiLogger.debug("  tap / hold threshold? (duration #{touch_buffer.duration})")
+            return unless touch_buffer.duration > tap_hold_threshold
+
+            MultiLogger.debug("  hold (#{touch_buffer.finger}) detected!")
+            Plugin::Events::Records::TouchRecords::HoldRecord.new(finger: touch_buffer.finger)
+          end
+
+        end # class HoldDetector
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+require_relative './base'
+
+module Fusuma
+  module Plugin
+    module Detectors
+      module TouchDetectors
+        class PinchDetector < Base
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+require_relative './base'
+
+module Fusuma
+  module Plugin
+    module Detectors
+      module TouchDetectors
+        class RotateDetector < Base
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+require_relative './base'
+require_relative '../../../utils/angle'
+
+module Fusuma
+  module Plugin
+    module Detectors
+      module TouchDetectors
+        class SwipeDetector
+
+          def detect(touch_buffer)
+            MultiLogger.debug('> swipe detector')
+
+            MultiLogger.debug('  movement?')
+            return unless touch_buffer.moved?
+
+            MultiLogger.debug('  angles?')
+            angles = touch_buffer.finger_movements.map { |_, movement| movement[:angle] }
+            angles.combination(2).each do |angle1, angle2|
+              if Utils::Angle.difference(angle1, angle2) > 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
+
+            MultiLogger.debug('  direction?')
+            case angle
+            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))
+              direction = :down
+            when (180 - (direction_angle_width / 2))...(180 + (direction_angle_width / 2))
+              direction = :left
+            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")
+              return
+            end
+            MultiLogger.debug("  swipe #{direction} detected!")
+
+            Plugin::Events::Records::TouchRecords::SwipeRecord.new(finger: touch_buffer.finger, direction: direction)
+          end
+
+          private
+
+          def movement_angle_threshold
+            30 # TODO: configurable
+          end
+
+          def direction_angle_width
+            45 # TODO: configurable
+          end
+
+        end # class SwipeDetector
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require_relative './base'
+
+module Fusuma
+  module Plugin
+    module Detectors
+      module TouchDetectors
+        class TapDetector < Base
+
+          def detect(touch_buffer)
+            MultiLogger.debug('> tap detector')
+
+            MultiLogger.debug('  no movement?')
+            return if touch_buffer.moved?
+
+            MultiLogger.debug('  began?')
+            return unless touch_buffer.began?
+
+            MultiLogger.debug('  ended?')
+            return unless touch_buffer.ended?
+
+            MultiLogger.debug("  tap / hold threshold? (duration #{touch_buffer.duration})")
+            return unless touch_buffer.duration <= tap_hold_threshold
+
+            MultiLogger.debug("  tap (#{touch_buffer.finger}) detected!")
+            Plugin::Events::Records::TouchRecords::TapRecord.new(finger: touch_buffer.finger)
+          end
+
+        end # class TapDetector
+      end
+    end
+  end
+end

data/lib/fusuma/plugin/devices/touchscreen_device.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Fusuma
+  module Plugin
+    module Touchscreen
+      module DevicePatch
+        module ClassMethods
+          def all
+            @all ||= super.tap do |devices|
+              devices.each do |device|
+                device.assign_attributes(available: true) if device.capabilities.match?(/touch/)
+              end
+            end
+          end
+        end
+
+        Fusuma::Device.singleton_class.prepend(ClassMethods)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative './touch_records/tap_record'
+require_relative './touch_records/hold_record'
+require_relative './touch_records/swipe_record'
+
+module Fusuma
+  module Plugin
+    module Events
+      module Records
+        class TouchRecord < Record
+          attr_reader :status,
+                      :finger,
+                      :x_px,
+                      :y_px,
+                      :x_mm,
+                      :y_mm,
+                      :time_offset
+
+          def initialize(status:, finger:, time_offset:, x_px: nil, y_px: nil, x_mm: nil, y_mm: nil)
+            super()
+            @status = status.to_s
+            @finger = finger.to_i
+            @time_offset = time_offset.to_f
+            @x_px = x_px.to_f if x_px
+            @y_px = y_px.to_f if y_px
+            @x_mm = x_mm.to_f if x_mm
+            @y_mm = y_mm.to_f if y_mm
+          end
+
+          def position?
+            @x_px || @y_px
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Fusuma
+  module Plugin
+    module Events
+      module Records
+        module TouchRecords
+          class Base < Record
+            attr_reader :finger
+
+            def initialize(finger:)
+              super()
+              @finger = finger.to_i
+            end
+
+            def repeatable?
+              raise NotImplementedError
+            end
+
+            def ==(other)
+              return false unless other.is_a?(self.class)
+              @finger == other.finger
+            end
+
+            def create_index_record(status: nil, trigger: :oneshot)
+              keys = config_index_keys
+              keys << Config::Index::Key.new(status) if status
+              Events::Records::IndexRecord.new(index: Config::Index.new(keys), trigger: trigger)
+            end
+
+            protected
+
+            def config_index_keys
+              [
+                Config::Index::Key.new(gesture_type),
+                Config::Index::Key.new(@finger),
+              ]
+            end
+
+            private
+
+            def self.gesture_type
+              @gesture_type ||= self.to_s.split('::').last.downcase.delete_suffix('record')
+            end
+
+            def gesture_type
+              # yes, that's not a good practice, but I'm not sure if we need this method in the public interface
+              self.class.send(:gesture_type)
+            end
+
+          end # class Base
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+require_relative './base'
+
+# frozen_string_literal: true
+
+module Fusuma
+  module Plugin
+    module Events
+      module Records
+        module TouchRecords
+          class HoldRecord < Base
+
+            def repeatable?
+              true
+            end
+
+          end # class HoldRecord
+        end
+      end
+    end
+  end
+end