mirror of
https://github.com/Genymobile/scrcpy.git
synced 2026-04-21 01:33:36 +00:00
9de332bbe5
Add a command-line option to enable "raw key events" mode (-k,--raw-key-events). This disable text inputs and forwards "text" key events (which are not forwarded by default). This is helpful for gaming: <https://github.com/Genymobile/scrcpy/issues/87> <https://github.com/Genymobile/scrcpy/issues/127>
264 lines
9.5 KiB
C
264 lines
9.5 KiB
C
#include "convert.h"
|
|
|
|
#define MAP(FROM, TO) case FROM: *to = TO; return SDL_TRUE
|
|
#define FAIL default: return SDL_FALSE
|
|
|
|
static SDL_bool convert_keycode_action(SDL_EventType from, enum android_keyevent_action *to) {
|
|
switch (from) {
|
|
MAP(SDL_KEYDOWN, AKEY_EVENT_ACTION_DOWN);
|
|
MAP(SDL_KEYUP, AKEY_EVENT_ACTION_UP);
|
|
FAIL;
|
|
}
|
|
}
|
|
|
|
static enum android_metastate autocomplete_metastate(enum android_metastate metastate) {
|
|
// fill dependant flags
|
|
if (metastate & (AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_RIGHT_ON)) {
|
|
metastate |= AMETA_SHIFT_ON;
|
|
}
|
|
if (metastate & (AMETA_CTRL_LEFT_ON | AMETA_CTRL_RIGHT_ON)) {
|
|
metastate |= AMETA_CTRL_ON;
|
|
}
|
|
if (metastate & (AMETA_ALT_LEFT_ON | AMETA_ALT_RIGHT_ON)) {
|
|
metastate |= AMETA_ALT_ON;
|
|
}
|
|
if (metastate & (AMETA_META_LEFT_ON | AMETA_META_RIGHT_ON)) {
|
|
metastate |= AMETA_META_ON;
|
|
}
|
|
|
|
return metastate;
|
|
}
|
|
|
|
|
|
static enum android_metastate convert_meta_state(SDL_Keymod mod) {
|
|
enum android_metastate metastate = 0;
|
|
if (mod & KMOD_LSHIFT) {
|
|
metastate |= AMETA_SHIFT_LEFT_ON;
|
|
}
|
|
if (mod & KMOD_RSHIFT) {
|
|
metastate |= AMETA_SHIFT_RIGHT_ON;
|
|
}
|
|
if (mod & KMOD_LCTRL) {
|
|
metastate |= AMETA_CTRL_LEFT_ON;
|
|
}
|
|
if (mod & KMOD_RCTRL) {
|
|
metastate |= AMETA_CTRL_RIGHT_ON;
|
|
}
|
|
if (mod & KMOD_LALT) {
|
|
metastate |= AMETA_ALT_LEFT_ON;
|
|
}
|
|
if (mod & KMOD_RALT) {
|
|
metastate |= AMETA_ALT_RIGHT_ON;
|
|
}
|
|
if (mod & KMOD_LGUI) { // Windows key
|
|
metastate |= AMETA_META_LEFT_ON;
|
|
}
|
|
if (mod & KMOD_RGUI) { // Windows key
|
|
metastate |= AMETA_META_RIGHT_ON;
|
|
}
|
|
if (mod & KMOD_NUM) {
|
|
metastate |= AMETA_NUM_LOCK_ON;
|
|
}
|
|
if (mod & KMOD_CAPS) {
|
|
metastate |= AMETA_CAPS_LOCK_ON;
|
|
}
|
|
if (mod & KMOD_MODE) { // Alt Gr
|
|
// no mapping?
|
|
}
|
|
|
|
// fill the dependent fields
|
|
return autocomplete_metastate(metastate);
|
|
}
|
|
|
|
// only used if raw_key_events is enabled
|
|
static SDL_bool convert_text_keycode(SDL_Keycode from, enum android_keycode *to) {
|
|
switch (from) {
|
|
MAP(SDLK_SPACE, AKEYCODE_SPACE);
|
|
MAP(SDLK_HASH, AKEYCODE_POUND);
|
|
MAP(SDLK_QUOTE, AKEYCODE_APOSTROPHE);
|
|
MAP(SDLK_ASTERISK, AKEYCODE_STAR);
|
|
MAP(SDLK_COMMA, AKEYCODE_COMMA);
|
|
MAP(SDLK_MINUS, AKEYCODE_MINUS);
|
|
MAP(SDLK_PERIOD, AKEYCODE_PERIOD);
|
|
MAP(SDLK_SLASH, AKEYCODE_SLASH);
|
|
MAP(SDLK_0, AKEYCODE_0);
|
|
MAP(SDLK_1, AKEYCODE_1);
|
|
MAP(SDLK_2, AKEYCODE_2);
|
|
MAP(SDLK_3, AKEYCODE_3);
|
|
MAP(SDLK_4, AKEYCODE_4);
|
|
MAP(SDLK_5, AKEYCODE_5);
|
|
MAP(SDLK_6, AKEYCODE_6);
|
|
MAP(SDLK_7, AKEYCODE_7);
|
|
MAP(SDLK_8, AKEYCODE_8);
|
|
MAP(SDLK_9, AKEYCODE_9);
|
|
MAP(SDLK_SEMICOLON, AKEYCODE_SEMICOLON);
|
|
MAP(SDLK_EQUALS, AKEYCODE_EQUALS);
|
|
MAP(SDLK_AT, AKEYCODE_AT);
|
|
MAP(SDLK_LEFTBRACKET, AKEYCODE_LEFT_BRACKET);
|
|
MAP(SDLK_BACKSLASH, AKEYCODE_BACKSLASH);
|
|
MAP(SDLK_RIGHTBRACKET, AKEYCODE_RIGHT_BRACKET);
|
|
MAP(SDLK_BACKQUOTE, AKEYCODE_GRAVE);
|
|
MAP(SDLK_a, AKEYCODE_A);
|
|
MAP(SDLK_b, AKEYCODE_B);
|
|
MAP(SDLK_c, AKEYCODE_C);
|
|
MAP(SDLK_d, AKEYCODE_D);
|
|
MAP(SDLK_e, AKEYCODE_E);
|
|
MAP(SDLK_f, AKEYCODE_F);
|
|
MAP(SDLK_g, AKEYCODE_G);
|
|
MAP(SDLK_h, AKEYCODE_H);
|
|
MAP(SDLK_i, AKEYCODE_I);
|
|
MAP(SDLK_j, AKEYCODE_J);
|
|
MAP(SDLK_k, AKEYCODE_K);
|
|
MAP(SDLK_l, AKEYCODE_L);
|
|
MAP(SDLK_m, AKEYCODE_M);
|
|
MAP(SDLK_n, AKEYCODE_N);
|
|
MAP(SDLK_o, AKEYCODE_O);
|
|
MAP(SDLK_p, AKEYCODE_P);
|
|
MAP(SDLK_q, AKEYCODE_Q);
|
|
MAP(SDLK_r, AKEYCODE_R);
|
|
MAP(SDLK_s, AKEYCODE_S);
|
|
MAP(SDLK_t, AKEYCODE_T);
|
|
MAP(SDLK_u, AKEYCODE_U);
|
|
MAP(SDLK_v, AKEYCODE_V);
|
|
MAP(SDLK_w, AKEYCODE_W);
|
|
MAP(SDLK_x, AKEYCODE_X);
|
|
MAP(SDLK_y, AKEYCODE_Y);
|
|
MAP(SDLK_z, AKEYCODE_Z);
|
|
MAP(SDLK_KP_ENTER, AKEYCODE_NUMPAD_ENTER);
|
|
MAP(SDLK_KP_1, AKEYCODE_NUMPAD_1);
|
|
MAP(SDLK_KP_2, AKEYCODE_NUMPAD_2);
|
|
MAP(SDLK_KP_3, AKEYCODE_NUMPAD_3);
|
|
MAP(SDLK_KP_4, AKEYCODE_NUMPAD_4);
|
|
MAP(SDLK_KP_5, AKEYCODE_NUMPAD_5);
|
|
MAP(SDLK_KP_6, AKEYCODE_NUMPAD_6);
|
|
MAP(SDLK_KP_7, AKEYCODE_NUMPAD_7);
|
|
MAP(SDLK_KP_8, AKEYCODE_NUMPAD_8);
|
|
MAP(SDLK_KP_9, AKEYCODE_NUMPAD_9);
|
|
MAP(SDLK_KP_0, AKEYCODE_NUMPAD_0);
|
|
MAP(SDLK_KP_DIVIDE, AKEYCODE_NUMPAD_DIVIDE);
|
|
MAP(SDLK_KP_MULTIPLY, AKEYCODE_NUMPAD_MULTIPLY);
|
|
MAP(SDLK_KP_MINUS, AKEYCODE_NUMPAD_SUBTRACT);
|
|
MAP(SDLK_KP_PLUS, AKEYCODE_NUMPAD_ADD);
|
|
MAP(SDLK_KP_PERIOD, AKEYCODE_NUMPAD_DOT);
|
|
MAP(SDLK_KP_EQUALS, AKEYCODE_NUMPAD_EQUALS);
|
|
MAP(SDLK_KP_LEFTPAREN, AKEYCODE_NUMPAD_LEFT_PAREN);
|
|
MAP(SDLK_KP_RIGHTPAREN, AKEYCODE_NUMPAD_RIGHT_PAREN);
|
|
FAIL;
|
|
}
|
|
}
|
|
|
|
static SDL_bool convert_keycode(SDL_Keycode from, enum android_keycode *to) {
|
|
switch (from) {
|
|
MAP(SDLK_RETURN, AKEYCODE_ENTER);
|
|
MAP(SDLK_KP_ENTER, AKEYCODE_NUMPAD_ENTER);
|
|
MAP(SDLK_ESCAPE, AKEYCODE_ESCAPE);
|
|
MAP(SDLK_BACKSPACE, AKEYCODE_DEL);
|
|
MAP(SDLK_TAB, AKEYCODE_TAB);
|
|
MAP(SDLK_HOME, AKEYCODE_HOME);
|
|
MAP(SDLK_PAGEUP, AKEYCODE_PAGE_UP);
|
|
MAP(SDLK_DELETE, AKEYCODE_FORWARD_DEL);
|
|
MAP(SDLK_END, AKEYCODE_MOVE_END);
|
|
MAP(SDLK_PAGEDOWN, AKEYCODE_PAGE_DOWN);
|
|
MAP(SDLK_RIGHT, AKEYCODE_DPAD_RIGHT);
|
|
MAP(SDLK_LEFT, AKEYCODE_DPAD_LEFT);
|
|
MAP(SDLK_DOWN, AKEYCODE_DPAD_DOWN);
|
|
MAP(SDLK_UP, AKEYCODE_DPAD_UP);
|
|
FAIL;
|
|
}
|
|
}
|
|
|
|
static SDL_bool convert_mouse_action(SDL_EventType from, enum android_motionevent_action *to) {
|
|
switch (from) {
|
|
MAP(SDL_MOUSEBUTTONDOWN, AMOTION_EVENT_ACTION_DOWN);
|
|
MAP(SDL_MOUSEBUTTONUP, AMOTION_EVENT_ACTION_UP);
|
|
FAIL;
|
|
}
|
|
}
|
|
|
|
static enum android_motionevent_buttons convert_mouse_buttons(Uint32 state) {
|
|
enum android_motionevent_buttons buttons = 0;
|
|
if (state & SDL_BUTTON_LMASK) {
|
|
buttons |= AMOTION_EVENT_BUTTON_PRIMARY;
|
|
}
|
|
if (state & SDL_BUTTON_RMASK) {
|
|
buttons |= AMOTION_EVENT_BUTTON_SECONDARY;
|
|
}
|
|
if (state & SDL_BUTTON_MMASK) {
|
|
buttons |= AMOTION_EVENT_BUTTON_TERTIARY;
|
|
}
|
|
if (state & SDL_BUTTON_X1) {
|
|
buttons |= AMOTION_EVENT_BUTTON_BACK;
|
|
}
|
|
if (state & SDL_BUTTON_X2) {
|
|
buttons |= AMOTION_EVENT_BUTTON_FORWARD;
|
|
}
|
|
return buttons;
|
|
}
|
|
|
|
SDL_bool input_key_from_sdl_to_android(const SDL_KeyboardEvent *from,
|
|
struct control_event *to,
|
|
SDL_bool raw_key_events) {
|
|
to->type = CONTROL_EVENT_TYPE_KEYCODE;
|
|
|
|
if (!convert_keycode_action(from->type, &to->keycode_event.action)) {
|
|
return SDL_FALSE;
|
|
}
|
|
|
|
if (!convert_keycode(from->keysym.sym, &to->keycode_event.keycode)) {
|
|
if (!raw_key_events ||
|
|
!convert_text_keycode(from->keysym.sym, &to->keycode_event.keycode)) {
|
|
return SDL_FALSE;
|
|
}
|
|
}
|
|
|
|
to->keycode_event.metastate = convert_meta_state(from->keysym.mod);
|
|
|
|
return SDL_TRUE;
|
|
}
|
|
|
|
SDL_bool mouse_button_from_sdl_to_android(const SDL_MouseButtonEvent *from,
|
|
struct size screen_size,
|
|
struct control_event *to) {
|
|
to->type = CONTROL_EVENT_TYPE_MOUSE;
|
|
|
|
if (!convert_mouse_action(from->type, &to->mouse_event.action)) {
|
|
return SDL_FALSE;
|
|
}
|
|
|
|
to->mouse_event.buttons = convert_mouse_buttons(SDL_BUTTON(from->button));
|
|
to->mouse_event.position.screen_size = screen_size;
|
|
to->mouse_event.position.point.x = from->x;
|
|
to->mouse_event.position.point.y = from->y;
|
|
|
|
return SDL_TRUE;
|
|
}
|
|
|
|
SDL_bool mouse_motion_from_sdl_to_android(const SDL_MouseMotionEvent *from,
|
|
struct size screen_size,
|
|
struct control_event *to) {
|
|
to->type = CONTROL_EVENT_TYPE_MOUSE;
|
|
to->mouse_event.action = AMOTION_EVENT_ACTION_MOVE;
|
|
to->mouse_event.buttons = convert_mouse_buttons(from->state);
|
|
to->mouse_event.position.screen_size = screen_size;
|
|
to->mouse_event.position.point.x = from->x;
|
|
to->mouse_event.position.point.y = from->y;
|
|
|
|
return SDL_TRUE;
|
|
}
|
|
|
|
SDL_bool mouse_wheel_from_sdl_to_android(const SDL_MouseWheelEvent *from,
|
|
struct position position,
|
|
struct control_event *to) {
|
|
to->type = CONTROL_EVENT_TYPE_SCROLL;
|
|
|
|
to->scroll_event.position = position;
|
|
|
|
int mul = from->direction == SDL_MOUSEWHEEL_NORMAL ? 1 : -1;
|
|
// SDL behavior seems inconsistent between horizontal and vertical scrolling
|
|
// so reverse the horizontal
|
|
// <https://wiki.libsdl.org/SDL_MouseWheelEvent#Remarks>
|
|
to->scroll_event.hscroll = -mul * from->x;
|
|
to->scroll_event.vscroll = mul * from->y;
|
|
|
|
return SDL_TRUE;
|
|
}
|