Archives
/
scrcpy
mirror of https://github.com/Genymobile/scrcpy
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Always pass input manager instance

Browse Source 
Some functions in input_manager.c only have access to a sub-object (for
example the controller). For consistency, always pass the whole
input manager instance.

This will allow to add assertions when keyboard and mouse could be
disabled separately.

PR #4473 <https://github.com/Genymobile/scrcpy/pull/4473>
uhid.38
Romain Vimont 4 months ago
parent a976417572
commit c0a1aee8ce
1 changed files with 107 additions and 86 deletions
Show Stats Download Patch File Download Diff File

193
app/src/input_manager.c
Unescape Escape View File

@ -87,8 +87,10 @@ sc_input_manager_init(struct sc_input_manager *im,
} }
static void static void
send_keycode(struct sc_controller *controller, enum android_keycode keycode, send_keycode(struct sc_input_manager *im, enum android_keycode keycode,
enum sc_action action, const char *name) { enum sc_action action, const char *name) {
assert(im->controller);
// send DOWN event // send DOWN event
struct sc_control_msg msg; struct sc_control_msg msg;
msg.type = SC_CONTROL_MSG_TYPE_INJECT_KEYCODE; msg.type = SC_CONTROL_MSG_TYPE_INJECT_KEYCODE;
@ -99,100 +101,109 @@ send_keycode(struct sc_controller *controller, enum android_keycode keycode,
msg.inject_keycode.metastate = 0; msg.inject_keycode.metastate = 0;
msg.inject_keycode.repeat = 0; msg.inject_keycode.repeat = 0;
if (!sc_controller_push_msg(controller, &msg)) { if (!sc_controller_push_msg(im->controller, &msg)) {
LOGW("Could not request 'inject %s'", name); LOGW("Could not request 'inject %s'", name);
} }
} }
static inline void static inline void
action_home(struct sc_controller *controller, enum sc_action action) { action_home(struct sc_input_manager *im, enum sc_action action) {
send_keycode(controller, AKEYCODE_HOME, action, "HOME"); send_keycode(im, AKEYCODE_HOME, action, "HOME");
} }
static inline void static inline void
action_back(struct sc_controller *controller, enum sc_action action) { action_back(struct sc_input_manager *im, enum sc_action action) {
send_keycode(controller, AKEYCODE_BACK, action, "BACK"); send_keycode(im, AKEYCODE_BACK, action, "BACK");
} }
static inline void static inline void
action_app_switch(struct sc_controller *controller, enum sc_action action) { action_app_switch(struct sc_input_manager *im, enum sc_action action) {
send_keycode(controller, AKEYCODE_APP_SWITCH, action, "APP_SWITCH"); send_keycode(im, AKEYCODE_APP_SWITCH, action, "APP_SWITCH");
} }
static inline void static inline void
action_power(struct sc_controller *controller, enum sc_action action) { action_power(struct sc_input_manager *im, enum sc_action action) {
send_keycode(controller, AKEYCODE_POWER, action, "POWER"); send_keycode(im, AKEYCODE_POWER, action, "POWER");
} }
static inline void static inline void
action_volume_up(struct sc_controller *controller, enum sc_action action) { action_volume_up(struct sc_input_manager *im, enum sc_action action) {
send_keycode(controller, AKEYCODE_VOLUME_UP, action, "VOLUME_UP"); send_keycode(im, AKEYCODE_VOLUME_UP, action, "VOLUME_UP");
} }
static inline void static inline void
action_volume_down(struct sc_controller *controller, enum sc_action action) { action_volume_down(struct sc_input_manager *im, enum sc_action action) {
send_keycode(controller, AKEYCODE_VOLUME_DOWN, action, "VOLUME_DOWN"); send_keycode(im, AKEYCODE_VOLUME_DOWN, action, "VOLUME_DOWN");
} }
static inline void static inline void
action_menu(struct sc_controller *controller, enum sc_action action) { action_menu(struct sc_input_manager *im, enum sc_action action) {
send_keycode(controller, AKEYCODE_MENU, action, "MENU"); send_keycode(im, AKEYCODE_MENU, action, "MENU");
} }
// turn the screen on if it was off, press BACK otherwise // turn the screen on if it was off, press BACK otherwise
// If the screen is off, it is turned on only on ACTION_DOWN // If the screen is off, it is turned on only on ACTION_DOWN
static void static void
press_back_or_turn_screen_on(struct sc_controller *controller, press_back_or_turn_screen_on(struct sc_input_manager *im,
enum sc_action action) { enum sc_action action) {
assert(im->controller);
struct sc_control_msg msg; struct sc_control_msg msg;
msg.type = SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON; msg.type = SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON;
msg.back_or_screen_on.action = action == SC_ACTION_DOWN msg.back_or_screen_on.action = action == SC_ACTION_DOWN
? AKEY_EVENT_ACTION_DOWN ? AKEY_EVENT_ACTION_DOWN
: AKEY_EVENT_ACTION_UP; : AKEY_EVENT_ACTION_UP;
if (!sc_controller_push_msg(controller, &msg)) { if (!sc_controller_push_msg(im->controller, &msg)) {
LOGW("Could not request 'press back or turn screen on'"); LOGW("Could not request 'press back or turn screen on'");
} }
} }
static void static void
expand_notification_panel(struct sc_controller *controller) { expand_notification_panel(struct sc_input_manager *im) {
assert(im->controller);
struct sc_control_msg msg; struct sc_control_msg msg;
msg.type = SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL; msg.type = SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL;
if (!sc_controller_push_msg(controller, &msg)) { if (!sc_controller_push_msg(im->controller, &msg)) {
LOGW("Could not request 'expand notification panel'"); LOGW("Could not request 'expand notification panel'");
} }
} }
static void static void
expand_settings_panel(struct sc_controller *controller) { expand_settings_panel(struct sc_input_manager *im) {
assert(im->controller);
struct sc_control_msg msg; struct sc_control_msg msg;
msg.type = SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL; msg.type = SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL;
if (!sc_controller_push_msg(controller, &msg)) { if (!sc_controller_push_msg(im->controller, &msg)) {
LOGW("Could not request 'expand settings panel'"); LOGW("Could not request 'expand settings panel'");
} }
} }
static void static void
collapse_panels(struct sc_controller *controller) { collapse_panels(struct sc_input_manager *im) {
assert(im->controller);
struct sc_control_msg msg; struct sc_control_msg msg;
msg.type = SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS; msg.type = SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS;
if (!sc_controller_push_msg(controller, &msg)) { if (!sc_controller_push_msg(im->controller, &msg)) {
LOGW("Could not request 'collapse notification panel'"); LOGW("Could not request 'collapse notification panel'");
} }
} }
static bool static bool
get_device_clipboard(struct sc_controller *controller, get_device_clipboard(struct sc_input_manager *im, enum sc_copy_key copy_key) {
enum sc_copy_key copy_key) { assert(im->controller);
struct sc_control_msg msg; struct sc_control_msg msg;
msg.type = SC_CONTROL_MSG_TYPE_GET_CLIPBOARD; msg.type = SC_CONTROL_MSG_TYPE_GET_CLIPBOARD;
msg.get_clipboard.copy_key = copy_key; msg.get_clipboard.copy_key = copy_key;
if (!sc_controller_push_msg(controller, &msg)) { if (!sc_controller_push_msg(im->controller, &msg)) {
LOGW("Could not request 'get device clipboard'"); LOGW("Could not request 'get device clipboard'");
return false; return false;
} }
@ -201,8 +212,10 @@ get_device_clipboard(struct sc_controller *controller,
} }
static bool static bool
set_device_clipboard(struct sc_controller *controller, bool paste, set_device_clipboard(struct sc_input_manager *im, bool paste,
uint64_t sequence) { uint64_t sequence) {
assert(im->controller);
char *text = SDL_GetClipboardText(); char *text = SDL_GetClipboardText();
if (!text) { if (!text) {
LOGW("Could not get clipboard text: %s", SDL_GetError()); LOGW("Could not get clipboard text: %s", SDL_GetError());
@ -222,7 +235,7 @@ set_device_clipboard(struct sc_controller *controller, bool paste,
msg.set_clipboard.text = text_dup; msg.set_clipboard.text = text_dup;
msg.set_clipboard.paste = paste; msg.set_clipboard.paste = paste;
if (!sc_controller_push_msg(controller, &msg)) { if (!sc_controller_push_msg(im->controller, &msg)) {
free(text_dup); free(text_dup);
LOGW("Could not request 'set device clipboard'"); LOGW("Could not request 'set device clipboard'");
return false; return false;
@ -232,19 +245,23 @@ set_device_clipboard(struct sc_controller *controller, bool paste,
} }
static void static void
set_screen_power_mode(struct sc_controller *controller, set_screen_power_mode(struct sc_input_manager *im,
enum sc_screen_power_mode mode) { enum sc_screen_power_mode mode) {
assert(im->controller);
struct sc_control_msg msg; struct sc_control_msg msg;
msg.type = SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE; msg.type = SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE;
msg.set_screen_power_mode.mode = mode; msg.set_screen_power_mode.mode = mode;
if (!sc_controller_push_msg(controller, &msg)) { if (!sc_controller_push_msg(im->controller, &msg)) {
LOGW("Could not request 'set screen power mode'"); LOGW("Could not request 'set screen power mode'");
} }
} }
static void static void
switch_fps_counter_state(struct sc_fps_counter *fps_counter) { switch_fps_counter_state(struct sc_input_manager *im) {
struct sc_fps_counter *fps_counter = &im->screen->fps_counter;
// the started state can only be written from the current thread, so there // the started state can only be written from the current thread, so there
// is no ToCToU issue // is no ToCToU issue
if (sc_fps_counter_is_started(fps_counter)) { if (sc_fps_counter_is_started(fps_counter)) {
@ -256,7 +273,9 @@ switch_fps_counter_state(struct sc_fps_counter *fps_counter) {
} }
static void static void
clipboard_paste(struct sc_controller *controller) { clipboard_paste(struct sc_input_manager *im) {
assert(im->controller);
char *text = SDL_GetClipboardText(); char *text = SDL_GetClipboardText();
if (!text) { if (!text) {
LOGW("Could not get clipboard text: %s", SDL_GetError()); LOGW("Could not get clipboard text: %s", SDL_GetError());
@ -278,25 +297,28 @@ clipboard_paste(struct sc_controller *controller) {
struct sc_control_msg msg; struct sc_control_msg msg;
msg.type = SC_CONTROL_MSG_TYPE_INJECT_TEXT; msg.type = SC_CONTROL_MSG_TYPE_INJECT_TEXT;
msg.inject_text.text = text_dup; msg.inject_text.text = text_dup;
if (!sc_controller_push_msg(controller, &msg)) { if (!sc_controller_push_msg(im->controller, &msg)) {
free(text_dup); free(text_dup);
LOGW("Could not request 'paste clipboard'"); LOGW("Could not request 'paste clipboard'");
} }
} }
static void static void
rotate_device(struct sc_controller *controller) { rotate_device(struct sc_input_manager *im) {
assert(im->controller);
struct sc_control_msg msg; struct sc_control_msg msg;
msg.type = SC_CONTROL_MSG_TYPE_ROTATE_DEVICE; msg.type = SC_CONTROL_MSG_TYPE_ROTATE_DEVICE;
if (!sc_controller_push_msg(controller, &msg)) { if (!sc_controller_push_msg(im->controller, &msg)) {
LOGW("Could not request device rotation"); LOGW("Could not request device rotation");
} }
} }
static void static void
apply_orientation_transform(struct sc_screen *screen, apply_orientation_transform(struct sc_input_manager *im,
enum sc_orientation transform) { enum sc_orientation transform) {
struct sc_screen *screen = im->screen;
enum sc_orientation new_orientation = enum sc_orientation new_orientation =
sc_orientation_apply(screen->orientation, transform); sc_orientation_apply(screen->orientation, transform);
sc_screen_set_orientation(screen, new_orientation); sc_screen_set_orientation(screen, new_orientation);
@ -364,7 +386,7 @@ static void
sc_input_manager_process_key(struct sc_input_manager *im, sc_input_manager_process_key(struct sc_input_manager *im,
const SDL_KeyboardEvent *event) { const SDL_KeyboardEvent *event) {
// controller is NULL if --no-control is requested // controller is NULL if --no-control is requested
struct sc_controller *controller = im->controller; bool control = im->controller;
SDL_Keycode keycode = event->keysym.sym; SDL_Keycode keycode = event->keysym.sym;
uint16_t mod = event->keysym.mod; uint16_t mod = event->keysym.mod;
@ -390,68 +412,68 @@ sc_input_manager_process_key(struct sc_input_manager *im,
enum sc_action action = down ? SC_ACTION_DOWN : SC_ACTION_UP; enum sc_action action = down ? SC_ACTION_DOWN : SC_ACTION_UP;
switch (keycode) { switch (keycode) {
case SDLK_h: case SDLK_h:
if (controller && !shift && !repeat) { if (control && !shift && !repeat) {
action_home(controller, action); action_home(im, action);
} }
return; return;
case SDLK_b: // fall-through case SDLK_b: // fall-through
case SDLK_BACKSPACE: case SDLK_BACKSPACE:
if (controller && !shift && !repeat) { if (control && !shift && !repeat) {
action_back(controller, action); action_back(im, action);
} }
return; return;
case SDLK_s: case SDLK_s:
if (controller && !shift && !repeat) { if (control && !shift && !repeat) {
action_app_switch(controller, action); action_app_switch(im, action);
} }
return; return;
case SDLK_m: case SDLK_m:
if (controller && !shift && !repeat) { if (control && !shift && !repeat) {
action_menu(controller, action); action_menu(im, action);
} }
return; return;
case SDLK_p: case SDLK_p:
if (controller && !shift && !repeat) { if (control && !shift && !repeat) {
action_power(controller, action); action_power(im, action);
} }
return; return;
case SDLK_o: case SDLK_o:
if (controller && !repeat && down) { if (control && !repeat && down) {
enum sc_screen_power_mode mode = shift enum sc_screen_power_mode mode = shift
? SC_SCREEN_POWER_MODE_NORMAL ? SC_SCREEN_POWER_MODE_NORMAL
: SC_SCREEN_POWER_MODE_OFF; : SC_SCREEN_POWER_MODE_OFF;
set_screen_power_mode(controller, mode); set_screen_power_mode(im, mode);
} }
return; return;
case SDLK_DOWN: case SDLK_DOWN:
if (shift) { if (shift) {
if (!repeat & down) { if (!repeat & down) {
apply_orientation_transform(im->screen, apply_orientation_transform(im,
SC_ORIENTATION_FLIP_180); SC_ORIENTATION_FLIP_180);
} }
} else if (controller) { } else if (control) {
// forward repeated events // forward repeated events
action_volume_down(controller, action); action_volume_down(im, action);
} }
return; return;
case SDLK_UP: case SDLK_UP:
if (shift) { if (shift) {
if (!repeat & down) { if (!repeat & down) {
apply_orientation_transform(im->screen, apply_orientation_transform(im,
SC_ORIENTATION_FLIP_180); SC_ORIENTATION_FLIP_180);
} }
} else if (controller) { } else if (control) {
// forward repeated events // forward repeated events
action_volume_up(controller, action); action_volume_up(im, action);
} }
return; return;
case SDLK_LEFT: case SDLK_LEFT:
if (!repeat && down) { if (!repeat && down) {
if (shift) { if (shift) {
apply_orientation_transform(im->screen, apply_orientation_transform(im,
SC_ORIENTATION_FLIP_0); SC_ORIENTATION_FLIP_0);
} else { } else {
apply_orientation_transform(im->screen, apply_orientation_transform(im,
SC_ORIENTATION_270); SC_ORIENTATION_270);
} }
} }
@ -459,34 +481,33 @@ sc_input_manager_process_key(struct sc_input_manager *im,
case SDLK_RIGHT: case SDLK_RIGHT:
if (!repeat && down) { if (!repeat && down) {
if (shift) { if (shift) {
apply_orientation_transform(im->screen, apply_orientation_transform(im,
SC_ORIENTATION_FLIP_0); SC_ORIENTATION_FLIP_0);
} else { } else {
apply_orientation_transform(im->screen, apply_orientation_transform(im,
SC_ORIENTATION_90); SC_ORIENTATION_90);
} }
} }
return; return;
case SDLK_c: case SDLK_c:
if (controller && !shift && !repeat && down) { if (control && !shift && !repeat && down) {
get_device_clipboard(controller, SC_COPY_KEY_COPY); get_device_clipboard(im, SC_COPY_KEY_COPY);
} }
return; return;
case SDLK_x: case SDLK_x:
if (controller && !shift && !repeat && down) { if (control && !shift && !repeat && down) {
get_device_clipboard(controller, SC_COPY_KEY_CUT); get_device_clipboard(im, SC_COPY_KEY_CUT);
} }
return; return;
case SDLK_v: case SDLK_v:
if (controller && !repeat && down) { if (control && !repeat && down) {
if (shift || im->legacy_paste) { if (shift || im->legacy_paste) {
// inject the text as input events // inject the text as input events
clipboard_paste(controller); clipboard_paste(im);
} else { } else {
// store the text in the device clipboard and paste, // store the text in the device clipboard and paste,
// without requesting an acknowledgment // without requesting an acknowledgment
set_device_clipboard(controller, true, set_device_clipboard(im, true, SC_SEQUENCE_INVALID);
SC_SEQUENCE_INVALID);
} }
} }
return; return;
@ -507,23 +528,23 @@ sc_input_manager_process_key(struct sc_input_manager *im,
return; return;
case SDLK_i: case SDLK_i:
if (!shift && !repeat && down) { if (!shift && !repeat && down) {
switch_fps_counter_state(&im->screen->fps_counter); switch_fps_counter_state(im);
} }
return; return;
case SDLK_n: case SDLK_n:
if (controller && !repeat && down) { if (control && !repeat && down) {
if (shift) { if (shift) {
collapse_panels(controller); collapse_panels(im);
} else if (im->key_repeat == 0) { } else if (im->key_repeat == 0) {
expand_notification_panel(controller); expand_notification_panel(im);
} else { } else {
expand_settings_panel(controller); expand_settings_panel(im);
} }
} }
return; return;
case SDLK_r: case SDLK_r:
if (controller && !shift && !repeat && down) { if (control && !shift && !repeat && down) {
rotate_device(controller); rotate_device(im);
} }
return; return;
} }
@ -531,7 +552,7 @@ sc_input_manager_process_key(struct sc_input_manager *im,
return; return;
} }
if (!controller) { if (!control) {
return; return;
} }
@ -540,7 +561,7 @@ sc_input_manager_process_key(struct sc_input_manager *im,
if (im->clipboard_autosync && is_ctrl_v) { if (im->clipboard_autosync && is_ctrl_v) {
if (im->legacy_paste) { if (im->legacy_paste) {
// inject the text as input events // inject the text as input events
clipboard_paste(controller); clipboard_paste(im);
return; return;
} }
@ -550,7 +571,7 @@ sc_input_manager_process_key(struct sc_input_manager *im,
// Synchronize the computer clipboard to the device clipboard before // Synchronize the computer clipboard to the device clipboard before
// sending Ctrl+v, to allow seamless copy-paste. // sending Ctrl+v, to allow seamless copy-paste.
bool ok = set_device_clipboard(controller, false, sequence); bool ok = set_device_clipboard(im, false, sequence);
if (!ok) { if (!ok) {
LOGW("Clipboard could not be synchronized, Ctrl+v not injected"); LOGW("Clipboard could not be synchronized, Ctrl+v not injected");
return; return;
@ -652,7 +673,7 @@ sc_input_manager_process_touch(struct sc_input_manager *im,
static void static void
sc_input_manager_process_mouse_button(struct sc_input_manager *im, sc_input_manager_process_mouse_button(struct sc_input_manager *im,
const SDL_MouseButtonEvent *event) { const SDL_MouseButtonEvent *event) {
struct sc_controller *controller = im->controller; bool control = im->controller;
if (event->which == SDL_TOUCH_MOUSEID) { if (event->which == SDL_TOUCH_MOUSEID) {
// simulated from touch events, so it's a duplicate // simulated from touch events, so it's a duplicate
@ -661,27 +682,27 @@ sc_input_manager_process_mouse_button(struct sc_input_manager *im,
bool down = event->type == SDL_MOUSEBUTTONDOWN; bool down = event->type == SDL_MOUSEBUTTONDOWN;
if (!im->forward_all_clicks) { if (!im->forward_all_clicks) {
if (controller) { if (control) {
enum sc_action action = down ? SC_ACTION_DOWN : SC_ACTION_UP; enum sc_action action = down ? SC_ACTION_DOWN : SC_ACTION_UP;
if (event->button == SDL_BUTTON_X1) { if (event->button == SDL_BUTTON_X1) {
action_app_switch(controller, action); action_app_switch(im, action);
return; return;
} }
if (event->button == SDL_BUTTON_X2 && down) { if (event->button == SDL_BUTTON_X2 && down) {
if (event->clicks < 2) { if (event->clicks < 2) {
expand_notification_panel(controller); expand_notification_panel(im);
} else { } else {
expand_settings_panel(controller); expand_settings_panel(im);
} }
return; return;
} }
if (event->button == SDL_BUTTON_RIGHT) { if (event->button == SDL_BUTTON_RIGHT) {
press_back_or_turn_screen_on(controller, action); press_back_or_turn_screen_on(im, action);
return; return;
} }
if (event->button == SDL_BUTTON_MIDDLE) { if (event->button == SDL_BUTTON_MIDDLE) {
action_home(controller, action); action_home(im, action);
return; return;
} }
} }
@ -704,7 +725,7 @@ sc_input_manager_process_mouse_button(struct sc_input_manager *im,
// otherwise, send the click event to the device // otherwise, send the click event to the device
} }
if (!controller) { if (!control) {
return; return;
} }

Write Preview
Loading…
Cancel
Save