fusuma 2.5.0 → 3.0.0

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

@@ -7,9 +7,25 @@ module Fusuma
     module Buffers
       # manage events and generate command
       class GestureBuffer < Buffer
+        CacheEntry = Struct.new(:checked, :value)
         DEFAULT_SOURCE = "libinput_gesture_parser"
         DEFAULT_SECONDS_TO_KEEP = 100
 
+
+        def initialize(*args)
+          super(*args)
+          @cache = {}
+          @cache_select_by = {}
+          @cache_sum10 = {}
+        end
+
+        def clear
+          super.clear
+          @cache = {}
+          @cache_select_by = {}
+          @cache_sum10 = {}
+        end
+
         def config_param_types
           {
             source: [String],
@@ -40,6 +56,9 @@ module Fusuma
             MultiLogger.debug("#{self.class.name}##{__method__}")
 
             @events.delete(e)
+            @cache = {}
+            @cache_select_by = {}
+            @cache_sum10 = {}
           end
         end
 
@@ -59,11 +78,35 @@ module Fusuma
         def sum_attrs(attr)
           updating_events.map do |gesture_event|
             gesture_event.record.delta[attr].to_f
-          end.inject(:+)
+          end.reduce(:+)
+        end
+
+        # @param attr [Symbol]
+        # @return [Float]
+        def sum_last10_attrs(attr) # sums last 10 values of attr (or all if length < 10)
+          cache_entry = ( @cache_sum10[attr] ||= CacheEntry.new(0, 0) )
+          upd_ev = updating_events
+          if upd_ev.length > cache_entry.checked + 1 then
+            cache_entry.value = upd_ev.last(10).map do |gesture_event|
+              gesture_event.record.delta[attr].to_f
+            end.reduce(:+)
+          elsif upd_ev.length > cache_entry.checked
+            cache_entry.value = cache_entry.value + upd_ev[-1].record.delta[attr].to_f - \
+              (upd_ev.length > 10 ? upd_ev[-11].record.delta[attr].to_f : 0)
+          else
+            return cache_entry.value
+          end
+          cache_entry.checked = upd_ev.length
+          cache_entry.value
         end
 
         def updating_events
-          @events.select { |e| e.record.status == "update" }
+          cache_entry = ( @cache[:updating_events] ||= CacheEntry.new(0, []) )
+          cache_entry.checked.upto(@events.length - 1).each do |i|
+            (cache_entry.value << @events[i]) if @events[i].record.status == "update"
+          end
+          cache_entry.checked = @events.length
+          cache_entry.value
         end
 
         # @param attr [Symbol]
@@ -96,14 +139,28 @@ module Fusuma
           self.class.new events
         end
 
+        def select_by_type(type)
+          cache_entry = ( @cache_select_by[type] ||= CacheEntry.new(0, self.class.new([])) )
+          cache_entry.checked.upto(@events.length - 1).each do |i|
+            (cache_entry.value.events << @events[i]) if @events[i].record.gesture == type
+          end
+          cache_entry.checked = @events.length
+          cache_entry.value
+        end
+
         def select_from_last_begin
           return self if empty?
+          cache_entry = ( @cache[:last_begin] ||= CacheEntry.new(0, nil) )
+
+          cache_entry.value = (@events.length - 1).downto(cache_entry.checked).find do |i|
+            @events[i].record.status == "begin"
+          end || cache_entry.value
+          cache_entry.checked = @events.length
 
-          index_from_last = @events.reverse.find_index { |e| e.record.status == "begin" }
-          return GestureBuffer.new([]) if index_from_last.nil?
+          return self if cache_entry.value == 0
+          return GestureBuffer.new([]) if cache_entry.value.nil?
 
-          index_last_begin = events.length - index_from_last - 1
-          GestureBuffer.new(@events[index_last_begin..-1])
+          GestureBuffer.new(@events[cache_entry.value..-1])
         end
       end
     end

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

@@ -8,9 +8,18 @@ module Fusuma
     module Detectors
       # Inherite this base
       class Detector < Base
+        def initialize(*args)
+          super(*args)
+          @tag = self.class.tag
+          @type = self.class.type
+        end
+
+        attr_reader :tag
+        attr_reader :type
+
         # @return [Array<String>]
         def sources
-          @source ||= self.class.const_get(:SOURCES)
+          @sources ||= self.class.const_get(:SOURCES)
         end
 
         # Always watch buffers and detect them or not
@@ -43,14 +52,6 @@ module Fusuma
           @last_time.nil?
         end
 
-        def tag
-          self.class.tag
-        end
-
-        def type
-          self.class.type
-        end
-
         class << self
           def tag
             name.split("Detectors::").last.underscore

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "./detector"
+require_relative "../inputs/timer_input"
 
 module Fusuma
   module Plugin
@@ -10,6 +11,7 @@ module Fusuma
         SOURCES = %w[gesture timer].freeze
         BUFFER_TYPE = "gesture"
         GESTURE_RECORD_TYPE = "hold"
+        Timer = Inputs::TimerInput.instance
 
         BASE_THERESHOLD = 0.7
 
@@ -21,16 +23,15 @@ module Fusuma
           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"
@@ -42,16 +43,19 @@ module Fusuma
           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)
@@ -97,12 +101,12 @@ module Fusuma
         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
@@ -110,7 +114,13 @@ module Fusuma
         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:)

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

@@ -19,7 +19,7 @@ module Fusuma
         def detect(buffers)
           gesture_buffer = 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)
 
           updating_events = gesture_buffer.updating_events
           return if updating_events.empty?
@@ -100,10 +100,10 @@ module Fusuma
         def create_repeat_index(gesture:, finger:, direction:, status:)
           Config::Index.new(
             [
-              Config::Index::Key.new(gesture),
-              Config::Index::Key.new(finger.to_i),
-              Config::Index::Key.new(direction, skippable: true),
-              Config::Index::Key.new(status)
+              Config::Index::Key.new(gesture), # 'pinch'
+              Config::Index::Key.new(finger.to_i), # 2, 3, 4
+              Config::Index::Key.new(direction, skippable: true), # 'in', 'out'
+              Config::Index::Key.new(status) # 'begin', 'update', 'end'
             ]
           )
         end
@@ -115,9 +115,9 @@ module Fusuma
         def create_oneshot_index(gesture:, finger:, direction:)
           Config::Index.new(
             [
-              Config::Index::Key.new(gesture),
-              Config::Index::Key.new(finger.to_i, skippable: true),
-              Config::Index::Key.new(direction)
+              Config::Index::Key.new(gesture), # 'pinch'
+              Config::Index::Key.new(finger.to_i, skippable: true), # 2, 3, 4
+              Config::Index::Key.new(direction) # 'in', 'out'
             ]
           )
         end
@@ -161,9 +161,9 @@ module Fusuma
 
           def calc
             if @target > @base
-              IN
-            else
               OUT
+            else
+              IN
             end
           end
         end

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

@@ -19,21 +19,14 @@ module Fusuma
         def detect(buffers)
           gesture_buffer = 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)
 
           updating_events = gesture_buffer.updating_events
           return if updating_events.empty?
 
-          oneshot_angle = if updating_events.size >= 10
-            updating_time = 100 * (updating_events[-1].time - updating_events[-10].time)
-            last_10 = gesture_buffer.class.new(updating_events[-10..-1])
-            last_10.sum_attrs(:rotate) / updating_time
-          else
-            updating_time = 100 * (updating_events.last.time - updating_events.first.time)
-            gesture_buffer.sum_attrs(:rotate) / updating_time
-          end
-
-          return if updating_events.empty?
+          updating_time = 100 * (updating_events[-1].time -
+                                 (updating_events[-10] || updating_events.first).time)
+          oneshot_angle = gesture_buffer.sum_last10_attrs(:rotate) / updating_time
 
           finger = gesture_buffer.finger
 

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

@@ -19,22 +19,15 @@ module Fusuma
         def detect(buffers)
           gesture_buffer = 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)
 
           updating_events = gesture_buffer.updating_events
           return if updating_events.empty?
 
-          oneshot_move_x, oneshot_move_y = if updating_events.size >= 10
-            updating_time = 100 * (updating_events[-1].time - updating_events[-10].time)
-            last_10 = gesture_buffer.class.new(updating_events[-10..-1])
-            [last_10.sum_attrs(:move_x) / updating_time,
-              last_10.sum_attrs(:move_y) / updating_time]
-          else
-            updating_time = 100 * (updating_events.last.time - updating_events.first.time)
-            [gesture_buffer.sum_attrs(:move_x) / updating_time,
-              gesture_buffer.sum_attrs(:move_y) / updating_time]
-          end
-          (gesture_buffer.sum_attrs(:move_x) / updating_time)
+          updating_time = 100 * (updating_events.last.time -
+                                 (updating_events[-10] || updating_events.first).time)
+          oneshot_move_x = gesture_buffer.sum_last10_attrs(:move_x) / updating_time
+          oneshot_move_y = gesture_buffer.sum_last10_attrs(:move_y) / updating_time
 
           finger = gesture_buffer.finger
           status = case gesture_buffer.events.last.record.status
@@ -67,8 +60,7 @@ module Fusuma
 
             oneshot_direction = Direction.new(move_x: oneshot_move_x, move_y: oneshot_move_y).to_s
             oneshot_quantity = Quantity.new(move_x: oneshot_move_x, move_y: oneshot_move_y).to_f
-            oneshot_index = create_oneshot_index(gesture: type, finger: finger,
-              direction: oneshot_direction)
+            oneshot_index = create_oneshot_index(gesture: type, finger: finger, direction: oneshot_direction)
             if enough_oneshot_threshold?(index: oneshot_index, quantity: oneshot_quantity)
               return [
                 create_event(record: Events::Records::IndexRecord.new(
@@ -109,7 +101,7 @@ module Fusuma
           Config::Index.new(
             [
               Config::Index::Key.new(gesture),
-              Config::Index::Key.new(finger.to_i, skippable: true),
+              Config::Index::Key.new(finger.to_i),
               Config::Index::Key.new(direction)
             ]
           )

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

@@ -11,9 +11,12 @@ module Fusuma
           # define gesture format
           attr_reader :status, :gesture, :finger, :delta
 
-          Delta = Struct.new(:move_x, :move_y,
+          Delta = Struct.new(
+            :move_x, :move_y,
             :unaccelerated_x, :unaccelerated_y,
-            :zoom, :rotate)
+            :zoom,
+            :rotate
+          )
 
           # @param status [String]
           # @param gesture [String]

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

@@ -35,7 +35,7 @@ module Fusuma
             raise "position is NOT body: #{self}" unless mergable?
 
             if records.empty?
-              if Config.find_execute_key(index)
+              if Config.instance.find_execute_key(index)
                 @index = index
                 return self
               end

data/lib/fusuma/plugin/executors/command_executor.rb

@@ -39,14 +39,14 @@ module Fusuma
         # @return [String]
         def search_command(event)
           command_index = Config::Index.new([*event.record.index.keys, :command])
-          Config.search(command_index)
+          Config.instance.search(command_index)
         end
 
         # @param event [Event]
         # @return [Float]
         def args_accel(event)
           accel_index = Config::Index.new([*event.record.index.keys, :accel])
-          (Config.search(accel_index) || 1).to_f
+          (Config.instance.search(accel_index) || 1).to_f
         end
       end
     end

data/lib/fusuma/plugin/executors/executor.rb

@@ -26,12 +26,9 @@ module Fusuma
         end
 
         # @param event [Events::Event]
-        # @param time [Time]
         # @return [TrueClass, FalseClass]
         def enough_interval?(event)
-          # NOTE: Cache at the index that is actually used, reflecting Fallback and Skip.
-          #       Otherwise, a wrong index will cause invalid intervals.
-          return true if event.record.index.with_context.keys.any? { |key| key.symbol == :end }
+          return true if event.record.index.keys.any? { |key| key.symbol == :end }
 
           return false if @wait_until && event.time < @wait_until
 

data/lib/fusuma/plugin/filters/libinput_device_filter.rb

@@ -25,7 +25,8 @@ module Fusuma
             keep_device.reset
             return false
           end
-          keep_device.all.map(&:id).any? { |device_id| record.to_s =~ /^[\s-]?#{device_id}\s/ }
+          device_id = record.to_s.match(/\S*/, 1).to_s
+          keep_device.all.map(&:id).include?(device_id)
         end
 
         def keep_device

data/lib/fusuma/plugin/inputs/input.rb

@@ -9,8 +9,14 @@ module Fusuma
       # Inherite this base
       # @abstract Subclass and override {#io} to implement
       class Input < Base
+        def initialize(*args)
+          super(*args)
+          @tag = self.class.name.split("Inputs::").last.underscore
+        end
+
+        attr_reader :tag
+
         # Wait multiple inputs until it becomes readable
-        # and read lines with nonblock
         # @param inputs [Array<Input>]
         # @return [Event]
         def self.select(inputs)
@@ -20,20 +26,17 @@ module Fusuma
           input = inputs.find { |i| i.io == io }
 
           begin
-            line = io.readline_nonblock("\n").chomp
+            # NOTE: io.readline is blocking method
+            # each input plugin must write line to pipe (include `\n`)
+            line = io.readline(chomp: true)
           rescue EOFError => e
-            warn "#{input.class.name}: #{e}"
-            warn "Send SIGKILL to fusuma processes"
-            inputs.reject { |i| i == input }.each do |i|
-              warn "stop process: #{i.class.name.underscore}"
-              Process.kill(:SIGKILL, i.pid)
-            end
-            exit 1
+            MultiLogger.error "#{input.class.name}: #{e}"
+            MultiLogger.error "Shutdown fusuma process..."
+            Process.kill("TERM", Process.pid)
           rescue => e
-            warn "#{input.class.name}: #{e}"
+            MultiLogger.error "#{input.class.name}: #{e}"
             exit 1
           end
-
           input.create_event(record: line)
         end
 
@@ -53,32 +56,7 @@ module Fusuma
           MultiLogger.debug(input_event: e)
           e
         end
-
-        def tag
-          self.class.name.split("Inputs::").last.underscore
-        end
       end
     end
   end
 end
-
-# ref: https://github.com/Homebrew/brew/blob/6b2dbbc96f7d8aa12f9b8c9c60107c9cc58befc4/Library/Homebrew/extend/io.rb
-class IO
-  def readline_nonblock(sep = $INPUT_RECORD_SEPARATOR)
-    line = +""
-    buffer = +""
-
-    loop do
-      break if buffer == sep
-
-      read_nonblock(1, buffer)
-      line.concat(buffer)
-    end
-
-    line.freeze
-  rescue IO::WaitReadable, EOFError => e
-    raise e if line.empty?
-
-    line.freeze
-  end
-end

data/lib/fusuma/plugin/inputs/timer_input.rb

@@ -1,20 +1,29 @@
 # frozen_string_literal: true
 
 require_relative "./input"
+require "timeout"
 
 module Fusuma
   module Plugin
     module Inputs
       # libinput commands wrapper
       class TimerInput < Input
-        DEFAULT_INTERVAL = 0.3
+        include Singleton
+        DEFAULT_INTERVAL = 5
+        EPSILON_TIME = 0.02
         def config_param_types
           {
             interval: [Float]
           }
         end
 
-        attr_reader :pid
+        def initialize(*args, interval: nil)
+          super(*args)
+          @interval = interval || config_params(:interval) || DEFAULT_INTERVAL
+          @early_wake_queue = Queue.new
+        end
+
+        attr_reader :pid, :interval
 
         def io
           @io ||= begin
@@ -26,26 +35,36 @@ module Fusuma
         end
 
         def start(reader, writer)
-          pid = fork do
-            timer_loop(reader, writer)
+          Thread.new do
+            timer_loop(writer)
           end
-          Process.detach(pid)
-          writer.close
-          pid
+          nil
         end
 
-        def timer_loop(reader, writer)
-          reader.close
-          begin
-            loop do
-              sleep interval
-              writer.puts "timer"
+        def timer_loop(writer)
+          delta_t = @interval
+          next_wake = Time.now + delta_t
+          loop do
+            sleep_time = next_wake - Time.now
+            if sleep_time <= 0
+              raise Timeout::Error
+            end
+
+            Timeout.timeout(sleep_time) do
+              next_wake = [@early_wake_queue.deq, next_wake].min
             end
-          rescue Errno::EPIPE
-            exit 0
-          rescue => e
-            MultiLogger.error e
+          rescue Timeout::Error
+            writer.puts "timer"
+            next_wake = Time.now + delta_t
           end
+        rescue Errno::EPIPE
+          exit 0
+        rescue => e
+          MultiLogger.error e
+        end
+
+        def wake_early(t)
+          @early_wake_queue.push(t + EPSILON_TIME)
         end
 
         private
@@ -53,10 +72,6 @@ module Fusuma
         def create_io
           IO.pipe
         end
-
-        def interval
-          config_params(:interval) || DEFAULT_INTERVAL
-        end
       end
     end
   end