wip-zoom-range

Replace "fps=[15, 30, 60]" with "fps={15, 30, 60}".

The default toString() implementation for a SortedSet uses '[]', but
it is more correct to use '{}' to denote a set.

app/data/bash-completion/scrcpy

@@ -18,6 +18,7 @@ _scrcpy() {
         --camera-fps=
         --camera-high-speed
         --camera-size=
+        --camera-torch
         --capture-orientation=
         --crop=
         -d --select-usb
@@ -197,6 +198,7 @@ _scrcpy() {
         |--camera-id \
         |--camera-fps \
         |--camera-size \
+        |--camera-torch \
         |--crop \
         |--display-id \
         |--max-fps \

app/data/zsh-completion/_scrcpy

@@ -25,6 +25,7 @@ arguments=(
     '--camera-facing=[Select the device camera by its facing direction]:facing:(front back external)'
     '--camera-fps=[Specify the camera capture frame rate]'
     '--camera-size=[Specify an explicit camera capture size]'
+    '--camera-torch[Turn on the camera torch when the camera starts]'
     '--capture-orientation=[Set the capture video orientation]:orientation:(0 90 180 270 flip0 flip90 flip180 flip270 @0 @90 @180 @270 @flip0 @flip90 @flip180 @flip270)'
     '--crop=[\[width\:height\:x\:y\] Crop the device screen on the server]'
     {-d,--select-usb}'[Use USB device]'

app/deps/_init

@@ -1,10 +1,9 @@
-#!/usr/bin/env bash
 # This file is intended to be sourced by other scripts, not executed
 
 process_args() {
     if [[ $# != 3 ]]
     then
-        # <host>: win32 or win64
+        # <host>: linux, macos, win32 or win64
         # <build_type>: native or cross
         # <link_type>: static or shared
         echo "Syntax: $0 <host> <build_type> <link_type>" >&2
@@ -12,8 +11,8 @@ process_args() {
     fi
 
     HOST="$1"
-    BUILD_TYPE="$2" # native or cross
-    LINK_TYPE="$3" # static or shared
+    BUILD_TYPE="$2"
+    LINK_TYPE="$3"
     DIRNAME="$HOST-$BUILD_TYPE-$LINK_TYPE"
 
     if [[ "$BUILD_TYPE" != native && "$BUILD_TYPE" != cross ]]

app/deps/adb_linux.sh

@@ -1,21 +1,21 @@
 #!/usr/bin/env bash
 set -ex
-DEPS_DIR=$(dirname ${BASH_SOURCE[0]})
-cd "$DEPS_DIR"
-. common
+. $(dirname ${BASH_SOURCE[0]})/_init "$@"
 
 VERSION=36.0.0
-FILENAME=platform-tools_r$VERSION-linux.zip
-PROJECT_DIR=platform-tools-$VERSION-linux
+URL="https://dl.google.com/android/repository/platform-tools_r$VERSION-linux.zip"
 SHA256SUM=0ead642c943ffe79701fccca8f5f1c69c4ce4f43df2eefee553f6ccb27cbfbe8
 
+PROJECT_DIR="platform-tools-$VERSION-linux"
+FILENAME="$PROJECT_DIR.zip"
+
 cd "$SOURCES_DIR"
 
 if [[ -d "$PROJECT_DIR" ]]
 then
     echo "$PWD/$PROJECT_DIR" found
 else
-    get_file "https://dl.google.com/android/repository/$FILENAME" "$FILENAME" "$SHA256SUM"
+    get_file "$URL" "$FILENAME" "$SHA256SUM"
     mkdir -p "$PROJECT_DIR"
     cd "$PROJECT_DIR"
     ZIP_PREFIX=platform-tools

app/deps/adb_macos.sh

@@ -1,21 +1,21 @@
 #!/usr/bin/env bash
 set -ex
-DEPS_DIR=$(dirname ${BASH_SOURCE[0]})
-cd "$DEPS_DIR"
-. common
+. $(dirname ${BASH_SOURCE[0]})/_init "$@"
 
 VERSION=36.0.0
-FILENAME=platform-tools_r$VERSION-darwin.zip
-PROJECT_DIR=platform-tools-$VERSION-darwin
+URL="https://dl.google.com/android/repository/platform-tools_r$VERSION-darwin.zip"
 SHA256SUM=d3e9fa1df3345cf728586908426615a60863d2632f73f1ce14f0f1349ef000fd
 
+PROJECT_DIR="platform-tools-$VERSION-darwin"
+FILENAME="$PROJECT_DIR.zip"
+
 cd "$SOURCES_DIR"
 
 if [[ -d "$PROJECT_DIR" ]]
 then
     echo "$PWD/$PROJECT_DIR" found
 else
-    get_file "https://dl.google.com/android/repository/$FILENAME" "$FILENAME" "$SHA256SUM"
+    get_file "$URL" "$FILENAME" "$SHA256SUM"
     mkdir -p "$PROJECT_DIR"
     cd "$PROJECT_DIR"
     ZIP_PREFIX=platform-tools

app/deps/adb_windows.sh

@@ -1,21 +1,21 @@
 #!/usr/bin/env bash
 set -ex
-DEPS_DIR=$(dirname ${BASH_SOURCE[0]})
-cd "$DEPS_DIR"
-. common
+. $(dirname ${BASH_SOURCE[0]})/_init "$@"
 
 VERSION=36.0.0
-FILENAME=platform-tools_r$VERSION-win.zip
-PROJECT_DIR=platform-tools-$VERSION-windows
+URL="https://dl.google.com/android/repository/platform-tools_r$VERSION-win.zip"
 SHA256SUM=12c2841f354e92a0eb2fd7bf6f0f9bf8538abce7bd6b060ac8349d6f6a61107c
 
+PROJECT_DIR="platform-tools-$VERSION-windows"
+FILENAME="$PROJECT_DIR.zip"
+
 cd "$SOURCES_DIR"
 
 if [[ -d "$PROJECT_DIR" ]]
 then
     echo "$PWD/$PROJECT_DIR" found
 else
-    get_file "https://dl.google.com/android/repository/$FILENAME" "$FILENAME" "$SHA256SUM"
+    get_file "$URL" "$FILENAME" "$SHA256SUM"
     mkdir -p "$PROJECT_DIR"
     cd "$PROJECT_DIR"
     ZIP_PREFIX=platform-tools

app/deps/dav1d.sh

@@ -1,22 +1,22 @@
 #!/usr/bin/env bash
 set -ex
-DEPS_DIR=$(dirname ${BASH_SOURCE[0]})
-cd "$DEPS_DIR"
-. common
+. $(dirname ${BASH_SOURCE[0]})/_init
 process_args "$@"
 
 VERSION=1.5.0
-FILENAME=dav1d-$VERSION.tar.gz
-PROJECT_DIR=dav1d-$VERSION
+URL="https://code.videolan.org/videolan/dav1d/-/archive/$VERSION/dav1d-$VERSION.tar.gz"
 SHA256SUM=78b15d9954b513ea92d27f39362535ded2243e1b0924fde39f37a31ebed5f76b
 
+PROJECT_DIR="dav1d-$VERSION"
+FILENAME="$PROJECT_DIR.tar.gz"
+
 cd "$SOURCES_DIR"
 
 if [[ -d "$PROJECT_DIR" ]]
 then
     echo "$PWD/$PROJECT_DIR" found
 else
-    get_file "https://code.videolan.org/videolan/dav1d/-/archive/$VERSION/$FILENAME" "$FILENAME" "$SHA256SUM"
+    get_file "$URL" "$FILENAME" "$SHA256SUM"
     tar xf "$FILENAME"  # First level directory is "$PROJECT_DIR"
 fi
 

app/deps/ffmpeg.sh

@@ -1,22 +1,22 @@
 #!/usr/bin/env bash
 set -ex
-DEPS_DIR=$(dirname ${BASH_SOURCE[0]})
-cd "$DEPS_DIR"
-. common
+. $(dirname ${BASH_SOURCE[0]})/_init
 process_args "$@"
 
 VERSION=7.1.1
-FILENAME=ffmpeg-$VERSION.tar.xz
-PROJECT_DIR=ffmpeg-$VERSION
+URL="https://ffmpeg.org/releases/ffmpeg-$VERSION.tar.xz"
 SHA256SUM=733984395e0dbbe5c046abda2dc49a5544e7e0e1e2366bba849222ae9e3a03b1
 
+PROJECT_DIR="ffmpeg-$VERSION"
+FILENAME="$PROJECT_DIR.tar.xz"
+
 cd "$SOURCES_DIR"
 
 if [[ -d "$PROJECT_DIR" ]]
 then
     echo "$PWD/$PROJECT_DIR" found
 else
-    get_file "https://ffmpeg.org/releases/$FILENAME" "$FILENAME" "$SHA256SUM"
+    get_file "$URL" "$FILENAME" "$SHA256SUM"
     tar xf "$FILENAME"  # First level directory is "$PROJECT_DIR"
 fi
 

app/deps/libusb.sh

@@ -1,22 +1,22 @@
 #!/usr/bin/env bash
 set -ex
-DEPS_DIR=$(dirname ${BASH_SOURCE[0]})
-cd "$DEPS_DIR"
-. common
+. $(dirname ${BASH_SOURCE[0]})/_init
 process_args "$@"
 
 VERSION=1.0.29
-FILENAME=libusb-$VERSION.tar.gz
-PROJECT_DIR=libusb-$VERSION
+URL="https://github.com/libusb/libusb/archive/refs/tags/v$VERSION.tar.gz"
 SHA256SUM=7c2dd39c0b2589236e48c93247c986ae272e27570942b4163cb00a060fcf1b74
 
+PROJECT_DIR="libusb-$VERSION"
+FILENAME="$PROJECT_DIR.tar.gz"
+
 cd "$SOURCES_DIR"
 
 if [[ -d "$PROJECT_DIR" ]]
 then
     echo "$PWD/$PROJECT_DIR" found
 else
-    get_file "https://github.com/libusb/libusb/archive/refs/tags/v$VERSION.tar.gz" "$FILENAME" "$SHA256SUM"
+    get_file "$URL" "$FILENAME" "$SHA256SUM"
     tar xf "$FILENAME"  # First level directory is "$PROJECT_DIR"
 fi
 

app/deps/sdl.sh

@@ -1,23 +1,24 @@
 #!/usr/bin/env bash
 set -ex
-DEPS_DIR=$(dirname ${BASH_SOURCE[0]})
-cd "$DEPS_DIR"
-. common
+. $(dirname ${BASH_SOURCE[0]})/_init
 process_args "$@"
 
 VERSION=3.2.18
-FILENAME=SDL-$VERSION.tar.gz
-PROJECT_DIR=SDL-release-$VERSION
+URL="https://github.com/libsdl-org/SDL/archive/refs/tags/release-$VERSION.tar.gz"
 SHA256SUM=51539fa13e546bc50c632beed3f34257de2baa38a4c642048de56377903b4265
 
+PROJECT_DIR="sdl-$VERSION"
+FILENAME="$PROJECT_DIR.tar.gz"
+
 cd "$SOURCES_DIR"
 
 if [[ -d "$PROJECT_DIR" ]]
 then
     echo "$PWD/$PROJECT_DIR" found
 else
-    get_file "https://github.com/libsdl-org/SDL/archive/refs/tags/release-$VERSION.tar.gz" "$FILENAME" "$SHA256SUM"
-    tar xf "$FILENAME"  # First level directory is "$PROJECT_DIR"
+    get_file "$URL" "$FILENAME" "$SHA256SUM"
+    tar xf "$FILENAME"  # First level directory is "SDL-release-$VERSION"
+    mv "SDL-release-$VERSION" "$PROJECT_DIR"
 fi
 
 mkdir -p "$BUILD_DIR/$PROJECT_DIR"

app/meson.build

@@ -57,13 +57,13 @@ src = [
     'src/util/process.c',
     'src/util/process_intr.c',
     'src/util/rand.c',
+    'src/util/sdl.c',
     'src/util/strbuf.c',
     'src/util/str.c',
     'src/util/term.c',
     'src/util/thread.c',
     'src/util/tick.c',
     'src/util/timeout.c',
-    'src/util/window.c',
 ]
 
 conf = configuration_data()

app/scrcpy.1

@@ -131,6 +131,10 @@ The available camera ids can be listed by \fB\-\-list\-cameras\fR.
 .BI "\-\-camera\-size " width\fRx\fIheight
 Specify an explicit camera capture size.
 
+.TP
+.BI \-\-camera\-torch
+Turn on the camera torch when the camera starts.
+
 .TP
 .BI "\-\-capture\-orientation " value
 Possible values are 0, 90, 180, 270, flip0, flip90, flip180 and flip270, possibly prefixed by '@'.
@@ -815,6 +819,14 @@ Install APK from computer
 .B Drag & drop non-APK file
 Push file to device (see \fB\-\-push\-target\fR)
 
+.TP
+.B MOD+l
+Turn on the camera torch (camera mode only)
+
+.TP
+.B MOD+Shift+l
+Turn off the camera torch (camera mode only)
+
 
 .SH Environment variables
 

app/src/cli.c

@@ -114,6 +114,7 @@ enum {
     OPT_NO_VD_SYSTEM_DECORATIONS,
     OPT_NO_VD_DESTROY_CONTENT,
     OPT_DISPLAY_IME_POLICY,
+    OPT_CAMERA_TORCH,
 };
 
 struct sc_option {
@@ -313,6 +314,11 @@ static const struct sc_option options[] = {
         .argdesc = "<width>x<height>",
         .text = "Specify an explicit camera capture size.",
     },
+    {
+        .longopt_id = OPT_CAMERA_TORCH,
+        .longopt = "camera-torch",
+        .text = "Turn on the camera torch when the camera starts.",
+    },
     {
         .longopt_id = OPT_CAPTURE_ORIENTATION,
         .longopt = "capture-orientation",
@@ -1207,6 +1213,14 @@ static const struct sc_shortcut shortcuts[] = {
         .shortcuts = { "Drag & drop non-APK file" },
         .text = "Push file to device (see --push-target)",
     },
+    {
+        .shortcuts = { "MOD+l" },
+        .text = "Turn on the camera torch (camera mode only)",
+    },
+    {
+        .shortcuts = { "MOD+Shift+l" },
+        .text = "Turn off the camera torch (camera mode only)",
+    },
 };
 
 static const struct sc_envvar envvars[] = {
@@ -2780,6 +2794,9 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
             case OPT_CAMERA_HIGH_SPEED:
                 opts->camera_high_speed = true;
                 break;
+            case OPT_CAMERA_TORCH:
+                opts->camera_torch = true;
+                break;
             case OPT_NO_WINDOW:
                 opts->window = false;
                 break;
@@ -2928,7 +2945,7 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
     }
 #endif
 
-    if (opts->control) {
+    if (opts->control && opts->video_source == SC_VIDEO_SOURCE_DISPLAY) {
         if (opts->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_AUTO) {
             opts->keyboard_input_mode = otg ? SC_KEYBOARD_INPUT_MODE_AOA
                                             : SC_KEYBOARD_INPUT_MODE_SDK;
@@ -3106,8 +3123,10 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
         }
 
         if (opts->control) {
-            LOGI("Camera video source: control disabled");
-            opts->control = false;
+            // Disable all inputs for camera
+            opts->keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_DISABLED;
+            opts->mouse_input_mode = SC_MOUSE_INPUT_MODE_DISABLED;
+            opts->gamepad_input_mode = SC_GAMEPAD_INPUT_MODE_DISABLED;
         }
     } else if (opts->camera_id
             || opts->camera_ar

app/src/control_msg.c

@@ -182,6 +182,9 @@ sc_control_msg_serialize(const struct sc_control_msg *msg, uint8_t *buf) {
             size_t len = write_string_tiny(&buf[1], msg->start_app.name, 255);
             return 1 + len;
         }
+        case SC_CONTROL_MSG_TYPE_CAMERA_SET_TORCH:
+            buf[1] = msg->camera_set_torch.on ? 1 : 0;
+            return 2;
         case SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL:
         case SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL:
         case SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS:

app/src/control_msg.h

@@ -43,6 +43,7 @@ enum sc_control_msg_type {
     SC_CONTROL_MSG_TYPE_OPEN_HARD_KEYBOARD_SETTINGS,
     SC_CONTROL_MSG_TYPE_START_APP,
     SC_CONTROL_MSG_TYPE_RESET_VIDEO,
+    SC_CONTROL_MSG_TYPE_CAMERA_SET_TORCH,
 };
 
 enum sc_copy_key {
@@ -111,6 +112,9 @@ struct sc_control_msg {
         struct {
             char *name;
         } start_app;
+        struct {
+            bool on;
+        } camera_set_torch;
     };
 };
 

app/src/display.c

@@ -6,6 +6,7 @@
 #include <libavutil/pixfmt.h>
 
 #include "util/log.h"
+#include "util/sdl.h"
 
 static bool
 sc_display_init_novideo_icon(struct sc_display *display,
@@ -374,9 +375,7 @@ sc_display_update_texture(struct sc_display *display, const AVFrame *frame) {
 enum sc_display_result
 sc_display_render(struct sc_display *display, const SDL_Rect *geometry,
                   enum sc_orientation orientation) {
-    bool always_ok = SDL_RenderClear(display->renderer);
-    (void) always_ok;
-    assert(always_ok);
+    sc_sdl_render_clear(display->renderer);
 
     if (display->pending.flags) {
         bool ok = sc_display_apply_pending(display);
@@ -421,8 +420,6 @@ sc_display_render(struct sc_display *display, const SDL_Rect *geometry,
         }
     }
 
-    always_ok = SDL_RenderPresent(display->renderer);
-    assert(always_ok);
-
+    sc_sdl_render_present(display->renderer);
     return SC_DISPLAY_RESULT_OK;
 }

app/src/input_manager.c

@@ -11,6 +11,7 @@
 #include "screen.h"
 #include "shortcut_mod.h"
 #include "util/log.h"
+#include "util/sdl.h"
 
 void
 sc_input_manager_init(struct sc_input_manager *im,
@@ -28,6 +29,7 @@ sc_input_manager_init(struct sc_input_manager *im,
     im->kp = params->kp;
     im->mp = params->mp;
     im->gp = params->gp;
+    im->camera = params->camera;
 
     im->mouse_bindings = params->mouse_bindings;
     im->legacy_paste = params->legacy_paste;
@@ -51,7 +53,7 @@ sc_input_manager_init(struct sc_input_manager *im,
 static void
 send_keycode(struct sc_input_manager *im, enum android_keycode keycode,
              enum sc_action action, const char *name) {
-    assert(im->controller && im->kp);
+    assert(im->controller && im->kp && !im->camera);
 
     // send DOWN event
     struct sc_control_msg msg;
@@ -108,7 +110,7 @@ action_menu(struct sc_input_manager *im, enum sc_action action) {
 static void
 press_back_or_turn_screen_on(struct sc_input_manager *im,
                              enum sc_action action) {
-    assert(im->controller && im->kp);
+    assert(im->controller && im->kp && !im->camera);
 
     struct sc_control_msg msg;
     msg.type = SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON;
@@ -123,7 +125,7 @@ press_back_or_turn_screen_on(struct sc_input_manager *im,
 
 static void
 expand_notification_panel(struct sc_input_manager *im) {
-    assert(im->controller);
+    assert(im->controller && !im->camera);
 
     struct sc_control_msg msg;
     msg.type = SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL;
@@ -135,7 +137,7 @@ expand_notification_panel(struct sc_input_manager *im) {
 
 static void
 expand_settings_panel(struct sc_input_manager *im) {
-    assert(im->controller);
+    assert(im->controller && !im->camera);
 
     struct sc_control_msg msg;
     msg.type = SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL;
@@ -147,7 +149,7 @@ expand_settings_panel(struct sc_input_manager *im) {
 
 static void
 collapse_panels(struct sc_input_manager *im) {
-    assert(im->controller);
+    assert(im->controller && !im->camera);
 
     struct sc_control_msg msg;
     msg.type = SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS;
@@ -159,7 +161,7 @@ collapse_panels(struct sc_input_manager *im) {
 
 static bool
 get_device_clipboard(struct sc_input_manager *im, enum sc_copy_key copy_key) {
-    assert(im->controller && im->kp);
+    assert(im->controller && im->kp && !im->camera);
 
     struct sc_control_msg msg;
     msg.type = SC_CONTROL_MSG_TYPE_GET_CLIPBOARD;
@@ -176,7 +178,7 @@ get_device_clipboard(struct sc_input_manager *im, enum sc_copy_key copy_key) {
 static bool
 set_device_clipboard(struct sc_input_manager *im, bool paste,
                      uint64_t sequence) {
-    assert(im->controller && im->kp);
+    assert(im->controller && im->kp && !im->camera);
 
     char *text = SDL_GetClipboardText();
     if (!text) {
@@ -208,7 +210,7 @@ set_device_clipboard(struct sc_input_manager *im, bool paste,
 
 static void
 set_display_power(struct sc_input_manager *im, bool on) {
-    assert(im->controller);
+    assert(im->controller && !im->camera);
 
     struct sc_control_msg msg;
     msg.type = SC_CONTROL_MSG_TYPE_SET_DISPLAY_POWER;
@@ -235,7 +237,7 @@ switch_fps_counter_state(struct sc_input_manager *im) {
 
 static void
 clipboard_paste(struct sc_input_manager *im) {
-    assert(im->controller && im->kp);
+    assert(im->controller && im->kp && !im->camera);
 
     char *text = SDL_GetClipboardText();
     if (!text) {
@@ -266,7 +268,7 @@ clipboard_paste(struct sc_input_manager *im) {
 
 static void
 rotate_device(struct sc_input_manager *im) {
-    assert(im->controller);
+    assert(im->controller && !im->camera);
 
     struct sc_control_msg msg;
     msg.type = SC_CONTROL_MSG_TYPE_ROTATE_DEVICE;
@@ -278,7 +280,7 @@ rotate_device(struct sc_input_manager *im) {
 
 static void
 open_hard_keyboard_settings(struct sc_input_manager *im) {
-    assert(im->controller);
+    assert(im->controller && !im->camera);
 
     struct sc_control_msg msg;
     msg.type = SC_CONTROL_MSG_TYPE_OPEN_HARD_KEYBOARD_SETTINGS;
@@ -300,6 +302,19 @@ reset_video(struct sc_input_manager *im) {
     }
 }
 
+static void
+camera_set_torch(struct sc_input_manager *im, bool on) {
+    assert(im->controller && im->camera);
+
+    struct sc_control_msg msg;
+    msg.type = SC_CONTROL_MSG_TYPE_CAMERA_SET_TORCH;
+    msg.camera_set_torch.on = on;
+
+    if (!sc_controller_push_msg(im->controller, &msg)) {
+        LOGW("Could not request setting camera torch");
+    }
+}
+
 static void
 apply_orientation_transform(struct sc_input_manager *im,
                             enum sc_orientation transform) {
@@ -312,6 +327,10 @@ 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) {
+        return;
+    }
+
     if (!im->kp->ops->process_text) {
         // The key processor does not support text input
         return;
@@ -369,6 +388,9 @@ inverse_point(struct sc_point point, struct sc_size size,
 static void
 sc_input_manager_process_key(struct sc_input_manager *im,
                              const SDL_KeyboardEvent *event) {
+    // some key events do not interact with the device, so process the event
+    // even if control is disabled
+
     // controller is NULL if --no-control is requested
     bool control = im->controller;
     bool paused = im->screen->paused;
@@ -402,106 +424,36 @@ sc_input_manager_process_key(struct sc_input_manager *im,
     if (is_shortcut) {
         enum sc_action action = down ? SC_ACTION_DOWN : SC_ACTION_UP;
         switch (sdl_keycode) {
-            case SDLK_H:
-                if (im->kp && !shift && !repeat && !paused) {
-                    action_home(im, action);
-                }
-                return;
-            case SDLK_B: // fall-through
-            case SDLK_BACKSPACE:
-                if (im->kp && !shift && !repeat && !paused) {
-                    action_back(im, action);
-                }
-                return;
-            case SDLK_S:
-                if (im->kp && !shift && !repeat && !paused) {
-                    action_app_switch(im, action);
-                }
-                return;
-            case SDLK_M:
-                if (im->kp && !shift && !repeat && !paused) {
-                    action_menu(im, action);
-                }
-                return;
-            case SDLK_P:
-                if (im->kp && !shift && !repeat && !paused) {
-                    action_power(im, action);
-                }
-                return;
-            case SDLK_O:
-                if (control && !repeat && down && !paused) {
-                    bool on = shift;
-                    set_display_power(im, on);
-                }
-                return;
             case SDLK_Z:
                 if (video && down && !repeat) {
                     sc_screen_set_paused(im->screen, !shift);
                 }
                 return;
             case SDLK_DOWN:
-                if (shift) {
-                    if (video && !repeat && down) {
-                        apply_orientation_transform(im,
-                                                    SC_ORIENTATION_FLIP_180);
-                    }
-                } else if (im->kp && !paused) {
-                    // forward repeated events
-                    action_volume_down(im, action);
+                if (video && shift && !repeat && down) {
+                    apply_orientation_transform(im, SC_ORIENTATION_FLIP_180);
                 }
                 return;
             case SDLK_UP:
-                if (shift) {
-                    if (video && !repeat && down) {
-                        apply_orientation_transform(im,
-                                                    SC_ORIENTATION_FLIP_180);
-                    }
-                } else if (im->kp && !paused) {
-                    // forward repeated events
-                    action_volume_up(im, action);
+                if (video && shift && !repeat && down) {
+                    apply_orientation_transform(im, SC_ORIENTATION_FLIP_180);
                 }
                 return;
             case SDLK_LEFT:
                 if (video && !repeat && down) {
                     if (shift) {
-                        apply_orientation_transform(im,
-                                                    SC_ORIENTATION_FLIP_0);
+                        apply_orientation_transform(im, SC_ORIENTATION_FLIP_0);
                     } else {
-                        apply_orientation_transform(im,
-                                                    SC_ORIENTATION_270);
+                        apply_orientation_transform(im, SC_ORIENTATION_270);
                     }
                 }
                 return;
             case SDLK_RIGHT:
                 if (video && !repeat && down) {
                     if (shift) {
-                        apply_orientation_transform(im,
-                                                    SC_ORIENTATION_FLIP_0);
+                        apply_orientation_transform(im, SC_ORIENTATION_FLIP_0);
                     } else {
-                        apply_orientation_transform(im,
-                                                    SC_ORIENTATION_90);
-                    }
-                }
-                return;
-            case SDLK_C:
-                if (im->kp && !shift && !repeat && down && !paused) {
-                    get_device_clipboard(im, SC_COPY_KEY_COPY);
-                }
-                return;
-            case SDLK_X:
-                if (im->kp && !shift && !repeat && down && !paused) {
-                    get_device_clipboard(im, SC_COPY_KEY_CUT);
-                }
-                return;
-            case SDLK_V:
-                if (im->kp && !repeat && down && !paused) {
-                    if (shift || im->legacy_paste) {
-                        // inject the text as input events
-                        clipboard_paste(im);
-                    } else {
-                        // store the text in the device clipboard and paste,
-                        // without requesting an acknowledgment
-                        set_device_clipboard(im, true, SC_SEQUENCE_INVALID);
+                        apply_orientation_transform(im, SC_ORIENTATION_90);
                     }
                 }
                 return;
@@ -525,33 +477,122 @@ sc_input_manager_process_key(struct sc_input_manager *im,
                     switch_fps_counter_state(im);
                 }
                 return;
-            case SDLK_N:
-                if (control && !repeat && down && !paused) {
-                    if (shift) {
-                        collapse_panels(im);
-                    } else if (im->key_repeat == 0) {
-                        expand_notification_panel(im);
-                    } else {
-                        expand_settings_panel(im);
-                    }
-                }
-                return;
-            case SDLK_R:
-                if (control && !repeat && down && !paused) {
-                    if (shift) {
+        }
+
+        // Flatten conditions to avoid additional indentation levels
+        if (control) {
+            // Controls for all sources
+            switch (sdl_keycode) {
+                case SDLK_R:
+                    if (!repeat && shift && down && !paused) {
                         reset_video(im);
-                    } else {
+                    }
+                    return;
+            }
+        }
+
+        if (control && !im->camera) {
+            switch (sdl_keycode) {
+                case SDLK_H:
+                    if (im->kp && !shift && !repeat && !paused) {
+                        action_home(im, action);
+                    }
+                    return;
+                case SDLK_B: // fall-through
+                case SDLK_BACKSPACE:
+                    if (im->kp && !shift && !repeat && !paused) {
+                        action_back(im, action);
+                    }
+                    return;
+                case SDLK_S:
+                    if (im->kp && !shift && !repeat && !paused) {
+                        action_app_switch(im, action);
+                    }
+                    return;
+                case SDLK_M:
+                    if (im->kp && !shift && !repeat && !paused) {
+                        action_menu(im, action);
+                    }
+                    return;
+                case SDLK_P:
+                    if (im->kp && !shift && !repeat && !paused) {
+                        action_power(im, action);
+                    }
+                    return;
+                case SDLK_O:
+                    if (control && !repeat && down && !paused) {
+                        bool on = shift;
+                        set_display_power(im, on);
+                    }
+                    return;
+                case SDLK_DOWN:
+                    if (im->kp && !shift && !paused) {
+                        // forward repeated events
+                        action_volume_down(im, action);
+                    }
+                    return;
+                case SDLK_UP:
+                    if (im->kp && !shift && !paused) {
+                        // forward repeated events
+                        action_volume_up(im, action);
+                    }
+                    return;
+                case SDLK_C:
+                    if (im->kp && !shift && !repeat && down && !paused) {
+                        get_device_clipboard(im, SC_COPY_KEY_COPY);
+                    }
+                    return;
+                case SDLK_X:
+                    if (im->kp && !shift && !repeat && down && !paused) {
+                        get_device_clipboard(im, SC_COPY_KEY_CUT);
+                    }
+                    return;
+                case SDLK_V:
+                    if (im->kp && !repeat && down && !paused) {
+                        if (shift || im->legacy_paste) {
+                            // inject the text as input events
+                            clipboard_paste(im);
+                        } else {
+                            // store the text in the device clipboard and paste,
+                            // without requesting an acknowledgment
+                            set_device_clipboard(im, true, SC_SEQUENCE_INVALID);
+                        }
+                    }
+                    return;
+                case SDLK_N:
+                    if (!repeat && down && !paused) {
+                        if (shift) {
+                            collapse_panels(im);
+                        } else if (im->key_repeat == 0) {
+                            expand_notification_panel(im);
+                        } else {
+                            expand_settings_panel(im);
+                        }
+                    }
+                    return;
+                case SDLK_R:
+                    if (!repeat && !shift && down && !paused) {
                         rotate_device(im);
                     }
-                }
-                return;
-            case SDLK_K:
-                if (control && !shift && !repeat && down && !paused
-                        && im->kp && im->kp->hid) {
-                    // Only if the current keyboard is hid
-                    open_hard_keyboard_settings(im);
-                }
-                return;
+                    return;
+                case SDLK_K:
+                    if (!shift && !repeat && down && !paused
+                            && im->kp && im->kp->hid) {
+                        // Only if the current keyboard is hid
+                        open_hard_keyboard_settings(im);
+                    }
+                    return;
+            }
+        }
+
+        if (control && im->camera) {
+            switch (sdl_keycode) {
+                case SDLK_L:
+                    if (!repeat && down) {
+                        camera_set_torch(im, !shift);
+                    }
+                    return;
+            }
         }
 
         return;
@@ -561,6 +602,8 @@ sc_input_manager_process_key(struct sc_input_manager *im,
         return;
     }
 
+    assert(!im->camera);
+
     uint64_t ack_to_wait = SC_SEQUENCE_INVALID;
     bool is_ctrl_v = ctrl && !shift && sdl_keycode == SDLK_V && down && !repeat;
     if (im->clipboard_autosync && is_ctrl_v) {
@@ -632,6 +675,10 @@ 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) {
+        return;
+    }
+
     if (event->which == SDL_TOUCH_MOUSEID) {
         // simulated from touch events, so it's a duplicate
         return;
@@ -667,20 +714,21 @@ 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) {
+        return;
+    }
+
     if (!im->mp->ops->process_touch) {
         // The mouse processor does not support touch events
         return;
     }
 
-    int dw;
-    int dh;
-    bool always_ok = SDL_GetWindowSizeInPixels(im->screen->window, &dw, &dh);
-    (void) always_ok;
-    assert(always_ok);
+    struct sc_size drawable_size =
+        sc_sdl_get_window_size_in_pixels(im->screen->window);
 
     // SDL touch event coordinates are normalized in the range [0; 1]
-    int32_t x = event->x * dw;
-    int32_t y = event->y * dh;
+    int32_t x = event->x * (int32_t) drawable_size.width;
+    int32_t y = event->y * (int32_t) drawable_size.height;
 
     struct sc_touch_event evt = {
         .position = {
@@ -718,6 +766,13 @@ sc_input_manager_get_binding(const struct sc_mouse_binding_set *bindings,
 static void
 sc_input_manager_process_mouse_button(struct sc_input_manager *im,
                                       const SDL_MouseButtonEvent *event) {
+    // some mouse events do not interact with the device, so process the event
+    // even if control is disabled
+
+    if (im->camera) {
+        return;
+    }
+
     if (event->which == SDL_TOUCH_MOUSEID) {
         // simulated from touch events, so it's a duplicate
         return;
@@ -885,6 +940,10 @@ 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) {
+        return;
+    }
+
     if (!im->mp->ops->process_mouse_scroll) {
         // The mouse processor does not support scroll events
         return;
@@ -909,6 +968,12 @@ sc_input_manager_process_mouse_wheel(struct sc_input_manager *im,
 static void
 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) {
+        return;
+    }
+
     if (event->type == SDL_EVENT_GAMEPAD_ADDED) {
         SDL_Gamepad *gc = SDL_OpenGamepad(event->which);
         if (!gc) {
@@ -950,6 +1015,10 @@ 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) {
+        return;
+    }
+
     enum sc_gamepad_axis axis = sc_gamepad_axis_from_sdl(event->axis);
     if (axis == SC_GAMEPAD_AXIS_UNKNOWN) {
         return;
@@ -966,6 +1035,10 @@ 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) {
+        return;
+    }
+
     enum sc_gamepad_button button = sc_gamepad_button_from_sdl(event->button);
     if (button == SC_GAMEPAD_BUTTON_UNKNOWN) {
         return;
@@ -988,6 +1061,10 @@ 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) {
+        return;
+    }
+
     assert(event->type == SDL_EVENT_DROP_FILE);
     char *file = strdup(event->data);
     if (!file) {
@@ -1010,72 +1087,41 @@ sc_input_manager_process_file(struct sc_input_manager *im,
 void
 sc_input_manager_handle_event(struct sc_input_manager *im,
                               const SDL_Event *event) {
-    bool control = im->controller;
-    bool paused = im->screen->paused;
     switch (event->type) {
         case SDL_EVENT_TEXT_INPUT:
-            if (!im->kp || paused) {
-                break;
-            }
             sc_input_manager_process_text_input(im, &event->text);
             break;
         case SDL_EVENT_KEY_DOWN:
         case SDL_EVENT_KEY_UP:
-            // some key events do not interact with the device, so process the
-            // event even if control is disabled
             sc_input_manager_process_key(im, &event->key);
             break;
         case SDL_EVENT_MOUSE_MOTION:
-            if (!im->mp || paused) {
-                break;
-            }
             sc_input_manager_process_mouse_motion(im, &event->motion);
             break;
         case SDL_EVENT_MOUSE_WHEEL:
-            if (!im->mp || paused) {
-                break;
-            }
             sc_input_manager_process_mouse_wheel(im, &event->wheel);
             break;
         case SDL_EVENT_MOUSE_BUTTON_DOWN:
         case SDL_EVENT_MOUSE_BUTTON_UP:
-            // some mouse events do not interact with the device, so process
-            // the event even if control is disabled
             sc_input_manager_process_mouse_button(im, &event->button);
             break;
         case SDL_EVENT_FINGER_MOTION:
         case SDL_EVENT_FINGER_DOWN:
         case SDL_EVENT_FINGER_UP:
-            if (!im->mp || paused) {
-                break;
-            }
             sc_input_manager_process_touch(im, &event->tfinger);
             break;
         case SDL_EVENT_GAMEPAD_ADDED:
         case SDL_EVENT_GAMEPAD_REMOVED:
-            // Handle device added or removed even if paused
-            if (!im->gp) {
-                break;
-            }
             sc_input_manager_process_gamepad_device(im, &event->gdevice);
             break;
         case SDL_EVENT_GAMEPAD_AXIS_MOTION:
-            if (!im->gp || paused) {
-                break;
-            }
             sc_input_manager_process_gamepad_axis(im, &event->gaxis);
             break;
         case SDL_EVENT_GAMEPAD_BUTTON_DOWN:
         case SDL_EVENT_GAMEPAD_BUTTON_UP:
-            if (!im->gp || paused) {
-                break;
-            }
             sc_input_manager_process_gamepad_button(im, &event->gbutton);
             break;
         case SDL_EVENT_DROP_FILE: {
-            if (!control) {
-                break;
-            }
             sc_input_manager_process_file(im, &event->drop);
         }
     }

app/src/input_manager.h

@@ -24,6 +24,8 @@ struct sc_input_manager {
     struct sc_mouse_processor *mp;
     struct sc_gamepad_processor *gp;
 
+    bool camera;
+
     struct sc_mouse_bindings mouse_bindings;
     bool legacy_paste;
     bool clipboard_autosync;
@@ -53,6 +55,7 @@ struct sc_input_manager_params {
     struct sc_key_processor *kp;
     struct sc_mouse_processor *mp;
     struct sc_gamepad_processor *gp;
+    bool camera;
 
     struct sc_mouse_bindings mouse_bindings;
     bool legacy_paste;

app/src/options.c

@@ -113,6 +113,7 @@ const struct scrcpy_options scrcpy_options_default = {
     .angle = NULL,
     .vd_destroy_content = true,
     .vd_system_decorations = true,
+    .camera_torch = false,
 };
 
 enum sc_orientation

app/src/options.h

@@ -327,6 +327,7 @@ struct scrcpy_options {
     const char *start_app;
     bool vd_destroy_content;
     bool vd_system_decorations;
+    bool camera_torch;
 };
 
 extern const struct scrcpy_options scrcpy_options_default;

app/src/scrcpy.c

@@ -469,6 +469,7 @@ scrcpy(struct scrcpy_options *options) {
         .power_on = options->power_on,
         .kill_adb_on_close = options->kill_adb_on_close,
         .camera_high_speed = options->camera_high_speed,
+        .camera_torch = options->camera_torch,
         .vd_destroy_content = options->vd_destroy_content,
         .vd_system_decorations = options->vd_system_decorations,
         .list = options->list,
@@ -802,6 +803,7 @@ aoa_complete:
 
         struct sc_screen_params screen_params = {
             .video = options->video_playback,
+            .camera = options->video_source == SC_VIDEO_SOURCE_CAMERA,
             .controller = controller,
             .fp = fp,
             .kp = kp,

app/src/screen.c

@@ -8,7 +8,7 @@
 #include "icon.h"
 #include "options.h"
 #include "util/log.h"
-#include "util/window.h"
+#include "util/sdl.h"
 
 #define DISPLAY_MARGINS 96
 
@@ -27,45 +27,13 @@ get_oriented_size(struct sc_size size, enum sc_orientation orientation) {
     return oriented_size;
 }
 
-// get the window size in a struct sc_size
-static struct sc_size
-get_window_size(const struct sc_screen *screen) {
-    int width;
-    int height;
-    bool always_ok = SDL_GetWindowSize(screen->window, &width, &height);
-    (void) always_ok;
-    assert(always_ok);
-
-    struct sc_size size;
-    size.width = width;
-    size.height = height;
-    return size;
-}
-
-static struct sc_point
-get_window_position(const struct sc_screen *screen) {
-    int x;
-    int y;
-    bool always_ok = SDL_GetWindowPosition(screen->window, &x, &y);
-    (void) always_ok;
-    assert(always_ok);
-
-    struct sc_point point;
-    point.x = x;
-    point.y = y;
-    return point;
-}
-
 // set the window size to be applied when fullscreen is disabled
-static void
-set_window_size(struct sc_screen *screen, struct sc_size new_size) {
+static inline void
+assert_not_fullscreen(struct sc_screen *screen) {
+    (void) screen;
     assert(!screen->fullscreen);
     assert(!screen->maximized);
     assert(!screen->minimized);
-    bool always_ok =
-        SDL_SetWindowSize(screen->window, new_size.width, new_size.height);
-    (void) always_ok;
-    assert(always_ok);
 }
 
 // get the preferred display bounds (i.e. the screen bounds with some margins)
@@ -176,15 +144,10 @@ static void
 sc_screen_update_content_rect(struct sc_screen *screen) {
     assert(screen->video);
 
-    int dw;
-    int dh;
-    bool always_ok = SDL_GetWindowSizeInPixels(screen->window, &dw, &dh);
-    (void) always_ok;
-    assert(always_ok);
-
     struct sc_size content_size = screen->content_size;
     // The drawable size is the window size * the HiDPI scale
-    struct sc_size drawable_size = {dw, dh};
+    struct sc_size drawable_size =
+        sc_sdl_get_window_size_in_pixels(screen->window);
 
     SDL_Rect *rect = &screen->rect;
 
@@ -339,6 +302,7 @@ sc_screen_init(struct sc_screen *screen,
     screen->orientation = SC_ORIENTATION_0;
 
     screen->video = params->video;
+    screen->camera = params->camera;
 
     screen->req.x = params->window_x;
     screen->req.y = params->window_y;
@@ -399,7 +363,7 @@ sc_screen_init(struct sc_screen *screen,
 
     // The window will be positioned and sized on first video frame
     screen->window =
-        sc_create_sdl_window(title, x, y, width, height, window_flags);
+        sc_sdl_create_window(title, x, y, width, height, window_flags);
     if (!screen->window) {
         LOGE("Could not create window: %s", SDL_GetError());
         goto error_destroy_fps_counter;
@@ -449,6 +413,7 @@ sc_screen_init(struct sc_screen *screen,
         .kp = params->kp,
         .mp = params->mp,
         .gp = params->gp,
+        .camera = params->camera,
         .mouse_bindings = params->mouse_bindings,
         .legacy_paste = params->legacy_paste,
         .clipboard_autosync = params->clipboard_autosync,
@@ -507,18 +472,18 @@ sc_screen_show_initial_window(struct sc_screen *screen) {
           ? screen->req.x : (int) SDL_WINDOWPOS_CENTERED;
     int y = screen->req.y != SC_WINDOW_POSITION_UNDEFINED
           ? screen->req.y : (int) SDL_WINDOWPOS_CENTERED;
+    struct sc_point position = {
+        .x = x,
+        .y = y,
+    };
 
     struct sc_size window_size =
         get_initial_optimal_size(screen->content_size, screen->req.width,
                                                        screen->req.height);
 
-    set_window_size(screen, window_size);
-
-    bool always_ok;
-    (void) always_ok;
-
-    always_ok = SDL_SetWindowPosition(screen->window, x, y);
-    assert(always_ok);
+    assert_not_fullscreen(screen);
+    sc_sdl_set_window_size(screen->window, window_size);
+    sc_sdl_set_window_position(screen->window, position);
 
     if (screen->req.fullscreen) {
         sc_screen_toggle_fullscreen(screen);
@@ -528,17 +493,13 @@ sc_screen_show_initial_window(struct sc_screen *screen) {
         sc_fps_counter_start(&screen->fps_counter);
     }
 
-    always_ok = SDL_ShowWindow(screen->window);
-    assert(always_ok);
-
+    sc_sdl_show_window(screen->window);
     sc_screen_update_content_rect(screen);
 }
 
 void
 sc_screen_hide_window(struct sc_screen *screen) {
-    bool always_ok = SDL_HideWindow(screen->window);
-    (void) always_ok;
-    assert(always_ok);
+    sc_sdl_hide_window(screen->window);
 }
 
 void
@@ -568,7 +529,7 @@ resize_for_content(struct sc_screen *screen, struct sc_size old_content_size,
                    struct sc_size new_content_size) {
     assert(screen->video);
 
-    struct sc_size window_size = get_window_size(screen);
+    struct sc_size window_size = sc_sdl_get_window_size(screen->window);
     struct sc_size target_size = {
         .width = (uint32_t) window_size.width * new_content_size.width
                 / old_content_size.width,
@@ -576,7 +537,8 @@ resize_for_content(struct sc_screen *screen, struct sc_size old_content_size,
                 / old_content_size.height,
     };
     target_size = get_optimal_size(target_size, new_content_size, true);
-    set_window_size(screen, target_size);
+    assert_not_fullscreen(screen);
+    sc_sdl_set_window_size(screen->window, target_size);
 }
 
 static void
@@ -772,8 +734,8 @@ sc_screen_resize_to_fit(struct sc_screen *screen) {
         return;
     }
 
-    struct sc_point point = get_window_position(screen);
-    struct sc_size window_size = get_window_size(screen);
+    struct sc_point point = sc_sdl_get_window_position(screen->window);
+    struct sc_size window_size = sc_sdl_get_window_size(screen->window);
 
     struct sc_size optimal_size =
         get_optimal_size(window_size, screen->content_size, false);
@@ -781,19 +743,14 @@ sc_screen_resize_to_fit(struct sc_screen *screen) {
     // Center the window related to the device screen
     assert(optimal_size.width <= window_size.width);
     assert(optimal_size.height <= window_size.height);
-    uint32_t new_x = point.x + (window_size.width - optimal_size.width) / 2;
-    uint32_t new_y = point.y + (window_size.height - optimal_size.height) / 2;
 
-    bool always_ok;
-    (void) always_ok;
-
-    always_ok = SDL_SetWindowSize(screen->window, optimal_size.width,
-                                                  optimal_size.height);
-    assert(always_ok);
-
-    always_ok = SDL_SetWindowPosition(screen->window, new_x, new_y);
-    assert(always_ok);
+    struct sc_point new_position = {
+        .x = point.x + (window_size.width - optimal_size.width) / 2,
+        .y = point.y + (window_size.height - optimal_size.height) / 2,
+    };
 
+    sc_sdl_set_window_size(screen->window, optimal_size);
+    sc_sdl_set_window_position(screen->window, new_position);
     LOGD("Resized to optimal size: %ux%u", optimal_size.width,
                                            optimal_size.height);
 }
@@ -806,20 +763,13 @@ sc_screen_resize_to_pixel_perfect(struct sc_screen *screen) {
         return;
     }
 
-    bool always_ok;
-    (void) always_ok;
-
     if (screen->maximized) {
-        always_ok = SDL_RestoreWindow(screen->window);
-        assert(always_ok);
+        sc_sdl_restore_window(screen->window);
         screen->maximized = false;
     }
 
     struct sc_size content_size = screen->content_size;
-    always_ok = SDL_SetWindowSize(screen->window, content_size.width,
-                                                  content_size.height);
-    assert(always_ok);
-
+    sc_sdl_set_window_size(screen->window, content_size);
     LOGD("Resized to pixel-perfect: %ux%u", content_size.width,
                                             content_size.height);
 }
@@ -948,16 +898,16 @@ sc_screen_convert_window_to_frame_coords(struct sc_screen *screen,
 
 void
 sc_screen_hidpi_scale_coords(struct sc_screen *screen, int32_t *x, int32_t *y) {
-    bool always_ok;
-    (void) always_ok;
-
     // take the HiDPI scaling (dw/ww and dh/wh) into account
-    int ww, wh, dw, dh;
-    always_ok = SDL_GetWindowSize(screen->window, &ww, &wh);
-    assert(always_ok);
 
-    always_ok = SDL_GetWindowSizeInPixels(screen->window, &dw, &dh);
-    assert(always_ok);
+    struct sc_size window_size = sc_sdl_get_window_size(screen->window);
+    int64_t ww = window_size.width;
+    int64_t wh = window_size.height;
+
+    struct sc_size drawable_size =
+        sc_sdl_get_window_size_in_pixels(screen->window);
+    int64_t dw = drawable_size.width;
+    int64_t dh = drawable_size.height;
 
     // scale for HiDPI (64 bits for intermediate multiplications)
     *x = (int64_t) *x * dw / ww;

app/src/screen.h

@@ -30,6 +30,7 @@ struct sc_screen {
 #endif
 
     bool video;
+    bool camera;
 
     struct sc_display display;
     struct sc_input_manager im;
@@ -74,6 +75,7 @@ struct sc_screen {
 
 struct sc_screen_params {
     bool video;
+    bool camera;
 
     struct sc_controller *controller;
     struct sc_file_pusher *fp;

app/src/server.c

@@ -357,6 +357,9 @@ execute_server(struct sc_server *server,
     if (params->camera_high_speed) {
         ADD_PARAM("camera_high_speed=true");
     }
+    if (params->camera_torch) {
+        ADD_PARAM("camera_torch=true");
+    }
     if (params->show_touches) {
         ADD_PARAM("show_touches=true");
     }

app/src/server.h

@@ -68,6 +68,7 @@ struct sc_server_params {
     bool power_on;
     bool kill_adb_on_close;
     bool camera_high_speed;
+    bool camera_torch;
     bool vd_destroy_content;
     bool vd_system_decorations;
     uint8_t list;

app/src/usb/screen_otg.c

@@ -7,14 +7,11 @@
 #include "options.h"
 #include "util/acksync.h"
 #include "util/log.h"
-#include "util/window.h"
+#include "util/sdl.h"
 
 static void
 sc_screen_otg_render(struct sc_screen_otg *screen) {
-    bool always_ok = SDL_RenderClear(screen->renderer);
-    (void) always_ok;
-    assert(always_ok);
-
+    sc_sdl_render_clear(screen->renderer);
     if (screen->texture) {
         bool ok =
             SDL_RenderTexture(screen->renderer, screen->texture, NULL, NULL);
@@ -22,9 +19,7 @@ sc_screen_otg_render(struct sc_screen_otg *screen) {
             LOGW("Could not render texture: %s", SDL_GetError());
         }
     }
-
-    always_ok = SDL_RenderPresent(screen->renderer);
-    assert(always_ok);
+    sc_sdl_render_present(screen->renderer);
 }
 
 bool
@@ -53,7 +48,7 @@ sc_screen_otg_init(struct sc_screen_otg *screen,
     }
 
     screen->window =
-        sc_create_sdl_window(title, x, y, width, height, window_flags);
+        sc_sdl_create_window(title, x, y, width, height, window_flags);
     if (!screen->window) {
         LOGE("Could not create window: %s", SDL_GetError());
         return false;

app/src/util/sdl.c

@@ -0,0 +1,158 @@
+#include "sdl.h"
+
+#include <assert.h>
+#include <stdlib.h>
+
+#include "util/log.h"
+
+SDL_Window *
+sc_sdl_create_window(const char *title, int64_t x, int64_t y, int64_t width,
+                     int64_t height, int64_t flags) {
+    SDL_Window *window = NULL;
+
+    SDL_PropertiesID props = SDL_CreateProperties();
+    if (!props) {
+        return NULL;
+    }
+
+    bool ok =
+        SDL_SetStringProperty(props, SDL_PROP_WINDOW_CREATE_TITLE_STRING,
+                              title);
+    ok &= SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_X_NUMBER, x);
+    ok &= SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_Y_NUMBER, y);
+    ok &= SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_WIDTH_NUMBER,
+                                width);
+    ok &= SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_HEIGHT_NUMBER,
+                                height);
+    ok &= SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_FLAGS_NUMBER,
+                                flags);
+
+    if (!ok) {
+        SDL_DestroyProperties(props);
+        return NULL;
+    }
+
+    window = SDL_CreateWindowWithProperties(props);
+    SDL_DestroyProperties(props);
+    return window;
+}
+
+struct sc_size
+sc_sdl_get_window_size(SDL_Window *window) {
+    int width;
+    int height;
+    bool ok = SDL_GetWindowSize(window, &width, &height);
+    if (!ok) {
+        LOGE("Could not get window size: %s", SDL_GetError());
+        LOGE("Please report the error");
+        // fatal error
+        abort();
+    }
+
+    struct sc_size size = {
+        .width = width,
+        .height = height,
+    };
+    return size;
+}
+
+struct sc_size
+sc_sdl_get_window_size_in_pixels(SDL_Window *window) {
+    int width;
+    int height;
+    bool ok = SDL_GetWindowSizeInPixels(window, &width, &height);
+    if (!ok) {
+        LOGE("Could not get window size: %s", SDL_GetError());
+        LOGE("Please report the error");
+        // fatal error
+        abort();
+    }
+
+    struct sc_size size = {
+        .width = width,
+        .height = height,
+    };
+    return size;
+}
+
+void
+sc_sdl_set_window_size(SDL_Window *window, struct sc_size size) {
+    bool ok = SDL_SetWindowSize(window, size.width, size.height);
+    if (!ok) {
+        LOGE("Could not set window size: %s", SDL_GetError());
+        assert(!"unexpected");
+    }
+}
+
+struct sc_point
+sc_sdl_get_window_position(SDL_Window *window) {
+    int x;
+    int y;
+    bool ok = SDL_GetWindowPosition(window, &x, &y);
+    if (!ok) {
+        LOGE("Could not get window position: %s", SDL_GetError());
+        LOGE("Please report the error");
+        // fatal error
+        abort();
+    }
+
+    struct sc_point point = {
+        .x = x,
+        .y = y,
+    };
+    return point;
+}
+
+void
+sc_sdl_set_window_position(SDL_Window *window, struct sc_point point) {
+    bool ok = SDL_SetWindowPosition(window, point.x, point.y);
+    if (!ok) {
+        LOGE("Could not set window position: %s", SDL_GetError());
+        assert(!"unexpected");
+    }
+}
+
+void
+sc_sdl_show_window(SDL_Window *window) {
+    bool ok = SDL_ShowWindow(window);
+    if (!ok) {
+        LOGE("Could not show window: %s", SDL_GetError());
+        assert(!"unexpected");
+    }
+}
+
+void
+sc_sdl_hide_window(SDL_Window *window) {
+    bool ok = SDL_HideWindow(window);
+    if (!ok) {
+        LOGE("Could not hide window: %s", SDL_GetError());
+        assert(!"unexpected");
+    }
+}
+
+void
+sc_sdl_restore_window(SDL_Window *window) {
+    bool ok = SDL_RestoreWindow(window);
+    if (!ok) {
+        LOGE("Could not restore window: %s", SDL_GetError());
+        assert(!"unexpected");
+    }
+}
+
+bool
+sc_sdl_render_clear(SDL_Renderer *renderer) {
+    bool ok = SDL_RenderClear(renderer);
+    if (!ok) {
+        LOGW("Could not clear rendering: %s", SDL_GetError());
+    }
+    return ok;
+}
+
+void
+sc_sdl_render_present(SDL_Renderer *renderer) {
+    bool ok = SDL_RenderPresent(renderer);
+    if (!ok) {
+        LOGE("Could not render: %s", SDL_GetError());
+        assert(!"unexpected");
+    }
+}

app/src/util/sdl.h

@@ -0,0 +1,46 @@
+#ifndef SC_SDL_H
+#define SC_SDL_H
+
+#include "common.h"
+
+#include <stdint.h>
+#include <SDL3/SDL_render.h>
+#include <SDL3/SDL_video.h>
+
+#include "coords.h"
+
+SDL_Window *
+sc_sdl_create_window(const char *title, int64_t x, int64_t y, int64_t width,
+                     int64_t height, int64_t flags);
+
+struct sc_size
+sc_sdl_get_window_size(SDL_Window *window);
+
+void
+sc_sdl_set_window_size(SDL_Window *window, struct sc_size size);
+
+struct sc_size
+sc_sdl_get_window_size_in_pixels(SDL_Window *window);
+
+struct sc_point
+sc_sdl_get_window_position(SDL_Window *window);
+
+void
+sc_sdl_set_window_position(SDL_Window *window, struct sc_point point);
+
+void
+sc_sdl_show_window(SDL_Window *window);
+
+void
+sc_sdl_hide_window(SDL_Window *window);
+
+void
+sc_sdl_restore_window(SDL_Window *window);
+
+bool
+sc_sdl_render_clear(SDL_Renderer *renderer);
+
+void
+sc_sdl_render_present(SDL_Renderer *renderer);
+
+#endif

app/src/util/window.c

@@ -1,33 +0,0 @@
-#include "window.h"
-
-SDL_Window *
-sc_create_sdl_window(const char *title, int64_t x, int64_t y, int64_t width,
-                     int64_t height, int64_t flags) {
-    SDL_Window *window = NULL;
-
-    SDL_PropertiesID props = SDL_CreateProperties();
-    if (!props) {
-        return NULL;
-    }
-
-    bool ok =
-        SDL_SetStringProperty(props, SDL_PROP_WINDOW_CREATE_TITLE_STRING,
-                              title);
-    ok &= SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_X_NUMBER, x);
-    ok &= SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_Y_NUMBER, y);
-    ok &= SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_WIDTH_NUMBER,
-                                width);
-    ok &= SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_HEIGHT_NUMBER,
-                                height);
-    ok &= SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_FLAGS_NUMBER,
-                                flags);
-
-    if (!ok) {
-        SDL_DestroyProperties(props);
-        return NULL;
-    }
-
-    window = SDL_CreateWindowWithProperties(props);
-    SDL_DestroyProperties(props);
-    return window;
-}

app/src/util/window.h

@@ -1,13 +0,0 @@
-#ifndef SC_WINDOW_H
-#define SC_WINDOW_H
-
-#include "common.h"
-
-#include <stdint.h>
-#include <SDL3/SDL_video.h>
-
-SDL_Window *
-sc_create_sdl_window(const char *title, int64_t x, int64_t y, int64_t width,
-                     int64_t height, int64_t flags);
-
-#endif

app/tests/test_control_msg_serialize.c

@@ -411,6 +411,26 @@ static void test_serialize_open_hard_keyboard(void) {
     assert(!memcmp(buf, expected, sizeof(expected)));
 }
 
+static void test_serialize_start_app(void) {
+    struct sc_control_msg msg = {
+        .type = SC_CONTROL_MSG_TYPE_START_APP,
+        .start_app = {
+            .name = "firefox",
+        },
+    };
+
+    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
+    size_t size = sc_control_msg_serialize(&msg, buf);
+    assert(size == 9);
+
+    const uint8_t expected[] = {
+        SC_CONTROL_MSG_TYPE_START_APP,
+        7, // length
+        'f', 'i', 'r', 'e', 'f', 'o', 'x', // app name
+    };
+    assert(!memcmp(buf, expected, sizeof(expected)));
+}
+
 static void test_serialize_reset_video(void) {
     struct sc_control_msg msg = {
         .type = SC_CONTROL_MSG_TYPE_RESET_VIDEO,
@@ -426,6 +446,25 @@ static void test_serialize_reset_video(void) {
     assert(!memcmp(buf, expected, sizeof(expected)));
 }
 
+static void test_serialize_camera_set_torch(void) {
+    struct sc_control_msg msg = {
+        .type = SC_CONTROL_MSG_TYPE_CAMERA_SET_TORCH,
+        .camera_set_torch = {
+            .on = true,
+        },
+    };
+
+    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
+    size_t size = sc_control_msg_serialize(&msg, buf);
+    assert(size == 2);
+
+    const uint8_t expected[] = {
+        SC_CONTROL_MSG_TYPE_CAMERA_SET_TORCH,
+        0x01, // true
+    };
+    assert(!memcmp(buf, expected, sizeof(expected)));
+}
+
 int main(int argc, char *argv[]) {
     (void) argc;
     (void) argv;
@@ -448,6 +487,8 @@ int main(int argc, char *argv[]) {
     test_serialize_uhid_input();
     test_serialize_uhid_destroy();
     test_serialize_open_hard_keyboard();
+    test_serialize_start_app();
     test_serialize_reset_video();
+    test_serialize_camera_set_torch();
     return 0;
 }

build.gradle

@@ -7,7 +7,7 @@ buildscript {
         mavenCentral()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:8.7.1'
+        classpath 'com.android.tools.build:gradle:8.13.0'
 
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle files

gradle/wrapper/gradle-wrapper.properties

@@ -1,7 +1,7 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.9-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.3-bin.zip
 # https://gradle.org/release-checksums/
-distributionSha256Sum=d725d707bfabd4dfdc958c624003b3c80accc03f7037b5122c4b1d0ef15cecab
+distributionSha256Sum=bd71102213493060956ec229d946beee57158dbd89d0e62b91bca0fa2c5f3531
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

server/build.gradle

@@ -1,15 +1,15 @@
 apply plugin: 'com.android.application'
 
 android {
-    namespace 'com.genymobile.scrcpy'
-    compileSdk 35
+    namespace = 'com.genymobile.scrcpy'
+    compileSdk 36
     defaultConfig {
-        applicationId "com.genymobile.scrcpy"
+        applicationId = "com.genymobile.scrcpy"
         minSdkVersion 21
-        targetSdkVersion 35
+        targetSdkVersion 36
         versionCode 30303
         versionName "3.3.3"
-        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
+        testInstrumentationRunner = "android.support.test.runner.AndroidJUnitRunner"
     }
     buildTypes {
         release {
@@ -18,8 +18,11 @@ android {
         }
     }
     buildFeatures {
-        buildConfig true
-        aidl true
+        buildConfig = true
+        aidl = true
+    }
+    lint {
+        disable 'UseRequiresApi'
     }
 }
 

server/build_without_gradle.sh

@@ -14,8 +14,8 @@ set -e
 SCRCPY_DEBUG=false
 SCRCPY_VERSION_NAME=3.3.3
 
-PLATFORM=${ANDROID_PLATFORM:-35}
-BUILD_TOOLS=${ANDROID_BUILD_TOOLS:-35.0.0}
+PLATFORM=${ANDROID_PLATFORM:-36}
+BUILD_TOOLS=${ANDROID_BUILD_TOOLS:-36.0.0}
 PLATFORM_TOOLS="$ANDROID_HOME/platforms/android-$PLATFORM"
 BUILD_TOOLS_DIR="$ANDROID_HOME/build-tools/$BUILD_TOOLS"
 
@@ -86,7 +86,7 @@ javac -encoding UTF-8 -bootclasspath "$ANDROID_JAR" \
 echo "Dexing..."
 cd "$CLASSES_DIR"
 
-if [[ $PLATFORM -lt 31 ]]
+if [[ "${PLATFORM%%.*}" -lt 31 ]]
 then
     # use dx
     "$BUILD_TOOLS_DIR/dx" --dex --output "$BUILD_DIR/classes.dex" \

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

@@ -109,8 +109,10 @@ public final class FakeContext extends ContextWrapper {
         }
 
         // "semclipboard" is a Samsung-internal service
-        // See <https://github.com/Genymobile/scrcpy/issues/6224>
-        if (Context.CLIPBOARD_SERVICE.equals(name) || "semclipboard".equals(name)) {
+        // See:
+        //  - <https://github.com/Genymobile/scrcpy/issues/6224>
+        //  - <https://github.com/Genymobile/scrcpy/issues/6523>
+        if (Context.CLIPBOARD_SERVICE.equals(name) || "semclipboard".equals(name) || Context.ACTIVITY_SERVICE.equals(name)) {
             try {
                 Field field = service.getClass().getDeclaredField("mContext");
                 field.setAccessible(true);

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

@@ -46,6 +46,7 @@ public class Options {
     private CameraAspectRatio cameraAspectRatio;
     private int cameraFps;
     private boolean cameraHighSpeed;
+    private boolean cameraTorch;
     private boolean showTouches;
     private boolean stayAwake;
     private int screenOffTimeout = -1;
@@ -176,6 +177,10 @@ public class Options {
         return cameraHighSpeed;
     }
 
+    public boolean getCameraTorch() {
+        return cameraTorch;
+    }
+
     public boolean getShowTouches() {
         return showTouches;
     }
@@ -474,6 +479,9 @@ public class Options {
                 case "camera_high_speed":
                     options.cameraHighSpeed = Boolean.parseBoolean(value);
                     break;
+                case "camera_torch":
+                    options.cameraTorch = Boolean.parseBoolean(value);
+                    break;
                 case "new_display":
                     options.newDisplay = parseNewDisplay(value);
                     break;

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

@@ -225,8 +225,12 @@ public final class Server {
     }
 
     private static void internalMain(String... args) throws Exception {
+        Thread.UncaughtExceptionHandler defaultHandler = Thread.getDefaultUncaughtExceptionHandler();
         Thread.setDefaultUncaughtExceptionHandler((t, e) -> {
             Ln.e("Exception on thread " + t, e);
+            if (defaultHandler != null) {
+                defaultHandler.uncaughtException(t, e);
+            }
         });
 
         prepareMainLooper();

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

@@ -6,9 +6,9 @@ import com.genymobile.scrcpy.util.Ln;
 import android.annotation.SuppressLint;
 import android.annotation.TargetApi;
 import android.app.Application;
+import android.app.Instrumentation;
 import android.content.AttributionSource;
 import android.content.Context;
-import android.content.ContextWrapper;
 import android.content.pm.ApplicationInfo;
 import android.media.AudioAttributes;
 import android.media.AudioManager;
@@ -103,10 +103,7 @@ public final class Workarounds {
 
     private static void fillAppContext() {
         try {
-            Application app = new Application();
-            Field baseField = ContextWrapper.class.getDeclaredField("mBase");
-            baseField.setAccessible(true);
-            baseField.set(app, FakeContext.get());
+            Application app = Instrumentation.newApplication(Application.class, FakeContext.get());
 
             // activityThread.mInitialApplication = app;
             Field mInitialApplicationField = ACTIVITY_THREAD_CLASS.getDeclaredField("mInitialApplication");

server/src/main/java/com/genymobile/scrcpy/control/ControlMessage.java

@@ -25,6 +25,7 @@ public final class ControlMessage {
     public static final int TYPE_OPEN_HARD_KEYBOARD_SETTINGS = 15;
     public static final int TYPE_START_APP = 16;
     public static final int TYPE_RESET_VIDEO = 17;
+    public static final int TYPE_CAMERA_SET_TORCH = 18;
 
     public static final long SEQUENCE_INVALID = 0;
 
@@ -166,6 +167,13 @@ public final class ControlMessage {
         return msg;
     }
 
+    public static ControlMessage createCameraSetTorch(boolean on) {
+        ControlMessage msg = new ControlMessage();
+        msg.type = TYPE_CAMERA_SET_TORCH;
+        msg.on = on;
+        return msg;
+    }
+
     public int getType() {
         return type;
     }

server/src/main/java/com/genymobile/scrcpy/control/ControlMessageReader.java

@@ -56,6 +56,8 @@ public class ControlMessageReader {
                 return parseUhidDestroy();
             case ControlMessage.TYPE_START_APP:
                 return parseStartApp();
+            case ControlMessage.TYPE_CAMERA_SET_TORCH:
+                return parseCameraSetTorch();
             default:
                 throw new ControlProtocolException("Unknown event type: " + type);
         }
@@ -166,6 +168,11 @@ public class ControlMessageReader {
         return ControlMessage.createStartApp(name);
     }
 
+    private ControlMessage parseCameraSetTorch() throws IOException {
+        boolean on = dis.readBoolean();
+        return ControlMessage.createCameraSetTorch(on);
+    }
+
     private Position parsePosition() throws IOException {
         int x = dis.readInt();
         int y = dis.readInt();

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

@@ -12,7 +12,9 @@ import com.genymobile.scrcpy.device.Position;
 import com.genymobile.scrcpy.device.Size;
 import com.genymobile.scrcpy.util.Ln;
 import com.genymobile.scrcpy.util.LogUtils;
+import com.genymobile.scrcpy.video.CameraCapture;
 import com.genymobile.scrcpy.video.SurfaceCapture;
+import com.genymobile.scrcpy.video.VideoSource;
 import com.genymobile.scrcpy.video.VirtualDisplayListener;
 import com.genymobile.scrcpy.wrappers.ClipboardManager;
 import com.genymobile.scrcpy.wrappers.InputManager;
@@ -75,6 +77,7 @@ public class Controller implements AsyncProcessor, VirtualDisplayListener {
 
     private UhidManager uhidManager;
 
+    private final boolean camera;
     private final int displayId;
     private final boolean supportsInputEvents;
     private final ControlChannel controlChannel;
@@ -97,13 +100,26 @@ public class Controller implements AsyncProcessor, VirtualDisplayListener {
 
     private boolean keepDisplayPowerOff;
 
-    // Used for resetting video encoding on RESET_VIDEO message
+    // Used for resetting video encoding on RESET_VIDEO message or for sending camera controls
     private SurfaceCapture surfaceCapture;
 
     public Controller(ControlChannel controlChannel, CleanUp cleanUp, Options options) {
-        this.displayId = options.getDisplayId();
+        this.camera = options.getVideoSource() == VideoSource.CAMERA;
         this.controlChannel = controlChannel;
         this.cleanUp = cleanUp;
+
+        if (this.camera) {
+            // Unused for camera
+            this.displayId = Device.DISPLAY_ID_NONE;
+            this.supportsInputEvents = false;
+            this.sender = null;
+            this.clipboardAutosync = false;
+            this.powerOn = false;
+            return;
+        }
+
+        this.displayId = options.getDisplayId();
+
         this.clipboardAutosync = options.getClipboardAutosync();
         this.powerOn = options.getPowerOn();
         initPointers();
@@ -201,7 +217,7 @@ public class Controller implements AsyncProcessor, VirtualDisplayListener {
 
     private void control() throws IOException {
         // on start, power on the device
-        if (powerOn && displayId == 0 && !Device.isScreenOn(displayId)) {
+        if (!camera && powerOn && displayId == 0 && !Device.isScreenOn(displayId)) {
             Device.pressReleaseKeycode(KeyEvent.KEYCODE_POWER, displayId, Device.INJECT_MODE_ASYNC);
 
             // dirty hack
@@ -236,7 +252,9 @@ public class Controller implements AsyncProcessor, VirtualDisplayListener {
             }
         }, "control-recv");
         thread.start();
-        sender.start();
+        if (sender != null) {
+            sender.start();
+        }
     }
 
     @Override
@@ -244,7 +262,9 @@ public class Controller implements AsyncProcessor, VirtualDisplayListener {
         if (thread != null) {
             thread.interrupt();
         }
-        sender.stop();
+        if (sender != null) {
+            sender.stop();
+        }
     }
 
     @Override
@@ -252,7 +272,9 @@ public class Controller implements AsyncProcessor, VirtualDisplayListener {
         if (thread != null) {
             thread.join();
         }
-        sender.join();
+        if (sender != null) {
+            sender.join();
+        }
     }
 
     private boolean handleEvent() throws IOException {
@@ -264,78 +286,99 @@ public class Controller implements AsyncProcessor, VirtualDisplayListener {
             return false;
         }
 
-        switch (msg.getType()) {
-            case ControlMessage.TYPE_INJECT_KEYCODE:
-                if (supportsInputEvents) {
-                    injectKeycode(msg.getAction(), msg.getKeycode(), msg.getRepeat(), msg.getMetaState());
-                }
-                break;
-            case ControlMessage.TYPE_INJECT_TEXT:
-                if (supportsInputEvents) {
-                    injectText(msg.getText());
-                }
-                break;
-            case ControlMessage.TYPE_INJECT_TOUCH_EVENT:
-                if (supportsInputEvents) {
-                    injectTouch(msg.getAction(), msg.getPointerId(), msg.getPosition(), msg.getPressure(), msg.getActionButton(), msg.getButtons());
-                }
-                break;
-            case ControlMessage.TYPE_INJECT_SCROLL_EVENT:
-                if (supportsInputEvents) {
-                    injectScroll(msg.getPosition(), msg.getHScroll(), msg.getVScroll(), msg.getButtons());
-                }
-                break;
-            case ControlMessage.TYPE_BACK_OR_SCREEN_ON:
-                if (supportsInputEvents) {
-                    pressBackOrTurnScreenOn(msg.getAction());
-                }
-                break;
-            case ControlMessage.TYPE_EXPAND_NOTIFICATION_PANEL:
-                Device.expandNotificationPanel();
-                break;
-            case ControlMessage.TYPE_EXPAND_SETTINGS_PANEL:
-                Device.expandSettingsPanel();
-                break;
-            case ControlMessage.TYPE_COLLAPSE_PANELS:
-                Device.collapsePanels();
-                break;
-            case ControlMessage.TYPE_GET_CLIPBOARD:
-                getClipboard(msg.getCopyKey());
-                break;
-            case ControlMessage.TYPE_SET_CLIPBOARD:
-                setClipboard(msg.getText(), msg.getPaste(), msg.getSequence());
-                break;
-            case ControlMessage.TYPE_SET_DISPLAY_POWER:
-                if (supportsInputEvents) {
-                    setDisplayPower(msg.getOn());
-                }
-                break;
-            case ControlMessage.TYPE_ROTATE_DEVICE:
-                Device.rotateDevice(getActionDisplayId());
-                break;
-            case ControlMessage.TYPE_UHID_CREATE:
-                getUhidManager().open(msg.getId(), msg.getVendorId(), msg.getProductId(), msg.getText(), msg.getData());
-                break;
-            case ControlMessage.TYPE_UHID_INPUT:
-                getUhidManager().writeInput(msg.getId(), msg.getData());
-                break;
-            case ControlMessage.TYPE_UHID_DESTROY:
-                getUhidManager().close(msg.getId());
-                break;
-            case ControlMessage.TYPE_OPEN_HARD_KEYBOARD_SETTINGS:
-                openHardKeyboardSettings();
-                break;
-            case ControlMessage.TYPE_START_APP:
-                startAppAsync(msg.getText());
-                break;
+        int type = msg.getType();
+
+        // Events for all sources (display or camera)
+        switch (type) {
             case ControlMessage.TYPE_RESET_VIDEO:
                 resetVideo();
-                break;
+                return true;
             default:
-                // do nothing
+                // fall through
         }
 
-        return true;
+        if (!camera) {
+            switch (type) {
+                case ControlMessage.TYPE_INJECT_KEYCODE:
+                    if (supportsInputEvents) {
+                        injectKeycode(msg.getAction(), msg.getKeycode(), msg.getRepeat(), msg.getMetaState());
+                    }
+                    return true;
+                case ControlMessage.TYPE_INJECT_TEXT:
+                    if (supportsInputEvents) {
+                        injectText(msg.getText());
+                    }
+                    return true;
+                case ControlMessage.TYPE_INJECT_TOUCH_EVENT:
+                    if (supportsInputEvents) {
+                        injectTouch(
+                                msg.getAction(), msg.getPointerId(), msg.getPosition(), msg.getPressure(), msg.getActionButton(), msg.getButtons());
+                    }
+                    return true;
+                case ControlMessage.TYPE_INJECT_SCROLL_EVENT:
+                    if (supportsInputEvents) {
+                        injectScroll(msg.getPosition(), msg.getHScroll(), msg.getVScroll(), msg.getButtons());
+                    }
+                    return true;
+                case ControlMessage.TYPE_BACK_OR_SCREEN_ON:
+                    if (supportsInputEvents) {
+                        pressBackOrTurnScreenOn(msg.getAction());
+                    }
+                    return true;
+                case ControlMessage.TYPE_EXPAND_NOTIFICATION_PANEL:
+                    Device.expandNotificationPanel();
+                    return true;
+                case ControlMessage.TYPE_EXPAND_SETTINGS_PANEL:
+                    Device.expandSettingsPanel();
+                    return true;
+                case ControlMessage.TYPE_COLLAPSE_PANELS:
+                    Device.collapsePanels();
+                    return true;
+                case ControlMessage.TYPE_GET_CLIPBOARD:
+                    getClipboard(msg.getCopyKey());
+                    return true;
+                case ControlMessage.TYPE_SET_CLIPBOARD:
+                    setClipboard(msg.getText(), msg.getPaste(), msg.getSequence());
+                    return true;
+                case ControlMessage.TYPE_SET_DISPLAY_POWER:
+                    if (supportsInputEvents) {
+                        setDisplayPower(msg.getOn());
+                    }
+                    return true;
+                case ControlMessage.TYPE_ROTATE_DEVICE:
+                    Device.rotateDevice(getActionDisplayId());
+                    return true;
+                case ControlMessage.TYPE_UHID_CREATE:
+                    getUhidManager().open(msg.getId(), msg.getVendorId(), msg.getProductId(), msg.getText(), msg.getData());
+                    return true;
+                case ControlMessage.TYPE_UHID_INPUT:
+                    getUhidManager().writeInput(msg.getId(), msg.getData());
+                    return true;
+                case ControlMessage.TYPE_UHID_DESTROY:
+                    getUhidManager().close(msg.getId());
+                    return true;
+                case ControlMessage.TYPE_OPEN_HARD_KEYBOARD_SETTINGS:
+                    openHardKeyboardSettings();
+                    return true;
+                case ControlMessage.TYPE_START_APP:
+                    startAppAsync(msg.getText());
+                    return true;
+                default:
+                    // fall through
+            }
+        } else {
+            switch (type) {
+                case ControlMessage.TYPE_CAMERA_SET_TORCH:
+                    assert surfaceCapture instanceof CameraCapture;
+                    CameraCapture cameraCapture = (CameraCapture) surfaceCapture;
+                    cameraCapture.setTorchEnabled(msg.getOn());
+                    return true;
+                default:
+                    // fall through
+            }
+        }
+
+        throw new AssertionError("Unexpected message type: " + type);
     }
 
     private boolean injectKeycode(int action, int keycode, int repeat, int metaState) {
@@ -751,7 +794,7 @@ public class Controller implements AsyncProcessor, VirtualDisplayListener {
     private void resetVideo() {
         if (surfaceCapture != null) {
             Ln.i("Video capture reset");
-            surfaceCapture.requestInvalidate();
+            surfaceCapture.invalidate();
         }
     }
 }

server/src/main/java/com/genymobile/scrcpy/opengl/OpenGLRunner.java

@@ -1,6 +1,7 @@
 package com.genymobile.scrcpy.opengl;
 
 import com.genymobile.scrcpy.device.Size;
+import com.genymobile.scrcpy.util.Threads;
 
 import android.graphics.SurfaceTexture;
 import android.opengl.EGL14;
@@ -15,6 +16,7 @@ import android.os.Handler;
 import android.os.HandlerThread;
 import android.view.Surface;
 
+import java.util.concurrent.Callable;
 import java.util.concurrent.Semaphore;
 
 public final class OpenGLRunner {
@@ -80,31 +82,17 @@ public final class OpenGLRunner {
     public Surface start(Size inputSize, Size outputSize, Surface outputSurface) throws OpenGLException {
         initOnce();
 
-        // Simulate CompletableFuture, but working for all Android versions
-        final Semaphore sem = new Semaphore(0);
-        Throwable[] throwableRef = new Throwable[1];
-
         // The whole OpenGL execution must be performed on a Handler, so that SurfaceTexture.setOnFrameAvailableListener() works correctly.
         // See <https://github.com/Genymobile/scrcpy/issues/5444>
-        handler.post(() -> {
-            try {
-                run(inputSize, outputSize, outputSurface);
-            } catch (Throwable throwable) {
-                throwableRef[0] = throwable;
-            } finally {
-                sem.release();
-            }
-        });
-
         try {
-            sem.acquire();
-        } catch (InterruptedException e) {
-            // Behave as if this method call was synchronous
-            Thread.currentThread().interrupt();
-        }
-
-        Throwable throwable = throwableRef[0];
-        if (throwable != null) {
+            Threads.executeSynchronouslyOn(handler, new Callable<Void>() {
+                @Override
+                public Void call() throws Exception {
+                    run(inputSize, outputSize, outputSurface);
+                    return null;
+                }
+            });
+        } catch (Throwable throwable) {
             if (throwable instanceof OpenGLException) {
                 throw (OpenGLException) throwable;
             }

server/src/main/java/com/genymobile/scrcpy/util/Ln.java

@@ -74,9 +74,11 @@ public final class Ln {
     public static void w(String message, Throwable throwable) {
         if (isEnabled(Level.WARN)) {
             Log.w(TAG, message, throwable);
-            CONSOLE_ERR.print(PREFIX + "WARN: " + message + '\n');
-            if (throwable != null) {
-                throwable.printStackTrace(CONSOLE_ERR);
+            synchronized (CONSOLE_ERR) {
+                CONSOLE_ERR.print(PREFIX + "WARN: " + message + '\n');
+                if (throwable != null) {
+                    throwable.printStackTrace(CONSOLE_ERR);
+                }
             }
         }
     }
@@ -88,9 +90,11 @@ public final class Ln {
     public static void e(String message, Throwable throwable) {
         if (isEnabled(Level.ERROR)) {
             Log.e(TAG, message, throwable);
-            CONSOLE_ERR.print(PREFIX + "ERROR: " + message + '\n');
-            if (throwable != null) {
-                throwable.printStackTrace(CONSOLE_ERR);
+            synchronized (CONSOLE_ERR) {
+                CONSOLE_ERR.print(PREFIX + "ERROR: " + message + '\n');
+                if (throwable != null) {
+                    throwable.printStackTrace(CONSOLE_ERR);
+                }
             }
         }
     }

server/src/main/java/com/genymobile/scrcpy/util/LogUtils.java

@@ -23,6 +23,7 @@ import android.media.MediaCodecList;
 import android.os.Build;
 import android.util.Range;
 
+import java.text.DecimalFormat;
 import java.util.Collections;
 import java.util.List;
 import java.util.Objects;
@@ -164,7 +165,7 @@ public final class LogUtils {
                         // Capture frame rates for low-FPS mode are the same for every resolution
                         Range<Integer>[] lowFpsRanges = characteristics.get(CameraCharacteristics.CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES);
                         if (lowFpsRanges != null) {
-                            SortedSet<Integer> uniqueLowFps = getUniqueSet(lowFpsRanges);
+                            String uniqueLowFps = getFormattedUniqueSet(lowFpsRanges);
                             builder.append(", fps=").append(uniqueLowFps);
                         }
                     } catch (Exception e) {
@@ -172,8 +173,22 @@ public final class LogUtils {
                         Ln.w("Could not get available frame rates for camera " + id, e);
                     }
 
+                    if (Build.VERSION.SDK_INT >= AndroidVersions.API_30_ANDROID_11) {
+                        try {
+                            Range<Float> zoomRange = characteristics.get(CameraCharacteristics.CONTROL_ZOOM_RATIO_RANGE);
+                            if (zoomRange != null) {
+                                String zoom = getFormattedZoomRange(zoomRange);
+                                builder.append(", zoom-range=").append(zoom);
+                            }
+                        } catch (Exception e) {
+                            Ln.w("Could not get available zoom ranges for camera " + id, e);
+                        }
+                    }
+
                     builder.append(')');
 
+
+
                     if (includeSizes) {
                         StreamConfigurationMap configs = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
 
@@ -191,7 +206,7 @@ public final class LogUtils {
                             builder.append("\n      High speed capture (--camera-high-speed):");
                             for (android.util.Size size : highSpeedSizes) {
                                 Range<Integer>[] highFpsRanges = configs.getHighSpeedVideoFpsRanges();
-                                SortedSet<Integer> uniqueHighFps = getUniqueSet(highFpsRanges);
+                                String uniqueHighFps = getFormattedUniqueSet(highFpsRanges);
                                 builder.append("\n        - ").append(size.getWidth()).append("x").append(size.getHeight());
                                 builder.append(" (fps=").append(uniqueHighFps).append(')');
                             }
@@ -205,14 +220,31 @@ public final class LogUtils {
         return builder.toString();
     }
 
-    private static SortedSet<Integer> getUniqueSet(Range<Integer>[] ranges) {
+    private static String getFormattedUniqueSet(Range<Integer>[] ranges) {
         SortedSet<Integer> set = new TreeSet<>();
         for (Range<Integer> range : ranges) {
             set.add(range.getUpper());
         }
-        return set;
+
+        StringBuilder builder = new StringBuilder("{");
+        boolean first = true;
+        for (Integer i : set) {
+            if (!first) {
+                builder.append(", ");
+            } else {
+                first = false;
+            }
+            builder.append(i);
+        }
+        builder.append("}");
+
+        return builder.toString();
     }
 
+    private static String getFormattedZoomRange(Range<Float> range) {
+        DecimalFormat format = new DecimalFormat("#.##");
+        return "[" + format.format(range.getLower()) + ", " + format.format(range.getUpper()) + "]";
+    }
 
     public static String buildAppListMessage() {
         List<DeviceApp> apps = Device.listApps();

server/src/main/java/com/genymobile/scrcpy/util/Threads.java

@@ -0,0 +1,43 @@
+package com.genymobile.scrcpy.util;
+
+import android.os.Handler;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.Semaphore;
+
+public final class Threads {
+    private Threads() {
+        // not instantiable
+    }
+
+    public static <T> T executeSynchronouslyOn(Handler handler, Callable<T> callable) throws Throwable {
+        // Simulate CompletableFuture, but working for all Android versions
+        final Semaphore sem = new Semaphore(0);
+        @SuppressWarnings("unchecked")
+        T[] resultRef = (T[]) new Object[1];
+        Throwable[] throwableRef = new Throwable[1];
+
+        handler.post(() -> {
+            try {
+                resultRef[0] = callable.call();
+            } catch (Throwable throwable) {
+                throwableRef[0] = throwable;
+            } finally {
+                sem.release();
+            }
+        });
+
+        try {
+            sem.acquire();
+        } catch (InterruptedException e) {
+            // Behave as if this method call was synchronous
+            Thread.currentThread().interrupt();
+        }
+
+        if (throwableRef[0] != null) {
+            throw throwableRef[0];
+        }
+
+        return resultRef[0];
+    }
+}

server/src/main/java/com/genymobile/scrcpy/video/CameraCapture.java

@@ -36,6 +36,7 @@ import android.view.Surface;
 
 import java.io.IOException;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
@@ -63,6 +64,7 @@ public class CameraCapture extends SurfaceCapture {
     private final Rect crop;
     private final Orientation captureOrientation;
     private final float angle;
+    private final boolean initialTorch;
 
     private String cameraId;
     private Size captureSize;
@@ -78,6 +80,11 @@ public class CameraCapture extends SurfaceCapture {
 
     private final AtomicBoolean disconnected = new AtomicBoolean();
 
+    // The following fields must be accessed only from the camera thread
+    private boolean started;
+    private CaptureRequest.Builder requestBuilder;
+    private CameraCaptureSession currentSession;
+
     public CameraCapture(Options options) {
         this.explicitCameraId = options.getCameraId();
         this.cameraFacing = options.getCameraFacing();
@@ -90,6 +97,7 @@ public class CameraCapture extends SurfaceCapture {
         this.captureOrientation = options.getCaptureOrientation();
         assert captureOrientation != null;
         this.angle = options.getAngle();
+        this.initialTorch = options.getCameraTorch();
     }
 
     @Override
@@ -250,6 +258,7 @@ public class CameraCapture extends SurfaceCapture {
         return ratio.getAspectRatio();
     }
 
+    @TargetApi(AndroidVersions.API_28_ANDROID_9)
     @Override
     public void start(Surface surface) throws IOException {
         if (transform != null) {
@@ -261,11 +270,54 @@ public class CameraCapture extends SurfaceCapture {
             surface = glRunner.start(captureSize, videoSize, surface);
         }
 
+        cameraHandler.post(() -> {
+            assertCameraThread();
+            started = true;
+        });
+
+        Surface captureSurface = surface;
+        OutputConfiguration outputConfig = new OutputConfiguration(captureSurface);
+        List<OutputConfiguration> outputs = Collections.singletonList(outputConfig);
+        int sessionType = highSpeed ? SessionConfiguration.SESSION_HIGH_SPEED : SessionConfiguration.SESSION_REGULAR;
+        SessionConfiguration sessionConfig = new SessionConfiguration(sessionType, outputs, cameraExecutor, new CameraCaptureSession.StateCallback() {
+            @Override
+            public void onConfigured(CameraCaptureSession session) {
+                assertCameraThread();
+                if (!started) {
+                    // Stopped on the encoder thread between the call to start() and this callback
+                    return;
+                }
+
+                try {
+                    requestBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_RECORD);
+                    requestBuilder.addTarget(captureSurface);
+
+                    if (fps > 0) {
+                        requestBuilder.set(CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE, new Range<>(fps, fps));
+                    }
+                    if (initialTorch) {
+                        requestBuilder.set(CaptureRequest.FLASH_MODE, CaptureRequest.FLASH_MODE_TORCH);
+                    }
+
+                    CaptureRequest request = requestBuilder.build();
+                    setRepeatingRequest(session, request);
+                    currentSession = session;
+                } catch (CameraAccessException e) {
+                    Ln.e("Camera error", e);
+                    invalidate();
+                }
+            }
+
+            @Override
+            public void onConfigureFailed(CameraCaptureSession session) {
+                Ln.e("Camera configuration error");
+                invalidate();
+            }
+        });
+
         try {
-            CameraCaptureSession session = createCaptureSession(cameraDevice, surface);
-            CaptureRequest request = createCaptureRequest(surface);
-            setRepeatingRequest(session, request);
-        } catch (CameraAccessException | InterruptedException e) {
+            cameraDevice.createCaptureSession(sessionConfig);
+        } catch (CameraAccessException e) {
             stop();
             throw new IOException(e);
         }
@@ -273,6 +325,13 @@ public class CameraCapture extends SurfaceCapture {
 
     @Override
     public void stop() {
+        cameraHandler.post(() -> {
+            assertCameraThread();
+            currentSession = null;
+            requestBuilder = null;
+            started = false;
+        });
+
         if (glRunner != null) {
             glRunner.stopAndRelease();
             glRunner = null;
@@ -353,46 +412,7 @@ public class CameraCapture extends SurfaceCapture {
     }
 
     @TargetApi(AndroidVersions.API_31_ANDROID_12)
-    private CameraCaptureSession createCaptureSession(CameraDevice camera, Surface surface) throws CameraAccessException, InterruptedException {
-        CompletableFuture<CameraCaptureSession> future = new CompletableFuture<>();
-        OutputConfiguration outputConfig = new OutputConfiguration(surface);
-        List<OutputConfiguration> outputs = Arrays.asList(outputConfig);
-
-        int sessionType = highSpeed ? SessionConfiguration.SESSION_HIGH_SPEED : SessionConfiguration.SESSION_REGULAR;
-        SessionConfiguration sessionConfig = new SessionConfiguration(sessionType, outputs, cameraExecutor, new CameraCaptureSession.StateCallback() {
-            @Override
-            public void onConfigured(CameraCaptureSession session) {
-                future.complete(session);
-            }
-
-            @Override
-            public void onConfigureFailed(CameraCaptureSession session) {
-                future.completeExceptionally(new CameraAccessException(CameraAccessException.CAMERA_ERROR));
-            }
-        });
-
-        camera.createCaptureSession(sessionConfig);
-
-        try {
-            return future.get();
-        } catch (ExecutionException e) {
-            throw (CameraAccessException) e.getCause();
-        }
-    }
-
-    private CaptureRequest createCaptureRequest(Surface surface) throws CameraAccessException {
-        CaptureRequest.Builder requestBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_RECORD);
-        requestBuilder.addTarget(surface);
-
-        if (fps > 0) {
-            requestBuilder.set(CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE, new Range<>(fps, fps));
-        }
-
-        return requestBuilder.build();
-    }
-
-    @TargetApi(AndroidVersions.API_31_ANDROID_12)
-    private void setRepeatingRequest(CameraCaptureSession session, CaptureRequest request) throws CameraAccessException, InterruptedException {
+    private void setRepeatingRequest(CameraCaptureSession session, CaptureRequest request) throws CameraAccessException {
         CameraCaptureSession.CaptureCallback callback = new CameraCaptureSession.CaptureCallback() {
             @Override
             public void onCaptureStarted(CameraCaptureSession session, CaptureRequest request, long timestamp, long frameNumber) {
@@ -419,8 +439,22 @@ public class CameraCapture extends SurfaceCapture {
         return disconnected.get();
     }
 
-    @Override
-    public void requestInvalidate() {
-        // do nothing (the user could not request a reset anyway for now, since there is no controller for camera mirroring)
+    public void setTorchEnabled(boolean enabled) {
+        cameraHandler.post(() -> {
+            assertCameraThread();
+            if (currentSession != null && requestBuilder != null) {
+                try {
+                    requestBuilder.set(CaptureRequest.FLASH_MODE, enabled ? CaptureRequest.FLASH_MODE_TORCH : CaptureRequest.FLASH_MODE_OFF);
+                    CaptureRequest request = requestBuilder.build();
+                    setRepeatingRequest(currentSession, request);
+                } catch (CameraAccessException e) {
+                    Ln.e("Camera error", e);
+                }
+            }
+        });
+    }
+
+    private void assertCameraThread() {
+        assert Thread.currentThread() == cameraThread;
     }
 }

server/src/main/java/com/genymobile/scrcpy/video/NewDisplayCapture.java

@@ -261,9 +261,4 @@ public class NewDisplayCapture extends SurfaceCapture {
         int num = size.getMax();
         return initialDpi * num / den;
     }
-
-    @Override
-    public void requestInvalidate() {
-        invalidate();
-    }
 }

server/src/main/java/com/genymobile/scrcpy/video/ScreenCapture.java

@@ -211,9 +211,4 @@ public class ScreenCapture extends SurfaceCapture {
             SurfaceControl.closeTransaction();
         }
     }
-
-    @Override
-    public void requestInvalidate() {
-        invalidate();
-    }
 }

server/src/main/java/com/genymobile/scrcpy/video/SurfaceCapture.java

@@ -19,9 +19,9 @@ public abstract class SurfaceCapture {
     private CaptureListener listener;
 
     /**
-     * Notify the listener that the capture has been invalidated (for example, because its size changed).
+     * Notify the listener that the capture has been invalidated (for example, because its size changed, or due to a manual user request).
      */
-    protected void invalidate() {
+    public void invalidate() {
         listener.onInvalidated();
     }
 
@@ -86,11 +86,4 @@ public abstract class SurfaceCapture {
     public boolean isClosed() {
         return false;
     }
-
-    /**
-     * Manually request to invalidate (typically a user request).
-     * <p>
-     * The capture implementation is free to ignore the request and do nothing.
-     */
-    public abstract void requestInvalidate();
 }

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

@@ -139,7 +139,13 @@ public final class DisplayManager {
             int layerStack = cls.getDeclaredField("layerStack").getInt(displayInfo);
             int flags = cls.getDeclaredField("flags").getInt(displayInfo);
             int dpi = cls.getDeclaredField("logicalDensityDpi").getInt(displayInfo);
-            String uniqueId = (String) cls.getDeclaredField("uniqueId").get(displayInfo);
+            String uniqueId;
+            try {
+                uniqueId = (String) cls.getDeclaredField("uniqueId").get(displayInfo);
+            } catch (NoSuchFieldException e) {
+                // This field might not exist: <https://github.com/Genymobile/scrcpy/issues/6461>
+                uniqueId = null;
+            }
             return new DisplayInfo(displayId, new Size(width, height), rotation, layerStack, flags, dpi, uniqueId);
         } catch (ReflectiveOperationException e) {
             throw new AssertionError(e);

server/src/test/java/com/genymobile/scrcpy/control/ControlMessageReaderTest.java

@@ -422,6 +422,24 @@ public class ControlMessageReaderTest {
         Assert.assertEquals(-1, bis.read()); // EOS
     }
 
+    @Test
+    public void testParseCameraSetTorch() throws IOException {
+        ByteArrayOutputStream bos = new ByteArrayOutputStream();
+        DataOutputStream dos = new DataOutputStream(bos);
+        dos.writeByte(ControlMessage.TYPE_CAMERA_SET_TORCH);
+        dos.writeBoolean(true);
+        byte[] packet = bos.toByteArray();
+
+        ByteArrayInputStream bis = new ByteArrayInputStream(packet);
+        ControlMessageReader reader = new ControlMessageReader(bis);
+
+        ControlMessage event = reader.read();
+        Assert.assertEquals(ControlMessage.TYPE_CAMERA_SET_TORCH, event.getType());
+        Assert.assertTrue(event.getOn());
+
+        Assert.assertEquals(-1, bis.read()); // EOS
+    }
+
     @Test
     public void testMultiEvents() throws IOException {
         ByteArrayOutputStream bos = new ByteArrayOutputStream();