libs/input/VirtualInputDevice.cpp - LeafOS-Project/android_frameworks_native - Gitiles

 /*
  * Copyright (C) 2023 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #define LOG_TAG "VirtualInputDevice"

 #include <android/input.h>
 #include <android/keycodes.h>
 #include <fcntl.h>
 #include <input/Input.h>
 #include <input/VirtualInputDevice.h>
 #include <linux/uinput.h>
 #include <math.h>
 #include <utils/Log.h>

 #include <map>
 #include <string>

 using android::base::unique_fd;

 /**
  * Log debug messages about native virtual input devices.
  * Enable this via "adb shell setprop log.tag.VirtualInputDevice DEBUG"
  */
 static bool isDebug() {
     return __android_log_is_loggable(ANDROID_LOG_DEBUG, LOG_TAG, ANDROID_LOG_INFO);
 }

 namespace android {
 VirtualInputDevice::VirtualInputDevice(unique_fd fd) : mFd(std::move(fd)) {}
 VirtualInputDevice::~VirtualInputDevice() {
     ioctl(mFd, UI_DEV_DESTROY);
 }

 bool VirtualInputDevice::writeInputEvent(uint16_t type, uint16_t code, int32_t value,
                                          std::chrono::nanoseconds eventTime) {
     std::chrono::seconds seconds = std::chrono::duration_cast<std::chrono::seconds>(eventTime);
     std::chrono::microseconds microseconds =
             std::chrono::duration_cast<std::chrono::microseconds>(eventTime - seconds);
     struct input_event ev = {.type = type, .code = code, .value = value};
     ev.input_event_sec = static_cast<decltype(ev.input_event_sec)>(seconds.count());
     ev.input_event_usec = static_cast<decltype(ev.input_event_usec)>(microseconds.count());

     return TEMP_FAILURE_RETRY(write(mFd, &ev, sizeof(struct input_event))) == sizeof(ev);
 }

 /** Utility method to write keyboard key events or mouse button events. */
 bool VirtualInputDevice::writeEvKeyEvent(int32_t androidCode, int32_t androidAction,
                                          const std::map<int, int>& evKeyCodeMapping,
                                          const std::map<int, UinputAction>& actionMapping,
                                          std::chrono::nanoseconds eventTime) {
     auto evKeyCodeIterator = evKeyCodeMapping.find(androidCode);
     if (evKeyCodeIterator == evKeyCodeMapping.end()) {
         ALOGE("Unsupported native EV keycode for android code %d", androidCode);
         return false;
     }
     auto actionIterator = actionMapping.find(androidAction);
     if (actionIterator == actionMapping.end()) {
         return false;
     }
     if (!writeInputEvent(EV_KEY, static_cast<uint16_t>(evKeyCodeIterator->second),
                          static_cast<int32_t>(actionIterator->second), eventTime)) {
         return false;
     }
     if (!writeInputEvent(EV_SYN, SYN_REPORT, 0, eventTime)) {
         return false;
     }
     return true;
 }

 // --- VirtualKeyboard ---
 const std::map<int, UinputAction> VirtualKeyboard::KEY_ACTION_MAPPING = {
         {AKEY_EVENT_ACTION_DOWN, UinputAction::PRESS},
         {AKEY_EVENT_ACTION_UP, UinputAction::RELEASE},
 };
 // Keycode mapping from https://source.android.com/devices/input/keyboard-devices
 const std::map<int, int> VirtualKeyboard::KEY_CODE_MAPPING = {
         {AKEYCODE_0, KEY_0},
         {AKEYCODE_1, KEY_1},
         {AKEYCODE_2, KEY_2},
         {AKEYCODE_3, KEY_3},
         {AKEYCODE_4, KEY_4},
         {AKEYCODE_5, KEY_5},
         {AKEYCODE_6, KEY_6},
         {AKEYCODE_7, KEY_7},
         {AKEYCODE_8, KEY_8},
         {AKEYCODE_9, KEY_9},
         {AKEYCODE_A, KEY_A},
         {AKEYCODE_B, KEY_B},
         {AKEYCODE_C, KEY_C},
         {AKEYCODE_D, KEY_D},
         {AKEYCODE_E, KEY_E},
         {AKEYCODE_F, KEY_F},
         {AKEYCODE_G, KEY_G},
         {AKEYCODE_H, KEY_H},
         {AKEYCODE_I, KEY_I},
         {AKEYCODE_J, KEY_J},
         {AKEYCODE_K, KEY_K},
         {AKEYCODE_L, KEY_L},
         {AKEYCODE_M, KEY_M},
         {AKEYCODE_N, KEY_N},
         {AKEYCODE_O, KEY_O},
         {AKEYCODE_P, KEY_P},
         {AKEYCODE_Q, KEY_Q},
         {AKEYCODE_R, KEY_R},
         {AKEYCODE_S, KEY_S},
         {AKEYCODE_T, KEY_T},
         {AKEYCODE_U, KEY_U},
         {AKEYCODE_V, KEY_V},
         {AKEYCODE_W, KEY_W},
         {AKEYCODE_X, KEY_X},
         {AKEYCODE_Y, KEY_Y},
         {AKEYCODE_Z, KEY_Z},
         {AKEYCODE_GRAVE, KEY_GRAVE},
         {AKEYCODE_MINUS, KEY_MINUS},
         {AKEYCODE_EQUALS, KEY_EQUAL},
         {AKEYCODE_LEFT_BRACKET, KEY_LEFTBRACE},
         {AKEYCODE_RIGHT_BRACKET, KEY_RIGHTBRACE},
         {AKEYCODE_BACKSLASH, KEY_BACKSLASH},
         {AKEYCODE_SEMICOLON, KEY_SEMICOLON},
         {AKEYCODE_APOSTROPHE, KEY_APOSTROPHE},
         {AKEYCODE_COMMA, KEY_COMMA},
         {AKEYCODE_PERIOD, KEY_DOT},
         {AKEYCODE_SLASH, KEY_SLASH},
         {AKEYCODE_ALT_LEFT, KEY_LEFTALT},
         {AKEYCODE_ALT_RIGHT, KEY_RIGHTALT},
         {AKEYCODE_CTRL_LEFT, KEY_LEFTCTRL},
         {AKEYCODE_CTRL_RIGHT, KEY_RIGHTCTRL},
         {AKEYCODE_SHIFT_LEFT, KEY_LEFTSHIFT},
         {AKEYCODE_SHIFT_RIGHT, KEY_RIGHTSHIFT},
         {AKEYCODE_META_LEFT, KEY_LEFTMETA},
         {AKEYCODE_META_RIGHT, KEY_RIGHTMETA},
         {AKEYCODE_CAPS_LOCK, KEY_CAPSLOCK},
         {AKEYCODE_SCROLL_LOCK, KEY_SCROLLLOCK},
         {AKEYCODE_NUM_LOCK, KEY_NUMLOCK},
         {AKEYCODE_ENTER, KEY_ENTER},
         {AKEYCODE_TAB, KEY_TAB},
         {AKEYCODE_SPACE, KEY_SPACE},
         {AKEYCODE_DPAD_DOWN, KEY_DOWN},
         {AKEYCODE_DPAD_UP, KEY_UP},
         {AKEYCODE_DPAD_LEFT, KEY_LEFT},
         {AKEYCODE_DPAD_RIGHT, KEY_RIGHT},
         {AKEYCODE_MOVE_END, KEY_END},
         {AKEYCODE_MOVE_HOME, KEY_HOME},
         {AKEYCODE_PAGE_DOWN, KEY_PAGEDOWN},
         {AKEYCODE_PAGE_UP, KEY_PAGEUP},
         {AKEYCODE_DEL, KEY_BACKSPACE},
         {AKEYCODE_FORWARD_DEL, KEY_DELETE},
         {AKEYCODE_INSERT, KEY_INSERT},
         {AKEYCODE_ESCAPE, KEY_ESC},
         {AKEYCODE_BREAK, KEY_PAUSE},
         {AKEYCODE_F1, KEY_F1},
         {AKEYCODE_F2, KEY_F2},
         {AKEYCODE_F3, KEY_F3},
         {AKEYCODE_F4, KEY_F4},
         {AKEYCODE_F5, KEY_F5},
         {AKEYCODE_F6, KEY_F6},
         {AKEYCODE_F7, KEY_F7},
         {AKEYCODE_F8, KEY_F8},
         {AKEYCODE_F9, KEY_F9},
         {AKEYCODE_F10, KEY_F10},
         {AKEYCODE_F11, KEY_F11},
         {AKEYCODE_F12, KEY_F12},
         {AKEYCODE_BACK, KEY_BACK},
         {AKEYCODE_FORWARD, KEY_FORWARD},
         {AKEYCODE_NUMPAD_1, KEY_KP1},
         {AKEYCODE_NUMPAD_2, KEY_KP2},
         {AKEYCODE_NUMPAD_3, KEY_KP3},
         {AKEYCODE_NUMPAD_4, KEY_KP4},
         {AKEYCODE_NUMPAD_5, KEY_KP5},
         {AKEYCODE_NUMPAD_6, KEY_KP6},
         {AKEYCODE_NUMPAD_7, KEY_KP7},
         {AKEYCODE_NUMPAD_8, KEY_KP8},
         {AKEYCODE_NUMPAD_9, KEY_KP9},
         {AKEYCODE_NUMPAD_0, KEY_KP0},
         {AKEYCODE_NUMPAD_ADD, KEY_KPPLUS},
         {AKEYCODE_NUMPAD_SUBTRACT, KEY_KPMINUS},
         {AKEYCODE_NUMPAD_MULTIPLY, KEY_KPASTERISK},
         {AKEYCODE_NUMPAD_DIVIDE, KEY_KPSLASH},
         {AKEYCODE_NUMPAD_DOT, KEY_KPDOT},
         {AKEYCODE_NUMPAD_ENTER, KEY_KPENTER},
         {AKEYCODE_NUMPAD_EQUALS, KEY_KPEQUAL},
         {AKEYCODE_NUMPAD_COMMA, KEY_KPCOMMA},
         {AKEYCODE_LANGUAGE_SWITCH, KEY_LANGUAGE},
 };
 VirtualKeyboard::VirtualKeyboard(unique_fd fd) : VirtualInputDevice(std::move(fd)) {}
 VirtualKeyboard::~VirtualKeyboard() {}

 bool VirtualKeyboard::writeKeyEvent(int32_t androidKeyCode, int32_t androidAction,
                                     std::chrono::nanoseconds eventTime) {
     return writeEvKeyEvent(androidKeyCode, androidAction, KEY_CODE_MAPPING, KEY_ACTION_MAPPING,
                            eventTime);
 }

 // --- VirtualDpad ---
 // Dpad keycode mapping from https://source.android.com/devices/input/keyboard-devices
 const std::map<int, int> VirtualDpad::DPAD_KEY_CODE_MAPPING = {
         // clang-format off
         {AKEYCODE_DPAD_DOWN, KEY_DOWN},
         {AKEYCODE_DPAD_UP, KEY_UP},
         {AKEYCODE_DPAD_LEFT, KEY_LEFT},
         {AKEYCODE_DPAD_RIGHT, KEY_RIGHT},
         {AKEYCODE_DPAD_CENTER, KEY_SELECT},
         {AKEYCODE_BACK, KEY_BACK},
         // clang-format on
 };

 VirtualDpad::VirtualDpad(unique_fd fd) : VirtualInputDevice(std::move(fd)) {}

 VirtualDpad::~VirtualDpad() {}

 bool VirtualDpad::writeDpadKeyEvent(int32_t androidKeyCode, int32_t androidAction,
                                     std::chrono::nanoseconds eventTime) {
     return writeEvKeyEvent(androidKeyCode, androidAction, DPAD_KEY_CODE_MAPPING,
                            VirtualKeyboard::KEY_ACTION_MAPPING, eventTime);
 }

 // --- VirtualMouse ---
 const std::map<int, UinputAction> VirtualMouse::BUTTON_ACTION_MAPPING = {
         {AMOTION_EVENT_ACTION_BUTTON_PRESS, UinputAction::PRESS},
         {AMOTION_EVENT_ACTION_BUTTON_RELEASE, UinputAction::RELEASE},
 };

 // Button code mapping from https://source.android.com/devices/input/touch-devices
 const std::map<int, int> VirtualMouse::BUTTON_CODE_MAPPING = {
         // clang-format off
         {AMOTION_EVENT_BUTTON_PRIMARY, BTN_LEFT},
         {AMOTION_EVENT_BUTTON_SECONDARY, BTN_RIGHT},
         {AMOTION_EVENT_BUTTON_TERTIARY, BTN_MIDDLE},
         {AMOTION_EVENT_BUTTON_BACK, BTN_BACK},
         {AMOTION_EVENT_BUTTON_FORWARD, BTN_FORWARD},
         // clang-format on
 };

 VirtualMouse::VirtualMouse(unique_fd fd) : VirtualInputDevice(std::move(fd)) {}

 VirtualMouse::~VirtualMouse() {}

 bool VirtualMouse::writeButtonEvent(int32_t androidButtonCode, int32_t androidAction,
                                     std::chrono::nanoseconds eventTime) {
     return writeEvKeyEvent(androidButtonCode, androidAction, BUTTON_CODE_MAPPING,
                            BUTTON_ACTION_MAPPING, eventTime);
 }

 bool VirtualMouse::writeRelativeEvent(float relativeX, float relativeY,
                                       std::chrono::nanoseconds eventTime) {
     return writeInputEvent(EV_REL, REL_X, relativeX, eventTime) &&
             writeInputEvent(EV_REL, REL_Y, relativeY, eventTime) &&
             writeInputEvent(EV_SYN, SYN_REPORT, 0, eventTime);
 }

 bool VirtualMouse::writeScrollEvent(float xAxisMovement, float yAxisMovement,
                                     std::chrono::nanoseconds eventTime) {
     return writeInputEvent(EV_REL, REL_HWHEEL, xAxisMovement, eventTime) &&
             writeInputEvent(EV_REL, REL_WHEEL, yAxisMovement, eventTime) &&
             writeInputEvent(EV_SYN, SYN_REPORT, 0, eventTime);
 }

 // --- VirtualTouchscreen ---
 const std::map<int, UinputAction> VirtualTouchscreen::TOUCH_ACTION_MAPPING = {
         {AMOTION_EVENT_ACTION_DOWN, UinputAction::PRESS},
         {AMOTION_EVENT_ACTION_UP, UinputAction::RELEASE},
         {AMOTION_EVENT_ACTION_MOVE, UinputAction::MOVE},
         {AMOTION_EVENT_ACTION_CANCEL, UinputAction::CANCEL},
 };
 // Tool type mapping from https://source.android.com/devices/input/touch-devices
 const std::map<int, int> VirtualTouchscreen::TOOL_TYPE_MAPPING = {
         {AMOTION_EVENT_TOOL_TYPE_FINGER, MT_TOOL_FINGER},
         {AMOTION_EVENT_TOOL_TYPE_PALM, MT_TOOL_PALM},
 };

 VirtualTouchscreen::VirtualTouchscreen(unique_fd fd) : VirtualInputDevice(std::move(fd)) {}

 VirtualTouchscreen::~VirtualTouchscreen() {}

 bool VirtualTouchscreen::isValidPointerId(int32_t pointerId, UinputAction uinputAction) {
     if (pointerId < -1 || pointerId >= (int)MAX_POINTERS) {
         ALOGE("Virtual touch event has invalid pointer id %d; value must be between -1 and %zu",
               pointerId, MAX_POINTERS - 0);
         return false;
     }

     if (uinputAction == UinputAction::PRESS && mActivePointers.test(pointerId)) {
         ALOGE("Repetitive action DOWN event received on a pointer %d that is already down.",
               pointerId);
         return false;
     }
     if (uinputAction == UinputAction::RELEASE && !mActivePointers.test(pointerId)) {
         ALOGE("PointerId %d action UP received with no prior action DOWN on touchscreen %d.",
               pointerId, mFd.get());
         return false;
     }
     return true;
 }

 bool VirtualTouchscreen::writeTouchEvent(int32_t pointerId, int32_t toolType, int32_t action,
                                          float locationX, float locationY, float pressure,
                                          float majorAxisSize, std::chrono::nanoseconds eventTime) {
     auto actionIterator = TOUCH_ACTION_MAPPING.find(action);
     if (actionIterator == TOUCH_ACTION_MAPPING.end()) {
         return false;
     }
     UinputAction uinputAction = actionIterator->second;
     if (!isValidPointerId(pointerId, uinputAction)) {
         return false;
     }
     if (!writeInputEvent(EV_ABS, ABS_MT_SLOT, pointerId, eventTime)) {
         return false;
     }
     auto toolTypeIterator = TOOL_TYPE_MAPPING.find(toolType);
     if (toolTypeIterator == TOOL_TYPE_MAPPING.end()) {
         return false;
     }
     if (!writeInputEvent(EV_ABS, ABS_MT_TOOL_TYPE, static_cast<int32_t>(toolTypeIterator->second),
                          eventTime)) {
         return false;
     }
     if (uinputAction == UinputAction::PRESS && !handleTouchDown(pointerId, eventTime)) {
         return false;
     }
     if (uinputAction == UinputAction::RELEASE && !handleTouchUp(pointerId, eventTime)) {
         return false;
     }
     if (!writeInputEvent(EV_ABS, ABS_MT_POSITION_X, locationX, eventTime)) {
         return false;
     }
     if (!writeInputEvent(EV_ABS, ABS_MT_POSITION_Y, locationY, eventTime)) {
         return false;
     }
     if (!isnan(pressure)) {
         if (!writeInputEvent(EV_ABS, ABS_MT_PRESSURE, pressure, eventTime)) {
             return false;
         }
     }
     if (!isnan(majorAxisSize)) {
         if (!writeInputEvent(EV_ABS, ABS_MT_TOUCH_MAJOR, majorAxisSize, eventTime)) {
             return false;
         }
     }
     return writeInputEvent(EV_SYN, SYN_REPORT, 0, eventTime);
 }

 bool VirtualTouchscreen::handleTouchUp(int32_t pointerId, std::chrono::nanoseconds eventTime) {
     if (!writeInputEvent(EV_ABS, ABS_MT_TRACKING_ID, static_cast<int32_t>(-1), eventTime)) {
         return false;
     }
     // When a pointer is no longer in touch, remove the pointer id from the corresponding
     // entry in the unreleased touches map.
     mActivePointers.reset(pointerId);
     ALOGD_IF(isDebug(), "Pointer %d erased from the touchscreen %d", pointerId, mFd.get());

     // Only sends the BTN UP event when there's no pointers on the touchscreen.
     if (mActivePointers.none()) {
         if (!writeInputEvent(EV_KEY, BTN_TOUCH, static_cast<int32_t>(UinputAction::RELEASE),
                              eventTime)) {
             return false;
         }
         ALOGD_IF(isDebug(), "No pointers on touchscreen %d, BTN UP event sent.", mFd.get());
     }
     return true;
 }

 bool VirtualTouchscreen::handleTouchDown(int32_t pointerId, std::chrono::nanoseconds eventTime) {
     // When a new pointer is down on the touchscreen, add the pointer id in the corresponding
     // entry in the unreleased touches map.
     if (mActivePointers.none()) {
         // Only sends the BTN Down event when the first pointer on the touchscreen is down.
         if (!writeInputEvent(EV_KEY, BTN_TOUCH, static_cast<int32_t>(UinputAction::PRESS),
                              eventTime)) {
             return false;
         }
         ALOGD_IF(isDebug(), "First pointer %d down under touchscreen %d, BTN DOWN event sent",
                  pointerId, mFd.get());
     }

     mActivePointers.set(pointerId);
     ALOGD_IF(isDebug(), "Added pointer %d under touchscreen %d in the map", pointerId, mFd.get());
     if (!writeInputEvent(EV_ABS, ABS_MT_TRACKING_ID, static_cast<int32_t>(pointerId), eventTime)) {
         return false;
     }
     return true;
 }

 } // namespace android
	/*
	* Copyright (C) 2023 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#define LOG_TAG "VirtualInputDevice"

	#include <android/input.h>
	#include <android/keycodes.h>
	#include <fcntl.h>
	#include <input/Input.h>
	#include <input/VirtualInputDevice.h>
	#include <linux/uinput.h>
	#include <math.h>
	#include <utils/Log.h>

	#include <map>
	#include <string>

	using android::base::unique_fd;

	/**
	* Log debug messages about native virtual input devices.
	* Enable this via "adb shell setprop log.tag.VirtualInputDevice DEBUG"
	*/
	static bool isDebug() {
	return __android_log_is_loggable(ANDROID_LOG_DEBUG, LOG_TAG, ANDROID_LOG_INFO);
	}

	namespace android {
	VirtualInputDevice::VirtualInputDevice(unique_fd fd) : mFd(std::move(fd)) {}
	VirtualInputDevice::~VirtualInputDevice() {
	ioctl(mFd, UI_DEV_DESTROY);
	}

	bool VirtualInputDevice::writeInputEvent(uint16_t type, uint16_t code, int32_t value,
	std::chrono::nanoseconds eventTime) {
	std::chrono::seconds seconds = std::chrono::duration_cast<std::chrono::seconds>(eventTime);
	std::chrono::microseconds microseconds =
	std::chrono::duration_cast<std::chrono::microseconds>(eventTime - seconds);
	struct input_event ev = {.type = type, .code = code, .value = value};
	ev.input_event_sec = static_cast<decltype(ev.input_event_sec)>(seconds.count());
	ev.input_event_usec = static_cast<decltype(ev.input_event_usec)>(microseconds.count());

	return TEMP_FAILURE_RETRY(write(mFd, &ev, sizeof(struct input_event))) == sizeof(ev);
	}

	/** Utility method to write keyboard key events or mouse button events. */
	bool VirtualInputDevice::writeEvKeyEvent(int32_t androidCode, int32_t androidAction,
	const std::map<int, int>& evKeyCodeMapping,
	const std::map<int, UinputAction>& actionMapping,
	std::chrono::nanoseconds eventTime) {
	auto evKeyCodeIterator = evKeyCodeMapping.find(androidCode);
	if (evKeyCodeIterator == evKeyCodeMapping.end()) {
	ALOGE("Unsupported native EV keycode for android code %d", androidCode);
	return false;
	}
	auto actionIterator = actionMapping.find(androidAction);
	if (actionIterator == actionMapping.end()) {
	return false;
	}
	if (!writeInputEvent(EV_KEY, static_cast<uint16_t>(evKeyCodeIterator->second),
	static_cast<int32_t>(actionIterator->second), eventTime)) {
	return false;
	}
	if (!writeInputEvent(EV_SYN, SYN_REPORT, 0, eventTime)) {
	return false;
	}
	return true;
	}

	// --- VirtualKeyboard ---
	const std::map<int, UinputAction> VirtualKeyboard::KEY_ACTION_MAPPING = {
	{AKEY_EVENT_ACTION_DOWN, UinputAction::PRESS},
	{AKEY_EVENT_ACTION_UP, UinputAction::RELEASE},
	};
	// Keycode mapping from https://source.android.com/devices/input/keyboard-devices
	const std::map<int, int> VirtualKeyboard::KEY_CODE_MAPPING = {
	{AKEYCODE_0, KEY_0},
	{AKEYCODE_1, KEY_1},
	{AKEYCODE_2, KEY_2},
	{AKEYCODE_3, KEY_3},
	{AKEYCODE_4, KEY_4},
	{AKEYCODE_5, KEY_5},
	{AKEYCODE_6, KEY_6},
	{AKEYCODE_7, KEY_7},
	{AKEYCODE_8, KEY_8},
	{AKEYCODE_9, KEY_9},
	{AKEYCODE_A, KEY_A},
	{AKEYCODE_B, KEY_B},
	{AKEYCODE_C, KEY_C},
	{AKEYCODE_D, KEY_D},
	{AKEYCODE_E, KEY_E},
	{AKEYCODE_F, KEY_F},
	{AKEYCODE_G, KEY_G},
	{AKEYCODE_H, KEY_H},
	{AKEYCODE_I, KEY_I},
	{AKEYCODE_J, KEY_J},
	{AKEYCODE_K, KEY_K},
	{AKEYCODE_L, KEY_L},
	{AKEYCODE_M, KEY_M},
	{AKEYCODE_N, KEY_N},
	{AKEYCODE_O, KEY_O},
	{AKEYCODE_P, KEY_P},
	{AKEYCODE_Q, KEY_Q},
	{AKEYCODE_R, KEY_R},
	{AKEYCODE_S, KEY_S},
	{AKEYCODE_T, KEY_T},
	{AKEYCODE_U, KEY_U},
	{AKEYCODE_V, KEY_V},
	{AKEYCODE_W, KEY_W},
	{AKEYCODE_X, KEY_X},
	{AKEYCODE_Y, KEY_Y},
	{AKEYCODE_Z, KEY_Z},
	{AKEYCODE_GRAVE, KEY_GRAVE},
	{AKEYCODE_MINUS, KEY_MINUS},
	{AKEYCODE_EQUALS, KEY_EQUAL},
	{AKEYCODE_LEFT_BRACKET, KEY_LEFTBRACE},
	{AKEYCODE_RIGHT_BRACKET, KEY_RIGHTBRACE},
	{AKEYCODE_BACKSLASH, KEY_BACKSLASH},
	{AKEYCODE_SEMICOLON, KEY_SEMICOLON},
	{AKEYCODE_APOSTROPHE, KEY_APOSTROPHE},
	{AKEYCODE_COMMA, KEY_COMMA},
	{AKEYCODE_PERIOD, KEY_DOT},
	{AKEYCODE_SLASH, KEY_SLASH},
	{AKEYCODE_ALT_LEFT, KEY_LEFTALT},
	{AKEYCODE_ALT_RIGHT, KEY_RIGHTALT},
	{AKEYCODE_CTRL_LEFT, KEY_LEFTCTRL},
	{AKEYCODE_CTRL_RIGHT, KEY_RIGHTCTRL},
	{AKEYCODE_SHIFT_LEFT, KEY_LEFTSHIFT},
	{AKEYCODE_SHIFT_RIGHT, KEY_RIGHTSHIFT},
	{AKEYCODE_META_LEFT, KEY_LEFTMETA},
	{AKEYCODE_META_RIGHT, KEY_RIGHTMETA},
	{AKEYCODE_CAPS_LOCK, KEY_CAPSLOCK},
	{AKEYCODE_SCROLL_LOCK, KEY_SCROLLLOCK},
	{AKEYCODE_NUM_LOCK, KEY_NUMLOCK},
	{AKEYCODE_ENTER, KEY_ENTER},
	{AKEYCODE_TAB, KEY_TAB},
	{AKEYCODE_SPACE, KEY_SPACE},
	{AKEYCODE_DPAD_DOWN, KEY_DOWN},
	{AKEYCODE_DPAD_UP, KEY_UP},
	{AKEYCODE_DPAD_LEFT, KEY_LEFT},
	{AKEYCODE_DPAD_RIGHT, KEY_RIGHT},
	{AKEYCODE_MOVE_END, KEY_END},
	{AKEYCODE_MOVE_HOME, KEY_HOME},
	{AKEYCODE_PAGE_DOWN, KEY_PAGEDOWN},
	{AKEYCODE_PAGE_UP, KEY_PAGEUP},
	{AKEYCODE_DEL, KEY_BACKSPACE},
	{AKEYCODE_FORWARD_DEL, KEY_DELETE},
	{AKEYCODE_INSERT, KEY_INSERT},
	{AKEYCODE_ESCAPE, KEY_ESC},
	{AKEYCODE_BREAK, KEY_PAUSE},
	{AKEYCODE_F1, KEY_F1},
	{AKEYCODE_F2, KEY_F2},
	{AKEYCODE_F3, KEY_F3},
	{AKEYCODE_F4, KEY_F4},
	{AKEYCODE_F5, KEY_F5},
	{AKEYCODE_F6, KEY_F6},
	{AKEYCODE_F7, KEY_F7},
	{AKEYCODE_F8, KEY_F8},
	{AKEYCODE_F9, KEY_F9},
	{AKEYCODE_F10, KEY_F10},
	{AKEYCODE_F11, KEY_F11},
	{AKEYCODE_F12, KEY_F12},
	{AKEYCODE_BACK, KEY_BACK},
	{AKEYCODE_FORWARD, KEY_FORWARD},
	{AKEYCODE_NUMPAD_1, KEY_KP1},
	{AKEYCODE_NUMPAD_2, KEY_KP2},
	{AKEYCODE_NUMPAD_3, KEY_KP3},
	{AKEYCODE_NUMPAD_4, KEY_KP4},
	{AKEYCODE_NUMPAD_5, KEY_KP5},
	{AKEYCODE_NUMPAD_6, KEY_KP6},
	{AKEYCODE_NUMPAD_7, KEY_KP7},
	{AKEYCODE_NUMPAD_8, KEY_KP8},
	{AKEYCODE_NUMPAD_9, KEY_KP9},
	{AKEYCODE_NUMPAD_0, KEY_KP0},
	{AKEYCODE_NUMPAD_ADD, KEY_KPPLUS},
	{AKEYCODE_NUMPAD_SUBTRACT, KEY_KPMINUS},
	{AKEYCODE_NUMPAD_MULTIPLY, KEY_KPASTERISK},
	{AKEYCODE_NUMPAD_DIVIDE, KEY_KPSLASH},
	{AKEYCODE_NUMPAD_DOT, KEY_KPDOT},
	{AKEYCODE_NUMPAD_ENTER, KEY_KPENTER},
	{AKEYCODE_NUMPAD_EQUALS, KEY_KPEQUAL},
	{AKEYCODE_NUMPAD_COMMA, KEY_KPCOMMA},
	{AKEYCODE_LANGUAGE_SWITCH, KEY_LANGUAGE},
	};
	VirtualKeyboard::VirtualKeyboard(unique_fd fd) : VirtualInputDevice(std::move(fd)) {}
	VirtualKeyboard::~VirtualKeyboard() {}

	bool VirtualKeyboard::writeKeyEvent(int32_t androidKeyCode, int32_t androidAction,
	std::chrono::nanoseconds eventTime) {
	return writeEvKeyEvent(androidKeyCode, androidAction, KEY_CODE_MAPPING, KEY_ACTION_MAPPING,
	eventTime);
	}

	// --- VirtualDpad ---
	// Dpad keycode mapping from https://source.android.com/devices/input/keyboard-devices
	const std::map<int, int> VirtualDpad::DPAD_KEY_CODE_MAPPING = {
	// clang-format off
	{AKEYCODE_DPAD_DOWN, KEY_DOWN},
	{AKEYCODE_DPAD_UP, KEY_UP},
	{AKEYCODE_DPAD_LEFT, KEY_LEFT},
	{AKEYCODE_DPAD_RIGHT, KEY_RIGHT},
	{AKEYCODE_DPAD_CENTER, KEY_SELECT},
	{AKEYCODE_BACK, KEY_BACK},
	// clang-format on
	};

	VirtualDpad::VirtualDpad(unique_fd fd) : VirtualInputDevice(std::move(fd)) {}

	VirtualDpad::~VirtualDpad() {}

	bool VirtualDpad::writeDpadKeyEvent(int32_t androidKeyCode, int32_t androidAction,
	std::chrono::nanoseconds eventTime) {
	return writeEvKeyEvent(androidKeyCode, androidAction, DPAD_KEY_CODE_MAPPING,
	VirtualKeyboard::KEY_ACTION_MAPPING, eventTime);
	}

	// --- VirtualMouse ---
	const std::map<int, UinputAction> VirtualMouse::BUTTON_ACTION_MAPPING = {
	{AMOTION_EVENT_ACTION_BUTTON_PRESS, UinputAction::PRESS},
	{AMOTION_EVENT_ACTION_BUTTON_RELEASE, UinputAction::RELEASE},
	};

	// Button code mapping from https://source.android.com/devices/input/touch-devices
	const std::map<int, int> VirtualMouse::BUTTON_CODE_MAPPING = {
	// clang-format off
	{AMOTION_EVENT_BUTTON_PRIMARY, BTN_LEFT},
	{AMOTION_EVENT_BUTTON_SECONDARY, BTN_RIGHT},
	{AMOTION_EVENT_BUTTON_TERTIARY, BTN_MIDDLE},
	{AMOTION_EVENT_BUTTON_BACK, BTN_BACK},
	{AMOTION_EVENT_BUTTON_FORWARD, BTN_FORWARD},
	// clang-format on
	};

	VirtualMouse::VirtualMouse(unique_fd fd) : VirtualInputDevice(std::move(fd)) {}

	VirtualMouse::~VirtualMouse() {}

	bool VirtualMouse::writeButtonEvent(int32_t androidButtonCode, int32_t androidAction,
	std::chrono::nanoseconds eventTime) {
	return writeEvKeyEvent(androidButtonCode, androidAction, BUTTON_CODE_MAPPING,
	BUTTON_ACTION_MAPPING, eventTime);
	}

	bool VirtualMouse::writeRelativeEvent(float relativeX, float relativeY,
	std::chrono::nanoseconds eventTime) {
	return writeInputEvent(EV_REL, REL_X, relativeX, eventTime) &&
	writeInputEvent(EV_REL, REL_Y, relativeY, eventTime) &&
	writeInputEvent(EV_SYN, SYN_REPORT, 0, eventTime);
	}

	bool VirtualMouse::writeScrollEvent(float xAxisMovement, float yAxisMovement,
	std::chrono::nanoseconds eventTime) {
	return writeInputEvent(EV_REL, REL_HWHEEL, xAxisMovement, eventTime) &&
	writeInputEvent(EV_REL, REL_WHEEL, yAxisMovement, eventTime) &&
	writeInputEvent(EV_SYN, SYN_REPORT, 0, eventTime);
	}

	// --- VirtualTouchscreen ---
	const std::map<int, UinputAction> VirtualTouchscreen::TOUCH_ACTION_MAPPING = {
	{AMOTION_EVENT_ACTION_DOWN, UinputAction::PRESS},
	{AMOTION_EVENT_ACTION_UP, UinputAction::RELEASE},
	{AMOTION_EVENT_ACTION_MOVE, UinputAction::MOVE},
	{AMOTION_EVENT_ACTION_CANCEL, UinputAction::CANCEL},
	};
	// Tool type mapping from https://source.android.com/devices/input/touch-devices
	const std::map<int, int> VirtualTouchscreen::TOOL_TYPE_MAPPING = {
	{AMOTION_EVENT_TOOL_TYPE_FINGER, MT_TOOL_FINGER},
	{AMOTION_EVENT_TOOL_TYPE_PALM, MT_TOOL_PALM},
	};

	VirtualTouchscreen::VirtualTouchscreen(unique_fd fd) : VirtualInputDevice(std::move(fd)) {}

	VirtualTouchscreen::~VirtualTouchscreen() {}

	bool VirtualTouchscreen::isValidPointerId(int32_t pointerId, UinputAction uinputAction) {
	if (pointerId < -1 \|\| pointerId >= (int)MAX_POINTERS) {
	ALOGE("Virtual touch event has invalid pointer id %d; value must be between -1 and %zu",
	pointerId, MAX_POINTERS - 0);
	return false;
	}

	if (uinputAction == UinputAction::PRESS && mActivePointers.test(pointerId)) {
	ALOGE("Repetitive action DOWN event received on a pointer %d that is already down.",
	pointerId);
	return false;
	}
	if (uinputAction == UinputAction::RELEASE && !mActivePointers.test(pointerId)) {
	ALOGE("PointerId %d action UP received with no prior action DOWN on touchscreen %d.",
	pointerId, mFd.get());
	return false;
	}
	return true;
	}

	bool VirtualTouchscreen::writeTouchEvent(int32_t pointerId, int32_t toolType, int32_t action,
	float locationX, float locationY, float pressure,
	float majorAxisSize, std::chrono::nanoseconds eventTime) {
	auto actionIterator = TOUCH_ACTION_MAPPING.find(action);
	if (actionIterator == TOUCH_ACTION_MAPPING.end()) {
	return false;
	}
	UinputAction uinputAction = actionIterator->second;
	if (!isValidPointerId(pointerId, uinputAction)) {
	return false;
	}
	if (!writeInputEvent(EV_ABS, ABS_MT_SLOT, pointerId, eventTime)) {
	return false;
	}
	auto toolTypeIterator = TOOL_TYPE_MAPPING.find(toolType);
	if (toolTypeIterator == TOOL_TYPE_MAPPING.end()) {
	return false;
	}
	if (!writeInputEvent(EV_ABS, ABS_MT_TOOL_TYPE, static_cast<int32_t>(toolTypeIterator->second),
	eventTime)) {
	return false;
	}
	if (uinputAction == UinputAction::PRESS && !handleTouchDown(pointerId, eventTime)) {
	return false;
	}
	if (uinputAction == UinputAction::RELEASE && !handleTouchUp(pointerId, eventTime)) {
	return false;
	}
	if (!writeInputEvent(EV_ABS, ABS_MT_POSITION_X, locationX, eventTime)) {
	return false;
	}
	if (!writeInputEvent(EV_ABS, ABS_MT_POSITION_Y, locationY, eventTime)) {
	return false;
	}
	if (!isnan(pressure)) {
	if (!writeInputEvent(EV_ABS, ABS_MT_PRESSURE, pressure, eventTime)) {
	return false;
	}
	}
	if (!isnan(majorAxisSize)) {
	if (!writeInputEvent(EV_ABS, ABS_MT_TOUCH_MAJOR, majorAxisSize, eventTime)) {
	return false;
	}
	}
	return writeInputEvent(EV_SYN, SYN_REPORT, 0, eventTime);
	}

	bool VirtualTouchscreen::handleTouchUp(int32_t pointerId, std::chrono::nanoseconds eventTime) {
	if (!writeInputEvent(EV_ABS, ABS_MT_TRACKING_ID, static_cast<int32_t>(-1), eventTime)) {
	return false;
	}
	// When a pointer is no longer in touch, remove the pointer id from the corresponding
	// entry in the unreleased touches map.
	mActivePointers.reset(pointerId);
	ALOGD_IF(isDebug(), "Pointer %d erased from the touchscreen %d", pointerId, mFd.get());

	// Only sends the BTN UP event when there's no pointers on the touchscreen.
	if (mActivePointers.none()) {
	if (!writeInputEvent(EV_KEY, BTN_TOUCH, static_cast<int32_t>(UinputAction::RELEASE),
	eventTime)) {
	return false;
	}
	ALOGD_IF(isDebug(), "No pointers on touchscreen %d, BTN UP event sent.", mFd.get());
	}
	return true;
	}

	bool VirtualTouchscreen::handleTouchDown(int32_t pointerId, std::chrono::nanoseconds eventTime) {
	// When a new pointer is down on the touchscreen, add the pointer id in the corresponding
	// entry in the unreleased touches map.
	if (mActivePointers.none()) {
	// Only sends the BTN Down event when the first pointer on the touchscreen is down.
	if (!writeInputEvent(EV_KEY, BTN_TOUCH, static_cast<int32_t>(UinputAction::PRESS),
	eventTime)) {
	return false;
	}
	ALOGD_IF(isDebug(), "First pointer %d down under touchscreen %d, BTN DOWN event sent",
	pointerId, mFd.get());
	}

	mActivePointers.set(pointerId);
	ALOGD_IF(isDebug(), "Added pointer %d under touchscreen %d in the map", pointerId, mFd.get());
	if (!writeInputEvent(EV_ABS, ABS_MT_TRACKING_ID, static_cast<int32_t>(pointerId), eventTime)) {
	return false;
	}
	return true;
	}

	} // namespace android