fusuma 1.10.2 → 2.0.1

data/lib/fusuma/multi_logger.rb

@@ -12,15 +12,11 @@ module Fusuma
     attr_accessor :debug_mode
 
     def initialize
-      super(STDOUT)
-      @err_logger = Logger.new(STDERR)
+      super($stdout)
+      @err_logger = Logger.new($stderr)
       @debug_mode = false
     end
 
-    def info(msg)
-      super(msg)
-    end
-
     def debug(msg)
       return unless debug_mode?
 

data/lib/fusuma/plugin/base.rb

@@ -1,22 +1,23 @@
 # frozen_string_literal: true
 
-require_relative './manager.rb'
-require_relative '../config.rb'
+require_relative './manager'
+require_relative '../config'
+require_relative '../custom_process'
 
 module Fusuma
   module Plugin
     # Create a Plugin Class with extending this class
     class Base
+      include CustomProcess
       # when inherited from subclass
       def self.inherited(subclass)
+        super
         subclass_path = caller_locations(1..1).first.path
         Manager.add(plugin_class: subclass, plugin_path: subclass_path)
       end
 
-      # get inherited classes
-      # @example
-      #  [Vectors::Vector]
-      # @return [Array]
+      # get subclasses
+      # @return [Array<Class>]
       def self.plugins
         Manager.plugins[name]
       end
@@ -33,19 +34,21 @@ module Fusuma
 
         return params unless key
 
-        params.fetch(key, nil).tap do |val|
-          next if val.nil?
+        @config_params ||= {}
+        @config_params["#{base.cache_key},#{key}"] ||=
+          params.fetch(key, nil).tap do |val|
+            next if val.nil?
 
-          # NOTE: Type checking for config.yml
-          param_types = Array(config_param_types.fetch(key))
+            # NOTE: Type checking for config.yml
+            param_types = Array(config_param_types.fetch(key))
 
-          next if param_types.any? { |klass| val.is_a?(klass) }
+            next if param_types.any? { |klass| val.is_a?(klass) }
 
-          MultiLogger.error('Please fix config.yml.')
-          MultiLogger.error(":#{base.keys.map(&:symbol)
+            MultiLogger.error('Please fix config.yml.')
+            MultiLogger.error(":#{base.keys.map(&:symbol)
             .join(' => :')} => :#{key} should be #{param_types.join(' OR ')}.")
-          exit 1
-        end
+            exit 1
+          end
       end
 
       def config_index

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../base.rb'
+require_relative '../base'
 
 module Fusuma
   module Plugin
@@ -8,6 +8,7 @@ module Fusuma
       # buffer events and output
       class Buffer < Base
         def initialize(*args)
+          super()
           @events = Array.new(*args)
         end
 
@@ -15,7 +16,7 @@ module Fusuma
 
         # @return [String]
         def type
-          self.class.name.underscore.split('/').last.gsub('_buffer', '')
+          @type ||= self.class.name.underscore.split('/').last.gsub('_buffer', '')
         end
 
         # @param event [Event]

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative './buffer.rb'
+require_relative './buffer'
 
 module Fusuma
   module Plugin
@@ -8,17 +8,17 @@ module Fusuma
       # manage events and generate command
       class GestureBuffer < Buffer
         DEFAULT_SOURCE = 'libinput_gesture_parser'
-        DEFAULT_SECONDS_TO_KEEP = 0.1
+        DEFAULT_SECONDS_TO_KEEP = 100
 
         def config_param_types
           {
-            'source': [String],
-            'seconds_to_keep': [Float, Integer]
+            source: [String],
+            seconds_to_keep: [Float, Integer]
           }
         end
 
         # @param event [Event]
-        # @return [Buffer, false]
+        # @return [Buffer, FalseClass]
         def buffer(event)
           # TODO: buffering events into buffer plugins
           # - gesture event buffer
@@ -26,16 +26,13 @@ module Fusuma
           # - other event buffer
           return if event&.tag != source
 
-          if bufferable?(event)
-            @events.push(event)
-            self
-          else
-            clear
-            false
-          end
+          @events.push(event)
+          self
         end
 
         def clear_expired(current_time: Time.now)
+          clear if ended?
+
           @seconds_to_keep ||= (config_params(:seconds_to_keep) || DEFAULT_SECONDS_TO_KEEP)
           @events.each do |e|
             break if current_time - e.time < @seconds_to_keep
@@ -46,17 +43,28 @@ module Fusuma
           end
         end
 
+        def ended?
+          return false if empty?
+
+          @events.last.record.status == 'end'
+        end
+
         # @param attr [Symbol]
         # @return [Float]
         def sum_attrs(attr)
-          @events.map { |gesture_event| gesture_event.record.direction[attr].to_f }
-                 .inject(:+)
+          updating_events.map do |gesture_event|
+            gesture_event.record.delta[attr].to_f
+          end.inject(:+)
+        end
+
+        def updating_events
+          @events.select { |e| e.record.status == 'update' }
         end
 
         # @param attr [Symbol]
         # @return [Float]
         def avg_attrs(attr)
-          sum_attrs(attr).to_f / @events.length
+          sum_attrs(attr).to_f / updating_events.length
         end
 
         # return [Integer]
@@ -76,20 +84,21 @@ module Fusuma
           @events.empty?
         end
 
-        def select_by_events
-          return enum_for(:select) unless block_given?
+        def select_by_events(&block)
+          return enum_for(:select_by_events) unless block_given?
 
-          events = @events.select { |event| yield event }
+          events = @events.select(&block)
           self.class.new events
         end
 
-        def bufferable?(event)
-          case event.record.status
-          when 'begin', 'end'
-            false
-          else
-            true
-          end
+        def select_from_last_begin
+          return self if empty?
+
+          index_from_last = @events.reverse.find_index { |e| e.record.status == 'begin' }
+          return GestureBuffer.new([]) if index_from_last.nil?
+
+          index_last_begin = events.length - index_from_last - 1
+          GestureBuffer.new(@events[index_last_begin..-1])
         end
       end
     end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative './buffer'
+
+module Fusuma
+  module Plugin
+    module Buffers
+      # manage events and generate command
+      class TimerBuffer < Buffer
+        DEFAULT_SOURCE = 'timer_input'
+        DEFAULT_SECONDS_TO_KEEP = 60
+
+        def config_param_types
+          {
+            source: [String],
+            seconds_to_keep: [Float, Integer]
+          }
+        end
+
+        # @param event [Event]
+        # @return [Buffer, NilClass]
+        def buffer(event)
+          return if event&.tag != source
+
+          @events.push(event)
+          self
+        end
+
+        def clear_expired(current_time: Time.now)
+          @seconds_to_keep ||= (config_params(:seconds_to_keep) || DEFAULT_SECONDS_TO_KEEP)
+          @events.each do |e|
+            break if current_time - e.time < @seconds_to_keep
+
+            MultiLogger.debug("#{self.class.name}##{__method__}")
+
+            @events.delete(e)
+          end
+        end
+
+        def empty?
+          @events.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -1,13 +1,24 @@
 # frozen_string_literal: true
 
-require_relative '../base.rb'
-require_relative '../events/event.rb'
+require_relative '../base'
+require_relative '../events/event'
 
 module Fusuma
   module Plugin
     module Detectors
       # Inherite this base
       class Detector < Base
+        # @return [Array<String>]
+        def sources
+          @source ||= self.class.const_get('SOURCES')
+        end
+
+        # Always watch buffers and detect them or not
+        # @return [TrueClass,FalseClass]
+        def watch?
+          false
+        end
+
         # @param _buffers [Array<Buffer>]
         # @return [Event] if event is detected
         # @return [NilClass] if event is NOT detected
@@ -21,7 +32,7 @@ module Fusuma
         # @return [Events::Event]
         def create_event(record:)
           @last_time = Time.now
-          Events::Event.new(time: Time.now, tag: tag, record: record)
+          Events::Event.new(time: @last_time, tag: tag, record: record)
         end
 
         def last_time
@@ -33,11 +44,21 @@ module Fusuma
         end
 
         def tag
-          self.class.name.split('Detectors::').last.underscore
+          self.class.tag
         end
 
         def type
-          self.class.name.underscore.split('/').last.gsub('_detector', '')
+          self.class.type
+        end
+
+        class << self
+          def tag
+            name.split('Detectors::').last.underscore
+          end
+
+          def type(tag_name = tag)
+            tag_name.gsub('_detector', '')
+          end
         end
       end
     end

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

@@ -1,50 +1,111 @@
 # frozen_string_literal: true
 
-require_relative './detector.rb'
+require_relative './detector'
 
 module Fusuma
   module Plugin
     module Detectors
       class PinchDetector < Detector
+        SOURCES = ['gesture'].freeze
         BUFFER_TYPE = 'gesture'
         GESTURE_RECORD_TYPE = 'pinch'
 
         FINGERS = [2, 3, 4].freeze
-        BASE_THERESHOLD = 0.1
-        BASE_INTERVAL   = 0.1
+        BASE_THERESHOLD = 1.3
 
         # @param buffers [Array<Buffer>]
-        # @return [Event] if event is detected
+        # @return [Events::Event] if event is detected
         # @return [NilClass] if event is NOT detected
         def detect(buffers)
-          buffer = buffers.find { |b| b.type == BUFFER_TYPE }
-                          .select_by_events { |e| e.record.gesture == GESTURE_RECORD_TYPE }
-
-          return if buffer.empty?
-
-          finger = buffer.finger
-
-          avg_zoom = buffer.avg_attrs(:zoom)
-          first_zoom = buffer.events.first.record.direction.zoom
-          diameter = avg_zoom / first_zoom
-
-          direction = Direction.new(diameter: diameter).to_s
-          quantity = Quantity.new(diameter: diameter).to_f
-
-          index = create_index(gesture: type,
-                               finger: finger,
-                               direction: direction)
-
-          return unless enough?(index: index, quantity: quantity)
+          gesture_buffer = buffers.find { |b| b.type == BUFFER_TYPE }
+                                  .select_from_last_begin
+                                  .select_by_events { |e| e.record.gesture == GESTURE_RECORD_TYPE }
+
+          updating_events = gesture_buffer.updating_events
+          return if updating_events.empty?
+
+          finger = gesture_buffer.finger
+
+          status = case gesture_buffer.events.last.record.status
+                   when 'end'
+                     'end'
+                   when 'update'
+                     if updating_events.length == 1
+                       'begin'
+                     else
+                       'update'
+                     end
+                   else
+                     gesture_buffer.events.last.record.status
+                   end
+
+          prev_event, event = if status == 'end'
+                                [
+                                  gesture_buffer.events[-3],
+                                  gesture_buffer.events[-2]
+                                ]
+                              else
+                                [
+                                  gesture_buffer.events[-2],
+                                  gesture_buffer.events[-1]
+                                ]
+                              end
+          delta = event.record.delta
+          prev_delta = prev_event.record.delta
+
+          repeat_direction = Direction.new(target: delta.zoom, base: (prev_delta&.zoom || 1.0)).to_s
+          # repeat_quantity = Quantity.new(target: delta.zoom, base: (prev_delta&.zoom || 1.0)).to_f
+
+          repeat_index = create_repeat_index(gesture: type, finger: finger,
+                                             direction: repeat_direction,
+                                             status: status)
+          if status == 'update'
+            return unless moved?(prev_event, event)
+
+            avg_zoom = gesture_buffer.avg_attrs(:zoom)
+            first_zoom = updating_events.first.record.delta.zoom
+
+            oneshot_quantity = Quantity.new(target: avg_zoom, base: first_zoom).to_f
+            oneshot_direction = Direction.new(target: avg_zoom, base: first_zoom).to_s
+            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(
+                  index: oneshot_index, trigger: :oneshot, args: delta.to_h
+                )),
+                create_event(record: Events::Records::IndexRecord.new(
+                  index: repeat_index, trigger: :repeat, args: delta.to_h
+                ))
+              ]
+            end
+          end
+          create_event(record: Events::Records::IndexRecord.new(
+            index: repeat_index, trigger: :repeat, args: delta.to_h
+          ))
+        end
 
-          create_event(record: Events::Records::IndexRecord.new(index: index))
+        # @param [String] gesture
+        # @param [Integer] finger
+        # @param [String] direction
+        # @param [String] status
+        # @return [Config::Index]
+        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)
+            ]
+          )
         end
 
         # @param [String] gesture
         # @param [Integer] finger
         # @param [String] direction
         # @return [Config::Index]
-        def create_index(gesture:, finger:, direction:)
+        def create_oneshot_index(gesture:, finger:, direction:)
           Config::Index.new(
             [
               Config::Index::Key.new(gesture),
@@ -56,41 +117,25 @@ module Fusuma
 
         private
 
-        def enough?(index:, quantity:)
-          enough_interval?(index: index) && enough_diameter?(index: index, quantity: quantity)
+        def moved?(prev_event, event)
+          zoom_delta = (event.record.delta.zoom - prev_event.record.delta.zoom).abs
+          updating_time = (event.time - prev_event.time) * 100
+          zoom_delta / updating_time > 0.01
         end
 
-        def enough_diameter?(index:, quantity:)
+        def enough_oneshot_threshold?(index:, quantity:)
           quantity >= threshold(index: index)
         end
 
-        def enough_interval?(index:)
-          return true if first_time?
-          return true if (Time.now - last_time) > interval_time(index: index)
-
-          false
-        end
-
         def threshold(index:)
           @threshold ||= {}
           @threshold[index.cache_key] ||= begin
-                           keys_specific = Config::Index.new [*index.keys, 'threshold']
-                           keys_global   = Config::Index.new ['threshold', type]
-                           config_value  = Config.search(keys_specific) ||
-                                           Config.search(keys_global) || 1
-                           BASE_THERESHOLD * config_value
-                         end
-        end
-
-        def interval_time(index:)
-          @interval_time ||= {}
-          @interval_time[index.cache_key] ||= begin
-                               keys_specific = Config::Index.new [*index.keys, 'interval']
-                               keys_global = Config::Index.new ['interval', type]
-                               config_value = Config.search(keys_specific) ||
-                                              Config.search(keys_global) || 1
-                               BASE_INTERVAL * config_value
-                             end
+            keys_specific = Config::Index.new [*index.keys, 'threshold']
+            keys_global   = Config::Index.new ['threshold', type]
+            config_value  = Config.search(keys_specific) ||
+                            Config.search(keys_global) || 1
+            BASE_THERESHOLD * config_value
+          end
         end
 
         # direction of gesture
@@ -98,8 +143,9 @@ module Fusuma
           IN = 'in'
           OUT = 'out'
 
-          def initialize(diameter:)
-            @diameter = diameter
+          def initialize(target:, base:)
+            @target = target.to_f
+            @base = base.to_f
           end
 
           def to_s
@@ -107,7 +153,7 @@ module Fusuma
           end
 
           def calc
-            if @diameter > 1
+            if @target > @base
               IN
             else
               OUT
@@ -117,8 +163,9 @@ module Fusuma
 
         # quantity of gesture
         class Quantity
-          def initialize(diameter:)
-            @diameter = diameter
+          def initialize(target:, base:)
+            @target = target.to_f
+            @base = base.to_f
           end
 
           def to_f
@@ -126,7 +173,11 @@ module Fusuma
           end
 
           def calc
-            (1.0 - @diameter).abs
+            if @target > @base
+              @target / @base
+            else
+              @base / @target
+            end
           end
         end
       end