Display and control your Android device
Use scrcpy input events for key processors
Romain Vimontb4b638e8fe2a
diff --git a/app/src/hid_keyboard.c b/app/src/hid_keyboard.cindex cf8eab61..be5f8a19 100644--- a/app/src/hid_keyboard.c+++ b/app/src/hid_keyboard.c@@ -1,8 +1,8 @@#include "hid_keyboard.h"#include <assert.h>-#include <SDL2/SDL_events.h>+#include "input_events.h"#include "util/log.h"/** Downcast key processor to hid_keyboard */@@ -201,30 +201,30 @@ static const unsigned char keyboard_report_desc[] = {*/static unsigned char-sdl_keymod_to_hid_modifiers(SDL_Keymod mod) {+sdl_keymod_to_hid_modifiers(uint16_t mod) {unsigned char modifiers = HID_MODIFIER_NONE;- if (mod & KMOD_LCTRL) {+ if (mod & SC_MOD_LCTRL) {modifiers |= HID_MODIFIER_LEFT_CONTROL;}- if (mod & KMOD_LSHIFT) {+ if (mod & SC_MOD_LSHIFT) {modifiers |= HID_MODIFIER_LEFT_SHIFT;}- if (mod & KMOD_LALT) {+ if (mod & SC_MOD_LALT) {modifiers |= HID_MODIFIER_LEFT_ALT;}- if (mod & KMOD_LGUI) {+ if (mod & SC_MOD_LGUI) {modifiers |= HID_MODIFIER_LEFT_GUI;}- if (mod & KMOD_RCTRL) {+ if (mod & SC_MOD_RCTRL) {modifiers |= HID_MODIFIER_RIGHT_CONTROL;}- if (mod & KMOD_RSHIFT) {+ if (mod & SC_MOD_RSHIFT) {modifiers |= HID_MODIFIER_RIGHT_SHIFT;}- if (mod & KMOD_RALT) {+ if (mod & SC_MOD_RALT) {modifiers |= HID_MODIFIER_RIGHT_ALT;}- if (mod & KMOD_RGUI) {+ if (mod & SC_MOD_RGUI) {modifiers |= HID_MODIFIER_RIGHT_GUI;}return modifiers;@@ -248,15 +248,15 @@ sc_hid_keyboard_event_init(struct sc_hid_event *hid_event) {}static inline bool-scancode_is_modifier(SDL_Scancode scancode) {- return scancode >= SDL_SCANCODE_LCTRL && scancode <= SDL_SCANCODE_RGUI;+scancode_is_modifier(enum sc_scancode scancode) {+ return scancode >= SC_SCANCODE_LCTRL && scancode <= SC_SCANCODE_RGUI;}static boolconvert_hid_keyboard_event(struct sc_hid_keyboard *kb,struct sc_hid_event *hid_event,- const SDL_KeyboardEvent *event) {- SDL_Scancode scancode = event->keysym.scancode;+ const struct sc_key_event *event) {+ enum sc_scancode scancode = event->scancode;assert(scancode >= 0);// SDL also generates events when only modifiers are pressed, we cannot@@ -272,11 +272,11 @@ convert_hid_keyboard_event(struct sc_hid_keyboard *kb,return false;}- unsigned char modifiers = sdl_keymod_to_hid_modifiers(event->keysym.mod);+ unsigned char modifiers = sdl_keymod_to_hid_modifiers(event->mods_state);if (scancode < SC_HID_KEYBOARD_KEYS) {// Pressed is true and released is false- kb->keys[scancode] = (event->type == SDL_KEYDOWN);+ kb->keys[scancode] = (event->action == SC_ACTION_DOWN);LOGV("keys[%02x] = %s", scancode,kb->keys[scancode] ? "true" : "false");}@@ -306,17 +306,17 @@ convert_hid_keyboard_event(struct sc_hid_keyboard *kb,end:LOGV("hid keyboard: key %-4s scancode=%02x (%u) mod=%02x",- event->type == SDL_KEYDOWN ? "down" : "up", event->keysym.scancode,- event->keysym.scancode, modifiers);+ event->action == SC_ACTION_DOWN ? "down" : "up", event->scancode,+ event->scancode, modifiers);return true;}static bool-push_mod_lock_state(struct sc_hid_keyboard *kb, uint16_t sdl_mod) {- bool capslock = sdl_mod & KMOD_CAPS;- bool numlock = sdl_mod & KMOD_NUM;+push_mod_lock_state(struct sc_hid_keyboard *kb, uint16_t mods_state) {+ bool capslock = mods_state & SC_MOD_CAPS;+ bool numlock = mods_state & SC_MOD_NUM;if (!capslock && !numlock) {// Nothing to doreturn true;@@ -328,8 +328,6 @@ push_mod_lock_state(struct sc_hid_keyboard *kb, uint16_t sdl_mod) {return false;}-#define SC_SCANCODE_CAPSLOCK SDL_SCANCODE_CAPSLOCK-#define SC_SCANCODE_NUMLOCK SDL_SCANCODE_NUMLOCKCLEARunsigned i = 0;if (capslock) {hid_event.buffer[HID_KEYBOARD_INDEX_KEYS + i] = SC_SCANCODE_CAPSLOCK;@@ -353,7 +351,7 @@ push_mod_lock_state(struct sc_hid_keyboard *kb, uint16_t sdl_mod) {static voidsc_key_processor_process_key(struct sc_key_processor *kp,- const SDL_KeyboardEvent *event,+ const struct sc_key_event *event,uint64_t ack_to_wait) {if (event->repeat) {// In USB HID protocol, key repeat is handled by the host (Android), so@@ -369,7 +367,7 @@ sc_key_processor_process_key(struct sc_key_processor *kp,if (!kb->mod_lock_synchronized) {// Inject CAPSLOCK and/or NUMLOCK if necessary to synchronize// keyboard state- if (push_mod_lock_state(kb, event->keysym.mod)) {+ if (push_mod_lock_state(kb, event->mods_state)) {kb->mod_lock_synchronized = true;}}@@ -391,7 +389,7 @@ sc_key_processor_process_key(struct sc_key_processor *kp,static voidsc_key_processor_process_text(struct sc_key_processor *kp,- const SDL_TextInputEvent *event) {+ const struct sc_text_event *event) {(void) kp;(void) event;diff --git a/app/src/input_manager.c b/app/src/input_manager.cindex 0ed364b1..03d19b0e 100644--- a/app/src/input_manager.c+++ b/app/src/input_manager.c@@ -6,6 +6,30 @@#include "input_events.h"#include "util/log.h"+static inline uint16_t+sc_mods_state_from_sdl(uint16_t mods_state) {+ return mods_state;+}++static inline enum sc_keycode+sc_keycode_from_sdl(SDL_Keycode keycode) {+ return (enum sc_keycode) keycode;+}++static inline enum sc_scancode+sc_scancode_from_sdl(SDL_Scancode scancode) {+ return (enum sc_scancode) scancode;+}++static inline enum sc_action+sc_action_from_sdl_keyboard_type(uint32_t type) {+ assert(type == SDL_KEYDOWN || type == SDL_KEYUP);+ if (type == SDL_KEYDOWN) {+ return SC_ACTION_DOWN;+ }+ return SC_ACTION_UP;+}+#define SC_SDL_SHORTCUT_MODS_MASK (KMOD_CTRL | KMOD_ALT | KMOD_GUI)static inline uint16_t@@ -317,7 +341,11 @@ input_manager_process_text_input(struct input_manager *im,return;}- im->kp->ops->process_text(im->kp, event);+ struct sc_text_event evt = {+ .text = event->text,+ };++ im->kp->ops->process_text(im->kp, &evt);}static bool@@ -536,7 +564,15 @@ input_manager_process_key(struct input_manager *im,}}- im->kp->ops->process_key(im->kp, event, ack_to_wait);+ struct sc_key_event evt = {+ .action = sc_action_from_sdl_keyboard_type(event->type),+ .keycode = sc_keycode_from_sdl(event->keysym.sym),+ .scancode = sc_scancode_from_sdl(event->keysym.scancode),+ .repeat = event->repeat,+ .mods_state = sc_mods_state_from_sdl(event->keysym.mod),+ };++ im->kp->ops->process_key(im->kp, &evt, ack_to_wait);}static voiddiff --git a/app/src/keyboard_inject.c b/app/src/keyboard_inject.cindex 5143eafc..968a3c4f 100644--- a/app/src/keyboard_inject.c+++ b/app/src/keyboard_inject.c@@ -1,11 +1,11 @@#include "keyboard_inject.h"#include <assert.h>-#include <SDL2/SDL_events.h>#include "android/input.h"#include "control_msg.h"#include "controller.h"+#include "input_events.h"#include "util/intmap.h"#include "util/log.h"@@ -13,10 +13,10 @@#define DOWNCAST(KP) container_of(KP, struct sc_keyboard_inject, key_processor)static bool-convert_keycode_action(SDL_EventType from, enum android_keyevent_action *to) {+convert_keycode_action(enum sc_action from, enum android_keyevent_action *to) {static const struct sc_intmap_entry actions[] = {- {SDL_KEYDOWN, AKEY_EVENT_ACTION_DOWN},- {SDL_KEYUP, AKEY_EVENT_ACTION_UP},+ {SC_ACTION_DOWN, AKEY_EVENT_ACTION_DOWN},+ {SC_ACTION_UP, AKEY_EVENT_ACTION_UP},};const struct sc_intmap_entry *entry = SC_INTMAP_FIND_ENTRY(actions, from);@@ -29,125 +29,125 @@ convert_keycode_action(SDL_EventType from, enum android_keyevent_action *to) {}static bool-convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,+convert_keycode(enum sc_keycode from, enum android_keycode *to, uint16_t mod,enum sc_key_inject_mode key_inject_mode) {// Navigation keys and ENTER.// Used in all modes.static const struct sc_intmap_entry special_keys[] = {- {SDLK_RETURN, AKEYCODE_ENTER},- {SDLK_KP_ENTER, AKEYCODE_NUMPAD_ENTER},- {SDLK_ESCAPE, AKEYCODE_ESCAPE},- {SDLK_BACKSPACE, AKEYCODE_DEL},- {SDLK_TAB, AKEYCODE_TAB},- {SDLK_PAGEUP, AKEYCODE_PAGE_UP},- {SDLK_DELETE, AKEYCODE_FORWARD_DEL},- {SDLK_HOME, AKEYCODE_MOVE_HOME},- {SDLK_END, AKEYCODE_MOVE_END},- {SDLK_PAGEDOWN, AKEYCODE_PAGE_DOWN},- {SDLK_RIGHT, AKEYCODE_DPAD_RIGHT},- {SDLK_LEFT, AKEYCODE_DPAD_LEFT},- {SDLK_DOWN, AKEYCODE_DPAD_DOWN},- {SDLK_UP, AKEYCODE_DPAD_UP},- {SDLK_LCTRL, AKEYCODE_CTRL_LEFT},- {SDLK_RCTRL, AKEYCODE_CTRL_RIGHT},- {SDLK_LSHIFT, AKEYCODE_SHIFT_LEFT},- {SDLK_RSHIFT, AKEYCODE_SHIFT_RIGHT},+ {SC_KEYCODE_RETURN, AKEYCODE_ENTER},+ {SC_KEYCODE_KP_ENTER, AKEYCODE_NUMPAD_ENTER},+ {SC_KEYCODE_ESCAPE, AKEYCODE_ESCAPE},+ {SC_KEYCODE_BACKSPACE, AKEYCODE_DEL},+ {SC_KEYCODE_TAB, AKEYCODE_TAB},+ {SC_KEYCODE_PAGEUP, AKEYCODE_PAGE_UP},+ {SC_KEYCODE_DELETE, AKEYCODE_FORWARD_DEL},+ {SC_KEYCODE_HOME, AKEYCODE_MOVE_HOME},+ {SC_KEYCODE_END, AKEYCODE_MOVE_END},+ {SC_KEYCODE_PAGEDOWN, AKEYCODE_PAGE_DOWN},+ {SC_KEYCODE_RIGHT, AKEYCODE_DPAD_RIGHT},+ {SC_KEYCODE_LEFT, AKEYCODE_DPAD_LEFT},+ {SC_KEYCODE_DOWN, AKEYCODE_DPAD_DOWN},+ {SC_KEYCODE_UP, AKEYCODE_DPAD_UP},+ {SC_KEYCODE_LCTRL, AKEYCODE_CTRL_LEFT},+ {SC_KEYCODE_RCTRL, AKEYCODE_CTRL_RIGHT},+ {SC_KEYCODE_LSHIFT, AKEYCODE_SHIFT_LEFT},+ {SC_KEYCODE_RSHIFT, AKEYCODE_SHIFT_RIGHT},};// Numpad navigation keys.// Used in all modes, when NumLock and Shift are disabled.static const struct sc_intmap_entry kp_nav_keys[] = {- {SDLK_KP_0, AKEYCODE_INSERT},- {SDLK_KP_1, AKEYCODE_MOVE_END},- {SDLK_KP_2, AKEYCODE_DPAD_DOWN},- {SDLK_KP_3, AKEYCODE_PAGE_DOWN},- {SDLK_KP_4, AKEYCODE_DPAD_LEFT},- {SDLK_KP_6, AKEYCODE_DPAD_RIGHT},- {SDLK_KP_7, AKEYCODE_MOVE_HOME},- {SDLK_KP_8, AKEYCODE_DPAD_UP},- {SDLK_KP_9, AKEYCODE_PAGE_UP},- {SDLK_KP_PERIOD, AKEYCODE_FORWARD_DEL},+ {SC_KEYCODE_KP_0, AKEYCODE_INSERT},+ {SC_KEYCODE_KP_1, AKEYCODE_MOVE_END},+ {SC_KEYCODE_KP_2, AKEYCODE_DPAD_DOWN},+ {SC_KEYCODE_KP_3, AKEYCODE_PAGE_DOWN},+ {SC_KEYCODE_KP_4, AKEYCODE_DPAD_LEFT},+ {SC_KEYCODE_KP_6, AKEYCODE_DPAD_RIGHT},+ {SC_KEYCODE_KP_7, AKEYCODE_MOVE_HOME},+ {SC_KEYCODE_KP_8, AKEYCODE_DPAD_UP},+ {SC_KEYCODE_KP_9, AKEYCODE_PAGE_UP},+ {SC_KEYCODE_KP_PERIOD, AKEYCODE_FORWARD_DEL},};// Letters and space.// Used in non-text mode.static const struct sc_intmap_entry alphaspace_keys[] = {- {SDLK_a, AKEYCODE_A},- {SDLK_b, AKEYCODE_B},- {SDLK_c, AKEYCODE_C},- {SDLK_d, AKEYCODE_D},- {SDLK_e, AKEYCODE_E},- {SDLK_f, AKEYCODE_F},- {SDLK_g, AKEYCODE_G},- {SDLK_h, AKEYCODE_H},- {SDLK_i, AKEYCODE_I},- {SDLK_j, AKEYCODE_J},- {SDLK_k, AKEYCODE_K},- {SDLK_l, AKEYCODE_L},- {SDLK_m, AKEYCODE_M},- {SDLK_n, AKEYCODE_N},- {SDLK_o, AKEYCODE_O},- {SDLK_p, AKEYCODE_P},- {SDLK_q, AKEYCODE_Q},- {SDLK_r, AKEYCODE_R},- {SDLK_s, AKEYCODE_S},- {SDLK_t, AKEYCODE_T},- {SDLK_u, AKEYCODE_U},- {SDLK_v, AKEYCODE_V},- {SDLK_w, AKEYCODE_W},- {SDLK_x, AKEYCODE_X},- {SDLK_y, AKEYCODE_Y},- {SDLK_z, AKEYCODE_Z},- {SDLK_SPACE, AKEYCODE_SPACE},+ {SC_KEYCODE_a, AKEYCODE_A},+ {SC_KEYCODE_b, AKEYCODE_B},+ {SC_KEYCODE_c, AKEYCODE_C},+ {SC_KEYCODE_d, AKEYCODE_D},+ {SC_KEYCODE_e, AKEYCODE_E},+ {SC_KEYCODE_f, AKEYCODE_F},+ {SC_KEYCODE_g, AKEYCODE_G},+ {SC_KEYCODE_h, AKEYCODE_H},+ {SC_KEYCODE_i, AKEYCODE_I},+ {SC_KEYCODE_j, AKEYCODE_J},+ {SC_KEYCODE_k, AKEYCODE_K},+ {SC_KEYCODE_l, AKEYCODE_L},+ {SC_KEYCODE_m, AKEYCODE_M},+ {SC_KEYCODE_n, AKEYCODE_N},+ {SC_KEYCODE_o, AKEYCODE_O},+ {SC_KEYCODE_p, AKEYCODE_P},+ {SC_KEYCODE_q, AKEYCODE_Q},+ {SC_KEYCODE_r, AKEYCODE_R},+ {SC_KEYCODE_s, AKEYCODE_S},+ {SC_KEYCODE_t, AKEYCODE_T},+ {SC_KEYCODE_u, AKEYCODE_U},+ {SC_KEYCODE_v, AKEYCODE_V},+ {SC_KEYCODE_w, AKEYCODE_W},+ {SC_KEYCODE_x, AKEYCODE_X},+ {SC_KEYCODE_y, AKEYCODE_Y},+ {SC_KEYCODE_z, AKEYCODE_Z},+ {SC_KEYCODE_SPACE, AKEYCODE_SPACE},};// Numbers and punctuation keys.// Used in raw mode only.static const struct sc_intmap_entry numbers_punct_keys[] = {- {SDLK_HASH, AKEYCODE_POUND},- {SDLK_PERCENT, AKEYCODE_PERIOD},- {SDLK_QUOTE, AKEYCODE_APOSTROPHE},- {SDLK_ASTERISK, AKEYCODE_STAR},- {SDLK_PLUS, AKEYCODE_PLUS},- {SDLK_COMMA, AKEYCODE_COMMA},- {SDLK_MINUS, AKEYCODE_MINUS},- {SDLK_PERIOD, AKEYCODE_PERIOD},- {SDLK_SLASH, AKEYCODE_SLASH},- {SDLK_0, AKEYCODE_0},- {SDLK_1, AKEYCODE_1},- {SDLK_2, AKEYCODE_2},- {SDLK_3, AKEYCODE_3},- {SDLK_4, AKEYCODE_4},- {SDLK_5, AKEYCODE_5},- {SDLK_6, AKEYCODE_6},- {SDLK_7, AKEYCODE_7},- {SDLK_8, AKEYCODE_8},- {SDLK_9, AKEYCODE_9},- {SDLK_SEMICOLON, AKEYCODE_SEMICOLON},- {SDLK_EQUALS, AKEYCODE_EQUALS},- {SDLK_AT, AKEYCODE_AT},- {SDLK_LEFTBRACKET, AKEYCODE_LEFT_BRACKET},- {SDLK_BACKSLASH, AKEYCODE_BACKSLASH},- {SDLK_RIGHTBRACKET, AKEYCODE_RIGHT_BRACKET},- {SDLK_BACKQUOTE, AKEYCODE_GRAVE},- {SDLK_KP_1, AKEYCODE_NUMPAD_1},- {SDLK_KP_2, AKEYCODE_NUMPAD_2},- {SDLK_KP_3, AKEYCODE_NUMPAD_3},- {SDLK_KP_4, AKEYCODE_NUMPAD_4},- {SDLK_KP_5, AKEYCODE_NUMPAD_5},- {SDLK_KP_6, AKEYCODE_NUMPAD_6},- {SDLK_KP_7, AKEYCODE_NUMPAD_7},- {SDLK_KP_8, AKEYCODE_NUMPAD_8},- {SDLK_KP_9, AKEYCODE_NUMPAD_9},- {SDLK_KP_0, AKEYCODE_NUMPAD_0},- {SDLK_KP_DIVIDE, AKEYCODE_NUMPAD_DIVIDE},- {SDLK_KP_MULTIPLY, AKEYCODE_NUMPAD_MULTIPLY},- {SDLK_KP_MINUS, AKEYCODE_NUMPAD_SUBTRACT},- {SDLK_KP_PLUS, AKEYCODE_NUMPAD_ADD},- {SDLK_KP_PERIOD, AKEYCODE_NUMPAD_DOT},- {SDLK_KP_EQUALS, AKEYCODE_NUMPAD_EQUALS},- {SDLK_KP_LEFTPAREN, AKEYCODE_NUMPAD_LEFT_PAREN},- {SDLK_KP_RIGHTPAREN, AKEYCODE_NUMPAD_RIGHT_PAREN},+ {SC_KEYCODE_HASH, AKEYCODE_POUND},+ {SC_KEYCODE_PERCENT, AKEYCODE_PERIOD},+ {SC_KEYCODE_QUOTE, AKEYCODE_APOSTROPHE},+ {SC_KEYCODE_ASTERISK, AKEYCODE_STAR},+ {SC_KEYCODE_PLUS, AKEYCODE_PLUS},+ {SC_KEYCODE_COMMA, AKEYCODE_COMMA},+ {SC_KEYCODE_MINUS, AKEYCODE_MINUS},+ {SC_KEYCODE_PERIOD, AKEYCODE_PERIOD},+ {SC_KEYCODE_SLASH, AKEYCODE_SLASH},+ {SC_KEYCODE_0, AKEYCODE_0},+ {SC_KEYCODE_1, AKEYCODE_1},+ {SC_KEYCODE_2, AKEYCODE_2},+ {SC_KEYCODE_3, AKEYCODE_3},+ {SC_KEYCODE_4, AKEYCODE_4},+ {SC_KEYCODE_5, AKEYCODE_5},+ {SC_KEYCODE_6, AKEYCODE_6},+ {SC_KEYCODE_7, AKEYCODE_7},+ {SC_KEYCODE_8, AKEYCODE_8},+ {SC_KEYCODE_9, AKEYCODE_9},+ {SC_KEYCODE_SEMICOLON, AKEYCODE_SEMICOLON},+ {SC_KEYCODE_EQUALS, AKEYCODE_EQUALS},+ {SC_KEYCODE_AT, AKEYCODE_AT},+ {SC_KEYCODE_LEFTBRACKET, AKEYCODE_LEFT_BRACKET},+ {SC_KEYCODE_BACKSLASH, AKEYCODE_BACKSLASH},+ {SC_KEYCODE_RIGHTBRACKET, AKEYCODE_RIGHT_BRACKET},+ {SC_KEYCODE_BACKQUOTE, AKEYCODE_GRAVE},+ {SC_KEYCODE_KP_1, AKEYCODE_NUMPAD_1},+ {SC_KEYCODE_KP_2, AKEYCODE_NUMPAD_2},+ {SC_KEYCODE_KP_3, AKEYCODE_NUMPAD_3},+ {SC_KEYCODE_KP_4, AKEYCODE_NUMPAD_4},+ {SC_KEYCODE_KP_5, AKEYCODE_NUMPAD_5},+ {SC_KEYCODE_KP_6, AKEYCODE_NUMPAD_6},+ {SC_KEYCODE_KP_7, AKEYCODE_NUMPAD_7},+ {SC_KEYCODE_KP_8, AKEYCODE_NUMPAD_8},+ {SC_KEYCODE_KP_9, AKEYCODE_NUMPAD_9},+ {SC_KEYCODE_KP_0, AKEYCODE_NUMPAD_0},+ {SC_KEYCODE_KP_DIVIDE, AKEYCODE_NUMPAD_DIVIDE},+ {SC_KEYCODE_KP_MULTIPLY, AKEYCODE_NUMPAD_MULTIPLY},+ {SC_KEYCODE_KP_MINUS, AKEYCODE_NUMPAD_SUBTRACT},+ {SC_KEYCODE_KP_PLUS, AKEYCODE_NUMPAD_ADD},+ {SC_KEYCODE_KP_PERIOD, AKEYCODE_NUMPAD_DOT},+ {SC_KEYCODE_KP_EQUALS, AKEYCODE_NUMPAD_EQUALS},+ {SC_KEYCODE_KP_LEFTPAREN, AKEYCODE_NUMPAD_LEFT_PAREN},+ {SC_KEYCODE_KP_RIGHTPAREN, AKEYCODE_NUMPAD_RIGHT_PAREN},};const struct sc_intmap_entry *entry =@@ -157,7 +157,7 @@ convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,return true;}- if (!(mod & (KMOD_NUM | KMOD_SHIFT))) {+ if (!(mod & (SC_MOD_NUM | SC_MOD_LSHIFT | SC_MOD_RSHIFT))) {// Handle Numpad events when Num Lock is disabled// If SHIFT is pressed, a text event will be sent insteadentry = SC_INTMAP_FIND_ENTRY(kp_nav_keys, from);@@ -167,12 +167,13 @@ convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,}}- if (key_inject_mode == SC_KEY_INJECT_MODE_TEXT && !(mod & KMOD_CTRL)) {+ if (key_inject_mode == SC_KEY_INJECT_MODE_TEXT &&+ !(mod & (SC_MOD_LCTRL | SC_MOD_RCTRL))) {// do not forward alpha and space key events (unless Ctrl is pressed)return false;}- if (mod & (KMOD_LALT | KMOD_RALT | KMOD_LGUI | KMOD_RGUI)) {+ if (mod & (SC_MOD_LALT | SC_MOD_RALT | SC_MOD_LGUI | SC_MOD_RGUI)) {return false;}@@ -214,70 +215,66 @@ autocomplete_metastate(enum android_metastate metastate) {}static enum android_metastate-convert_meta_state(SDL_Keymod mod) {+convert_meta_state(uint16_t mod) {enum android_metastate metastate = 0;- if (mod & KMOD_LSHIFT) {+ if (mod & SC_MOD_LSHIFT) {metastate |= AMETA_SHIFT_LEFT_ON;}- if (mod & KMOD_RSHIFT) {+ if (mod & SC_MOD_RSHIFT) {metastate |= AMETA_SHIFT_RIGHT_ON;}- if (mod & KMOD_LCTRL) {+ if (mod & SC_MOD_LCTRL) {metastate |= AMETA_CTRL_LEFT_ON;}- if (mod & KMOD_RCTRL) {+ if (mod & SC_MOD_RCTRL) {metastate |= AMETA_CTRL_RIGHT_ON;}- if (mod & KMOD_LALT) {+ if (mod & SC_MOD_LALT) {metastate |= AMETA_ALT_LEFT_ON;}- if (mod & KMOD_RALT) {+ if (mod & SC_MOD_RALT) {metastate |= AMETA_ALT_RIGHT_ON;}- if (mod & KMOD_LGUI) { // Windows key+ if (mod & SC_MOD_LGUI) { // Windows keymetastate |= AMETA_META_LEFT_ON;}- if (mod & KMOD_RGUI) { // Windows key+ if (mod & SC_MOD_RGUI) { // Windows keymetastate |= AMETA_META_RIGHT_ON;}- if (mod & KMOD_NUM) {+ if (mod & SC_MOD_NUM) {metastate |= AMETA_NUM_LOCK_ON;}- if (mod & KMOD_CAPS) {+ if (mod & SC_MOD_CAPS) {metastate |= AMETA_CAPS_LOCK_ON;}- if (mod & KMOD_MODE) { // Alt Gr- // no mapping?- }// fill the dependent fieldsreturn autocomplete_metastate(metastate);}static bool-convert_input_key(const SDL_KeyboardEvent *from, struct control_msg *to,+convert_input_key(const struct sc_key_event *event, struct control_msg *msg,enum sc_key_inject_mode key_inject_mode, uint32_t repeat) {- to->type = CONTROL_MSG_TYPE_INJECT_KEYCODE;+ msg->type = CONTROL_MSG_TYPE_INJECT_KEYCODE;- if (!convert_keycode_action(from->type, &to->inject_keycode.action)) {+ if (!convert_keycode_action(event->action, &msg->inject_keycode.action)) {return false;}- uint16_t mod = from->keysym.mod;- if (!convert_keycode(from->keysym.sym, &to->inject_keycode.keycode, mod,- key_inject_mode)) {+ if (!convert_keycode(event->keycode, &msg->inject_keycode.keycode,+ event->mods_state, key_inject_mode)) {return false;}- to->inject_keycode.repeat = repeat;- to->inject_keycode.metastate = convert_meta_state(mod);+ msg->inject_keycode.repeat = repeat;+ msg->inject_keycode.metastate = convert_meta_state(event->mods_state);return true;}static voidsc_key_processor_process_key(struct sc_key_processor *kp,- const SDL_KeyboardEvent *event,+ const struct sc_key_event *event,uint64_t ack_to_wait) {// The device clipboard synchronization and the key event messages are// serialized, there is nothing special to do to ensure that the clipboard@@ -305,7 +302,7 @@ sc_key_processor_process_key(struct sc_key_processor *kp,static voidsc_key_processor_process_text(struct sc_key_processor *kp,- const SDL_TextInputEvent *event) {+ const struct sc_text_event *event) {struct sc_keyboard_inject *ki = DOWNCAST(kp);if (ki->key_inject_mode == SC_KEY_INJECT_MODE_RAW) {diff --git a/app/src/trait/key_processor.h b/app/src/trait/key_processor.hindex f4afe27b..045e5e7b 100644--- a/app/src/trait/key_processor.h+++ b/app/src/trait/key_processor.h@@ -6,7 +6,7 @@#include <assert.h>#include <stdbool.h>-#include <SDL2/SDL_events.h>+#include "input_events.h"/*** Key processor trait.@@ -37,12 +37,12 @@ struct sc_key_processor_ops {* Ctrl+v on the device.*/void- (*process_key)(struct sc_key_processor *kp, const SDL_KeyboardEvent *event,- uint64_t ack_to_wait);+ (*process_key)(struct sc_key_processor *kp,+ const struct sc_key_event *event, uint64_t ack_to_wait);void(*process_text)(struct sc_key_processor *kp,- const SDL_TextInputEvent *event);+ const struct sc_text_event *event);};#endif