Apply resizing workaround on size changed

The "resized" event is called on user resizing only, while "size
changed" is called on any resize, including at every step of a
progressive resize animation.

BUILD.md

@@ -249,10 +249,10 @@ You can then [run](README.md#run) _scrcpy_.
 
 ## Prebuilt server
 
- - [`scrcpy-server-v1.12.1`][direct-scrcpy-server]  
-   _(SHA-256: 63e569c8a1d0c1df31d48c4214871c479a601782945fed50c1e61167d78266ea)_
+ - [`scrcpy-server-v1.13`][direct-scrcpy-server]  
+   _(SHA-256: 5fee64ca1ccdc2f38550f31f5353c66de3de30c2e929a964e30fa2d005d5f885)_
 
-[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.12.1/scrcpy-server-v1.12.1
+[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.13/scrcpy-server-v1.13
 
 Download the prebuilt server somewhere, and specify its path during the Meson
 configuration:

Makefile.CrossWindows

@@ -100,30 +100,30 @@ dist-win32: build-server build-win32 build-win32-noconsole
 	cp "$(SERVER_BUILD_DIR)"/server/scrcpy-server "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp "$(WIN32_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp "$(WIN32_NOCONSOLE_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN32_TARGET_DIR)/scrcpy-noconsole.exe"
-	cp prebuilt-deps/ffmpeg-4.2.1-win32-shared/bin/avutil-56.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.2.1-win32-shared/bin/avcodec-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.2.1-win32-shared/bin/avformat-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.2.1-win32-shared/bin/swresample-3.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.2.1-win32-shared/bin/swscale-5.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.2.2-win32-shared/bin/avutil-56.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.2.2-win32-shared/bin/avcodec-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.2.2-win32-shared/bin/avformat-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.2.2-win32-shared/bin/swresample-3.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.2.2-win32-shared/bin/swscale-5.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/adb.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinUsbApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/SDL2-2.0.10/i686-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/SDL2-2.0.12/i686-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 
 dist-win64: build-server build-win64 build-win64-noconsole
 	mkdir -p "$(DIST)/$(WIN64_TARGET_DIR)"
 	cp "$(SERVER_BUILD_DIR)"/server/scrcpy-server "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp "$(WIN64_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp "$(WIN64_NOCONSOLE_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN64_TARGET_DIR)/scrcpy-noconsole.exe"
-	cp prebuilt-deps/ffmpeg-4.2.1-win64-shared/bin/avutil-56.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.2.1-win64-shared/bin/avcodec-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.2.1-win64-shared/bin/avformat-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.2.1-win64-shared/bin/swresample-3.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.2.1-win64-shared/bin/swscale-5.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.2.2-win64-shared/bin/avutil-56.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.2.2-win64-shared/bin/avcodec-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.2.2-win64-shared/bin/avformat-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.2.2-win64-shared/bin/swresample-3.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.2.2-win64-shared/bin/swscale-5.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/adb.exe "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinUsbApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/SDL2-2.0.10/x86_64-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/SDL2-2.0.12/x86_64-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 
 zip-win32: dist-win32
 	cd "$(DIST)/$(WIN32_TARGET_DIR)"; \

README.md

@@ -1,4 +1,4 @@
-# scrcpy (v1.12.1)
+# scrcpy (v1.13)
 
 This application provides display and control of Android devices connected on
 USB (or [over TCP/IP][article-tcpip]). It does not require any _root_ access.
@@ -37,7 +37,7 @@ control it using keyboard and mouse.
 
 ### Linux
 
-In Debian (_testing_ and _sid_ for now):
+On Debian (_testing_ and _sid_ for now) and Ubuntu (20.04):
 
 ```
 apt install scrcpy
@@ -69,10 +69,10 @@ hard).
 For Windows, for simplicity, a prebuilt archive with all the dependencies
 (including `adb`) is available:
 
- - [`scrcpy-win64-v1.12.1.zip`][direct-win64]  
-   _(SHA-256: 57d34b6d16cfd9fe169bc37c4df58ebd256d05c1ea3febc63d9cb0a027ab47c9)_
+ - [`scrcpy-win64-v1.13.zip`][direct-win64]  
+   _(SHA-256: 806aafc00d4db01513193addaa24f47858893ba5efe75770bfef6ae1ea987d27)_
 
-[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.12.1/scrcpy-win64-v1.12.1.zip
+[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.13/scrcpy-win64-v1.13.zip
 
 It is also available in [Chocolatey]:
 
@@ -210,7 +210,6 @@ To disable mirroring while recording:
 scrcpy --no-display --record file.mp4
 scrcpy -Nr file.mkv
 # interrupt recording with Ctrl+C
-# Ctrl+C does not terminate properly on Windows, so disconnect the device
 ```
 
 "Skipped frames" are recorded, even if they are not displayed in real time (for
@@ -270,7 +269,7 @@ You could use [AutoAdb]:
 autoadb scrcpy -s '{}'
 ```
 
-[AutoAdb]: https://github.com/rom1v/usbaudio
+[AutoAdb]: https://github.com/rom1v/autoadb
 
 #### SSH tunnel
 
@@ -396,6 +395,18 @@ The list of display ids can be retrieved by:
 adb shell dumpsys display   # search "mDisplayId=" in the output
 ```
 
+#### Stay awake
+
+To prevent the device to sleep after some delay:
+
+```bash
+scrcpy --stay-awake
+scrcpy -w
+```
+
+The initial state is restored when scrcpy is closed.
+
+
 #### Turn screen off
 
 It is possible to turn the device screen off while mirroring on start with a
@@ -410,6 +421,14 @@ Or by pressing `Ctrl`+`o` at any time.
 
 To turn it back on, press `POWER` (or `Ctrl`+`p`).
 
+It can be useful to also prevent the device to sleep:
+
+```bash
+scrcpy --turn-screen-off --stay-awake
+scrcpy -Sw
+```
+
+
 #### Render expired frames
 
 By default, to minimize latency, _scrcpy_ always renders the last decoded frame
@@ -429,7 +448,8 @@ device).
 
 Android provides this feature in _Developers options_.
 
-_Scrcpy_ provides an option to enable this feature on start and disable on exit:
+_Scrcpy_ provides an option to enable this feature on start and restore the
+initial value on exit:
 
 ```bash
 scrcpy --show-touches

app/scrcpy.1

@@ -136,7 +136,7 @@ Turn the device screen off immediately.
 
 .TP
 .B \-t, \-\-show\-touches
-Enable "show touches" on start, disable on quit.
+Enable "show touches" on start, restore the initial value on exit..
 
 It only shows physical touches (not clicks from scrcpy).
 
@@ -144,6 +144,10 @@ It only shows physical touches (not clicks from scrcpy).
 .B \-v, \-\-version
 Print the version of scrcpy.
 
+.TP
+.B \-w, \-\-stay-awake
+Keep the device on while scrcpy is running.
+
 .TP
 .B \-\-window\-borderless
 Disable window decorations (display borderless window).

app/src/cli.c

@@ -130,12 +130,16 @@ scrcpy_print_usage(const char *arg0) {
         "        Turn the device screen off immediately.\n"
         "\n"
         "    -t, --show-touches\n"
-        "        Enable \"show touches\" on start, disable on quit.\n"
+        "        Enable \"show touches\" on start, restore the initial value\n"
+        "        on exit.\n"
         "        It only shows physical touches (not clicks from scrcpy).\n"
         "\n"
         "    -v, --version\n"
         "        Print the version of scrcpy.\n"
         "\n"
+        "    -w, --stay-awake\n"
+        "        Keep the device on while scrcpy is running.\n"
+        "\n"
         "    --window-borderless\n"
         "        Disable window decorations (display borderless window).\n"
         "\n"
@@ -486,6 +490,7 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
         {"no-display",             no_argument,       NULL, 'N'},
         {"no-mipmaps",             no_argument,       NULL, OPT_NO_MIPMAPS},
         {"port",                   required_argument, NULL, 'p'},
+        {"prefer-text",            no_argument,       NULL, OPT_PREFER_TEXT},
         {"push-target",            required_argument, NULL, OPT_PUSH_TARGET},
         {"record",                 required_argument, NULL, 'r'},
         {"record-format",          required_argument, NULL, OPT_RECORD_FORMAT},
@@ -495,8 +500,8 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
         {"rotation",               required_argument, NULL, OPT_ROTATION},
         {"serial",                 required_argument, NULL, 's'},
         {"show-touches",           no_argument,       NULL, 't'},
+        {"stay-awake",             no_argument,       NULL, 'w'},
         {"turn-screen-off",        no_argument,       NULL, 'S'},
-        {"prefer-text",            no_argument,       NULL, OPT_PREFER_TEXT},
         {"version",                no_argument,       NULL, 'v'},
         {"window-title",           required_argument, NULL, OPT_WINDOW_TITLE},
         {"window-x",               required_argument, NULL, OPT_WINDOW_X},
@@ -513,7 +518,7 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
     optind = 0; // reset to start from the first argument in tests
 
     int c;
-    while ((c = getopt_long(argc, argv, "b:c:fF:hm:nNp:r:s:StTv", long_options,
+    while ((c = getopt_long(argc, argv, "b:c:fF:hm:nNp:r:s:StTvw", long_options,
                             NULL)) != -1) {
         switch (c) {
             case 'b':
@@ -593,6 +598,9 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
             case 'v':
                 args->version = true;
                 break;
+            case 'w':
+                opts->stay_awake = true;
+                break;
             case OPT_RENDER_EXPIRED_FRAMES:
                 opts->render_expired_frames = true;
                 break;
@@ -675,5 +683,10 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
         return false;
     }
 
+    if (!opts->control && opts->stay_awake) {
+        LOGE("Could not request to stay awake if control is disabled");
+        return false;
+    }
+
     return true;
 }

app/src/scrcpy.c

@@ -7,6 +7,10 @@
 #include <sys/time.h>
 #include <SDL2/SDL.h>
 
+#ifdef _WIN32
+# include <windows.h>
+#endif
+
 #include "config.h"
 #include "command.h"
 #include "common.h"
@@ -45,6 +49,18 @@ static struct input_manager input_manager = {
     .prefer_text = false, // initialized later
 };
 
+#ifdef _WIN32
+BOOL WINAPI windows_ctrl_handler(DWORD ctrl_type) {
+    if (ctrl_type == CTRL_C_EVENT) {
+        SDL_Event event;
+        event.type = SDL_QUIT;
+        SDL_PushEvent(&event);
+        return TRUE;
+    }
+    return FALSE;
+}
+#endif // _WIN32
+
 // init SDL and set appropriate hints
 static bool
 sdl_init_and_configure(bool display, const char *render_driver) {
@@ -56,6 +72,14 @@ sdl_init_and_configure(bool display, const char *render_driver) {
 
     atexit(SDL_Quit);
 
+#ifdef _WIN32
+    // Clean up properly on Ctrl+C on Windows
+    bool ok = SetConsoleCtrlHandler(windows_ctrl_handler, TRUE);
+    if (!ok) {
+        LOGW("Could not set Ctrl+C handler");
+    }
+#endif // _WIN32
+
     if (!display) {
         return true;
     }
@@ -109,8 +133,9 @@ static int
 event_watcher(void *data, SDL_Event *event) {
     (void) data;
     if (event->type == SDL_WINDOWEVENT
-            && event->window.event == SDL_WINDOWEVENT_RESIZED) {
-        // called from another thread, not very safe, but it's a workaround!
+            && event->window.event == SDL_WINDOWEVENT_SIZE_CHANGED) {
+        // In practice, it seems to always be called from the same thread in
+        // that specific case. Anyway, it's just a workaround.
         screen_render(&screen);
     }
     return 0;
@@ -228,21 +253,6 @@ event_loop(bool display, bool control) {
     return false;
 }
 
-static process_t
-set_show_touches_enabled(const char *serial, bool enabled) {
-    const char *value = enabled ? "1" : "0";
-    const char *const adb_cmd[] = {
-        "shell", "settings", "put", "system", "show_touches", value
-    };
-    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
-}
-
-static void
-wait_show_touches(process_t process) {
-    // reap the process, ignore the result
-    process_check_success(process, "show_touches");
-}
-
 static SDL_LogPriority
 sdl_priority_from_av_level(int level) {
     switch (level) {
@@ -291,19 +301,13 @@ scrcpy(const struct scrcpy_options *options) {
         .lock_video_orientation = options->lock_video_orientation,
         .control = options->control,
         .display_id = options->display_id,
+        .show_touches = options->show_touches,
+        .stay_awake = options->stay_awake,
     };
     if (!server_start(&server, options->serial, &params)) {
         return false;
     }
 
-    process_t proc_show_touches = PROCESS_NONE;
-    bool show_touches_waited;
-    if (options->show_touches) {
-        LOGI("Enable show_touches");
-        proc_show_touches = set_show_touches_enabled(options->serial, true);
-        show_touches_waited = false;
-    }
-
     bool ret = false;
 
     bool fps_counter_initialized = false;
@@ -420,11 +424,6 @@ scrcpy(const struct scrcpy_options *options) {
         }
     }
 
-    if (options->show_touches) {
-        wait_show_touches(proc_show_touches);
-        show_touches_waited = true;
-    }
-
     input_manager.prefer_text = options->prefer_text;
 
     ret = event_loop(options->display, options->control);
@@ -481,16 +480,6 @@ end:
         fps_counter_destroy(&fps_counter);
     }
 
-    if (options->show_touches) {
-        if (!show_touches_waited) {
-            // wait the process which enabled "show touches"
-            wait_show_touches(proc_show_touches);
-        }
-        LOGI("Disable show_touches");
-        proc_show_touches = set_show_touches_enabled(options->serial, false);
-        wait_show_touches(proc_show_touches);
-    }
-
     server_destroy(&server);
 
     return ret;

app/src/scrcpy.h

@@ -38,6 +38,7 @@ struct scrcpy_options {
     bool prefer_text;
     bool window_borderless;
     bool mipmaps;
+    bool stay_awake;
 };
 
 #define SCRCPY_OPTIONS_DEFAULT { \
@@ -72,6 +73,7 @@ struct scrcpy_options {
     .prefer_text = false, \
     .window_borderless = false, \
     .mipmaps = true, \
+    .stay_awake = false, \
 }
 
 bool

app/src/screen.c

@@ -30,10 +30,10 @@ get_rotated_size(struct size size, int rotation) {
 
 // get the window size in a struct size
 static struct size
-get_window_size(SDL_Window *window) {
+get_window_size(const struct screen *screen) {
     int width;
     int height;
-    SDL_GetWindowSize(window, &width, &height);
+    SDL_GetWindowSize(screen->window, &width, &height);
 
     struct size size;
     size.width = width;
@@ -41,31 +41,12 @@ get_window_size(SDL_Window *window) {
     return size;
 }
 
-// get the windowed window size
-static struct size
-get_windowed_window_size(const struct screen *screen) {
-    if (screen->fullscreen || screen->maximized) {
-        return screen->windowed_window_size;
-    }
-    return get_window_size(screen->window);
-}
-
-// apply the windowed window size if fullscreen and maximized are disabled
-static void
-apply_windowed_size(struct screen *screen) {
-    if (!screen->fullscreen && !screen->maximized) {
-        SDL_SetWindowSize(screen->window, screen->windowed_window_size.width,
-                                          screen->windowed_window_size.height);
-    }
-}
-
 // set the window size to be applied when fullscreen is disabled
 static void
 set_window_size(struct screen *screen, struct size new_size) {
-    // setting the window size during fullscreen is implementation defined,
-    // so apply the resize only after fullscreen is disabled
-    screen->windowed_window_size = new_size;
-    apply_windowed_size(screen);
+    assert(!screen->fullscreen);
+    assert(!screen->maximized);
+    SDL_SetWindowSize(screen->window, new_size.width, new_size.height);
 }
 
 // get the preferred display bounds (i.e. the screen bounds with some margins)
@@ -113,6 +94,13 @@ get_optimal_size(struct size current_size, struct size content_size) {
         h = MIN(current_size.height, display_size.height);
     }
 
+    if (h == w * content_size.height / content_size.width
+     || w == h * content_size.width / content_size.height) {
+        // The size is already optimal, if we ignore rounding errors due to
+        // integer window dimensions
+        return (struct size) {w, h};
+    }
+
     bool keep_width = content_size.width * h > content_size.height * w;
     if (keep_width) {
         // remove black borders on top and bottom
@@ -131,8 +119,8 @@ get_optimal_size(struct size current_size, struct size content_size) {
 // same as get_optimal_size(), but read the current size from the window
 static inline struct size
 get_optimal_window_size(const struct screen *screen, struct size content_size) {
-    struct size windowed_size = get_windowed_window_size(screen);
-    return get_optimal_size(windowed_size, content_size);
+    struct size window_size = get_window_size(screen);
+    return get_optimal_size(window_size, content_size);
 }
 
 // initially, there is no current size, so use the frame size as current size
@@ -258,7 +246,7 @@ screen_init_rendering(struct screen *screen, const char *window_title,
         return false;
     }
 
-    // stats with "opengl"
+    // starts with "opengl"
     screen->use_opengl = renderer_name && !strncmp(renderer_name, "opengl", 6);
     if (screen->use_opengl) {
         struct sc_opengl *gl = &screen->gl;
@@ -301,8 +289,6 @@ screen_init_rendering(struct screen *screen, const char *window_title,
         return false;
     }
 
-    screen->windowed_window_size = window_size;
-
     return true;
 }
 
@@ -324,6 +310,45 @@ screen_destroy(struct screen *screen) {
     }
 }
 
+static void
+resize_for_content(struct screen *screen, struct size old_content_size,
+                                                 struct size new_content_size) {
+    struct size window_size = get_window_size(screen);
+    struct size target_size = {
+        .width = (uint32_t) window_size.width * new_content_size.width
+                / old_content_size.width,
+        .height = (uint32_t) window_size.height * new_content_size.height
+                / old_content_size.height,
+    };
+    target_size = get_optimal_size(target_size, new_content_size);
+    set_window_size(screen, target_size);
+}
+
+static void
+set_content_size(struct screen *screen, struct size new_content_size) {
+    if (!screen->fullscreen && !screen->maximized) {
+        resize_for_content(screen, screen->content_size, new_content_size);
+    } else if (!screen->resize_pending) {
+        // Store the windowed size to be able to compute the optimal size once
+        // fullscreen and maximized are disabled
+        screen->windowed_content_size = screen->content_size;
+        screen->resize_pending = true;
+    }
+
+    screen->content_size = new_content_size;
+}
+
+static void
+apply_pending_resize(struct screen *screen) {
+    assert(!screen->fullscreen);
+    assert(!screen->maximized);
+    if (screen->resize_pending) {
+        resize_for_content(screen, screen->windowed_content_size,
+                                   screen->content_size);
+        screen->resize_pending = false;
+    }
+}
+
 void
 screen_set_rotation(struct screen *screen, unsigned rotation) {
     assert(rotation < 4);
@@ -331,7 +356,6 @@ screen_set_rotation(struct screen *screen, unsigned rotation) {
         return;
     }
 
-    struct size old_content_size = screen->content_size;
     struct size new_content_size =
         get_rotated_size(screen->frame_size, rotation);
 
@@ -342,17 +366,7 @@ screen_set_rotation(struct screen *screen, unsigned rotation) {
         return;
     }
 
-    struct size windowed_size = get_windowed_window_size(screen);
-    struct size target_size = {
-        .width = (uint32_t) windowed_size.width * new_content_size.width
-                / old_content_size.width,
-        .height = (uint32_t) windowed_size.height * new_content_size.height
-                / old_content_size.height,
-    };
-    target_size = get_optimal_size(target_size, new_content_size);
-    set_window_size(screen, target_size);
-
-    screen->content_size = new_content_size;
+    set_content_size(screen, new_content_size);
     screen->rotation = rotation;
     LOGI("Display rotation set to %u", rotation);
 
@@ -376,19 +390,8 @@ prepare_for_frame(struct screen *screen, struct size new_frame_size) {
         // frame dimension changed, destroy texture
         SDL_DestroyTexture(screen->texture);
 
-        struct size content_size = screen->content_size;
-        struct size windowed_size = get_windowed_window_size(screen);
-        struct size target_size = {
-            (uint32_t) windowed_size.width * new_content_size.width
-                    / content_size.width,
-            (uint32_t) windowed_size.height * new_content_size.height
-                    / content_size.height,
-        };
-        target_size = get_optimal_size(target_size, new_content_size);
-        set_window_size(screen, target_size);
-
+        set_content_size(screen, new_content_size);
         screen->frame_size = new_frame_size;
-        screen->content_size = new_content_size;
 
         LOGI("New texture: %" PRIu16 "x%" PRIu16,
                      screen->frame_size.width, screen->frame_size.height);
@@ -471,7 +474,9 @@ screen_switch_fullscreen(struct screen *screen) {
     }
 
     screen->fullscreen = !screen->fullscreen;
-    apply_windowed_size(screen);
+    if (!screen->fullscreen && !screen->maximized) {
+        apply_pending_resize(screen);
+    }
 
     LOGD("Switched to %s mode", screen->fullscreen ? "fullscreen" : "windowed");
     screen_render(screen);
@@ -512,6 +517,26 @@ screen_resize_to_pixel_perfect(struct screen *screen) {
                                             content_size.height);
 }
 
+static inline bool
+is_fullscreen(const struct screen *screen) {
+    uint32_t flags = SDL_GetWindowFlags(screen->window);
+    return !!(flags & (SDL_WINDOW_FULLSCREEN | SDL_WINDOW_FULLSCREEN_DESKTOP));
+}
+
+static void
+update_fullscreen_state(struct screen *screen) {
+    // There is no SDL event to detect fullscreen changes, so store the
+    // state in a field and compare on every "size changed" event
+    bool fullscreen = is_fullscreen(screen);
+    if (fullscreen != screen->fullscreen) {
+        // Fullscreen state have changed
+        screen->fullscreen = fullscreen;
+        if (!fullscreen && !screen->maximized) {
+            apply_pending_resize(screen);
+        }
+    }
+}
+
 void
 screen_handle_window_event(struct screen *screen,
                            const SDL_WindowEvent *event) {
@@ -520,36 +545,15 @@ screen_handle_window_event(struct screen *screen,
             screen_render(screen);
             break;
         case SDL_WINDOWEVENT_SIZE_CHANGED:
-            if (!screen->fullscreen && !screen->maximized) {
-                // Backup the previous size: if we receive the MAXIMIZED event,
-                // then the new size must be ignored (it's the maximized size).
-                // We could not rely on the window flags due to race conditions
-                // (they could be updated asynchronously, at least on X11).
-                screen->windowed_window_size_backup =
-                    screen->windowed_window_size;
-
-                // Save the windowed size, so that it is available once the
-                // window is maximized or fullscreen is enabled.
-                screen->windowed_window_size = get_window_size(screen->window);
-            }
+            update_fullscreen_state(screen);
             screen_render(screen);
             break;
         case SDL_WINDOWEVENT_MAXIMIZED:
-            // The backup size must be non-nul.
-            assert(screen->windowed_window_size_backup.width);
-            assert(screen->windowed_window_size_backup.height);
-            // Revert the last size, it was updated while screen was maximized.
-            screen->windowed_window_size = screen->windowed_window_size_backup;
-#ifdef DEBUG
-            // Reset the backup to invalid values to detect unexpected usage
-            screen->windowed_window_size_backup.width = 0;
-            screen->windowed_window_size_backup.height = 0;
-#endif
             screen->maximized = true;
             break;
         case SDL_WINDOWEVENT_RESTORED:
             screen->maximized = false;
-            apply_windowed_size(screen);
+            apply_pending_resize(screen);
             break;
     }
 }

app/src/screen.h

@@ -21,11 +21,12 @@ struct screen {
     struct sc_opengl gl;
     struct size frame_size;
     struct size content_size; // rotated frame_size
-    // The window size the last time it was not maximized or fullscreen.
-    struct size windowed_window_size;
-    // Since we receive the event SIZE_CHANGED before MAXIMIZED, we must be
-    // able to revert the size to its non-maximized value.
-    struct size windowed_window_size_backup;
+
+    bool resize_pending; // resize requested while fullscreen or maximized
+    // The content size the last time the window was not maximized or
+    // fullscreen (meaningful only when resize_pending is true)
+    struct size windowed_content_size;
+
     // client rotation: 0, 1, 2 or 3 (x90 degrees counterclockwise)
     unsigned rotation;
     bool has_frame;
@@ -49,11 +50,8 @@ struct screen {
         .width = 0, \
         .height = 0, \
     }, \
-    .windowed_window_size = { \
-        .width = 0, \
-        .height = 0, \
-    }, \
-    .windowed_window_size_backup = { \
+    .resize_pending = false, \
+    .windowed_content_size = { \
         .width = 0, \
         .height = 0, \
     }, \

app/src/server.c

@@ -268,6 +268,8 @@ execute_server(struct server *server, const struct server_params *params) {
         "true", // always send frame meta (packet boundaries + timestamp)
         params->control ? "true" : "false",
         display_id_string,
+        params->show_touches ? "true" : "false",
+        params->stay_awake ? "true" : "false",
     };
 #ifdef SERVER_DEBUGGER
     LOGI("Server debugger waiting for a client on device port "

app/src/server.h

@@ -51,6 +51,8 @@ struct server_params {
     int8_t lock_video_orientation;
     bool control;
     uint16_t display_id;
+    bool show_touches;
+    bool stay_awake;
 };
 
 // init default values

cross_win32.txt

@@ -15,6 +15,6 @@ cpu = 'i686'
 endian = 'little'
 
 [properties]
-prebuilt_ffmpeg_shared = 'ffmpeg-4.2.1-win32-shared'
-prebuilt_ffmpeg_dev = 'ffmpeg-4.2.1-win32-dev'
-prebuilt_sdl2 = 'SDL2-2.0.10/i686-w64-mingw32'
+prebuilt_ffmpeg_shared = 'ffmpeg-4.2.2-win32-shared'
+prebuilt_ffmpeg_dev = 'ffmpeg-4.2.2-win32-dev'
+prebuilt_sdl2 = 'SDL2-2.0.12/i686-w64-mingw32'

cross_win64.txt

@@ -15,6 +15,6 @@ cpu = 'x86_64'
 endian = 'little'
 
 [properties]
-prebuilt_ffmpeg_shared = 'ffmpeg-4.2.1-win64-shared'
-prebuilt_ffmpeg_dev = 'ffmpeg-4.2.1-win64-dev'
-prebuilt_sdl2 = 'SDL2-2.0.10/x86_64-w64-mingw32'
+prebuilt_ffmpeg_shared = 'ffmpeg-4.2.2-win64-shared'
+prebuilt_ffmpeg_dev = 'ffmpeg-4.2.2-win64-dev'
+prebuilt_sdl2 = 'SDL2-2.0.12/x86_64-w64-mingw32'

meson.build

@@ -1,5 +1,5 @@
 project('scrcpy', 'c',
-        version: '1.12.1',
+        version: '1.13',
         meson_version: '>= 0.48',
         default_options: [
             'c_std=c11',

prebuilt-deps/Makefile

@@ -10,29 +10,29 @@ prepare-win32: prepare-sdl2 prepare-ffmpeg-shared-win32 prepare-ffmpeg-dev-win32
 prepare-win64: prepare-sdl2 prepare-ffmpeg-shared-win64 prepare-ffmpeg-dev-win64 prepare-adb
 
 prepare-ffmpeg-shared-win32:
-	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win32/shared/ffmpeg-4.2.1-win32-shared.zip \
-		9208255f409410d95147151d7e829b5699bf8d91bfe1e81c3f470f47c2fa66d2 \
-		ffmpeg-4.2.1-win32-shared
+	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win32/shared/ffmpeg-4.2.2-win32-shared.zip \
+		ab5d603aaa54de360db2c2ffe378c82376b9343ea1175421dd644639aa07ee31 \
+		ffmpeg-4.2.2-win32-shared
 
 prepare-ffmpeg-dev-win32:
-	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win32/dev/ffmpeg-4.2.1-win32-dev.zip \
-		c3469e6c5f031cbcc8cba88dee92d6548c5c6b6ff14f4097f18f72a92d0d70c4 \
-		ffmpeg-4.2.1-win32-dev
+	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win32/dev/ffmpeg-4.2.2-win32-dev.zip \
+		8d224be567a2950cad4be86f4aabdd045bfa52ad758e87c72cedd278613bc6c8 \
+		ffmpeg-4.2.2-win32-dev
 
 prepare-ffmpeg-shared-win64:
-	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win64/shared/ffmpeg-4.2.1-win64-shared.zip \
-		55063d3cf750a75485c7bf196031773d81a1b25d0980c7db48ecfc7701a42331 \
-		ffmpeg-4.2.1-win64-shared
+	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win64/shared/ffmpeg-4.2.2-win64-shared.zip \
+		5aedf268952b7d9f6541dbfcb47cd86a7e7881a3b7ba482fd3bc4ca33bda7bf5 \
+		ffmpeg-4.2.2-win64-shared
 
 prepare-ffmpeg-dev-win64:
-	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win64/dev/ffmpeg-4.2.1-win64-dev.zip \
-		5af393be5f25c0a71aa29efce768e477c35347f7f8e0d9696767d5b9d405b74e \
-		ffmpeg-4.2.1-win64-dev
+	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win64/dev/ffmpeg-4.2.2-win64-dev.zip \
+		f4885f859c5b0d6663c2a0a4c1cf035b1c60b146402790b796bd3ad84f4f3ca2 \
+		ffmpeg-4.2.2-win64-dev
 
 prepare-sdl2:
-	@./prepare-dep https://libsdl.org/release/SDL2-devel-2.0.10-mingw.tar.gz \
-		a90a7cddaec4996f4d7be6d80c57ec69b062e132bffc513965f99217f603274a \
-		SDL2-2.0.10
+	@./prepare-dep https://libsdl.org/release/SDL2-devel-2.0.12-mingw.tar.gz \
+		e614a60f797e35ef9f3f96aef3dc6a1d786de3cc7ca6216f97e435c0b6aafc46 \
+		SDL2-2.0.12
 
 prepare-adb:
 	@./prepare-dep https://dl.google.com/android/repository/platform-tools_r29.0.5-windows.zip \

server/build.gradle

@@ -6,8 +6,8 @@ android {
         applicationId "com.genymobile.scrcpy"
         minSdkVersion 21
         targetSdkVersion 29
-        versionCode 14
-        versionName "1.12.1"
+        versionCode 15
+        versionName "1.13"
         testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
     }
     buildTypes {

server/build_without_gradle.sh

@@ -12,7 +12,7 @@
 set -e
 
 SCRCPY_DEBUG=false
-SCRCPY_VERSION_NAME=1.12.1
+SCRCPY_VERSION_NAME=1.13
 
 PLATFORM=${ANDROID_PLATFORM:-29}
 BUILD_TOOLS=${ANDROID_BUILD_TOOLS:-29.0.2}

server/src/main/java/com/genymobile/scrcpy/CleanUp.java

@@ -0,0 +1,77 @@
+package com.genymobile.scrcpy;
+
+import com.genymobile.scrcpy.wrappers.ContentProvider;
+import com.genymobile.scrcpy.wrappers.ServiceManager;
+
+import java.io.File;
+import java.io.IOException;
+
+/**
+ * Handle the cleanup of scrcpy, even if the main process is killed.
+ * <p>
+ * This is useful to restore some state when scrcpy is closed, even on device disconnection (which kills the scrcpy process).
+ */
+public final class CleanUp {
+
+    public static final String SERVER_PATH = "/data/local/tmp/scrcpy-server.jar";
+
+    private CleanUp() {
+        // not instantiable
+    }
+
+    public static void configure(boolean disableShowTouches, int restoreStayOn) throws IOException {
+        boolean needProcess = disableShowTouches || restoreStayOn != -1;
+        if (needProcess) {
+            startProcess(disableShowTouches, restoreStayOn);
+        } else {
+            // There is no additional clean up to do when scrcpy dies
+            unlinkSelf();
+        }
+    }
+
+    private static void startProcess(boolean disableShowTouches, int restoreStayOn) throws IOException {
+        String[] cmd = {"app_process", "/", CleanUp.class.getName(), String.valueOf(disableShowTouches), String.valueOf(restoreStayOn)};
+
+        ProcessBuilder builder = new ProcessBuilder(cmd);
+        builder.environment().put("CLASSPATH", SERVER_PATH);
+        builder.start();
+    }
+
+    private static void unlinkSelf() {
+        try {
+            new File(SERVER_PATH).delete();
+        } catch (Exception e) {
+            Ln.e("Could not unlink server", e);
+        }
+    }
+
+    public static void main(String... args) {
+        unlinkSelf();
+
+        try {
+            // Wait for the server to die
+            System.in.read();
+        } catch (IOException e) {
+            // Expected when the server is dead
+        }
+
+        Ln.i("Cleaning up");
+
+        boolean disableShowTouches = Boolean.parseBoolean(args[0]);
+        int restoreStayOn = Integer.parseInt(args[1]);
+
+        if (disableShowTouches || restoreStayOn != -1) {
+            ServiceManager serviceManager = new ServiceManager();
+            try (ContentProvider settings = serviceManager.getActivityManager().createSettingsProvider()) {
+                if (disableShowTouches) {
+                    Ln.i("Disabling \"show touches\"");
+                    settings.putValue(ContentProvider.TABLE_SYSTEM, "show_touches", "0");
+                }
+                if (restoreStayOn != -1) {
+                    Ln.i("Restoring \"stay awake\"");
+                    settings.putValue(ContentProvider.TABLE_GLOBAL, "stay_on_while_plugged_in", String.valueOf(restoreStayOn));
+                }
+            }
+        }
+    }
+}

server/src/main/java/com/genymobile/scrcpy/Controller.java

@@ -215,7 +215,7 @@ public class Controller {
 
         MotionEvent event = MotionEvent
                 .obtain(lastTouchDown, now, MotionEvent.ACTION_SCROLL, 1, pointerProperties, pointerCoords, 0, 0, 1f, 1f, DEVICE_ID_VIRTUAL, 0,
-                        InputDevice.SOURCE_MOUSE, 0);
+                        InputDevice.SOURCE_TOUCHSCREEN, 0);
         return injectEvent(event);
     }
 

server/src/main/java/com/genymobile/scrcpy/Device.java

@@ -1,5 +1,6 @@
 package com.genymobile.scrcpy;
 
+import com.genymobile.scrcpy.wrappers.ContentProvider;
 import com.genymobile.scrcpy.wrappers.InputManager;
 import com.genymobile.scrcpy.wrappers.ServiceManager;
 import com.genymobile.scrcpy.wrappers.SurfaceControl;
@@ -199,4 +200,8 @@ public final class Device {
             wm.thawRotation();
         }
     }
+
+    public ContentProvider createSettingsProvider() {
+        return serviceManager.getActivityManager().createSettingsProvider();
+    }
 }

server/src/main/java/com/genymobile/scrcpy/Options.java

@@ -12,6 +12,8 @@ public class Options {
     private boolean sendFrameMeta; // send PTS so that the client may record properly
     private boolean control;
     private int displayId;
+    private boolean showTouches;
+    private boolean stayAwake;
 
     public int getMaxSize() {
         return maxSize;
@@ -84,4 +86,20 @@ public class Options {
     public void setDisplayId(int displayId) {
         this.displayId = displayId;
     }
+
+    public boolean getShowTouches() {
+        return showTouches;
+    }
+
+    public void setShowTouches(boolean showTouches) {
+        this.showTouches = showTouches;
+    }
+
+    public boolean getStayAwake() {
+        return stayAwake;
+    }
+
+    public void setStayAwake(boolean stayAwake) {
+        this.stayAwake = stayAwake;
+    }
 }

server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java

@@ -47,9 +47,21 @@ public class ScreenEncoder implements Device.RotationListener {
 
     public void streamScreen(Device device, FileDescriptor fd) throws IOException {
         Workarounds.prepareMainLooper();
-        Workarounds.fillAppInfo();
 
-        MediaFormat format = createFormat(bitRate, maxFps, DEFAULT_I_FRAME_INTERVAL);
+        try {
+            internalStreamScreen(device, fd);
+        } catch (NullPointerException e) {
+            // Retry with workarounds enabled:
+            // <https://github.com/Genymobile/scrcpy/issues/365>
+            // <https://github.com/Genymobile/scrcpy/issues/940>
+            Ln.d("Applying workarounds to avoid NullPointerException");
+            Workarounds.fillAppInfo();
+            internalStreamScreen(device, fd);
+        }
+    }
+
+    private void internalStreamScreen(Device device, FileDescriptor fd) throws IOException {
+        MediaFormat format = createFormat(bitRate, maxFps);
         device.setRotationListener(this);
         boolean alive;
         try {
@@ -139,14 +151,14 @@ public class ScreenEncoder implements Device.RotationListener {
         return MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_VIDEO_AVC);
     }
 
-    private static MediaFormat createFormat(int bitRate, int maxFps, int iFrameInterval) {
+    private static MediaFormat createFormat(int bitRate, int maxFps) {
         MediaFormat format = new MediaFormat();
         format.setString(MediaFormat.KEY_MIME, MediaFormat.MIMETYPE_VIDEO_AVC);
         format.setInteger(MediaFormat.KEY_BIT_RATE, bitRate);
         // must be present to configure the encoder, but does not impact the actual frame rate, which is variable
         format.setInteger(MediaFormat.KEY_FRAME_RATE, 60);
         format.setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface);
-        format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, iFrameInterval);
+        format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, DEFAULT_I_FRAME_INTERVAL);
         // display the very first frame, and recover from bad quality when no new frames
         format.setLong(MediaFormat.KEY_REPEAT_PREVIOUS_FRAME_AFTER, REPEAT_FRAME_DELAY_US); // µs
         if (maxFps > 0) {

server/src/main/java/com/genymobile/scrcpy/Server.java

@@ -1,15 +1,16 @@
 package com.genymobile.scrcpy;
 
+import com.genymobile.scrcpy.wrappers.ContentProvider;
+
 import android.graphics.Rect;
 import android.media.MediaCodec;
+import android.os.BatteryManager;
 import android.os.Build;
 
-import java.io.File;
 import java.io.IOException;
 
 public final class Server {
 
-    private static final String SERVER_PATH = "/data/local/tmp/scrcpy-server.jar";
 
     private Server() {
         // not instantiable
@@ -18,6 +19,35 @@ public final class Server {
     private static void scrcpy(Options options) throws IOException {
         Ln.i("Device: " + Build.MANUFACTURER + " " + Build.MODEL + " (Android " + Build.VERSION.RELEASE + ")");
         final Device device = new Device(options);
+
+        boolean mustDisableShowTouchesOnCleanUp = false;
+        int restoreStayOn = -1;
+        if (options.getShowTouches() || options.getStayAwake()) {
+            try (ContentProvider settings = device.createSettingsProvider()) {
+                if (options.getShowTouches()) {
+                    String oldValue = settings.getAndPutValue(ContentProvider.TABLE_SYSTEM, "show_touches", "1");
+                    // If "show touches" was disabled, it must be disabled back on clean up
+                    mustDisableShowTouchesOnCleanUp = !"1".equals(oldValue);
+                }
+
+                if (options.getStayAwake()) {
+                    int stayOn = BatteryManager.BATTERY_PLUGGED_AC | BatteryManager.BATTERY_PLUGGED_USB | BatteryManager.BATTERY_PLUGGED_WIRELESS;
+                    String oldValue = settings.getAndPutValue(ContentProvider.TABLE_GLOBAL, "stay_on_while_plugged_in", String.valueOf(stayOn));
+                    try {
+                        restoreStayOn = Integer.parseInt(oldValue);
+                        if (restoreStayOn == stayOn) {
+                            // No need to restore
+                            restoreStayOn = -1;
+                        }
+                    } catch (NumberFormatException e) {
+                        restoreStayOn = 0;
+                    }
+                }
+            }
+        }
+
+        CleanUp.configure(mustDisableShowTouchesOnCleanUp, restoreStayOn);
+
         boolean tunnelForward = options.isTunnelForward();
         try (DesktopConnection connection = DesktopConnection.open(device, tunnelForward)) {
             ScreenEncoder screenEncoder = new ScreenEncoder(options.getSendFrameMeta(), options.getBitRate(), options.getMaxFps());
@@ -79,8 +109,9 @@ public final class Server {
                     "The server version (" + BuildConfig.VERSION_NAME + ") does not match the client " + "(" + clientVersion + ")");
         }
 
-        if (args.length != 10) {
-            throw new IllegalArgumentException("Expecting 10 parameters");
+        final int expectedParameters = 12;
+        if (args.length != expectedParameters) {
+            throw new IllegalArgumentException("Expecting " + expectedParameters + " parameters");
         }
 
         Options options = new Options();
@@ -113,6 +144,12 @@ public final class Server {
         int displayId = Integer.parseInt(args[9]);
         options.setDisplayId(displayId);
 
+        boolean showTouches = Boolean.parseBoolean(args[10]);
+        options.setShowTouches(showTouches);
+
+        boolean stayAwake = Boolean.parseBoolean(args[11]);
+        options.setStayAwake(stayAwake);
+
         return options;
     }
 
@@ -132,14 +169,6 @@ public final class Server {
         return new Rect(x, y, x + width, y + height);
     }
 
-    private static void unlinkSelf() {
-        try {
-            new File(SERVER_PATH).delete();
-        } catch (Exception e) {
-            Ln.e("Could not unlink server", e);
-        }
-    }
-
     private static void suggestFix(Throwable e) {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
             if (e instanceof MediaCodec.CodecException) {
@@ -172,7 +201,6 @@ public final class Server {
             }
         });
 
-        unlinkSelf();
         Options options = createOptions(args);
         scrcpy(options);
     }

server/src/main/java/com/genymobile/scrcpy/wrappers/ActivityManager.java

@@ -0,0 +1,87 @@
+package com.genymobile.scrcpy.wrappers;
+
+import com.genymobile.scrcpy.Ln;
+
+import android.os.Binder;
+import android.os.IBinder;
+import android.os.IInterface;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class ActivityManager {
+
+    private final IInterface manager;
+    private Method getContentProviderExternalMethod;
+    private boolean getContentProviderExternalMethodLegacy;
+    private Method removeContentProviderExternalMethod;
+
+    public ActivityManager(IInterface manager) {
+        this.manager = manager;
+    }
+
+    private Method getGetContentProviderExternalMethod() throws NoSuchMethodException {
+        if (getContentProviderExternalMethod == null) {
+            try {
+                getContentProviderExternalMethod = manager.getClass()
+                        .getMethod("getContentProviderExternal", String.class, int.class, IBinder.class, String.class);
+            } catch (NoSuchMethodException e) {
+                // old version
+                getContentProviderExternalMethod = manager.getClass().getMethod("getContentProviderExternal", String.class, int.class, IBinder.class);
+                getContentProviderExternalMethodLegacy = true;
+            }
+        }
+        return getContentProviderExternalMethod;
+    }
+
+    private Method getRemoveContentProviderExternalMethod() throws NoSuchMethodException {
+        if (removeContentProviderExternalMethod == null) {
+            removeContentProviderExternalMethod = manager.getClass().getMethod("removeContentProviderExternal", String.class, IBinder.class);
+        }
+        return removeContentProviderExternalMethod;
+    }
+
+    private ContentProvider getContentProviderExternal(String name, IBinder token) {
+        try {
+            Method method = getGetContentProviderExternalMethod();
+            Object[] args;
+            if (!getContentProviderExternalMethodLegacy) {
+                // new version
+                args = new Object[]{name, ServiceManager.USER_ID, token, null};
+            } else {
+                // old version
+                args = new Object[]{name, ServiceManager.USER_ID, token};
+            }
+            // ContentProviderHolder providerHolder = getContentProviderExternal(...);
+            Object providerHolder = method.invoke(manager, args);
+            if (providerHolder == null) {
+                return null;
+            }
+            // IContentProvider provider = providerHolder.provider;
+            Field providerField = providerHolder.getClass().getDeclaredField("provider");
+            providerField.setAccessible(true);
+            Object provider = providerField.get(providerHolder);
+            if (provider == null) {
+                return null;
+            }
+            return new ContentProvider(this, provider, name, token);
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException | NoSuchFieldException e) {
+            Ln.e("Could not invoke method", e);
+            return null;
+        }
+    }
+
+    void removeContentProviderExternal(String name, IBinder token) {
+        try {
+            Method method = getRemoveContentProviderExternalMethod();
+            method.invoke(manager, name, token);
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
+            Ln.e("Could not invoke method", e);
+        }
+    }
+
+    public ContentProvider createSettingsProvider() {
+        return getContentProviderExternal("settings", new Binder());
+    }
+}

server/src/main/java/com/genymobile/scrcpy/wrappers/ClipboardManager.java

@@ -10,10 +10,6 @@ import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 
 public class ClipboardManager {
-
-    private static final String PACKAGE_NAME = "com.android.shell";
-    private static final int USER_ID = 0;
-
     private final IInterface manager;
     private Method getPrimaryClipMethod;
     private Method setPrimaryClipMethod;
@@ -46,17 +42,17 @@ public class ClipboardManager {
 
     private static ClipData getPrimaryClip(Method method, IInterface manager) throws InvocationTargetException, IllegalAccessException {
         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
-            return (ClipData) method.invoke(manager, PACKAGE_NAME);
+            return (ClipData) method.invoke(manager, ServiceManager.PACKAGE_NAME);
         }
-        return (ClipData) method.invoke(manager, PACKAGE_NAME, USER_ID);
+        return (ClipData) method.invoke(manager, ServiceManager.PACKAGE_NAME, ServiceManager.USER_ID);
     }
 
     private static void setPrimaryClip(Method method, IInterface manager, ClipData clipData)
             throws InvocationTargetException, IllegalAccessException {
         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
-            method.invoke(manager, clipData, PACKAGE_NAME);
+            method.invoke(manager, clipData, ServiceManager.PACKAGE_NAME);
         } else {
-            method.invoke(manager, clipData, PACKAGE_NAME, USER_ID);
+            method.invoke(manager, clipData, ServiceManager.PACKAGE_NAME, ServiceManager.USER_ID);
         }
     }
 

server/src/main/java/com/genymobile/scrcpy/wrappers/ContentProvider.java

@@ -0,0 +1,132 @@
+package com.genymobile.scrcpy.wrappers;
+
+import com.genymobile.scrcpy.Ln;
+
+import android.os.Bundle;
+import android.os.IBinder;
+
+import java.io.Closeable;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class ContentProvider implements Closeable {
+
+    public static final String TABLE_SYSTEM = "system";
+    public static final String TABLE_SECURE = "secure";
+    public static final String TABLE_GLOBAL = "global";
+
+    // See android/providerHolder/Settings.java
+    private static final String CALL_METHOD_GET_SYSTEM = "GET_system";
+    private static final String CALL_METHOD_GET_SECURE = "GET_secure";
+    private static final String CALL_METHOD_GET_GLOBAL = "GET_global";
+
+    private static final String CALL_METHOD_PUT_SYSTEM = "PUT_system";
+    private static final String CALL_METHOD_PUT_SECURE = "PUT_secure";
+    private static final String CALL_METHOD_PUT_GLOBAL = "PUT_global";
+
+    private static final String CALL_METHOD_USER_KEY = "_user";
+
+    private static final String NAME_VALUE_TABLE_VALUE = "value";
+
+    private final ActivityManager manager;
+    // android.content.IContentProvider
+    private final Object provider;
+    private final String name;
+    private final IBinder token;
+
+    private Method callMethod;
+    private boolean callMethodLegacy;
+
+    ContentProvider(ActivityManager manager, Object provider, String name, IBinder token) {
+        this.manager = manager;
+        this.provider = provider;
+        this.name = name;
+        this.token = token;
+    }
+
+    private Method getCallMethod() throws NoSuchMethodException {
+        if (callMethod == null) {
+            try {
+                callMethod = provider.getClass().getMethod("call", String.class, String.class, String.class, String.class, Bundle.class);
+            } catch (NoSuchMethodException e) {
+                // old version
+                callMethod = provider.getClass().getMethod("call", String.class, String.class, String.class, Bundle.class);
+                callMethodLegacy = true;
+            }
+        }
+        return callMethod;
+    }
+
+    private Bundle call(String callMethod, String arg, Bundle extras) {
+        try {
+            Method method = getCallMethod();
+            Object[] args;
+            if (!callMethodLegacy) {
+                args = new Object[]{ServiceManager.PACKAGE_NAME, "settings", callMethod, arg, extras};
+            } else {
+                args = new Object[]{ServiceManager.PACKAGE_NAME, callMethod, arg, extras};
+            }
+            return (Bundle) method.invoke(provider, args);
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
+            Ln.e("Could not invoke method", e);
+            return null;
+        }
+    }
+
+    public void close() {
+        manager.removeContentProviderExternal(name, token);
+    }
+
+    private static String getGetMethod(String table) {
+        switch (table) {
+            case TABLE_SECURE:
+                return CALL_METHOD_GET_SECURE;
+            case TABLE_SYSTEM:
+                return CALL_METHOD_GET_SYSTEM;
+            case TABLE_GLOBAL:
+                return CALL_METHOD_GET_GLOBAL;
+            default:
+                throw new IllegalArgumentException("Invalid table: " + table);
+        }
+    }
+
+    private static String getPutMethod(String table) {
+        switch (table) {
+            case TABLE_SECURE:
+                return CALL_METHOD_PUT_SECURE;
+            case TABLE_SYSTEM:
+                return CALL_METHOD_PUT_SYSTEM;
+            case TABLE_GLOBAL:
+                return CALL_METHOD_PUT_GLOBAL;
+            default:
+                throw new IllegalArgumentException("Invalid table: " + table);
+        }
+    }
+
+    public String getValue(String table, String key) {
+        String method = getGetMethod(table);
+        Bundle arg = new Bundle();
+        arg.putInt(CALL_METHOD_USER_KEY, ServiceManager.USER_ID);
+        Bundle bundle = call(method, key, arg);
+        if (bundle == null) {
+            return null;
+        }
+        return bundle.getString("value");
+    }
+
+    public void putValue(String table, String key, String value) {
+        String method = getPutMethod(table);
+        Bundle arg = new Bundle();
+        arg.putInt(CALL_METHOD_USER_KEY, ServiceManager.USER_ID);
+        arg.putString(NAME_VALUE_TABLE_VALUE, value);
+        call(method, key, arg);
+    }
+
+    public String getAndPutValue(String table, String key, String value) {
+        String oldValue = getValue(table, key);
+        if (!value.equals(oldValue)) {
+            putValue(table, key, value);
+        }
+        return oldValue;
+    }
+}

server/src/main/java/com/genymobile/scrcpy/wrappers/ServiceManager.java

@@ -8,6 +8,10 @@ import java.lang.reflect.Method;
 
 @SuppressLint("PrivateApi,DiscouragedPrivateApi")
 public final class ServiceManager {
+
+    public static final String PACKAGE_NAME = "com.android.shell";
+    public static final int USER_ID = 0;
+
     private final Method getServiceMethod;
 
     private WindowManager windowManager;
@@ -16,6 +20,7 @@ public final class ServiceManager {
     private PowerManager powerManager;
     private StatusBarManager statusBarManager;
     private ClipboardManager clipboardManager;
+    private ActivityManager activityManager;
 
     public ServiceManager() {
         try {
@@ -76,4 +81,21 @@ public final class ServiceManager {
         }
         return clipboardManager;
     }
+
+    public ActivityManager getActivityManager() {
+        if (activityManager == null) {
+            try {
+                // On old Android versions, the ActivityManager is not exposed via AIDL,
+                // so use ActivityManagerNative.getDefault()
+                Class<?> cls = Class.forName("android.app.ActivityManagerNative");
+                Method getDefaultMethod = cls.getDeclaredMethod("getDefault");
+                IInterface am = (IInterface) getDefaultMethod.invoke(null);
+                activityManager = new ActivityManager(am);
+            } catch (Exception e) {
+                throw new AssertionError(e);
+            }
+        }
+
+        return activityManager;
+    }
 }