| // Copyright 2017 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <fuchsia/ui/input/cpp/fidl.h> |
| #include <hid/usages.h> |
| #include <lib/async-loop/cpp/loop.h> |
| #include <lib/async/cpp/task.h> |
| #include <lib/async/default.h> |
| #include <lib/sys/cpp/component_context.h> |
| #include <lib/ui/input/cpp/formatting.h> |
| #include <lib/zx/time.h> |
| #include <trace-provider/provider.h> |
| #include <trace/event.h> |
| |
| #include <iostream> |
| #include <memory> |
| |
| #include "garnet/bin/ui/input/inverse_keymap.h" |
| #include "src/lib/fxl/command_line.h" |
| #include "src/lib/fxl/log_settings.h" |
| #include "src/lib/fxl/log_settings_command_line.h" |
| #include "src/lib/fxl/logging.h" |
| #include "src/lib/fxl/strings/string_number_conversions.h" |
| #include "src/lib/fxl/time/time_point.h" |
| |
| namespace { |
| |
| int64_t InputEventTimestampNow() { |
| return fxl::TimePoint::Now().ToEpochDelta().ToNanoseconds(); |
| } |
| |
| } // namespace |
| |
| namespace input { |
| class InputApp { |
| public: |
| InputApp(async::Loop* loop) |
| : loop_(loop), component_context_(sys::ComponentContext::Create()) { |
| registry_ = component_context_->svc() |
| ->Connect<fuchsia::ui::input::InputDeviceRegistry>(); |
| } |
| |
| ~InputApp() {} |
| |
| void Run(const fxl::CommandLine& command_line) { |
| const auto& positional_args = command_line.positional_args(); |
| if (positional_args.empty()) { |
| Usage(); |
| return; |
| } |
| |
| zx::duration duration; |
| { |
| std::string duration_str; |
| if (command_line.GetOptionValue("duration", &duration_str)) { |
| uint32_t duration_ms; |
| if (!fxl::StringToNumberWithError(duration_str, &duration_ms)) { |
| Error("Invalid duration parameter"); |
| return; |
| } |
| duration = zx::msec(duration_ms); |
| } |
| } |
| |
| if (positional_args[0] == "tap" || positional_args[0] == "swipe") { |
| uint32_t width = 1000; |
| std::string width_str; |
| if (command_line.GetOptionValue("width", &width_str)) { |
| if (!fxl::StringToNumberWithError(width_str, &width)) { |
| Error("Invalid width parameter"); |
| return; |
| } |
| } |
| |
| uint32_t height = 1000; |
| std::string height_str; |
| if (command_line.GetOptionValue("height", &height_str)) { |
| if (!fxl::StringToNumberWithError(height_str, &height)) { |
| Error("Invalid height parameter"); |
| return; |
| } |
| } |
| |
| input_device_ = RegisterTouchscreen(width, height); |
| |
| if (positional_args[0] == "tap") { |
| uint32_t tap_event_count = 1; |
| std::string tap_event_count_str; |
| if (command_line.GetOptionValue("tap_event_count", |
| &tap_event_count_str)) { |
| if (!fxl::StringToNumberWithError(tap_event_count_str, |
| &tap_event_count)) { |
| Error("Invalid tap_event_count parameter"); |
| return; |
| } |
| } |
| TapEventCommand(positional_args, duration, tap_event_count); |
| } else { // "swipe" |
| uint32_t move_event_count = 100; |
| std::string move_event_count_str; |
| if (command_line.GetOptionValue("move_event_count", |
| &move_event_count_str)) { |
| if (!fxl::StringToNumberWithError(move_event_count_str, |
| &move_event_count)) { |
| Error("Invalid move_event_count parameter"); |
| return; |
| } |
| } |
| SwipeEventCommand(positional_args, duration, move_event_count); |
| } |
| } else if (positional_args[0] == "keyevent") { |
| KeyEventCommand(positional_args, duration); |
| } else if (positional_args[0] == "text") { |
| TextCommand(positional_args, duration); |
| } else if (positional_args[0] == "media_button") { |
| MediaButtonEventCommand(positional_args); |
| } else { |
| Usage(); |
| } |
| } |
| |
| private: |
| void Usage() { |
| // Keep this up to date with README.md. |
| // Until we have standardized usage doc formatting, let's do 100 cols. |
| std::cout |
| << R"END(usage: input [<options>] text|keyevent|tap|swipe|media_button <args> |
| input text <text> |
| input keyevent <hid_usage (int)> |
| input tap <x> <y> |
| input swipe <x0> <y0> <x1> <y1> |
| input media_button <mic_mute> <volume_up> <volume_down> <reset> |
| |
| global options: |
| --duration=<ms> the duration of the event, in milliseconds (default: 0) |
| |
| commands: |
| text Text is injected by translating to keystrokes using a QWERTY |
| keymap. Only simple strings are supported; see README.md for |
| details. |
| |
| The --duration option is divided over the key events. Care should |
| be taken not to provide so long a duration that key repeat kicks |
| in. |
| |
| Note: when using through fx shell with quotes, you may need to |
| surround the invocation in strong quotes, e.g.: |
| fx shell 'input text "Hello, world!"' |
| |
| keyevent Common usage codes: |
| |
| key | code (dec) |
| ----------|----- |
| enter | 40 |
| escape | 41 |
| backspace | 42 |
| tab | 43 |
| |
| tap/swipe By default, the x and y coordinates are in the range 0 to 1000 |
| and will be proportionally transformed to the current display, |
| but you can specify a virtual range for the input with the |
| --width and --height options. |
| |
| media_button Sends a MediaButton event. All fields are booleans and must |
| be either 0 or 1. |
| |
| options: |
| --width=<w> the width of the display (default: 1000) |
| --height=<h> the height of the display (default: 1000) |
| |
| swipe options: |
| --move_event_count=<count> the number of move events to send in between the down and up |
| events of the swipe (default: 100) |
| |
| --tap_event_count=<count> the number of tap events to send (default: 1) |
| The --duration option is divided over the tap events. |
| |
| For further details, see README.md. |
| )END"; |
| |
| loop_->Quit(); |
| } |
| |
| void Error(std::string message) { |
| std::cout << message << std::endl; |
| loop_->Quit(); |
| } |
| |
| fuchsia::ui::input::InputDevicePtr RegisterTouchscreen(uint32_t width, |
| uint32_t height) { |
| fuchsia::ui::input::InputDevicePtr input_device; |
| |
| fuchsia::ui::input::TouchscreenDescriptorPtr touchscreen = |
| fuchsia::ui::input::TouchscreenDescriptor::New(); |
| touchscreen->x.range.min = 0; |
| touchscreen->x.range.max = width; |
| |
| touchscreen->y.range.min = 0; |
| touchscreen->y.range.max = height; |
| |
| fuchsia::ui::input::DeviceDescriptor descriptor; |
| descriptor.touchscreen = std::move(touchscreen); |
| |
| FXL_VLOG(1) << "Registering " << descriptor; |
| registry_->RegisterDevice(std::move(descriptor), input_device.NewRequest()); |
| return input_device; |
| } |
| |
| fuchsia::ui::input::InputDevicePtr RegisterKeyboard() { |
| fuchsia::ui::input::KeyboardDescriptorPtr keyboard = |
| fuchsia::ui::input::KeyboardDescriptor::New(); |
| keyboard->keys.reserve(HID_USAGE_KEY_RIGHT_GUI - HID_USAGE_KEY_A); |
| for (uint32_t usage = HID_USAGE_KEY_A; usage < HID_USAGE_KEY_RIGHT_GUI; |
| ++usage) { |
| keyboard->keys.push_back(usage); |
| } |
| fuchsia::ui::input::DeviceDescriptor descriptor; |
| descriptor.keyboard = std::move(keyboard); |
| |
| fuchsia::ui::input::InputDevicePtr input_device; |
| FXL_VLOG(1) << "Registering " << descriptor; |
| registry_->RegisterDevice(std::move(descriptor), input_device.NewRequest()); |
| return input_device; |
| } |
| |
| fuchsia::ui::input::InputDevicePtr RegisterMediaButtons() { |
| fuchsia::ui::input::MediaButtonsDescriptorPtr mediabuttons = |
| fuchsia::ui::input::MediaButtonsDescriptor::New(); |
| mediabuttons->buttons = fuchsia::ui::input::kMicMute | |
| fuchsia::ui::input::kVolumeUp | |
| fuchsia::ui::input::kVolumeDown; |
| fuchsia::ui::input::DeviceDescriptor descriptor; |
| descriptor.media_buttons = std::move(mediabuttons); |
| |
| fuchsia::ui::input::InputDevicePtr input_device; |
| FXL_VLOG(1) << "Registering " << descriptor; |
| registry_->RegisterDevice(std::move(descriptor), input_device.NewRequest()); |
| return input_device; |
| } |
| |
| void MediaButtonEventCommand(const std::vector<std::string>& args) { |
| if (args.size() != 5) { |
| Usage(); |
| return; |
| } |
| |
| int32_t mic_mute, volume_up, volume_down, reset; |
| if (!fxl::StringToNumberWithError(args[1], &mic_mute)) { |
| Error("Invalid mic_mute number"); |
| return; |
| } |
| if (mic_mute != 0 && mic_mute != 1) { |
| Error("mic_mute must be 0 or 1"); |
| return; |
| } |
| if (!fxl::StringToNumberWithError(args[2], &volume_up)) { |
| Error("Invalid volume_up number"); |
| return; |
| } |
| if (volume_up < 0 || volume_up > 1) { |
| Error("volume_up must be 0 or 1"); |
| return; |
| } |
| if (!fxl::StringToNumberWithError(args[3], &volume_down)) { |
| Error("Invalid volume_down number"); |
| return; |
| } |
| if (volume_down < 0 || volume_down > 1) { |
| Error("volume_down must be 0 or 1"); |
| return; |
| } |
| if (!fxl::StringToNumberWithError(args[4], &reset)) { |
| Error("Invalid reset number"); |
| return; |
| } |
| if (reset < 0 || reset > 1) { |
| Error("reset must be 0 or 1"); |
| return; |
| } |
| |
| fuchsia::ui::input::InputDevicePtr input_device = RegisterMediaButtons(); |
| SendMediaButton(std::move(input_device), mic_mute, volume_up, volume_down, |
| reset); |
| } |
| |
| void SendMediaButton(fuchsia::ui::input::InputDevicePtr input_device, |
| bool mic_mute, bool volume_up, bool volume_down, |
| bool reset) { |
| TRACE_DURATION("input", "SendMediaButton"); |
| fuchsia::ui::input::MediaButtonsReportPtr media_buttons = |
| fuchsia::ui::input::MediaButtonsReport::New(); |
| media_buttons->mic_mute = mic_mute; |
| media_buttons->volume_up = volume_up; |
| media_buttons->volume_down = volume_down; |
| media_buttons->reset = reset; |
| |
| fuchsia::ui::input::InputReport report; |
| report.event_time = InputEventTimestampNow(); |
| report.media_buttons = std::move(media_buttons); |
| |
| FXL_VLOG(1) << "SendMediaButton " << report; |
| TRACE_FLOW_BEGIN("input", "hid_read_to_listener", report.trace_id); |
| input_device->DispatchReport(std::move(report)); |
| loop_->Quit(); |
| } |
| |
| void TapEventCommand(const std::vector<std::string>& args, |
| zx::duration duration, uint32_t tap_event_count) { |
| if (args.size() != 3) { |
| Usage(); |
| return; |
| } |
| |
| int32_t x, y; |
| |
| if (!fxl::StringToNumberWithError(args[1], &x)) { |
| Error("Invalid x coordinate"); |
| return; |
| } |
| if (!fxl::StringToNumberWithError(args[2], &y)) { |
| Error("Invalid y coordinate"); |
| return; |
| } |
| |
| FXL_VLOG(1) << "TapEvent " << x << "x" << y; |
| |
| zx::duration tap_duration = duration; |
| if (tap_event_count > 1) |
| tap_duration = duration / tap_event_count; |
| |
| SendTap(x, y, tap_duration, tap_event_count, 0); |
| } |
| |
| void KeyEventCommand(const std::vector<std::string>& args, |
| zx::duration duration) { |
| if (args.size() != 2) { |
| Usage(); |
| return; |
| } |
| |
| uint32_t usage; |
| |
| if (!fxl::StringToNumberWithError(args[1], &usage)) { |
| Error("Invalid HID usage value"); |
| return; |
| } |
| |
| if (usage < HID_USAGE_KEY_A || usage > HID_USAGE_KEY_RIGHT_GUI) { |
| Error("Invalid HID usage value"); |
| return; |
| } |
| |
| FXL_VLOG(1) << "KeyEvent " << usage; |
| |
| fuchsia::ui::input::InputDevicePtr input_device = RegisterKeyboard(); |
| SendKeyPress(std::move(input_device), usage, duration); |
| } |
| |
| void TextCommand(const std::vector<std::string>& args, |
| zx::duration duration) { |
| if (args.size() != 2) { |
| Usage(); |
| return; |
| } |
| |
| // TODO(SCN-1068): Default to IME-based input, and have the current mode |
| // available as an option. |
| // TODO(SCN-1068): Pull default keymap from environment if possible. |
| KeySequence key_sequence; |
| bool ok; |
| std::tie(key_sequence, ok) = |
| DeriveKeySequence(InvertKeymap(qwerty_map), args[1]); |
| if (!ok) { |
| Error("Cannot translate text to key sequence"); |
| return; |
| } |
| |
| FXL_VLOG(1) << "Text " << args[1]; |
| |
| fuchsia::ui::input::InputDevicePtr input_device = RegisterKeyboard(); |
| SendText(std::move(input_device), std::move(key_sequence), duration); |
| } |
| |
| void SwipeEventCommand(const std::vector<std::string>& args, |
| zx::duration duration, uint32_t move_event_count) { |
| if (args.size() != 5) { |
| Usage(); |
| return; |
| } |
| |
| int32_t x0, y0, x1, y1; |
| |
| if (!fxl::StringToNumberWithError(args[1], &x0)) { |
| Error("Invalid x0 coordinate"); |
| return; |
| } |
| if (!fxl::StringToNumberWithError(args[2], &y0)) { |
| Error("Invalid y0 coordinate"); |
| return; |
| } |
| if (!fxl::StringToNumberWithError(args[3], &x1)) { |
| Error("Invalid x1 coordinate"); |
| return; |
| } |
| if (!fxl::StringToNumberWithError(args[4], &y1)) { |
| Error("Invalid y1 coordinate"); |
| return; |
| } |
| |
| FXL_VLOG(1) << "SwipeEvent " << x0 << "x" << y0 << " -> " << x1 << "x" |
| << y1; |
| |
| SendSwipe(x0, y0, x1, y1, duration, move_event_count); |
| } |
| |
| void SendTap(int32_t x, int32_t y, zx::duration tap_duration, |
| uint32_t max_tap_count, uint32_t cur_tap_count) { |
| TRACE_DURATION("input", "SendTap"); |
| |
| // DOWN |
| fuchsia::ui::input::Touch touch; |
| touch.finger_id = 1; |
| touch.x = x; |
| touch.y = y; |
| fuchsia::ui::input::TouchscreenReportPtr touchscreen = |
| fuchsia::ui::input::TouchscreenReport::New(); |
| touchscreen->touches.push_back(std::move(touch)); |
| |
| fuchsia::ui::input::InputReport report; |
| report.event_time = InputEventTimestampNow(); |
| report.touchscreen = std::move(touchscreen); |
| |
| FXL_VLOG(1) << "SendTap " << report; |
| TRACE_FLOW_BEGIN("input", "hid_read_to_listener", report.trace_id); |
| input_device_->DispatchReport(std::move(report)); |
| |
| async::PostDelayedTask( |
| async_get_default_dispatcher(), |
| [this, x, y, tap_duration, max_tap_count, cur_tap_count]() mutable { |
| TRACE_DURATION("input", "SendTap"); |
| // UP |
| fuchsia::ui::input::TouchscreenReportPtr touchscreen = |
| fuchsia::ui::input::TouchscreenReport::New(); |
| touchscreen->touches.resize(0); |
| |
| fuchsia::ui::input::InputReport report; |
| report.event_time = InputEventTimestampNow(); |
| report.touchscreen = std::move(touchscreen); |
| |
| FXL_VLOG(1) << "SendTap " << report; |
| TRACE_FLOW_BEGIN("input", "hid_read_to_listener", report.trace_id); |
| input_device_->DispatchReport(std::move(report)); |
| if (++cur_tap_count >= max_tap_count) { |
| loop_->Quit(); |
| return; |
| } |
| SendTap(x, y, tap_duration, max_tap_count, cur_tap_count); |
| }, |
| tap_duration); |
| } |
| |
| void SendKeyPress(fuchsia::ui::input::InputDevicePtr input_device, |
| uint32_t usage, zx::duration duration) { |
| TRACE_DURATION("input", "SendKeyPress"); |
| // PRESSED |
| fuchsia::ui::input::KeyboardReportPtr keyboard = |
| fuchsia::ui::input::KeyboardReport::New(); |
| keyboard->pressed_keys.push_back(usage); |
| |
| fuchsia::ui::input::InputReport report; |
| report.event_time = InputEventTimestampNow(); |
| report.keyboard = std::move(keyboard); |
| FXL_VLOG(1) << "SendKeyPress " << report; |
| TRACE_FLOW_BEGIN("input", "hid_read_to_listener", report.trace_id); |
| input_device->DispatchReport(std::move(report)); |
| |
| async::PostDelayedTask( |
| async_get_default_dispatcher(), |
| [this, device = std::move(input_device)] { |
| TRACE_DURATION("input", "SendKeyPress"); |
| // RELEASED |
| fuchsia::ui::input::KeyboardReportPtr keyboard = |
| fuchsia::ui::input::KeyboardReport::New(); |
| keyboard->pressed_keys.resize(0); |
| |
| fuchsia::ui::input::InputReport report; |
| report.event_time = InputEventTimestampNow(); |
| report.keyboard = std::move(keyboard); |
| FXL_VLOG(1) << "SendKeyPress " << report; |
| TRACE_FLOW_BEGIN("input", "hid_read_to_listener", report.trace_id); |
| device->DispatchReport(std::move(report)); |
| loop_->Quit(); |
| }, |
| duration); |
| } |
| |
| void SendText(fuchsia::ui::input::InputDevicePtr input_device, |
| std::vector<fuchsia::ui::input::KeyboardReportPtr> key_sequence, |
| zx::duration duration, size_t at = 0) { |
| TRACE_DURATION("input", "SendText"); |
| if (at >= key_sequence.size()) { |
| loop_->Quit(); |
| return; |
| } |
| fuchsia::ui::input::KeyboardReportPtr keyboard = |
| std::move(key_sequence[at]); |
| |
| fuchsia::ui::input::InputReport report; |
| report.event_time = InputEventTimestampNow(); |
| report.keyboard = std::move(keyboard); |
| FXL_VLOG(1) << "SendText " << report; |
| TRACE_FLOW_BEGIN("input", "hid_read_to_listener", report.trace_id); |
| input_device->DispatchReport(std::move(report)); |
| |
| zx::duration stroke_duration; |
| if (key_sequence.size() > 1) { |
| stroke_duration = duration / (key_sequence.size() - 1); |
| } |
| |
| async::PostDelayedTask( |
| async_get_default_dispatcher(), |
| [this, device = std::move(input_device), |
| key_sequence = std::move(key_sequence), duration, at]() mutable { |
| SendText(std::move(device), std::move(key_sequence), duration, |
| at + 1); |
| }, |
| stroke_duration); |
| // If the sequence is empty at this point, the next iteration (Quit) is |
| // scheduled asap. |
| } |
| |
| void SendSwipe(int32_t x0, int32_t y0, int32_t x1, int32_t y1, |
| zx::duration duration, uint32_t move_event_count) { |
| TRACE_DURATION("input", "SendSwipe"); |
| |
| zx::duration swipe_event_delay = duration; |
| float deltaX = (x1 - x0); |
| float deltaY = (y1 - y0); |
| if (move_event_count > 1) { |
| // We have move_event_count + 2 events: |
| // DOWN |
| // MOVE x move_event_count |
| // UP |
| // so we need (move_event_count + 1) delays. |
| swipe_event_delay = duration / (move_event_count + 1); |
| deltaX = deltaX / move_event_count; |
| deltaY = deltaY / move_event_count; |
| } |
| |
| // DOWN |
| SendTouchEvent(x0, y0); |
| |
| for (int32_t i = 1; i <= (int32_t)move_event_count; i++) { |
| // MOVE |
| async::PostDelayedTask( |
| async_get_default_dispatcher(), |
| [this, i, x0, y0, deltaX, deltaY] { |
| SendTouchEvent(x0 + round(i * deltaX), y0 + round(i * deltaY)); |
| }, |
| swipe_event_delay * i); |
| } |
| |
| async::PostDelayedTask( |
| async_get_default_dispatcher(), |
| [this] { |
| TRACE_DURATION("input", "SendSwipe"); |
| |
| // UP |
| fuchsia::ui::input::TouchscreenReportPtr touchscreen = |
| fuchsia::ui::input::TouchscreenReport::New(); |
| touchscreen->touches.resize(0); |
| |
| fuchsia::ui::input::InputReport report = |
| fuchsia::ui::input::InputReport(); |
| report.event_time = InputEventTimestampNow(); |
| report.touchscreen = std::move(touchscreen); |
| FXL_VLOG(1) << "SendSwipe " << report; |
| TRACE_FLOW_BEGIN("input", "hid_read_to_listener", report.trace_id); |
| input_device_->DispatchReport(std::move(report)); |
| |
| loop_->Quit(); |
| }, |
| duration); |
| } |
| |
| void SendTouchEvent(int32_t x, int32_t y) { |
| TRACE_DURATION("input", "SendSwipe"); |
| fuchsia::ui::input::Touch touch; |
| touch.finger_id = 1; |
| |
| touch.x = x; |
| touch.y = y; |
| |
| fuchsia::ui::input::TouchscreenReportPtr touchscreen = |
| fuchsia::ui::input::TouchscreenReport::New(); |
| touchscreen->touches.push_back(std::move(touch)); |
| |
| fuchsia::ui::input::InputReport report; |
| report.event_time = InputEventTimestampNow(); |
| report.touchscreen = std::move(touchscreen); |
| FXL_VLOG(1) << "SendSwipe " << report; |
| TRACE_FLOW_BEGIN("input", "hid_read_to_listener", report.trace_id); |
| input_device_->DispatchReport(std::move(report)); |
| } |
| |
| async::Loop* const loop_; |
| std::unique_ptr<sys::ComponentContext> component_context_; |
| fidl::InterfacePtr<fuchsia::ui::input::InputDeviceRegistry> registry_; |
| fuchsia::ui::input::InputDevicePtr input_device_; |
| }; |
| } // namespace input |
| |
| int main(int argc, char** argv) { |
| auto command_line = fxl::CommandLineFromArgcArgv(argc, argv); |
| if (!fxl::SetLogSettingsFromCommandLine(command_line)) |
| return 1; |
| |
| async::Loop loop(&kAsyncLoopConfigAttachToThread); |
| input::InputApp app(&loop); |
| async::PostTask(loop.dispatcher(), |
| [&app, command_line] { app.Run(command_line); }); |
| trace::TraceProvider trace_provider(loop.dispatcher(), "input"); |
| loop.Run(); |
| return 0; |
| } |
