From b4b638e8fe2a632b045478e6038e6eef19562c5e Mon Sep 17 00:00:00 2001 From: Romain Vimont Date: Wed, 29 Dec 2021 16:14:34 +0100 Subject: [PATCH] Use scrcpy input events for key processors Pass scrcpy input events instead of SDL input events to key processors. This makes the source code of key processors independent of the SDL API. --- app/src/hid_keyboard.c | 50 ++++--- app/src/input_manager.c | 40 +++++- app/src/keyboard_inject.c | 259 +++++++++++++++++----------------- app/src/trait/key_processor.h | 8 +- 4 files changed, 194 insertions(+), 163 deletions(-) diff --git a/app/src/hid_keyboard.c b/app/src/hid_keyboard.c index cf8eab61..be5f8a19 100644 --- a/app/src/hid_keyboard.c +++ b/app/src/hid_keyboard.c @@ -1,8 +1,8 @@ #include "hid_keyboard.h" #include -#include +#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 bool convert_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 do return 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_NUMLOCKCLEAR unsigned 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 void sc_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 void sc_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.c index 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 void diff --git a/app/src/keyboard_inject.c b/app/src/keyboard_inject.c index 5143eafc..968a3c4f 100644 --- a/app/src/keyboard_inject.c +++ b/app/src/keyboard_inject.c @@ -1,11 +1,11 @@ #include "keyboard_inject.h" #include -#include #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 instead entry = 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 key metastate |= AMETA_META_LEFT_ON; } - if (mod & KMOD_RGUI) { // Windows key + if (mod & SC_MOD_RGUI) { // Windows key metastate |= 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 fields return 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 void sc_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 void sc_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.h index f4afe27b..045e5e7b 100644 --- a/app/src/trait/key_processor.h +++ b/app/src/trait/key_processor.h @@ -6,7 +6,7 @@ #include #include -#include +#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