drgreen/scrcpy
1
0
Fork 0
Code Issues Pull Requests Actions Packages 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.
This commit is contained in:
Romain Vimont 2024-01-20 18:19:39 +01:00
parent f6459dd742
commit 31efed3538
1 changed files with 107 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

193
app/src/input_manager.c
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;
} }