From 4c84937186f2b3ecb57f1c86230bd518363fc837 Mon Sep 17 00:00:00 2001 From: Romain Vimont Date: Tue, 24 Feb 2026 00:26:22 +0100 Subject: [PATCH] Display disconnected icon before closing Previously, when the connection to the device was lost while mirroring, the window closed immediately, suggesting scrcpy had crashed. To make it clear that a disconnection occurred, display a disconnected icon for 2 seconds before closing the window. PR #6662 --- app/data/disconnected.png | Bin 0 -> 4703 bytes app/meson.build | 1 + app/src/disconnect.c | 88 +++++++++++++++++++++++++++ app/src/disconnect.h | 47 +++++++++++++++ app/src/events.h | 3 +- app/src/icon.h | 1 + app/src/input_manager.c | 43 +++++++++---- app/src/input_manager.h | 2 + app/src/scrcpy.c | 24 +++++--- app/src/screen.c | 123 +++++++++++++++++++++++++++++++++++++- app/src/screen.h | 11 +++- app/src/usb/scrcpy_otg.c | 16 ++++- 12 files changed, 335 insertions(+), 24 deletions(-) create mode 100644 app/data/disconnected.png create mode 100644 app/src/disconnect.c create mode 100644 app/src/disconnect.h diff --git a/app/data/disconnected.png b/app/data/disconnected.png new file mode 100644 index 0000000000000000000000000000000000000000..37ff3d855ef7912a1cbc41403c551e8501dac740 GIT binary patch literal 4703 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 literal 0 HcmV?d00001 diff --git a/app/meson.build b/app/meson.build index d47a2d07..b0f6a37a 100644 --- a/app/meson.build +++ b/app/meson.build @@ -15,6 +15,7 @@ src = [ 'src/delay_buffer.c', 'src/demuxer.c', 'src/device_msg.c', + 'src/disconnect.c', 'src/events.c', 'src/icon.c', 'src/file_pusher.c', diff --git a/app/src/disconnect.c b/app/src/disconnect.c new file mode 100644 index 00000000..d494091b --- /dev/null +++ b/app/src/disconnect.c @@ -0,0 +1,88 @@ +#include "disconnect.h" + +#include + +#include "icon.h" +#include "util/log.h" + +static int +run(void *userdata) { + struct sc_disconnect *d = userdata; + + SDL_Surface *icon = sc_icon_load(SC_ICON_FILENAME_DISCONNECTED); + if (icon) { + d->cbs->on_icon_loaded(d, icon, d->cbs_userdata); + } else { + LOGE("Could not load disconnected icon"); + } + + sc_mutex_lock(&d->mutex); + bool timed_out = false; + while (!d->interrupted && !timed_out) { + timed_out = !sc_cond_timedwait(&d->cond, &d->mutex, d->deadline); + } + bool interrupted = d->interrupted; + sc_mutex_unlock(&d->mutex); + + if (!interrupted) { + d->cbs->on_timeout(d, d->cbs_userdata); + } + + return 0; +} + +bool +sc_disconnect_start(struct sc_disconnect *d, sc_tick deadline, + const struct sc_disconnect_callbacks *cbs, + void *cbs_userdata) { + bool ok = sc_mutex_init(&d->mutex); + if (!ok) { + return false; + } + + ok = sc_cond_init(&d->cond); + if (!ok) { + goto error_destroy_mutex; + } + + d->deadline = deadline; + d->interrupted = false; + + assert(cbs && cbs->on_icon_loaded && cbs->on_timeout); + d->cbs = cbs; + d->cbs_userdata = cbs_userdata; + + ok = sc_thread_create(&d->thread, run, "scrcpy-dis", d); + if (!ok) { + goto error_destroy_cond; + } + + return true; + +error_destroy_cond: + sc_cond_destroy(&d->cond); +error_destroy_mutex: + sc_mutex_destroy(&d->mutex); + + return false; +} + +void +sc_disconnect_interrupt(struct sc_disconnect *d) { + sc_mutex_lock(&d->mutex); + d->interrupted = true; + sc_mutex_unlock(&d->mutex); + // wake up blocking wait + sc_cond_signal(&d->cond); +} + +void +sc_disconnect_join(struct sc_disconnect *d) { + sc_thread_join(&d->thread, NULL); +} + +void +sc_disconnect_destroy(struct sc_disconnect *d) { + sc_cond_destroy(&d->cond); + sc_mutex_destroy(&d->mutex); +} diff --git a/app/src/disconnect.h b/app/src/disconnect.h new file mode 100644 index 00000000..5b63ee59 --- /dev/null +++ b/app/src/disconnect.h @@ -0,0 +1,47 @@ +#ifndef SC_DISCONNECT +#define SC_DISCONNECT + +#include "common.h" + +#include "SDL3/SDL_surface.h" +#include "util/tick.h" +#include "util/thread.h" + +// Tool to handle loading the icon and signal timeout when the device is +// unexpectedly disconnected +struct sc_disconnect { + sc_tick deadline; + + struct sc_thread thread; + struct sc_mutex mutex; + struct sc_cond cond; + bool interrupted; + + const struct sc_disconnect_callbacks *cbs; + void *cbs_userdata; +}; + +struct sc_disconnect_callbacks { + // Called when the disconnected icon is loaded + void (*on_icon_loaded)(struct sc_disconnect *d, SDL_Surface *icon, + void *userdata); + + // Called when the timeout expired (the scrcpy window must be closed) + void (*on_timeout)(struct sc_disconnect *d, void *userdata); +}; + +bool +sc_disconnect_start(struct sc_disconnect *d, sc_tick deadline, + const struct sc_disconnect_callbacks *cbs, + void *cbs_userdata); + +void +sc_disconnect_interrupt(struct sc_disconnect *d); + +void +sc_disconnect_join(struct sc_disconnect *d); + +void +sc_disconnect_destroy(struct sc_disconnect *d); + +#endif diff --git a/app/src/events.h b/app/src/events.h index 088863bd..c82741af 100644 --- a/app/src/events.h +++ b/app/src/events.h @@ -14,12 +14,13 @@ enum { SC_EVENT_DEVICE_DISCONNECTED, SC_EVENT_SERVER_CONNECTION_FAILED, SC_EVENT_SERVER_CONNECTED, - SC_EVENT_USB_DEVICE_DISCONNECTED, SC_EVENT_DEMUXER_ERROR, SC_EVENT_RECORDER_ERROR, SC_EVENT_TIME_LIMIT_REACHED, SC_EVENT_CONTROLLER_ERROR, SC_EVENT_AOA_OPEN_ERROR, + SC_EVENT_DISCONNECTED_ICON_LOADED, + SC_EVENT_DISCONNECTED_TIMEOUT, }; bool diff --git a/app/src/icon.h b/app/src/icon.h index 48817f37..44951cce 100644 --- a/app/src/icon.h +++ b/app/src/icon.h @@ -6,6 +6,7 @@ #include #define SC_ICON_FILENAME_SCRCPY "scrcpy.png" +#define SC_ICON_FILENAME_DISCONNECTED "disconnected.png" SDL_Surface * sc_icon_load(const char *filename); diff --git a/app/src/input_manager.c b/app/src/input_manager.c index 6e56d31c..6f85aa8b 100644 --- a/app/src/input_manager.c +++ b/app/src/input_manager.c @@ -7,6 +7,7 @@ #include "android/input.h" #include "android/keycodes.h" +#include "events.h" #include "input_events.h" #include "screen.h" #include "shortcut_mod.h" @@ -46,6 +47,8 @@ sc_input_manager_init(struct sc_input_manager *im, im->key_repeat = 0; im->next_sequence = 1; // 0 is reserved for SC_SEQUENCE_INVALID + + im->disconnected = false; } static void @@ -349,7 +352,7 @@ apply_orientation_transform(struct sc_input_manager *im, static void sc_input_manager_process_text_input(struct sc_input_manager *im, const SDL_TextInputEvent *event) { - if (im->camera || !im->kp || im->screen->paused) { + if (im->camera || !im->kp || im->screen->paused || im->disconnected) { return; } @@ -417,6 +420,7 @@ sc_input_manager_process_key(struct sc_input_manager *im, bool control = im->controller; bool paused = im->screen->paused; bool video = im->screen->video; + bool disconnected = im->disconnected; SDL_Keycode sdl_keycode = event->key; uint16_t mod = event->mod; @@ -433,7 +437,7 @@ sc_input_manager_process_key(struct sc_input_manager *im, bool is_shortcut = sc_shortcut_mods_is_shortcut_mod(mods, mod) || sc_shortcut_mods_is_shortcut_key(mods, sdl_keycode); - if (down && !repeat) { + if (down && !repeat && !disconnected) { if (sdl_keycode == im->last_keycode && mod == im->last_mod) { ++im->key_repeat; } else { @@ -510,6 +514,12 @@ sc_input_manager_process_key(struct sc_input_manager *im, return; } + if (disconnected) { + // Only handle shortcuts that do not interact with the device (since + // it is disconnected) + return; + } + // Flatten conditions to avoid additional indentation levels if (control) { // Controls for all sources @@ -718,7 +728,7 @@ sc_input_manager_get_position(struct sc_input_manager *im, int32_t x, static void sc_input_manager_process_mouse_motion(struct sc_input_manager *im, const SDL_MouseMotionEvent *event) { - if (im->camera || !im->mp || im->screen->paused) { + if (im->camera || !im->mp || im->screen->paused || im->disconnected) { return; } @@ -757,7 +767,7 @@ sc_input_manager_process_mouse_motion(struct sc_input_manager *im, static void sc_input_manager_process_touch(struct sc_input_manager *im, const SDL_TouchFingerEvent *event) { - if (im->camera || !im->mp || im->screen->paused) { + if (im->camera || !im->mp || im->screen->paused || im->disconnected) { return; } @@ -812,7 +822,7 @@ sc_input_manager_process_mouse_button(struct sc_input_manager *im, // some mouse events do not interact with the device, so process the event // even if control is disabled - if (im->camera) { + if (im->camera || im->disconnected) { return; } @@ -983,7 +993,7 @@ sc_input_manager_process_mouse_button(struct sc_input_manager *im, static void sc_input_manager_process_mouse_wheel(struct sc_input_manager *im, const SDL_MouseWheelEvent *event) { - if (im->camera || !im->kp || im->screen->paused) { + if (im->camera || !im->kp || im->screen->paused || im->disconnected) { return; } @@ -1013,7 +1023,7 @@ sc_input_manager_process_gamepad_device(struct sc_input_manager *im, const SDL_GamepadDeviceEvent *event) { // Handle device added or removed even if paused - if (im->camera || !im->gp) { + if (im->camera || !im->gp || im->disconnected) { return; } @@ -1058,7 +1068,7 @@ sc_input_manager_process_gamepad_device(struct sc_input_manager *im, static void sc_input_manager_process_gamepad_axis(struct sc_input_manager *im, const SDL_GamepadAxisEvent *event) { - if (im->camera || !im->gp || im->screen->paused) { + if (im->camera || !im->gp || im->screen->paused || im->disconnected) { return; } @@ -1078,7 +1088,7 @@ sc_input_manager_process_gamepad_axis(struct sc_input_manager *im, static void sc_input_manager_process_gamepad_button(struct sc_input_manager *im, const SDL_GamepadButtonEvent *event) { - if (im->camera || !im->gp || im->screen->paused) { + if (im->camera || !im->gp || im->screen->paused || im->disconnected) { return; } @@ -1104,7 +1114,7 @@ is_apk(const char *file) { static void sc_input_manager_process_file(struct sc_input_manager *im, const SDL_DropEvent *event) { - if (im->camera || !im->controller) { + if (im->camera || !im->controller || im->disconnected) { return; } @@ -1127,6 +1137,16 @@ sc_input_manager_process_file(struct sc_input_manager *im, } } +static void +sc_input_manager_on_device_disconnected(struct sc_input_manager *im) { + im->disconnected = true; + + struct sc_fps_counter *fps_counter = &im->screen->fps_counter; + if (sc_fps_counter_is_started(fps_counter)) { + sc_fps_counter_stop(fps_counter); + } +} + void sc_input_manager_handle_event(struct sc_input_manager *im, const SDL_Event *event) { @@ -1167,5 +1187,8 @@ sc_input_manager_handle_event(struct sc_input_manager *im, case SDL_EVENT_DROP_FILE: sc_input_manager_process_file(im, &event->drop); break; + case SC_EVENT_DEVICE_DISCONNECTED: + sc_input_manager_on_device_disconnected(im); + break; } } diff --git a/app/src/input_manager.h b/app/src/input_manager.h index ed96a3dd..c986cbc5 100644 --- a/app/src/input_manager.h +++ b/app/src/input_manager.h @@ -46,6 +46,8 @@ struct sc_input_manager { uint16_t last_mod; uint64_t next_sequence; // used for request acknowledgements + + bool disconnected; }; struct sc_input_manager_params { diff --git a/app/src/scrcpy.c b/app/src/scrcpy.c index 537bc6a7..fca52074 100644 --- a/app/src/scrcpy.c +++ b/app/src/scrcpy.c @@ -173,6 +173,9 @@ event_loop(struct scrcpy *s, bool has_screen) { switch (event.type) { case SC_EVENT_DEVICE_DISCONNECTED: LOGW("Device disconnected"); + if (has_screen) { + sc_screen_handle_event(&s->screen, &event); + } return SCRCPY_EXIT_DISCONNECTED; case SC_EVENT_DEMUXER_ERROR: LOGE("Demuxer error"); @@ -415,6 +418,7 @@ scrcpy(struct scrcpy_options *options) { bool screen_initialized = false; bool timeout_initialized = false; bool timeout_started = false; + bool disconnected = false; struct sc_acksync *acksync = NULL; @@ -948,14 +952,7 @@ aoa_complete: ret = event_loop(s, options->window); terminate_runnables_on_event_loop(); - LOGD("quit..."); - - if (options->window) { - // Close the window immediately on closing, because screen_destroy() - // may only be called once the video demuxer thread is joined (it may - // take time) - sc_screen_hide_window(&s->screen); - } + disconnected = ret == SCRCPY_EXIT_DISCONNECTED; end: if (timeout_started) { @@ -1000,6 +997,17 @@ end: sc_server_stop(&s->server); } + if (screen_initialized) { + if (disconnected) { + sc_screen_handle_disconnection(&s->screen); + } + LOGD("Quit..."); + + // Close the window immediately, because sc_screen_destroy() may only be + // called once the video demuxer thread is joined (it may take time) + sc_screen_hide_window(&s->screen); + } + if (timeout_started) { sc_timeout_join(&s->timeout); } diff --git a/app/src/screen.c b/app/src/screen.c index 6a6d8eb5..9f1876ed 100644 --- a/app/src/screen.c +++ b/app/src/screen.c @@ -184,7 +184,7 @@ compute_content_rect(struct sc_size render_size, struct sc_size content_size, static void sc_screen_update_content_rect(struct sc_screen *screen) { // Only upscale video frames, not icon - bool can_upscale = screen->video; + bool can_upscale = screen->video && !screen->disconnected; struct sc_size render_size = sc_sdl_get_render_output_size(screen->renderer); @@ -366,6 +366,8 @@ sc_screen_init(struct sc_screen *screen, screen->paused = false; screen->resume_frame = NULL; screen->orientation = SC_ORIENTATION_0; + screen->disconnected = false; + screen->disconnect_started = false; screen->video = params->video; screen->camera = params->camera; @@ -626,9 +628,19 @@ sc_screen_interrupt(struct sc_screen *screen) { sc_fps_counter_interrupt(&screen->fps_counter); } +static void +sc_screen_interrupt_disconnect(struct sc_screen *screen) { + if (screen->disconnect_started) { + sc_disconnect_interrupt(&screen->disconnect); + } +} + void sc_screen_join(struct sc_screen *screen) { sc_fps_counter_join(&screen->fps_counter); + if (screen->disconnect_started) { + sc_disconnect_join(&screen->disconnect); + } } void @@ -636,6 +648,9 @@ sc_screen_destroy(struct sc_screen *screen) { #ifndef NDEBUG assert(!screen->open); #endif + if (screen->disconnect_started) { + sc_disconnect_destroy(&screen->disconnect); + } sc_texture_destroy(&screen->tex); av_frame_free(&screen->frame); #ifdef SC_DISPLAY_FORCE_OPENGL_CORE_PROFILE @@ -645,6 +660,17 @@ sc_screen_destroy(struct sc_screen *screen) { SDL_DestroyWindow(screen->window); sc_fps_counter_destroy(&screen->fps_counter); sc_frame_buffer_destroy(&screen->fb); + + SDL_Event event; + int nevents = SDL_PeepEvents(&event, 1, SDL_GETEVENT, + SC_EVENT_DISCONNECTED_ICON_LOADED, + SC_EVENT_DISCONNECTED_ICON_LOADED); + if (nevents == 1) { + assert(event.type == SC_EVENT_DISCONNECTED_ICON_LOADED); + // The event was posted, but not handled, the icon must be freed + SDL_Surface *dangling_icon = event.user.data1; + sc_icon_destroy(dangling_icon); + } } static void @@ -857,6 +883,27 @@ sc_screen_resize_to_pixel_perfect(struct sc_screen *screen) { content_size.height); } +static void +sc_disconnect_on_icon_loaded(struct sc_disconnect *d, SDL_Surface *icon, + void *userdata) { + (void) d; + (void) userdata; + + bool ok = sc_push_event_with_data(SC_EVENT_DISCONNECTED_ICON_LOADED, icon); + if (!ok) { + sc_icon_destroy(icon); + } +} + +static void +sc_disconnect_on_timeout(struct sc_disconnect *d, void *userdata) { + (void) d; + (void) userdata; + + bool ok = sc_push_event(SC_EVENT_DISCONNECTED_TIMEOUT); + (void) ok; // ignore failure +} + void sc_screen_handle_event(struct sc_screen *screen, const SDL_Event *event) { switch (event->type) { @@ -903,6 +950,31 @@ sc_screen_handle_event(struct sc_screen *screen, const SDL_Event *event) { apply_pending_resize(screen); sc_screen_render(screen, true); } + return; + case SC_EVENT_DEVICE_DISCONNECTED: + assert(!screen->disconnected); + screen->disconnected = true; + if (!screen->window_shown) { + // No window open + return; + } + + sc_input_manager_handle_event(&screen->im, event); + + sc_texture_reset(&screen->tex); + sc_screen_render(screen, true); + + sc_tick deadline = sc_tick_now() + SC_TICK_FROM_SEC(2); + static const struct sc_disconnect_callbacks cbs = { + .on_icon_loaded = sc_disconnect_on_icon_loaded, + .on_timeout = sc_disconnect_on_timeout, + }; + bool ok = + sc_disconnect_start(&screen->disconnect, deadline, &cbs, NULL); + if (ok) { + screen->disconnect_started = true; + } + return; } @@ -915,6 +987,55 @@ sc_screen_handle_event(struct sc_screen *screen, const SDL_Event *event) { sc_input_manager_handle_event(&screen->im, event); } +void +sc_screen_handle_disconnection(struct sc_screen *screen) { + if (!screen->window_shown) { + // No window open, quit immediately + return; + } + + if (!screen->disconnect_started) { + // If sc_disconnect_start() failed, quit immediately + return; + } + + SDL_Event event; + while (SDL_WaitEvent(&event)) { + switch (event.type) { + case SDL_EVENT_WINDOW_EXPOSED: + sc_screen_render(screen, true); + break; + case SC_EVENT_DISCONNECTED_ICON_LOADED: { + SDL_Surface *icon_disconnected = event.user.data1; + assert(icon_disconnected); + + bool ok = sc_texture_set_from_surface(&screen->tex, + icon_disconnected); + if (ok) { + screen->content_size.width = icon_disconnected->w; + screen->content_size.height = icon_disconnected->h; + sc_screen_render(screen, true); + } else { + // not fatal + LOGE("Could not set disconnected icon"); + } + + sc_icon_destroy(icon_disconnected); + break; + } + case SC_EVENT_DISCONNECTED_TIMEOUT: + LOGD("Closing after device disconnection"); + return; + case SDL_EVENT_QUIT: + LOGD("User requested to quit"); + sc_screen_interrupt_disconnect(screen); + return; + default: + sc_input_manager_handle_event(&screen->im, &event); + } + } +} + struct sc_point sc_screen_convert_drawable_to_frame_coords(struct sc_screen *screen, int32_t x, int32_t y) { diff --git a/app/src/screen.h b/app/src/screen.h index 4ff835a8..a97a8256 100644 --- a/app/src/screen.h +++ b/app/src/screen.h @@ -12,6 +12,7 @@ #include "controller.h" #include "coords.h" +#include "disconnect.h" #include "fps_counter.h" #include "frame_buffer.h" #include "input_manager.h" @@ -76,6 +77,10 @@ struct sc_screen { bool paused; AVFrame *resume_frame; + + bool disconnected; + bool disconnect_started; + struct sc_disconnect disconnect; }; struct sc_screen_params { @@ -115,7 +120,7 @@ bool sc_screen_init(struct sc_screen *screen, const struct sc_screen_params *params); // request to interrupt any inner thread -// must be called before screen_join() +// must be called before sc_screen_join() void sc_screen_interrupt(struct sc_screen *screen); @@ -159,6 +164,10 @@ sc_screen_set_paused(struct sc_screen *screen, bool paused); void sc_screen_handle_event(struct sc_screen *screen, const SDL_Event *event); +// run the event loop once the device is disconnected +void +sc_screen_handle_disconnection(struct sc_screen *screen); + // convert point from window coordinates to frame coordinates // x and y are expressed in pixels struct sc_point diff --git a/app/src/usb/scrcpy_otg.c b/app/src/usb/scrcpy_otg.c index c79aee74..77189209 100644 --- a/app/src/usb/scrcpy_otg.c +++ b/app/src/usb/scrcpy_otg.c @@ -31,7 +31,7 @@ sc_usb_on_disconnected(struct sc_usb *usb, void *userdata) { (void) usb; (void) userdata; - sc_push_event(SC_EVENT_USB_DEVICE_DISCONNECTED); + sc_push_event(SC_EVENT_DEVICE_DISCONNECTED); } static enum scrcpy_exit_code @@ -39,8 +39,9 @@ event_loop(struct scrcpy_otg *s) { SDL_Event event; while (SDL_WaitEvent(&event)) { switch (event.type) { - case SC_EVENT_USB_DEVICE_DISCONNECTED: + case SC_EVENT_DEVICE_DISCONNECTED: LOGW("Device disconnected"); + sc_screen_handle_event(&s->screen, &event); return SCRCPY_EXIT_DISCONNECTED; case SC_EVENT_AOA_OPEN_ERROR: LOGE("AOA open error"); @@ -96,6 +97,7 @@ scrcpy_otg(struct scrcpy_options *options) { bool aoa_started = false; bool aoa_initialized = false; bool screen_initialized = false; + bool disconnected = false; #ifdef _WIN32 // On Windows, only one process could open a USB device @@ -221,7 +223,7 @@ scrcpy_otg(struct scrcpy_options *options) { usb_device_initialized = false; ret = event_loop(s); - LOGD("quit..."); + disconnected = ret == SCRCPY_EXIT_DISCONNECTED; end: if (aoa_started) { @@ -231,6 +233,14 @@ end: if (screen_initialized) { sc_screen_interrupt(&s->screen); + + if (disconnected) { + sc_screen_handle_disconnection(&s->screen); + } + LOGD("Quit..."); + + // Close the window immediately + sc_screen_hide_window(&s->screen); } if (mp) {