fusuma-plugin-sendkey 0.12.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 99275a36f4c77826f0b915f809aa8cca0dc52f1689c4f1e0226ba3f816ca2d06
-  data.tar.gz: cd5f7f8a2d78b4226610ff32d8468300b6ff3fda010b11016779400330433503
+  metadata.gz: c611a6d5d766d2e57a3c413e3c06b83561f20d9768d785601c0a3395128c77f9
+  data.tar.gz: 5ddd9dc6449c2db16e3e4de26e08ed4334c2e9b274f81ba4bdfa1301815bfb44
 SHA512:
-  metadata.gz: 99f4727c128b6131e9ede5ef8e12fd2a9cb6de74c1b97a23290ea29c505465527d16b87b5adda35b429790883c95f404b6b3c73f96298d1e5309afb9a429e222
-  data.tar.gz: 163a0a224c8ef964874f6fd9ac7c2acd2b55489e2773777a3da3b4e33994427b403525452b9ddf4778b4aad20b1a5d11cc3b9f3d3bf9c3abf1c5bb74fae0c630
+  metadata.gz: 118858d9a59878f2e830e444577be1b543ceac410027e3be5e564385d19876f0d5aa4a21f55935fede4cbc18f613e99cc8489b0c4128c1dc5d5d4d8b4e65ad0f
+  data.tar.gz: 28bbb84b4aaa9a5903d6473bffd5139bd2fe8ab942cbbbfc99a47e5a2567a6c76f737eb4e84ed917807f554c868f0e7c52f9d4d1bfd340694bbcfbdca4b5358b

data/exe/fusuma-sendkey

@@ -1,34 +1,32 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require 'optparse'
-require 'fusuma/config'
-require 'fusuma/plugin/inputs/libinput_command_input.rb'
-require_relative '../lib/fusuma/plugin/sendkey/keyboard.rb'
-require_relative '../lib/fusuma/plugin/sendkey/version.rb'
+require "optparse"
+require "fusuma/config"
+require "fusuma/plugin/executors/executor"
+require "fusuma/plugin/inputs/libinput_command_input"
+require_relative "../lib/fusuma/plugin/sendkey/keyboard"
+require_relative "../lib/fusuma/plugin/executors/sendkey_executor"
+require_relative "../lib/fusuma/plugin/sendkey/version"
 
 option = {}
 opt = OptionParser.new
 
-opt.on('-l', '--list-keycodes',
-       'List available keycodes') do |v|
+opt.on("-l", "--list-keycodes",
+  "List available keycodes") do |v|
   option[:list] = v
 end
 
-opt.on('--version', 'Show version') do |v|
+opt.on("--version", "Show version") do |v|
   option[:version] = v
 end
 
-opt.parse!(ARGV)
-
-device_name = Fusuma::Config.instance.fetch_config_params(
-  :device_name,
-  Fusuma::Config::Index.new([:plugin, :executors, :sendkey_executor])
-).fetch(:device_name)
-
-if option[:list]
-  puts Fusuma::Plugin::Sendkey::Keyboard.new(name_pattern: device_name).search_codes
-  return
+begin
+  opt.parse!(ARGV)
+rescue OptionParser::InvalidOption => e
+  warn e
+  warn opt.help
+  exit 1
 end
 
 if option[:version]
@@ -36,20 +34,29 @@ if option[:version]
   return
 end
 
+executor_index = Fusuma::Config::Index.new([:plugin, :executors, :sendkey_executor])
+name_patterns = Fusuma::Config.instance.fetch_config_params(:device_name, executor_index).fetch(:device_name)
+
+device = Fusuma::Plugin::Sendkey::Keyboard.find_device(name_patterns: name_patterns)
+keyboard = Fusuma::Plugin::Sendkey::Keyboard.new(device: device)
+if option[:list]
+  puts keyboard.search_codes("KEY_").map { |sym| sym.to_s.delete_prefix("KEY_") }
+  puts keyboard.search_codes("BTN_")
+  return
+end
+
 args = ARGV.first
 
 if args.nil?
-  warn 'fusuma-sendkey require 1 arugument'
-  warn 'e.g. fusuma-sendkey LEFTALT+LEFT'
-  warn 'e.g. fusuma-sendkey [A, B, C]'
+  warn "fusuma-sendkey require 1 arugument"
+  warn "e.g. fusuma-sendkey LEFTALT+LEFT"
+  warn "e.g. fusuma-sendkey [A, B, C]"
   exit 1
 end
 
-
 # remove [ and ] from args
-params = args.delete('[]').split(',').map(&:strip)
+params = args.delete("[]").split(",").map(&:strip)
 
-keyboard = Fusuma::Plugin::Sendkey::Keyboard.new(name_pattern: device_name)
 return unless keyboard.valid?(params)
 
 if params.size == 1

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

@@ -55,7 +55,10 @@ module Fusuma
         private
 
         def keyboard
-          @keyboard ||= Sendkey::Keyboard.new(name_pattern: @device_name)
+          @keyboard ||= begin
+            device = Sendkey::Keyboard.find_device(name_patterns: @device_name)
+            Sendkey::Keyboard.new(device: device)
+          end
         end
 
         def search_param(event)

data/lib/fusuma/plugin/sendkey/device.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "revdev"
+require "set"
+
 module Fusuma
   module Plugin
     module Sendkey
@@ -7,8 +10,11 @@ module Fusuma
       class Device
         def initialize(path:)
           @evdev = Revdev::EventDevice.new(path)
+          @capabilities = Set.new
         end
 
+        attr_reader :capabilities
+
         def path
           raise "Device path is not found" if @evdev.nil?
 
@@ -18,6 +24,31 @@ module Fusuma
         def write_event(event)
           @evdev.write_input_event(event)
         end
+
+        def reload_capability
+          @capabilities.clear
+
+          buf = fetch_capabilities
+          buf.unpack("C*").each_with_index do |byte, i|
+            8.times do |bit| # 0..7
+              if byte[bit] != 0
+                @capabilities << (i * 8 + bit)
+              end
+            end
+          end
+          @capabilities
+        end
+
+        private
+
+        EVIOCGBIT = 2153792801
+
+        def fetch_capabilities
+          file = File.open(path, "r")
+          buf = +"" # unfreeze string
+          file.ioctl(EVIOCGBIT, buf)
+          buf
+        end
       end
     end
   end

data/lib/fusuma/plugin/sendkey/keyboard.rb

@@ -10,7 +10,7 @@ module Fusuma
     module Sendkey
       # Emulate Keyboard
       class Keyboard
-        INTERVAL = 0.01
+        INTERVAL = 0.03
 
         MODIFIER_KEY_CODES = %w[
           KEY_CAPSLOCK
@@ -24,30 +24,28 @@ module Fusuma
           KEY_RIGHTMETA
         ].freeze
 
-        def self.find_device(name_pattern:)
+        def self.find_device(name_patterns:)
           Fusuma::Device.reset
-          Fusuma::Device.all.find { |d|
-            next unless /keyboard/.match?(d.capabilities)
 
-            d.name.match(/#{name_pattern}/)
-          }
-        end
-
-        def initialize(name_pattern: nil)
-          device = nil
+          Array(name_patterns).each do |name_pattern|
+            fusuma_device = Fusuma::Device.all.find { |d|
+              next unless d.capabilities.include?("keyboard")
 
-          Array(name_pattern).each do |pattern|
-            device = Keyboard.find_device(name_pattern: pattern)
-            break if device
-          end
+              d.name.match(/#{name_pattern}/)
+            }
 
-          if device.nil?
+            if fusuma_device
+              MultiLogger.info "sendkey: Keyboard: #{fusuma_device.name}"
+              return Device.new(path: "/dev/input/#{fusuma_device.id}")
+            end
             warn "sendkey: Keyboard: /#{name_pattern}/ is not found"
-            exit(1)
           end
-          MultiLogger.info "sendkey: Keyboard: #{device.name}"
 
-          @device = Device.new(path: "/dev/input/#{device.id}")
+          exit(1)
+        end
+
+        def initialize(device:)
+          @device = device
         end
 
         # @param params [Array]
@@ -70,8 +68,8 @@ module Fusuma
         def type(param:, keep: "", clear: :none)
           return unless param.is_a?(String)
 
-          param_keycodes = param_to_keycodes(param)
-          type_keycodes = param_keycodes - param_to_keycodes(keep)
+          param_keycodes = param_to_codes(param)
+          type_keycodes = param_keycodes - param_to_codes(keep)
 
           clear_keycodes =
             case clear
@@ -81,12 +79,13 @@ module Fusuma
               []
             else
               # release keys specified by clearmodifiers
-              param_to_keycodes(clear)
+              param_to_codes(clear)
             end
 
           clear_modifiers(clear_keycodes - param_keycodes)
 
           type_keycodes.each { |keycode| keydown(keycode) && key_sync }
+          sleep(INTERVAL)
           type_keycodes.reverse_each { |keycode| keyup(keycode) && key_sync }
         end
 
@@ -105,7 +104,7 @@ module Fusuma
             params.all? { |param| valid?(param) }
           when String
             param = params
-            keycodes = param_to_keycodes(param)
+            keycodes = param_to_codes(param)
             keycodes.all? { |keycode| support?(keycode) }
           else
             MultiLogger.error "sendkey: Invalid config: #{params}"
@@ -131,35 +130,40 @@ module Fusuma
             0
           )
           @device.write_event(event)
-          sleep(INTERVAL)
         end
 
-        def support?(keycode)
-          @supported_code ||= {}
-          @supported_code[keycode] ||= find_code(keycode: keycode)
+        def capabilities
+          return @capabilities if defined?(@capabilities)
+
+          @capabilities = Set.new.tap do |set|
+            @device.reload_capability.each do |id|
+              code_sym = Revdev::REVERSE_MAPS[:KEY][id]
+              set << code_sym if code_sym
+            end
+          end
         end
 
-        def warn_undefined_codes(keycode:)
-          query = keycode&.upcase&.gsub("KEY_", "")
+        def support?(code)
+          @supported_code ||= {}
+          @supported_code[code] ||= find_code(code)
+        end
 
-          candidates = search_codes(query: query)
+        def warn_undefined_codes(code)
+          candidates = search_codes(code).map { |c| remove_prefix(c.to_s) }
 
           warn "Did you mean? #{candidates.join(" / ")}" unless candidates.empty?
-          warn "sendkey: #{remove_prefix(keycode)} is unsupported."
-        end
 
-        def search_codes(query: nil)
-          Revdev.constants
-            .select { |c| c[/KEY_.*#{query}.*/] }
-            .map { |c| c.to_s.gsub("KEY_", "") }
+          warn "sendkey: #{remove_prefix(code)} is unsupported."
         end
 
-        def find_code(keycode: nil)
-          query = keycode&.upcase&.gsub("KEY_", "")
+        def search_codes(code)
+          capabilities.select { |c| c[code] }
+        end
 
-          result = Revdev.constants.find { |c| c == "KEY_#{query}".to_sym }
+        def find_code(code)
+          result = capabilities.find { |c| c == code.to_sym }
 
-          warn_undefined_codes(keycode: keycode) unless result
+          warn_undefined_codes(code) unless result
           result
         end
 
@@ -174,14 +178,19 @@ module Fusuma
 
         # @param [String]
         # @return [Array<String>]
-        def param_to_keycodes(param)
-          param.split("+").map { |keyname| add_key_prefix(keyname) }
+        def param_to_codes(param)
+          param.split("+").map { |keyname| add_prefix(keyname) }
         end
 
         private
 
-        def add_key_prefix(code)
-          "KEY_#{code.upcase}"
+        def add_prefix(code)
+          code.upcase!
+          if code.start_with?("BTN_")
+            code
+          else
+            "KEY_#{code}"
+          end
         end
 
         def remove_prefix(keycode)

data/lib/fusuma/plugin/sendkey/version.rb

@@ -3,7 +3,7 @@
 module Fusuma
   module Plugin
     module Sendkey
-      VERSION = "0.12.0"
+      VERSION = "0.13.0"
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fusuma-plugin-sendkey
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.13.0
 platform: ruby
 authors:
 - iberianpig
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-09-21 00:00:00.000000000 Z
+date: 2024-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fusuma