hold_detector.rb in fusuma-3.0.0

- old
+ new

@@ -1,17 +1,19 @@
 # frozen_string_literal: true
 
 require_relative "./detector"
+require_relative "../inputs/timer_input"
 
 module Fusuma
   module Plugin
     module Detectors
       # Detect Hold gesture
       class HoldDetector < Detector
         SOURCES = %w[gesture timer].freeze
         BUFFER_TYPE = "gesture"
         GESTURE_RECORD_TYPE = "hold"
+        Timer = Inputs::TimerInput.instance
 
         BASE_THERESHOLD = 0.7
 
         # @param buffers [Array<Buffers::Buffer>]
         # @return [Events::Event] if event is detected
@@ -19,20 +21,19 @@
         # @return [NilClass] if event is NOT detected
         def detect(buffers)
           hold_buffer = find_hold_buffer(buffers)
           return if hold_buffer.empty?
 
-          hold_events = hold_buffer.events
+          last_hold = hold_buffer.events.last
 
           timer_buffer = buffers.find { |b| b.type == "timer" }
-          timer_events = timer_buffer.events
+          last_timer = timer_buffer.events.last
 
           finger = hold_buffer.finger
-          holding_time = calc_holding_time(hold_events: hold_events, timer_events: timer_events)
+          holding_time = calc_holding_time(hold_events: hold_buffer.events, last_timer: last_timer)
 
-          @timeout ||= nil
-          status = case hold_events.last.record.status
+          status = case last_hold.record.status
           when "begin"
             if holding_time.zero?
               "begin"
             else
               "timer"
@@ -40,20 +41,23 @@
           when "cancelled"
             "cancelled"
           when "end"
             "end"
           else
-            last_record = hold_events.last.record.status
+            last_record = last_hold.record.status
             raise "Unexpected Status:#{last_record.status} in #{last_record}"
           end
 
           repeat_index = create_repeat_index(finger: finger, status: status)
           oneshot_index = create_oneshot_index(finger: finger)
 
-          @timeout = nil if status == "begin"
-
-          if status == "timer"
+          if status == "begin" then
+            @timeout = nil
+            if threshold(index: oneshot_index) < Timer.interval then
+              Timer.wake_early(Time.now + threshold(index: oneshot_index))
+            end
+          elsif status == "timer"
             return if @timeout
 
             return unless enough?(index: oneshot_index, holding_time: holding_time)
 
             @timeout = holding_time
@@ -95,23 +99,29 @@
         # @param buffers [Array<Buffers::Buffer>]
         # @return [Buffers::GestureBuffer]
         def find_hold_buffer(buffers)
           buffers.find { |b| b.type == BUFFER_TYPE }
             .select_from_last_begin
-            .select_by_events { |e| e.record.gesture == GESTURE_RECORD_TYPE }
+            .select_by_type(GESTURE_RECORD_TYPE)
         end
 
-        def calc_holding_time(hold_events:, timer_events:)
-          last_time = if !timer_events.empty? && (hold_events.last.time < timer_events.last.time)
-            timer_events.last.time
+        def calc_holding_time(hold_events:, last_timer:)
+          last_time = if last_timer && (hold_events.last.time < last_timer.time)
+            last_timer.time
           else
             hold_events.last.time
           end
           last_time - hold_events.first.time
         end
 
         def enough?(index:, holding_time:)
-          holding_time > threshold(index: index)
+          diff = threshold(index: index) - holding_time
+          if diff < 0 then
+            true
+          elsif diff < Timer.interval
+            Timer.wake_early(Time.now + diff)
+            false
+          end
         end
 
         def threshold(index:)
           @threshold ||= {}
           @threshold[index.cache_key] ||= begin