fusuma 0.11.1 → 1.0

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative '../base.rb'
+
+module Fusuma
+  module Plugin
+    module Buffers
+      # buffer events and output
+      class Buffer < Base
+        def initialize(*args)
+          @events = Array.new(*args)
+        end
+
+        attr_reader :events
+
+        # @return [String]
+        def type
+          self.class.name.underscore.split('/').last.gsub('_buffer', '')
+        end
+
+        # @param event [Event]
+        def buffer(event)
+          return if event&.tag != source
+
+          @events.push(event)
+        end
+
+        # clear buffer
+        def clear
+          @events.clear
+        end
+
+        # Set source for tag from config.yml.
+        # DEFAULT_SOURCE is defined in each plugins.
+        def source
+          @source ||= config_params(:source) || self.class.const_get('DEFAULT_SOURCE')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative './buffer.rb'
+
+module Fusuma
+  module Plugin
+    module Buffers
+      # manage events and generate command
+      class GestureBuffer < Buffer
+        DEFAULT_SOURCE = 'libinput_gesture_parser'
+
+        # @param event [Event]
+        def buffer(event)
+          # TODO: buffering events into buffer plugins
+          # - gesture event buffer
+          # - window event buffer
+          # - other event buffer
+          return if event&.tag != source
+          return if event.record.type != :gesture
+
+          @events.push(event)
+          clear unless updating?
+        end
+
+        # @param attr [Symbol]
+        # @return [Float]
+        def sum_attrs(attr)
+          @events.map { |gesture_event| gesture_event.record.direction[attr].to_f }
+                 .inject(:+)
+        end
+
+        # @param attr [Symbol]
+        # @return [Float]
+        def avg_attrs(attr)
+          sum_attrs(attr).to_f / @events.length
+        end
+
+        # return [Integer]
+        def finger
+          @events.last.record.finger.to_i
+        end
+
+        # @example
+        #  event_buffer.gesture
+        #  => 'swipe'
+        # @return [String]
+        def gesture
+          @events.last.record.gesture
+        end
+
+        def empty?
+          @events.empty?
+        end
+
+        def select_by_events
+          return enum_for(:select) unless block_given?
+
+          events = @events.select { |event| yield event }
+          self.class.new events
+        end
+
+        private
+
+        def updating?
+          return true unless @events.last.record.status =~ /begin|end/
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative '../base.rb'
+require_relative '../events/event.rb'
+
+module Fusuma
+  module Plugin
+    module Detectors
+      # Inherite this base
+      class Detector < Base
+        # @param _buffers [Array<Buffer>]
+        # @return [Event] if event is detected
+        # @return [NilClass] if event is NOT detected
+        def detect(_buffers)
+          raise NotImplementedError, "override #{self.class.name}##{__method__}"
+
+          # create_event(record:)
+        end
+
+        # @param record [Events::Records::Record]
+        # @return [Events::Event]
+        def create_event(record:)
+          @last_time = Time.now
+          Events::Event.new(time: Time.now, tag: tag, record: record)
+        end
+
+        def last_time
+          @last_time ||= Time.now
+        end
+
+        def tag
+          self.class.name.split('Detectors::').last.underscore
+        end
+
+        def type
+          self.class.name.underscore.split('/').last.gsub('_detector', '')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require_relative './detector.rb'
+
+module Fusuma
+  module Plugin
+    module Detectors
+      class PinchDetector < Detector
+        BUFFER_TYPE = 'gesture'
+        GESTURE_RECORD_TYPE = 'pinch'
+
+        FINGERS = [2, 3, 4].freeze
+        BASE_THERESHOLD = 0.1
+        BASE_INTERVAL   = 0.1
+
+        # @param buffers [Array<Buffer>]
+        # @return [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)
+
+          create_event(record: Events::Records::IndexRecord.new(index: index))
+        end
+
+        # @param [String] gesture
+        # @param [Integer] finger
+        # @param [String] direction
+        # @return [Config::Index]
+        def create_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)
+            ]
+          )
+        end
+
+        private
+
+        def enough?(index:, quantity:)
+          enough_interval?(index: index) && enough_diameter?(index: index, quantity: quantity)
+        end
+
+        def enough_diameter?(index:, quantity:)
+          MultiLogger.info(type: type, quantity: quantity,
+                           quantity_threshold: threshold(index: index))
+          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 first_time?
+          !@last_time
+        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
+        end
+
+        # direction of gesture
+        class Direction
+          IN = 'in'
+          OUT = 'out'
+
+          def initialize(diameter:)
+            @diameter = diameter
+          end
+
+          def to_s
+            calc
+          end
+
+          def calc
+            if @diameter > 1
+              IN
+            else
+              OUT
+            end
+          end
+        end
+
+        # quantity of gesture
+        class Quantity
+          def initialize(diameter:)
+            @diameter = diameter
+          end
+
+          def to_f
+            calc.to_f
+          end
+
+          def calc
+            (1.0 - @diameter).abs
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require_relative './detector.rb'
+
+module Fusuma
+  module Plugin
+    module Detectors
+      class RotateDetector < Detector
+        BUFFER_TYPE = 'gesture'
+        GESTURE_RECORD_TYPE = 'pinch'
+
+        FINGERS = [2, 3, 4].freeze
+        BASE_THERESHOLD = 0.5
+        BASE_INTERVAL   = 0.1
+
+        # @param buffers [Array<Buffer>]
+        # @return [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?
+
+          angle = buffer.avg_attrs(:rotate)
+
+          finger = buffer.finger
+          direction = Direction.new(angle: angle).to_s
+          quantity = Quantity.new(angle: angle).to_f
+
+          index = create_index(gesture: type,
+                               finger: finger,
+                               direction: direction)
+
+          return unless enough?(index: index, quantity: quantity)
+
+          create_event(record: Events::Records::IndexRecord.new(index: index))
+        end
+
+        # @param [String] gesture
+        # @param [Integer] finger
+        # @param [String] direction
+        # @return [Config::Index]
+        def create_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)
+            ]
+          )
+        end
+
+        private
+
+        def enough?(index:, quantity:)
+          enough_interval?(index: index) && enough_angle?(index: index, quantity: quantity)
+        end
+
+        def enough_angle?(index:, quantity:)
+          MultiLogger.info(type: type, quantity: quantity,
+                           quantity_threshold: threshold(index: index))
+
+          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 first_time?
+          !@last_time
+        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
+        end
+
+        # direction of gesture
+        class Direction
+          CLOCKWISE = 'clockwise'
+          COUNTERCLOCKWISE = 'counterclockwise'
+
+          def initialize(angle:)
+            @angle = angle
+          end
+
+          def to_s
+            calc
+          end
+
+          def calc
+            if @angle > 0
+              CLOCKWISE
+            else
+              COUNTERCLOCKWISE
+            end
+          end
+        end
+
+        # quantity of gesture
+        class Quantity
+          def initialize(angle:)
+            @angle = angle.abs
+          end
+
+          def to_f
+            @angle.to_f
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require_relative './detector.rb'
+
+module Fusuma
+  module Plugin
+    module Detectors
+      class SwipeDetector < Detector
+        BUFFER_TYPE = 'gesture'
+        GESTURE_RECORD_TYPE = 'swipe'
+
+        FINGERS = [3, 4].freeze
+        BASE_THERESHOLD = 10
+        BASE_INTERVAL = 0.5
+
+        # @param buffers [Array<Buffers::Buffer>]
+        # @return [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?
+
+          move_x = buffer.avg_attrs(:move_x)
+          move_y = buffer.avg_attrs(:move_y)
+
+          finger = buffer.finger
+          direction = Direction.new(move_x: move_x.to_f, move_y: move_y.to_f).to_s
+          quantity = Quantity.new(move_x: move_x.to_f, move_y: move_y.to_f).to_f
+
+          index = create_index(gesture: type,
+                               finger: finger,
+                               direction: direction)
+
+          return unless enough?(index: index, quantity: quantity)
+
+          create_event(record: Events::Records::IndexRecord.new(index: index))
+        end
+
+        # @param [String] gesture
+        # @param [Integer] finger
+        # @param [String] direction
+        # @return [Config::Index]
+        def create_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)
+            ]
+          )
+        end
+
+        private
+
+        def enough?(index:, quantity:)
+          enough_interval?(index: index) && enough_distance?(index: index, quantity: quantity)
+        end
+
+        def enough_distance?(index:, quantity:)
+          MultiLogger.info(type: type, quantity: quantity,
+                           quantity_threshold: threshold(index: index))
+          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 first_time?
+          !@last_time
+        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
+        end
+
+        # direction of gesture
+        class Direction
+          RIGHT = 'right'
+          LEFT = 'left'
+          DOWN = 'down'
+          UP = 'up'
+
+          def initialize(move_x:, move_y:)
+            @move_x = move_x
+            @move_y = move_y
+          end
+
+          def to_s
+            calc
+          end
+
+          def calc
+            if @move_x.abs > @move_y.abs
+              @move_x > 0 ? RIGHT : LEFT
+            elsif @move_y > 0
+              DOWN
+            else
+              UP
+            end
+          end
+        end
+
+        # quantity of gesture
+        class Quantity
+          def initialize(move_x:, move_y:)
+            @x = move_x.abs
+            @y = move_y.abs
+          end
+
+          def to_f
+            calc.to_f
+          end
+
+          def calc
+            @x > @y ? @x.abs : @y.abs
+          end
+        end
+      end
+    end
+  end
+end