fusuma-plugin-touchscreen 0.0.1.alpha → 0.1.0

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

@@ -0,0 +1,123 @@
+require 'spec_helper'
+require 'fusuma/plugin/detectors/touch_detectors/rotate_detector'
+
+module Fusuma
+  RSpec.describe Plugin::Detectors::TouchDetectors::RotateDetector do
+    include_context 'with touch buffer'
+    subject { described_class.new }
+
+    before do
+      allow(subject).to receive(:angle_threshold).and_return(0.1)
+    end
+
+    it 'no events' do
+      expect(subject.detect(touch_buffer)).to be_nil
+    end
+
+    it 'not moved' do
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'begin', finger: 1, x_mm: 10, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 1, x_mm: 10, y_mm: 10)))
+
+      expect(subject.detect(touch_buffer)).to be_nil
+    end
+
+    it 'moved, only one finger' do
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'begin', finger: 1, x_mm: 10, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 1, x_mm: 20, y_mm: 20)))
+
+      expect(subject.detect(touch_buffer)).to be_nil
+    end
+
+    it 'moved, 2 fingers, but not enough angle change' do
+      # left finger, a little bit to the down
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'begin', finger: 1, x_mm: 0, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 1, x_mm: 0, y_mm: 10.1)))
+      # right finger, a little bit to the up
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'begin', finger: 2, x_mm: 20, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 2, x_mm: 20, y_mm: 9.99)))
+
+      expect(subject.detect(touch_buffer)).to be_nil
+    end
+
+    it 'moved, 2 fingers, enough angle change, but not same direction' do
+      # left finger, to the down
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'begin', finger: 1, x_mm: 0, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 1, x_mm: 0, y_mm: 15)))
+      # right finger, to the down
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'begin', finger: 2, x_mm: 20, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 2, x_mm: 20, y_mm: 15)))
+
+      expect(subject.detect(touch_buffer)).to be_nil
+    end
+
+    it 'moved, 2 fingers, enough angle change, same direction' do
+      # left finger, to the down
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'begin', finger: 1, x_mm: 0, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 1, x_mm: 0, y_mm: 15)))
+      # right finger, to the up
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'begin', finger: 2, x_mm: 20, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 2, x_mm: 20, y_mm: 5)))
+
+      gesture = subject.detect(touch_buffer)
+      expect(gesture).to be_a Plugin::Events::Records::TouchRecords::RotateRecord
+      expect(gesture.finger).to eq 2
+      expect(gesture.direction).to eq 'counterclockwise'
+    end
+
+    it '2 fingers, clockwise' do
+      # left finger, to the up
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'begin', finger: 1, x_mm: 0, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 1, x_mm: 0, y_mm: 5)))
+      # right finger, to the down
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'begin', finger: 2, x_mm: 20, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 2, x_mm: 20, y_mm: 15)))
+
+      gesture = subject.detect(touch_buffer)
+      expect(gesture).to be_a Plugin::Events::Records::TouchRecords::RotateRecord
+      expect(gesture.finger).to eq 2
+      expect(gesture.direction).to eq 'clockwise'
+    end
+
+    it '3 fingers, one moved into wrong direction' do
+      # left finger, to the up
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'begin', finger: 1, x_mm: 0, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 1, x_mm: 0, y_mm: 5)))
+      # right finger, to the down
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'begin', finger: 2, x_mm: 20, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 2, x_mm: 20, y_mm: 15)))
+      # top finger, to the left
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'begin', finger: 3, x_mm: 10, y_mm: 0)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 3, x_mm: 5, y_mm: 0)))
+
+      expect(subject.detect(touch_buffer)).to be_nil
+    end
+
+    it '3 fingers, same direction' do
+      # left finger, to the up
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'begin', finger: 1, x_mm: 0, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 1, x_mm: 0, y_mm: 5)))
+      # right finger, to the down
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'begin', finger: 2, x_mm: 20, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 2, x_mm: 20, y_mm: 15)))
+      # top finger, to the right
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'begin', finger: 3, x_mm: 10, y_mm: 0)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 3, x_mm: 15, y_mm: 0)))
+
+      gesture = subject.detect(touch_buffer)
+      expect(gesture).to be_a Plugin::Events::Records::TouchRecords::RotateRecord
+      expect(gesture.finger).to eq 3
+      expect(gesture.direction).to eq 'clockwise'
+    end
+
+    it_behaves_like 'real sample',
+                    detector_class: Plugin::Detectors::TouchDetectors::RotateDetector,
+                    sample_path: 'spec/samples/2-fingers-rotate-clockwise.txt',
+                    expected_gesture_class: Plugin::Events::Records::TouchRecords::RotateRecord,
+                    expected_gesture_attributes: { finger: 2, direction: 'clockwise' }
+    it_behaves_like 'real sample',
+                    detector_class: Plugin::Detectors::TouchDetectors::RotateDetector,
+                    sample_path: 'spec/samples/2-fingers-rotate-counterclockwise.txt',
+                    expected_gesture_class: Plugin::Events::Records::TouchRecords::RotateRecord,
+                    expected_gesture_attributes: { finger: 2, direction: 'counterclockwise' }
+  end
+end

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

@@ -0,0 +1,141 @@
+require 'spec_helper'
+require 'fusuma/plugin/events/event'
+require 'fusuma/plugin/parsers/touch_parser'
+require 'fusuma/plugin/buffers/touch_buffer'
+require 'fusuma/plugin/detectors/touch_detectors/swipe_detector'
+require 'fusuma/plugin/events/records/touch_records/swipe_record'
+
+module Fusuma
+  RSpec.describe Plugin::Detectors::TouchDetectors::SwipeDetector do
+    subject { described_class.new }
+    let(:touch_buffer) { Plugin::Buffers::TouchBuffer.new }
+    let(:t) { Time.now }
+
+    before do
+      allow(touch_buffer).to receive(:movement_threshold).and_return(0.5)
+      allow(subject).to receive(:movement_angle_threshold).and_return(30)
+      allow(subject).to receive(:direction_angle_width).and_return(45)
+    end
+
+    it 'no events' do
+      expect(subject.detect(touch_buffer)).to be_nil
+    end
+
+    it 'not moved' do
+      touch_buffer.buffer(generate_touch_event(time: t - 1, record: generate_touch_record(status: 'begin', finger: 1, x_mm: 10, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 1, x_mm: 10, y_mm: 10)))
+
+      expect(subject.detect(touch_buffer)).to be_nil
+    end
+
+    it 'moved, just one finger' do
+      touch_buffer.buffer(generate_touch_event(time: t - 1, record: generate_touch_record(status: 'begin', finger: 1, x_mm: 10, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 1, x_mm: 20, y_mm: 10)))
+
+      gesture = subject.detect(touch_buffer)
+      expect(gesture).to be_a(Plugin::Events::Records::TouchRecords::SwipeRecord)
+      expect(gesture.finger).to eq(1)
+    end
+
+    it 'moved, more fingers, angle difference too big' do
+      touch_buffer.buffer(generate_touch_event(time: t - 1, record: generate_touch_record(status: 'begin', finger: 1, x_mm: 10, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 1, x_mm: 20, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t - 1, record: generate_touch_record(status: 'begin', finger: 2, x_mm: 10, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 2, x_mm: 10, y_mm: 20)))
+
+      expect(subject.detect(touch_buffer)).to be_nil
+    end
+
+    it 'moved, more fingers, angle difference under movement_angle_threshold' do
+      touch_buffer.buffer(generate_touch_event(time: t - 1, record: generate_touch_record(status: 'begin', finger: 1, x_mm: 10, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 1, x_mm: 20, y_mm: 8)))
+      touch_buffer.buffer(generate_touch_event(time: t - 1, record: generate_touch_record(status: 'begin', finger: 2, x_mm: 10, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 2, x_mm: 20, y_mm: 12)))
+
+      gesture = subject.detect(touch_buffer)
+      expect(gesture).to be_a(Plugin::Events::Records::TouchRecords::SwipeRecord)
+      expect(gesture.finger).to eq(2)
+    end
+
+    it 'swipe left' do
+      touch_buffer.buffer(generate_touch_event(time: t - 1, record: generate_touch_record(status: 'begin', finger: 1, x_mm: 10, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 1, x_mm: 0, y_mm: 10)))
+
+      gesture = subject.detect(touch_buffer)
+      expect(gesture).to be_a(Plugin::Events::Records::TouchRecords::SwipeRecord)
+      expect(gesture.direction).to eq('left')
+    end
+
+    it 'swipe right' do
+      touch_buffer.buffer(generate_touch_event(time: t - 1, record: generate_touch_record(status: 'begin', finger: 1, x_mm: 0, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 1, x_mm: 10, y_mm: 10)))
+
+      gesture = subject.detect(touch_buffer)
+      expect(gesture).to be_a(Plugin::Events::Records::TouchRecords::SwipeRecord)
+      expect(gesture.direction).to eq('right')
+    end
+
+    it 'swipe up' do
+      touch_buffer.buffer(generate_touch_event(time: t - 1, record: generate_touch_record(status: 'begin', finger: 1, x_mm: 10, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 1, x_mm: 10, y_mm: 0)))
+
+      gesture = subject.detect(touch_buffer)
+      expect(gesture).to be_a(Plugin::Events::Records::TouchRecords::SwipeRecord)
+      expect(gesture.direction).to eq('up')
+    end
+
+    it 'swipe down' do
+      touch_buffer.buffer(generate_touch_event(time: t - 1, record: generate_touch_record(status: 'begin', finger: 1, x_mm: 10, y_mm: 0)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 1, x_mm: 10, y_mm: 10)))
+
+      gesture = subject.detect(touch_buffer)
+      expect(gesture).to be_a(Plugin::Events::Records::TouchRecords::SwipeRecord)
+      expect(gesture.direction).to eq('down')
+    end
+
+    it 'wrong direction, up left' do
+      touch_buffer.buffer(generate_touch_event(time: t - 1, record: generate_touch_record(status: 'begin', finger: 1, x_mm: 20, y_mm: 20)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 1, x_mm: 10, y_mm: 10)))
+
+      expect(subject.detect(touch_buffer)).to be_nil
+    end
+
+    it 'wrong direction, up right' do
+      touch_buffer.buffer(generate_touch_event(time: t - 1, record: generate_touch_record(status: 'begin', finger: 1, x_mm: 0, y_mm: 20)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 1, x_mm: 10, y_mm: 10)))
+
+      expect(subject.detect(touch_buffer)).to be_nil
+    end
+
+    it 'wrong direction, down left' do
+      touch_buffer.buffer(generate_touch_event(time: t - 1, record: generate_touch_record(status: 'begin', finger: 1, x_mm: 20, y_mm: 0)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 1, x_mm: 10, y_mm: 10)))
+
+      expect(subject.detect(touch_buffer)).to be_nil
+    end
+
+    it 'wrong direction, down right' do
+      touch_buffer.buffer(generate_touch_event(time: t - 1, record: generate_touch_record(status: 'begin', finger: 1, x_mm: 0, y_mm: 0)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 1, x_mm: 10, y_mm: 10)))
+
+      expect(subject.detect(touch_buffer)).to be_nil
+    end
+
+    it 'works on real data' do
+      parser = Plugin::Parsers::TouchParser.new
+      buffer = Plugin::Buffers::TouchBuffer.new
+      lines = File.readlines("spec/samples/2-fingers-swipe-right.txt").map(&:strip).reject(&:empty?)
+      lines.each do |line|
+        record = parser.parse_record(line)
+        next unless record
+
+        event = Plugin::Events::Event.new(tag: 'libinput_touch_parser', record: record)
+        buffer.buffer(event)
+      end
+      gesture = subject.detect(buffer)
+      expect(gesture).to be_a(Plugin::Events::Records::TouchRecords::SwipeRecord)
+      expect(gesture.finger).to eq(2)
+      expect(gesture.direction).to eq('right')
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+require 'spec_helper'
+require 'fusuma/plugin/events/event'
+require 'fusuma/plugin/parsers/touch_parser'
+require 'fusuma/plugin/buffers/touch_buffer'
+require 'fusuma/plugin/detectors/touch_detectors/tap_detector'
+require 'fusuma/plugin/events/records/touch_records/tap_record'
+
+module Fusuma
+  RSpec.describe Plugin::Detectors::TouchDetectors::TapDetector do
+    include_context 'with touch buffer'
+    subject { described_class.new }
+
+    before do
+      allow(touch_buffer).to receive(:movement_threshold).and_return(0.5)
+      allow(subject).to receive(:tap_hold_threshold).and_return(0.5)
+      allow(subject).to receive(:jitter_threshold).and_return(5.0)
+    end
+
+    it 'no events' do
+      expect(subject.detect(touch_buffer)).to be nil
+    end
+
+    it 'not began in this cycle' do
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 1, x_mm: 10, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'end', finger: 1)))
+
+      expect(subject.detect(touch_buffer)).to be nil
+    end
+
+    it 'not ended in this cycle' do
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'begin', finger: 1, x_mm: 10, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 1, x_mm: 10, y_mm: 10)))
+
+      expect(subject.detect(touch_buffer)).to be nil
+    end
+
+    it 'moved too much' do
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'begin', finger: 1, x_mm: 10, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 1, x_mm: 20, y_mm: 20)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'end', finger: 1)))
+
+      expect(subject.detect(touch_buffer)).to be nil
+    end
+
+    it 'too long' do
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'begin', finger: 1, x_mm: 10, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t + 0.6, record: generate_touch_record(status: 'end', finger: 1)))
+
+      expect(subject.detect(touch_buffer)).to be nil
+    end
+
+    it 'not moved' do
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'begin', finger: 1, x_mm: 10, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t + 0.1, record: generate_touch_record(status: 'end', finger: 1)))
+      pp touch_buffer.finger_movements
+
+      expect(subject.detect(touch_buffer)).to be_a(Plugin::Events::Records::TouchRecords::TapRecord)
+    end
+
+    it 'moved under jitter threshold' do
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'begin', finger: 1, x_mm: 10, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t + 0.1, record: generate_touch_record(status: 'update', finger: 1, x_mm: 10.1, y_mm: 10.1)))
+      touch_buffer.buffer(generate_touch_event(time: t + 0.2, record: generate_touch_record(status: 'end', finger: 1)))
+
+      expect(subject.detect(touch_buffer)).to be_a(Plugin::Events::Records::TouchRecords::TapRecord)
+    end
+
+    it 'works on real data' do
+      parser = Plugin::Parsers::TouchParser.new
+      buffer = Plugin::Buffers::TouchBuffer.new
+      lines = File.readlines("spec/samples/3-fingers-tap.txt").map(&:strip).reject(&:empty?)
+      lines.each do |line|
+        record = parser.parse_record(line)
+        next unless record
+
+        event = Plugin::Events::Event.new(tag: 'libinput_touch_parser', record: record)
+        buffer.buffer(event)
+      end
+      gesture = subject.detect(buffer)
+      expect(gesture).to be_a(Plugin::Events::Records::TouchRecords::TapRecord)
+      expect(gesture.finger).to eq(3)
+    end
+  end
+end

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

@@ -0,0 +1,266 @@
+require 'timecop'
+require 'spec_helper'
+require 'fusuma/plugin/events/event'
+require 'fusuma/plugin/buffers/touch_buffer'
+require 'fusuma/plugin/detectors/touch_detector'
+
+module Fusuma
+  RSpec.describe Plugin::Detectors::TouchDetector do
+    subject { described_class.new }
+    let(:detectors) { subject.instance_variable_get(:@detectors) }
+    let(:tap_detector) { detectors.find { |d| d.is_a?(Plugin::Detectors::TouchDetectors::TapDetector) } }
+    let(:hold_detector) { subject.instance_variable_get(:@hold_detector) }
+    let(:swipe_detector) { detectors.find { |d| d.is_a?(Plugin::Detectors::TouchDetectors::SwipeDetector) } }
+    before do
+      expect(:detectors).not_to be_empty
+      expect(tap_detector).to be_a(Plugin::Detectors::TouchDetectors::TapDetector)
+      expect(hold_detector).to be_a(Plugin::Detectors::TouchDetectors::HoldDetector)
+      expect(swipe_detector).to be_a(Plugin::Detectors::TouchDetectors::SwipeDetector)
+
+      detectors.each do |detector|
+        allow(detector).to receive(:detect).and_return(nil)
+      end
+    end
+
+    it 'does nothing if no matching buffer' do
+      buffer = double('buffer', type: 'not-touch')
+      expect(subject.detect([buffer])).to eq []
+    end
+
+    it 'ends gesture if too much time passed' do
+      allow(hold_detector).to receive(:detect).and_call_original
+      allow(hold_detector).to receive(:tap_hold_threshold).and_return(1)
+      allow(subject).to receive(:event_expire_time).and_return(1)
+
+      t = Time.now
+      touch_buffer = Plugin::Buffers::TouchBuffer.new
+      Timecop.freeze(t - 4) do
+        touch_buffer.buffer(generate_touch_event(record: generate_touch_record(status: 'update'), time: t - 4))
+      end
+      # 2 seconds - enough to detect hold gesture
+      # event is not expired because of there's no event yet
+      events = Timecop.freeze(t - 2) do
+        # here we detect hold gesture, which makes it the last gesture known to the detector
+        subject.detect([touch_buffer])
+      end
+      expect(events.size).to eq 2
+      expect(events[0].record.index.keys.map(&:symbol)).to eq [:hold, 1]
+      expect(events[1].record.index.keys.map(&:symbol)).to eq [:hold, 1, :begin]
+
+      # now the last gesture becomes 1 second old
+      events = Timecop.freeze(t) do
+        timer_buffer = Plugin::Buffers::TimerBuffer.new
+        timer_buffer.buffer(generate_timer_event(time: t))
+        # here we waited for too long time without new events
+        subject.detect([timer_buffer])
+      end
+
+      expect(events.size).to eq 1
+      expect(events.first.record.index.keys.map(&:symbol)).to eq [:hold, 1, :end]
+    end
+
+    it 'ends gesture if end event is found' do
+      allow(hold_detector).to receive(:detect).and_call_original
+      allow(hold_detector).to receive(:tap_hold_threshold).and_return(1)
+      # let's guarantee the event won't be expired
+      allow(subject).to receive(:event_expire_time).and_return(10)
+
+      t = Time.now
+      touch_buffer = Plugin::Buffers::TouchBuffer.new
+      Timecop.freeze(t - 4) do
+        touch_buffer.buffer(generate_touch_event(record: generate_touch_record(status: 'update'), time: t - 4))
+      end
+      # 2 seconds - enough to detect hold gesture
+      # event is not expired because of there's no event yet
+      events = Timecop.freeze(t - 2) do
+        # here we detect hold gesture, which makes it the last gesture known to the detector
+        subject.detect([touch_buffer])
+      end
+
+      # now we send end event
+      events = Timecop.freeze(t) do
+        touch_buffer.buffer(generate_touch_event(record: generate_touch_record(status: 'end'), time: t))
+        subject.detect([touch_buffer])
+      end
+      expect(events.size).to eq 1
+      expect(events[0].record.index.keys.map(&:symbol)).to eq [:hold, 1, :end]
+    end
+
+    it 'ends gesture if new gesture began' do
+      record = Plugin::Events::Records::TouchRecords::HoldRecord.new(finger: 0)
+      allow(hold_detector).to receive(:detect).and_return(record)
+
+      touch_buffer = Plugin::Buffers::TouchBuffer.new
+      touch_buffer.buffer(generate_touch_event)
+      # let's push the hold gesture as the last known gesture
+      events = subject.detect([touch_buffer])
+      expect(events.size).to eq 2
+      expect(events[0].record.index.keys.map(&:symbol)).to eq [:hold, 0]
+      expect(events[1].record.index.keys.map(&:symbol)).to eq [:hold, 0, :begin]
+
+      record = Plugin::Events::Records::TouchRecords::SwipeRecord.new(finger: 0, direction: 'up')
+      allow(hold_detector).to receive(:detect).and_return(nil)
+      allow(swipe_detector).to receive(:detect).and_return(record)
+
+      # now let's not issue any more events for the hold gesture, but start a new swipe gesture
+      touch_buffer.buffer(generate_touch_event)
+      events = subject.detect([touch_buffer])
+      expect(events.size).to eq 3
+      expect(events[0].record.index.keys.map(&:symbol)).to eq [:hold, 0, :end]
+      expect(events[1].record.index.keys.map(&:symbol)).to eq [:swipe, 0, :up]
+      expect(events[2].record.index.keys.map(&:symbol)).to eq [:swipe, 0, :up, :begin]
+    end
+
+    it 'timer tick does nothing if no touch events' do
+      timer_buffer = Plugin::Buffers::TimerBuffer.new
+      timer_buffer.buffer(generate_timer_event)
+      detectors.each do |detector|
+        expect(detector).not_to receive(:detect)
+      end
+      subject.detect([timer_buffer])
+    end
+
+    it 'calls detectors if touch events' do
+      touch_buffer = Plugin::Buffers::TouchBuffer.new
+      touch_buffer.buffer(generate_touch_event)
+      detectors.each do |detector|
+        expect(detector).to receive(:detect)
+      end
+      subject.detect([touch_buffer])
+    end
+
+    it 'calls detectors if timer tick' do
+      touch_buffer = Plugin::Buffers::TouchBuffer.new
+      touch_buffer.buffer(generate_touch_event)
+      # we call detect which won't detect any gesture yet, but will save the reference to the touch buffer
+      subject.detect([touch_buffer])
+      timer_buffer = Plugin::Buffers::TimerBuffer.new
+      timer_buffer.buffer(generate_timer_event)
+      # in fact only the hold detector benefits from timer ticks for now
+      expect(hold_detector).to receive(:detect)
+      subject.detect([timer_buffer])
+    end
+
+    context 'gesture detected' do
+      it 'clears touch buffer' do
+        record = Plugin::Events::Records::TouchRecords::TapRecord.new(finger: 0)
+        allow(tap_detector).to receive(:detect).and_return(record)
+        touch_buffer = Plugin::Buffers::TouchBuffer.new
+        touch_buffer.buffer(generate_touch_event)
+        expect(touch_buffer).to receive(:clear)
+        subject.detect([touch_buffer])
+      end
+
+      context 'repeatable' do
+        it 'creates event' do
+          record = Plugin::Events::Records::TouchRecords::HoldRecord.new(finger: 0)
+          allow(hold_detector).to receive(:detect).and_return(record)
+          touch_buffer = Plugin::Buffers::TouchBuffer.new
+          touch_buffer.buffer(generate_touch_event)
+          events = subject.detect([touch_buffer])
+          expect(events.size).to eq 2
+          expect(events[0].record.index.keys.map(&:symbol)).to eq [:hold, 0]
+          expect(events[1].record.index.keys.map(&:symbol)).to eq [:hold, 0, :begin]
+        end
+
+        it 'matches last known gesture' do
+          record = Plugin::Events::Records::TouchRecords::HoldRecord.new(finger: 0)
+          allow(hold_detector).to receive(:detect).and_return(record)
+
+          touch_buffer = Plugin::Buffers::TouchBuffer.new
+          touch_buffer.buffer(generate_touch_event)
+          # make it the last known gesture
+          subject.detect([touch_buffer])
+
+          touch_buffer.buffer(generate_touch_event)
+          events = subject.detect([touch_buffer])
+
+          expect(events.size).to eq 1
+          expect(events[0].record.index.keys.map(&:symbol)).to eq [:hold, 0, :update]
+        end
+
+        it 'does not match last known gesture' do
+          record = Plugin::Events::Records::TouchRecords::HoldRecord.new(finger: 0)
+          allow(hold_detector).to receive(:detect).and_return(record)
+
+          touch_buffer = Plugin::Buffers::TouchBuffer.new
+          touch_buffer.buffer(generate_touch_event)
+          # make it the last known gesture
+          subject.detect([touch_buffer])
+
+          record = Plugin::Events::Records::TouchRecords::HoldRecord.new(finger: 1)
+          allow(hold_detector).to receive(:detect).and_return(record)
+          touch_buffer.buffer(generate_touch_event)
+          events = subject.detect([touch_buffer])
+
+          expect(events.size).to eq 3
+          expect(events[0].record.index.keys.map(&:symbol)).to eq [:hold, 0, :end]
+          expect(events[1].record.index.keys.map(&:symbol)).to eq [:hold, 1]
+          expect(events[2].record.index.keys.map(&:symbol)).to eq [:hold, 1, :begin]
+        end
+
+        it 'no last known gesture' do
+          record = Plugin::Events::Records::TouchRecords::HoldRecord.new(finger: 0)
+          allow(hold_detector).to receive(:detect).and_return(record)
+
+          touch_buffer = Plugin::Buffers::TouchBuffer.new
+          touch_buffer.buffer(generate_touch_event)
+          events = subject.detect([touch_buffer])
+
+          expect(events.size).to eq 2
+          expect(events[0].record.index.keys.map(&:symbol)).to eq [:hold, 0]
+          expect(events[1].record.index.keys.map(&:symbol)).to eq [:hold, 0, :begin]
+        end
+      end
+
+      context 'non-repeatable' do
+        it 'ends last known repeatable gesture if any' do
+          record = Plugin::Events::Records::TouchRecords::HoldRecord.new(finger: 0)
+          allow(hold_detector).to receive(:detect).and_return(record)
+
+          touch_buffer = Plugin::Buffers::TouchBuffer.new
+          touch_buffer.buffer(generate_touch_event)
+          # make it the last known gesture
+          subject.detect([touch_buffer])
+
+          allow(hold_detector).to receive(:detect).and_return(nil)
+          record = Plugin::Events::Records::TouchRecords::TapRecord.new(finger: 0)
+          allow(tap_detector).to receive(:detect).and_return(record)
+          touch_buffer.buffer(generate_touch_event)
+          events = subject.detect([touch_buffer])
+
+          expect(events.size).to eq 2
+          expect(events[0].record.index.keys.map(&:symbol)).to eq [:hold, 0, :end]
+          expect(events[1].record.index.keys.map(&:symbol)).to eq [:tap, 0]
+        end
+
+        it 'creates event' do
+          record = Plugin::Events::Records::TouchRecords::TapRecord.new(finger: 0)
+          allow(tap_detector).to receive(:detect).and_return(record)
+          touch_buffer = Plugin::Buffers::TouchBuffer.new
+          touch_buffer.buffer(generate_touch_event)
+          events = subject.detect([touch_buffer])
+          expect(events.size).to eq 1
+          expect(events[0].record.index.keys.map(&:symbol)).to eq [:tap, 0]
+        end
+
+        it 'does not repeat' do
+          record = Plugin::Events::Records::TouchRecords::TapRecord.new(finger: 0)
+          allow(tap_detector).to receive(:detect).and_return(record)
+
+          touch_buffer = Plugin::Buffers::TouchBuffer.new
+          touch_buffer.buffer(generate_touch_event)
+          events = subject.detect([touch_buffer])
+          expect(events.size).to eq 1
+          expect(events[0].record.index.keys.map(&:symbol)).to eq [:tap, 0]
+
+          touch_buffer.buffer(generate_touch_event)
+          events = subject.detect([touch_buffer])
+          expect(events.size).to eq 1
+          expect(events[0].record.index.keys.map(&:symbol)).to eq [:tap, 0]
+        end
+      end
+    end # context 'gesture detected'
+
+  end # describe Plugin::Detectors::TouchDetector
+end

data/spec/fusuma/plugin/devices/touchscreen_device_spec.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 require "spec_helper"
-require './lib/fusuma/plugin/devices/touchscreen_device'
+require 'fusuma/plugin/inputs/libinput_command_input'
+require 'fusuma/plugin/devices/touchscreen_device'
 
 module Fusuma
   RSpec.describe Plugin::Touchscreen::DevicePatch do
@@ -21,13 +22,15 @@ module Fusuma
     # that's the only touchscreen device I have :)
     context 'Microsoft Surface 3 Pro' do
       let(:list_devices_output) do
-        File.open("./spec/fixtures/libinput-list-devices_ms-surface-3-pro.txt")
+        File.open("./spec/samples/libinput-list-devices.txt")
       end
 
-      it 'detects Microsoft Surface 3 Pro touchscreen' do
+      it 'detects touchscreen' do
         expect(Device.available.map(&:name)).to include 'NTRG0001:01 1B96:1B05'
       end
     end
 
+    # TODO: create a test for a dummy device with touch capability
+
   end
 end