fusuma-plugin-tap 0.3.1 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dbcac570df7314c2824b8b8b2cff3b7b1e53c7f1d89214d15b41d771cff7450b
-  data.tar.gz: 065071af803859ba19f68e7031faa6682f03a654169b45dd30c2c5a65368a9da
+  metadata.gz: a0b6a2fa331a7031a3329d400dd4721da0232a7676ef857eaa366bc14e996fc9
+  data.tar.gz: fc4aea089191c918a02546398ccf47c4027ea1980282cc269bbdda697968ec12
 SHA512:
-  metadata.gz: 349c907d247d2dd5dc24499672255adf3e0721b41fdc400612e8bb9f608b2412d8d678a1f733d3b964f171bb4d521a2e491faf370eaceb617cdf271e1a91d9d3
-  data.tar.gz: 0cc70c1117850acb5f727c891815fdf3ae6793a571482b04d1ab1a354d414f4ccd906b45cf41b1a44dbc444da405a8f76db2a369a0fb27685a3fecee2f254fab
+  metadata.gz: fe19b07b7314b743b9d1da653944886500f869411d46a037417e3b053bedcd93e533be82a79323dd994d5b361e4b425bf12632b59ae521bc1ee98e92c810fc2a
+  data.tar.gz: 3e38a46bf4dba46853af4f716acc459d80daa772914c47ed4148b805cfc07f5c2f7e93f6a02330d0b3c2c41f57e6643cc2e15370afa5172b53a4427d09c52b99

data/README.md

@@ -62,6 +62,11 @@ plugin:
       verbose: true
 ```
 
+## Known issues
+* `libinput debug-events --verbose` outputs is unstable, so it may not work properly with some versions of libinput.
+* **libinput 1.10.4 contains a bug that suddenly stopped detecting taps.**
+  * ref: https://github.com/iberianpig/fusuma-plugin-tap/pull/8
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/bin/libinput_debug_events_generator.rb

@@ -4,15 +4,16 @@
 require 'fileutils'
 require 'pathname'
 require 'fusuma/device'
+require 'fusuma/plugin/inputs/libinput_command_input'
 
 # Generate libinput generator
 class LibinputDebugEventsGenerator
   def initialize(evemu_record:)
     @evemu_record = evemu_record
     @gesture_name = Pathname.new(evemu_record).basename
-    @list_devices = ENV.fetch('LIBINPUT_LIST_DEVICES', 'libinput list-devices')
-    @debug_events = ENV.fetch('LIBINPUT_DEBUG_EVENTS', 'libinput debug-events')
-    @libinput_version = ENV.fetch('LIBINPUT_VERSION', 'libinput list-devices')
+    @list_devices = ENV.fetch('LIBINPUT_LIST_DEVICES')
+    @debug_events = ENV.fetch('LIBINPUT_DEBUG_EVENTS')
+    @libinput_version = ENV.fetch('LIBINPUT_VERSION')
   end
 
   def generate_debug_events
@@ -41,6 +42,10 @@ class LibinputDebugEventsGenerator
       rescue Timeout::Error
         puts 'cut out device infos'
       end
+      if `which evemu-play` == ''
+        warn 'evemu-play is not found'
+        exit 1
+      end
 
       command = "evemu-play /dev/input/#{device_id} < #{@evemu_record}"
 

data/fusuma-plugin-tap.gemspec

@@ -16,17 +16,15 @@ Gem::Specification.new do |spec|
   spec.license       = 'MIT'
 
   # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files         = Dir.chdir(File.expand_path(__dir__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  end
+  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', '~> 1.10'
+  spec.add_dependency 'fusuma', '~> 2.0.0'
 
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'github_changelog_generator', '~> 1.14'

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

@@ -7,6 +7,7 @@ module Fusuma
     module Detectors
       # Detect tap event
       class TapDetector < Detector
+        SOURCES = ['tap', 'gesture', 'timer']
         BUFFER_TYPE = 'tap'
         GESTURE_RECORD_TYPE = 'tap'
 
@@ -18,24 +19,27 @@ module Fusuma
         # @return [Event] if event is detected
         # @return [NilClass] if event is NOT detected
         def detect(buffers)
-          buffer = buffers.find { |b| b.type == BUFFER_TYPE }
+          tap_buffer = buffers.find { |b| b.type == BUFFER_TYPE }
           gesture_buffer = buffers.find { |b| b.type == 'gesture' }
+          timer_buffer = buffers.find { |b| b.type == 'timer' }
 
-          return if buffer.empty? || moved?(tap_buffer: buffer, gesture_buffer: gesture_buffer)
+          if tap_buffer.empty? || moved?(tap_buffer: tap_buffer, gesture_buffer: gesture_buffer)
+            return
+          end
 
-          holding_time = buffer.events.last.time - buffer.events.first.time
+          holding_time = calc_holding_time(tap_buffer: tap_buffer, timer_buffer: timer_buffer)
 
-          direction = if hold?(buffer, holding_time)
+          direction = if hold?(tap_buffer, holding_time)
                         'hold'
-                      elsif tap?(buffer, holding_time)
+                      elsif tap?(tap_buffer, holding_time)
                         'tap'
                       end
 
           return if direction.nil?
 
-          finger = buffer.finger
+          finger = tap_buffer.finger
 
-          buffer.clear
+          tap_buffer.clear # NOTE: Clear after detecting hold
 
           index = create_index(finger: finger, direction: direction)
 
@@ -97,6 +101,16 @@ module Fusuma
           end
         end
 
+        def calc_holding_time(tap_buffer:, timer_buffer:)
+          last_time = if timer_buffer && !timer_buffer.empty? &&
+                         (tap_buffer.events.last.time < timer_buffer.events.last.time)
+                        timer_buffer.events.last.time
+                      else
+                        tap_buffer.events.last.time
+                      end
+          last_time - tap_buffer.events.first.time
+        end
+
         private
 
         def enough?(index:, direction:)
@@ -113,12 +127,12 @@ module Fusuma
         def interval_time(index:, direction:)
           @interval_time ||= {}
           @interval_time[index.cache_key] ||= begin
-                               keys_specific = Config::Index.new [*index.keys, 'interval']
-                               keys_global = Config::Index.new ['interval', direction]
-                               config_value = Config.search(keys_specific) ||
-                                              Config.search(keys_global) || 1
-                               BASE_INTERVAL * config_value
-                             end
+            keys_specific = Config::Index.new [*index.keys, 'interval']
+            keys_global = Config::Index.new ['interval', direction]
+            config_value = Config.search(keys_specific) ||
+                           Config.search(keys_global) || 1
+            BASE_INTERVAL * config_value
+          end
         end
       end
     end

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

@@ -67,7 +67,11 @@ module Fusuma
 
             finger = case Regexp.last_match(2)
                      when 'TAP_STATE_DEAD'
-                       4
+                       if Regexp.last_match(1) == 'TAP_STATE_TOUCH_3'
+                         4
+                       else
+                         0
+                       end
                      when 'TAP_STATE_TOUCH_3'
                        3
                      when 'TAP_STATE_TOUCH_2'
@@ -94,8 +98,7 @@ module Fusuma
                        1
                      end
           # KEEP
-          when 'LIBINPUT TIMEOUT',   # Timeout Event
-            /\sgesture(| state):\s/  # 1.10.4 prints "gesture state: GESTURE_STATE_.*"
+          when /\sgesture(| state):\s/ # 1.10.4 prints "gesture state: GESTURE_STATE_.*"
             # NOTE: treat the "gesture(| state):" as KEEP
             status = 'keep'
             finger = 0
@@ -144,7 +147,7 @@ module Fusuma
           Events::Records::GestureRecord.new(status: status,
                                              gesture: gesture,
                                              finger: finger,
-                                             direction: nil)
+                                             delta: nil)
         end
 
         def tag

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

@@ -3,7 +3,7 @@
 module Fusuma
   module Plugin
     module Tap
-      VERSION = '0.3.1'
+      VERSION = '0.4.1'
     end
   end
 end

data/spec/fusuma/plugin/buffers/tap_buffer_spec.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+require 'fusuma/plugin/events/records/gesture_record.rb'
+require 'fusuma/plugin/events/event.rb'
+require 'fusuma/plugin/buffers/buffer.rb'
+
+module Fusuma
+  module Plugin
+    module Buffers
+      RSpec.describe TapBuffer do
+        before do
+          @buffer = TapBuffer.new
+          @event_generator = lambda { |time = nil, finger = 1, status = 'begin'|
+            Events::Event.new(time: time,
+                              tag: 'libinput_tap_parser',
+                              record: Events::Records::GestureRecord.new(
+                                status: status,
+                                gesture: 'tap',
+                                finger: finger,
+                                delta: nil
+                              ))
+          }
+        end
+
+        describe '#type' do
+          it { expect(@buffer.type).to eq 'tap' }
+        end
+
+        describe '#buffer' do
+          it 'should buffer gesture event' do
+            event = @event_generator.call(Time.now)
+            @buffer.buffer(event)
+            expect(@buffer.events).to eq [event]
+          end
+
+          it 'should NOT buffer other event' do
+            event = Events::Event.new(tag: 'SHOULD NOT BUFFER', record: 'dummy record')
+            @buffer.buffer(event)
+            expect(@buffer.events).to eq []
+          end
+        end
+
+        describe '#clear_expired' do
+          context 'with including end' do
+            it 'should NOT clear any events' do
+              time = Time.now
+              event1 = @event_generator.call(time,       1, 'begin')
+              event2 = @event_generator.call(time + 0.1, 2, 'touch')
+              event3 = @event_generator.call(time + 0.2, 1, 'release')
+              event4 = @event_generator.call(time + 0.2, 1, 'end')
+              @buffer.buffer(event1)
+              @buffer.buffer(event2)
+              @buffer.buffer(event3)
+              @buffer.buffer(event4)
+
+              @buffer.clear_expired(current_time: time + 100)
+
+              expect(@buffer.events).to eq []
+            end
+          end
+          context 'WITHOUT including end' do
+            it 'should NOT clear any events' do
+              time = Time.now
+              event1 = @event_generator.call(time,       1, 'begin')
+              event2 = @event_generator.call(time + 0.1, 2, 'touch')
+              event3 = @event_generator.call(time + 0.2, 1, 'release')
+              @buffer.buffer(event1)
+              @buffer.buffer(event2)
+              @buffer.buffer(event3)
+
+              @buffer.clear_expired(current_time: time + 100)
+
+              expect(@buffer.events).to eq [event1, event2, event3]
+            end
+          end
+        end
+
+        describe '#bufferable?' do
+          it 'should buffer first begin event' do
+            time = Time.now
+            event1 = @event_generator.call(time, 1, 'begin')
+            expect(@buffer.bufferable?(event1)).to eq true
+          end
+
+          context 'already exists events in buffer' do
+            before do
+              event2 = @event_generator.call(Time.now, 1, 'begin')
+              @buffer.buffer(event2)
+            end
+            it 'should NOT buffer begin event' do
+              event2 = @event_generator.call(Time.now, 1, 'begin')
+              expect(@buffer.bufferable?(event2)).to eq false
+            end
+
+            it 'should buffer touch event' do
+              event2 = @event_generator.call(Time.now, 2, 'touch')
+              expect(@buffer.bufferable?(event2)).to eq true
+            end
+
+            it 'should buffer release event' do
+              event2 = @event_generator.call(Time.now, 1, 'release')
+              expect(@buffer.bufferable?(event2)).to eq true
+            end
+
+            it 'should buffer end event' do
+              event2 = @event_generator.call(Time.now, 1, 'end')
+              expect(@buffer.bufferable?(event2)).to eq true
+            end
+          end
+        end
+
+        describe '#source' do
+          it { expect(@buffer.source).to eq TapBuffer::DEFAULT_SOURCE }
+
+          context 'with config' do
+            around do |example|
+              @source = 'custom_event'
+
+              ConfigHelper.load_config_yml = <<~CONFIG
+                plugin:
+                  buffers:
+                    tap_buffer:
+                      source: #{@source}
+              CONFIG
+
+              example.run
+
+              Config.custom_path = nil
+            end
+
+            it { expect(@buffer.source).to eq @source }
+          end
+        end
+
+        describe '#finger' do
+          it 'should return number of fingers in gestures' do
+            @buffer.buffer(@event_generator.call(Time.now, 1, 'begin'))
+            expect(@buffer.finger).to eq 1
+            @buffer.buffer(@event_generator.call(Time.now, 2, 'touch'))
+            expect(@buffer.finger).to eq 2
+            @buffer.buffer(@event_generator.call(Time.now, 3, 'touch'))
+            expect(@buffer.finger).to eq 3
+            @buffer.buffer(@event_generator.call(Time.now, 3, 'release'))
+            expect(@buffer.finger).to eq 3
+          end
+        end
+
+        describe '#empty?' do
+          context 'no gestures in buffer' do
+            before { @buffer.clear }
+            it { expect(@buffer.empty?).to be true }
+          end
+
+          context 'buffered some gestures' do
+            before { @buffer.buffer(@event_generator.call(Time.now, 'begin')) }
+            it { expect(@buffer.empty?).to be false }
+          end
+        end
+      end
+    end
+  end
+end

data/spec/fusuma/plugin/detectors/tap_detector_spec.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+require 'fusuma/plugin/detectors/detector.rb'
+require 'fusuma/plugin/buffers/gesture_buffer.rb'
+require 'fusuma/plugin/events/event.rb'
+
+module Fusuma
+  module Plugin
+    module Detectors
+      RSpec.describe TapDetector do
+        before do
+          @detector = TapDetector.new
+          @buffer = Buffers::TapBuffer.new
+          @buffers = [@buffer, Buffers::GestureBuffer.new]
+
+          @event_generator = lambda { |time, finger, status|
+            Events::Event.new(
+              time: time,
+              tag: 'libinput_tap_parser',
+              record: Events::Records::GestureRecord.new(
+                finger: finger,
+                gesture: 'tap',
+                status: status,
+                delta: Events::Records::GestureRecord::Delta.new(0, 0, 0, 0)
+              )
+            )
+          }
+        end
+
+        describe '#detect' do
+          context 'with 1 finger tap events in buffer' do
+            before do
+              [
+                @event_generator.call(Time.now, 1, 'begin'),
+                @event_generator.call(Time.now, 1, 'release')
+              ].each { |event| @buffer.buffer(event) }
+            end
+
+            it 'should generate tap index' do
+              key_symbol = @detector.detect(@buffers).record.index.keys.map(&:symbol)
+              expect(key_symbol).to eq [:tap, 1]
+            end
+          end
+
+          context 'with 2 fingers tap events in buffer' do
+            before do
+              [
+                @event_generator.call(Time.now, 1, 'begin'),
+                @event_generator.call(Time.now, 2, 'touch'),
+                @event_generator.call(Time.now, 2, 'release')
+              ].each { |event| @buffer.buffer(event) }
+            end
+
+            it 'should generate tap index' do
+              key_symbol = @detector.detect(@buffers).record.index.keys.map(&:symbol)
+              expect(key_symbol).to eq [:tap, 2]
+            end
+          end
+
+          context 'with 3 fingers tap events in buffer' do
+            before do
+              time = Time.now
+              [
+                @event_generator.call(time,       1, 'begin'),
+                @event_generator.call(time,       2, 'touch'),
+                @event_generator.call(time,       3, 'touch'),
+                @event_generator.call(time,       3, 'release'),
+                @event_generator.call(time + 0.1, 2, 'release')
+              ].each { |event| @buffer.buffer(event) }
+            end
+
+            it 'should generate tap index' do
+              key_symbol = @detector.detect(@buffers).record.index.keys.map(&:symbol)
+              expect(key_symbol).to eq [:tap, 3]
+            end
+          end
+          context 'with 4 fingers tap events in buffer' do
+            before do
+              time = Time.now
+              [
+                @event_generator.call(time,       1, 'begin'),
+                @event_generator.call(time,       2, 'touch'),
+                @event_generator.call(time,       3, 'touch'),
+                @event_generator.call(time,       4, 'touch'),
+                @event_generator.call(time + 0.1, 4, 'end')
+              ].each { |event| @buffer.buffer(event) }
+            end
+
+            it 'should generate tap index' do
+              key_symbol = @detector.detect(@buffers).record.index.keys.map(&:symbol)
+              expect(key_symbol).to eq [:tap, 4]
+            end
+          end
+
+          context 'with 1 finger hold events in buffer' do
+            before do
+              time = Time.now
+              [
+                @event_generator.call(time,     1, 'begin'),
+                @event_generator.call(time + 2, 1, 'hold')
+              ].each { |event| @buffer.buffer(event) }
+            end
+
+            it 'should generate tap index' do
+              key_symbol = @detector.detect(@buffers).record.index.keys.map(&:symbol)
+              expect(key_symbol).to eq [:hold, 1]
+            end
+          end
+
+          context 'with 2 fingers hold events in buffer' do
+            before do
+              time = Time.now
+              [
+                @event_generator.call(time,     1, 'begin'),
+                @event_generator.call(time,     2, 'touch'),
+                @event_generator.call(time,     2, 'hold'),
+                @event_generator.call(time + 1, 2, 'release')
+              ].each { |event| @buffer.buffer(event) }
+            end
+
+            it 'should generate tap index' do
+              key_symbol = @detector.detect(@buffers).record.index.keys.map(&:symbol)
+              expect(key_symbol).to eq [:hold, 2]
+            end
+          end
+          context 'with 3 fingers hold events in buffer' do
+            before do
+              time = Time.now
+              [
+                @event_generator.call(time,     1, 'begin'),
+                @event_generator.call(time,     2, 'touch'),
+                @event_generator.call(time,     3, 'hold'),
+                @event_generator.call(time,     3, 'release'),
+                @event_generator.call(time + 1, 2, 'release')
+              ].each { |event| @buffer.buffer(event) }
+            end
+
+            it 'should generate hold index' do
+              key_symbol = @detector.detect(@buffers).record.index.keys.map(&:symbol)
+              expect(key_symbol).to eq [:hold, 3]
+            end
+          end
+          context 'with 4 fingers hold events in buffer' do
+            before do
+              time = Time.now
+              [
+                @event_generator.call(time,     1, 'begin'),
+                @event_generator.call(time,     2, 'touch'),
+                @event_generator.call(time,     3, 'touch'),
+                @event_generator.call(time,     4, 'touch'),
+                @event_generator.call(time,     0, 'keep'),
+                @event_generator.call(time,     0, 'keep'),
+                @event_generator.call(time,     0, 'keep'),
+                @event_generator.call(time + 1, 2, 'release')
+              ].each { |event| @buffer.buffer(event) }
+            end
+
+            it 'should generate hold index' do
+              key_symbol = @detector.detect(@buffers).record.index.keys.map(&:symbol)
+              expect(key_symbol).to eq [:hold, 4]
+            end
+          end
+        end
+      end
+    end
+  end
+end