Delay HID events on Ctrl+v

When Ctrl+v is pressed, a control is sent to the device to set the
device clipboard before injecting Ctrl+v.

With the InputManager method, it is guaranteed that the device
synchronization is executed before handling Ctrl+v, since the commands
are executed on the device in sequence.

However, HID are injected from the computer, so there is no such
guarantee. As a consequence, on Android, Ctrl+v triggers a paste with
the old clipboard content.

To workaround the issue, wait a bit (2 milliseconds) from the AOA
thread before injecting the event, to leave enough time for the
clipboard to be set before injecting Ctrl+v.
This commit is contained in:
Romain Vimont 2021-10-21 21:33:15 +02:00
parent c96874b257
commit e4163321f0
3 changed files with 32 additions and 0 deletions

View file

@ -35,6 +35,7 @@ sc_hid_event_init(struct sc_hid_event *hid_event, uint16_t accessory_id,
hid_event->accessory_id = accessory_id; hid_event->accessory_id = accessory_id;
hid_event->buffer = buffer; hid_event->buffer = buffer;
hid_event->size = buffer_size; hid_event->size = buffer_size;
hid_event->delay = 0;
} }
void void
@ -330,6 +331,22 @@ run_aoa_thread(void *data) {
bool non_empty = cbuf_take(&aoa->queue, &event); bool non_empty = cbuf_take(&aoa->queue, &event);
assert(non_empty); assert(non_empty);
(void) non_empty; (void) non_empty;
assert(event.delay >= 0);
if (event.delay) {
// Wait during the specified delay before injecting the HID event
sc_tick deadline = sc_tick_now() + event.delay;
bool timed_out = false;
while (!aoa->stopped && !timed_out) {
timed_out = !sc_cond_timedwait(&aoa->event_cond, &aoa->mutex,
deadline);
}
if (aoa->stopped) {
sc_mutex_unlock(&aoa->mutex);
break;
}
}
sc_mutex_unlock(&aoa->mutex); sc_mutex_unlock(&aoa->mutex);
bool ok = sc_aoa_send_hid_event(aoa, &event); bool ok = sc_aoa_send_hid_event(aoa, &event);

View file

@ -9,11 +9,13 @@
#include "scrcpy.h" #include "scrcpy.h"
#include "util/cbuf.h" #include "util/cbuf.h"
#include "util/thread.h" #include "util/thread.h"
#include "util/tick.h"
struct sc_hid_event { struct sc_hid_event {
uint16_t accessory_id; uint16_t accessory_id;
unsigned char *buffer; unsigned char *buffer;
uint16_t size; uint16_t size;
sc_tick delay;
}; };
// Takes ownership of buffer // Takes ownership of buffer

View file

@ -297,6 +297,19 @@ sc_key_processor_process_key(struct sc_key_processor *kp,
kb->mod_lock_synchronized = true; kb->mod_lock_synchronized = true;
} }
} }
SDL_Keycode keycode = event->keysym.sym;
bool down = event->type == SDL_KEYDOWN;
bool ctrl = event->keysym.mod & KMOD_CTRL;
bool shift = event->keysym.mod & KMOD_SHIFT;
if (ctrl && !shift && keycode == SDLK_v && down) {
// Ctrl+v is pressed, so clipboard synchronization has been
// requested. Wait a bit so that the clipboard is set before
// injecting Ctrl+v via HID, otherwise it would paste the old
// clipboard content.
hid_event.delay = SC_TICK_FROM_MS(2);
}
if (!sc_aoa_push_hid_event(kb->aoa, &hid_event)) { if (!sc_aoa_push_hid_event(kb->aoa, &hid_event)) {
sc_hid_event_destroy(&hid_event); sc_hid_event_destroy(&hid_event);
LOGW("Could request HID event"); LOGW("Could request HID event");