Turn device screen off after set up

Sometimes it can take quite a while for everything to get set up and
the screen to appear.

PR #3902 <https://github.com/Genymobile/scrcpy/pull/3902>

Signed-off-by: Romain Vimont <rom@rom1v.com>

app/meson.build

@@ -14,6 +14,7 @@ src = [
     'src/delay_buffer.c',
     'src/demuxer.c',
     'src/device_msg.c',
+    'src/display.c',
     'src/icon.c',
     'src/file_pusher.c',
     'src/fps_counter.c',

app/scrcpy.1

@@ -183,6 +183,10 @@ It may only work over USB.
 
 Also see \fB\-\-hid\-keyboard\fR.
 
+.TP
+.B \-\-no\-audio
+Disable audio forwarding.
+
 .TP
 .B \-\-no\-cleanup
 By default, scrcpy removes the server binary from the device and restores the device state (show touches, stay awake and power mode) on exit.

app/src/adb/adb_parser.c

@@ -204,6 +204,7 @@ sc_adb_parse_device_ip(char *str) {
     while (str[idx_line] != '\0') {
         char *line = &str[idx_line];
         size_t len = strcspn(line, "\n");
+        bool is_last_line = line[len] == '\0';
 
         // The same, but without any trailing '\r'
         size_t line_len = sc_str_remove_trailing_cr(line, len);
@@ -215,12 +216,12 @@ sc_adb_parse_device_ip(char *str) {
             return ip;
         }
 
-        idx_line += len;
+        if (is_last_line) {
-
+            break;
-        if (str[idx_line] != '\0') {
-            // The next line starts after the '\n'
-            ++idx_line;
         }
+
+        // The next line starts after the '\n'
+        idx_line += len + 1;
     }
 
     return NULL;

app/src/display.c

@@ -0,0 +1,185 @@
+#include "display.h"
+
+#include <assert.h>
+
+#include "util/log.h"
+
+bool
+sc_display_init(struct sc_display *display, SDL_Window *window, bool mipmaps) {
+    display->renderer =
+        SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
+    if (!display->renderer) {
+        LOGE("Could not create renderer: %s", SDL_GetError());
+        return false;
+    }
+
+    SDL_RendererInfo renderer_info;
+    int r = SDL_GetRendererInfo(display->renderer, &renderer_info);
+    const char *renderer_name = r ? NULL : renderer_info.name;
+    LOGI("Renderer: %s", renderer_name ? renderer_name : "(unknown)");
+
+    display->mipmaps = false;
+
+    // starts with "opengl"
+    bool use_opengl = renderer_name && !strncmp(renderer_name, "opengl", 6);
+    if (use_opengl) {
+
+#ifdef SC_DISPLAY_FORCE_OPENGL_CORE_PROFILE
+        // Persuade macOS to give us something better than OpenGL 2.1.
+        // If we create a Core Profile context, we get the best OpenGL version.
+        SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK,
+                            SDL_GL_CONTEXT_PROFILE_CORE);
+
+        LOGD("Creating OpenGL Core Profile context");
+        display->gl_context = SDL_GL_CreateContext(window);
+        if (!display->gl_context) {
+            LOGE("Could not create OpenGL context: %s", SDL_GetError());
+            SDL_DestroyRenderer(display->renderer);
+            return false;
+        }
+#endif
+
+        struct sc_opengl *gl = &display->gl;
+        sc_opengl_init(gl);
+
+        LOGI("OpenGL version: %s", gl->version);
+
+        if (mipmaps) {
+            bool supports_mipmaps =
+                sc_opengl_version_at_least(gl, 3, 0, /* OpenGL 3.0+ */
+                                               2, 0  /* OpenGL ES 2.0+ */);
+            if (supports_mipmaps) {
+                LOGI("Trilinear filtering enabled");
+                display->mipmaps = true;
+            } else {
+                LOGW("Trilinear filtering disabled "
+                     "(OpenGL 3.0+ or ES 2.0+ required");
+            }
+        } else {
+            LOGI("Trilinear filtering disabled");
+        }
+    } else if (mipmaps) {
+        LOGD("Trilinear filtering disabled (not an OpenGL renderer");
+    }
+
+    return true;
+}
+
+void
+sc_display_destroy(struct sc_display *display) {
+#ifdef SC_DISPLAY_FORCE_OPENGL_CORE_PROFILE
+    SDL_GL_DeleteContext(display->gl_context);
+#endif
+    if (display->texture) {
+        SDL_DestroyTexture(display->texture);
+    }
+    SDL_DestroyRenderer(display->renderer);
+}
+
+static SDL_Texture *
+sc_display_create_texture(struct sc_display *display,
+                          struct sc_size size) {
+    SDL_Renderer *renderer = display->renderer;
+    SDL_Texture *texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_YV12,
+                                             SDL_TEXTUREACCESS_STREAMING,
+                                             size.width, size.height);
+    if (!texture) {
+        LOGE("Could not create texture: %s", SDL_GetError());
+        return NULL;
+    }
+
+    if (display->mipmaps) {
+        struct sc_opengl *gl = &display->gl;
+
+        SDL_GL_BindTexture(texture, NULL, NULL);
+
+        // Enable trilinear filtering for downscaling
+        gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+                          GL_LINEAR_MIPMAP_LINEAR);
+        gl->TexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, -1.f);
+
+        SDL_GL_UnbindTexture(texture);
+    }
+
+    return texture;
+}
+
+bool
+sc_display_set_texture_size(struct sc_display *display, struct sc_size size) {
+    if (display->texture) {
+        SDL_DestroyTexture(display->texture);
+    }
+
+    display->texture = sc_display_create_texture(display, size);
+    if (!display->texture) {
+        return false;
+    }
+
+    LOGI("Texture: %" PRIu16 "x%" PRIu16, size.width, size.height);
+    return true;
+}
+
+bool
+sc_display_update_texture(struct sc_display *display, const AVFrame *frame) {
+    int ret = SDL_UpdateYUVTexture(display->texture, NULL,
+                                   frame->data[0], frame->linesize[0],
+                                   frame->data[1], frame->linesize[1],
+                                   frame->data[2], frame->linesize[2]);
+    if (ret) {
+        LOGE("Could not update texture: %s", SDL_GetError());
+        return false;
+    }
+
+    if (display->mipmaps) {
+        SDL_GL_BindTexture(display->texture, NULL, NULL);
+        display->gl.GenerateMipmap(GL_TEXTURE_2D);
+        SDL_GL_UnbindTexture(display->texture);
+    }
+
+    return true;
+}
+
+bool
+sc_display_render(struct sc_display *display, const SDL_Rect *geometry,
+                  unsigned rotation) {
+    SDL_RenderClear(display->renderer);
+
+    SDL_Renderer *renderer = display->renderer;
+    SDL_Texture *texture = display->texture;
+
+    if (rotation == 0) {
+        int ret = SDL_RenderCopy(renderer, texture, NULL, geometry);
+        if (ret) {
+            LOGE("Could not render texture: %s", SDL_GetError());
+            return false;
+        }
+    } else {
+        // rotation in RenderCopyEx() is clockwise, while screen->rotation is
+        // counterclockwise (to be consistent with --lock-video-orientation)
+        int cw_rotation = (4 - rotation) % 4;
+        double angle = 90 * cw_rotation;
+
+        const SDL_Rect *dstrect = NULL;
+        SDL_Rect rect;
+        if (rotation & 1) {
+            rect.x = geometry->x + (geometry->w - geometry->h) / 2;
+            rect.y = geometry->y + (geometry->h - geometry->w) / 2;
+            rect.w = geometry->h;
+            rect.h = geometry->w;
+            dstrect = &rect;
+        } else {
+            assert(rotation == 2);
+            dstrect = geometry;
+        }
+
+        int ret = SDL_RenderCopyEx(renderer, texture, NULL, dstrect, angle,
+                                   NULL, 0);
+        if (ret) {
+            LOGE("Could not render texture: %s", SDL_GetError());
+            return false;
+        }
+    }
+
+    SDL_RenderPresent(display->renderer);
+    return true;
+}

app/src/display.h

@@ -0,0 +1,45 @@
+#ifndef SC_DISPLAY_H
+#define SC_DISPLAY_H
+
+#include "common.h"
+
+#include <stdbool.h>
+#include <libavformat/avformat.h>
+#include <SDL2/SDL.h>
+
+#include "coords.h"
+#include "opengl.h"
+
+#ifdef __APPLE__
+# define SC_DISPLAY_FORCE_OPENGL_CORE_PROFILE
+#endif
+
+struct sc_display {
+    SDL_Renderer *renderer;
+    SDL_Texture *texture;
+
+    struct sc_opengl gl;
+#ifdef SC_DISPLAY_FORCE_OPENGL_CORE_PROFILE
+    SDL_GLContext *gl_context;
+#endif
+
+    bool mipmaps;
+};
+
+bool
+sc_display_init(struct sc_display *display, SDL_Window *window, bool mipmaps);
+
+void
+sc_display_destroy(struct sc_display *display);
+
+bool
+sc_display_set_texture_size(struct sc_display *display, struct sc_size size);
+
+bool
+sc_display_update_texture(struct sc_display *display, const AVFrame *frame);
+
+bool
+sc_display_render(struct sc_display *display, const SDL_Rect *geometry,
+                  unsigned rotation);
+
+#endif

app/src/input_manager.c

@@ -797,7 +797,8 @@ sc_input_manager_process_file(struct sc_input_manager *im,
 }
 
 void
-sc_input_manager_handle_event(struct sc_input_manager *im, SDL_Event *event) {
+sc_input_manager_handle_event(struct sc_input_manager *im,
+                              const SDL_Event *event) {
     bool control = im->controller;
     switch (event->type) {
         case SDL_TEXTINPUT:

app/src/input_manager.h

@@ -61,6 +61,7 @@ sc_input_manager_init(struct sc_input_manager *im,
                       const struct sc_input_manager_params *params);
 
 void
-sc_input_manager_handle_event(struct sc_input_manager *im, SDL_Event *event);
+sc_input_manager_handle_event(struct sc_input_manager *im,
+                              const SDL_Event *event);
 
 #endif

app/src/scrcpy.c

@@ -630,17 +630,6 @@ aoa_hid_end:
         }
         controller_started = true;
         controller = &s->controller;
-
-        if (options->turn_screen_off) {
-            struct sc_control_msg msg;
-            msg.type = SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE;
-            msg.set_screen_power_mode.mode = SC_SCREEN_POWER_MODE_OFF;
-
-            if (!sc_controller_push_msg(&s->controller, &msg)) {
-                LOGW("Could not request 'set screen power mode'");
-            }
-        }
-
     }
 
     // There is a controller if and only if control is enabled
@@ -728,6 +717,18 @@ aoa_hid_end:
         audio_demuxer_started = true;
     }
 
+    // If the device screen is to be turned off, send the control message after
+    // everything is set up
+    if (options->control && options->turn_screen_off) {
+        struct sc_control_msg msg;
+        msg.type = SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE;
+        msg.set_screen_power_mode.mode = SC_SCREEN_POWER_MODE_OFF;
+
+        if (!sc_controller_push_msg(&s->controller, &msg)) {
+            LOGW("Could not request 'set screen power mode'");
+        }
+    }
+
     ret = event_loop(s);
     LOGD("quit...");
 

app/src/screen.c

@@ -239,35 +239,6 @@ sc_screen_update_content_rect(struct sc_screen *screen) {
     }
 }
 
-static bool
-create_texture(struct sc_screen *screen) {
-    SDL_Renderer *renderer = screen->renderer;
-    struct sc_size size = screen->frame_size;
-    SDL_Texture *texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_YV12,
-                                             SDL_TEXTUREACCESS_STREAMING,
-                                             size.width, size.height);
-    if (!texture) {
-        LOGE("Could not create texture: %s", SDL_GetError());
-        return false;
-    }
-
-    if (screen->mipmaps) {
-        struct sc_opengl *gl = &screen->gl;
-
-        SDL_GL_BindTexture(texture, NULL, NULL);
-
-        // Enable trilinear filtering for downscaling
-        gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
-                          GL_LINEAR_MIPMAP_LINEAR);
-        gl->TexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, -1.f);
-
-        SDL_GL_UnbindTexture(texture);
-    }
-
-    screen->texture = texture;
-    return true;
-}
-
 // render the texture to the renderer
 //
 // Set the update_content_rect flag if the window or content size may have
@@ -278,35 +249,11 @@ sc_screen_render(struct sc_screen *screen, bool update_content_rect) {
         sc_screen_update_content_rect(screen);
     }
 
-    SDL_RenderClear(screen->renderer);
+    bool ok = sc_display_render(&screen->display, &screen->rect,
-    if (screen->rotation == 0) {
+                                screen->rotation);
-        SDL_RenderCopy(screen->renderer, screen->texture, NULL, &screen->rect);
+    (void) ok; // error already logged
-    } else {
-        // rotation in RenderCopyEx() is clockwise, while screen->rotation is
-        // counterclockwise (to be consistent with --lock-video-orientation)
-        int cw_rotation = (4 - screen->rotation) % 4;
-        double angle = 90 * cw_rotation;
-
-        SDL_Rect *dstrect = NULL;
-        SDL_Rect rect;
-        if (screen->rotation & 1) {
-            rect.x = screen->rect.x + (screen->rect.w - screen->rect.h) / 2;
-            rect.y = screen->rect.y + (screen->rect.h - screen->rect.w) / 2;
-            rect.w = screen->rect.h;
-            rect.h = screen->rect.w;
-            dstrect = ▭
-        } else {
-            assert(screen->rotation == 2);
-            dstrect = &screen->rect;
-        }
-
-        SDL_RenderCopyEx(screen->renderer, screen->texture, NULL, dstrect,
-                         angle, NULL, 0);
-    }
-    SDL_RenderPresent(screen->renderer);
 }
 
-
 #if defined(__APPLE__) || defined(__WINDOWS__)
 # define CONTINUOUS_RESIZING_WORKAROUND
 #endif
@@ -453,46 +400,11 @@ sc_screen_init(struct sc_screen *screen,
         goto error_destroy_fps_counter;
     }
 
-    screen->renderer = SDL_CreateRenderer(screen->window, -1,
+    ok = sc_display_init(&screen->display, screen->window, params->mipmaps);
-                                          SDL_RENDERER_ACCELERATED);
+    if (!ok) {
-    if (!screen->renderer) {
-        LOGE("Could not create renderer: %s", SDL_GetError());
         goto error_destroy_window;
     }
 
-    SDL_RendererInfo renderer_info;
-    int r = SDL_GetRendererInfo(screen->renderer, &renderer_info);
-    const char *renderer_name = r ? NULL : renderer_info.name;
-    LOGI("Renderer: %s", renderer_name ? renderer_name : "(unknown)");
-
-    screen->mipmaps = false;
-
-    // starts with "opengl"
-    bool use_opengl = renderer_name && !strncmp(renderer_name, "opengl", 6);
-    if (use_opengl) {
-        struct sc_opengl *gl = &screen->gl;
-        sc_opengl_init(gl);
-
-        LOGI("OpenGL version: %s", gl->version);
-
-        if (params->mipmaps) {
-            bool supports_mipmaps =
-                sc_opengl_version_at_least(gl, 3, 0, /* OpenGL 3.0+ */
-                                               2, 0  /* OpenGL ES 2.0+ */);
-            if (supports_mipmaps) {
-                LOGI("Trilinear filtering enabled");
-                screen->mipmaps = true;
-            } else {
-                LOGW("Trilinear filtering disabled "
-                     "(OpenGL 3.0+ or ES 2.0+ required)");
-            }
-        } else {
-            LOGI("Trilinear filtering disabled");
-        }
-    } else if (params->mipmaps) {
-        LOGD("Trilinear filtering disabled (not an OpenGL renderer)");
-    }
-
     SDL_Surface *icon = scrcpy_icon_load();
     if (icon) {
         SDL_SetWindowIcon(screen->window, icon);
@@ -504,7 +416,7 @@ sc_screen_init(struct sc_screen *screen,
     screen->frame = av_frame_alloc();
     if (!screen->frame) {
         LOG_OOM();
-        goto error_destroy_renderer;
+        goto error_destroy_display;
     }
 
     struct sc_input_manager_params im_params = {
@@ -539,8 +451,8 @@ sc_screen_init(struct sc_screen *screen,
 
     return true;
 
-error_destroy_renderer:
+error_destroy_display:
-    SDL_DestroyRenderer(screen->renderer);
+    sc_display_destroy(&screen->display);
 error_destroy_window:
     SDL_DestroyWindow(screen->window);
 error_destroy_fps_counter:
@@ -596,11 +508,8 @@ sc_screen_destroy(struct sc_screen *screen) {
 #ifndef NDEBUG
     assert(!screen->open);
 #endif
+    sc_display_destroy(&screen->display);
     av_frame_free(&screen->frame);
-    if (screen->texture) {
-        SDL_DestroyTexture(screen->texture);
-    }
-    SDL_DestroyRenderer(screen->renderer);
     SDL_DestroyWindow(screen->window);
     sc_fps_counter_destroy(&screen->fps_counter);
     sc_frame_buffer_destroy(&screen->fb);
@@ -667,7 +576,6 @@ static bool
 sc_screen_init_size(struct sc_screen *screen) {
     // Before first frame
     assert(!screen->has_frame);
-    assert(!screen->texture);
 
     // The requested size is passed via screen->frame_size
 
@@ -675,48 +583,27 @@ sc_screen_init_size(struct sc_screen *screen) {
         get_rotated_size(screen->frame_size, screen->rotation);
     screen->content_size = content_size;
 
-    LOGI("Initial texture: %" PRIu16 "x%" PRIu16,
+    return sc_display_set_texture_size(&screen->display, screen->frame_size);
-                 screen->frame_size.width, screen->frame_size.height);
-    return create_texture(screen);
 }
 
 // recreate the texture and resize the window if the frame size has changed
 static bool
 prepare_for_frame(struct sc_screen *screen, struct sc_size new_frame_size) {
-    if (screen->frame_size.width != new_frame_size.width
+    if (screen->frame_size.width == new_frame_size.width
-            || screen->frame_size.height != new_frame_size.height) {
+            && screen->frame_size.height == new_frame_size.height) {
-        // frame dimension changed, destroy texture
+        return true;
-        SDL_DestroyTexture(screen->texture);
-
-        screen->frame_size = new_frame_size;
-
-        struct sc_size new_content_size =
-            get_rotated_size(new_frame_size, screen->rotation);
-        set_content_size(screen, new_content_size);
-
-        sc_screen_update_content_rect(screen);
-
-        LOGI("New texture: %" PRIu16 "x%" PRIu16,
-                     screen->frame_size.width, screen->frame_size.height);
-        return create_texture(screen);
     }
 
-    return true;
+    // frame dimension changed
-}
+    screen->frame_size = new_frame_size;
 
-// write the frame into the texture
+    struct sc_size new_content_size =
-static void
+        get_rotated_size(new_frame_size, screen->rotation);
-update_texture(struct sc_screen *screen, const AVFrame *frame) {
+    set_content_size(screen, new_content_size);
-    SDL_UpdateYUVTexture(screen->texture, NULL,
-            frame->data[0], frame->linesize[0],
-            frame->data[1], frame->linesize[1],
-            frame->data[2], frame->linesize[2]);
 
-    if (screen->mipmaps) {
+    sc_screen_update_content_rect(screen);
-        SDL_GL_BindTexture(screen->texture, NULL, NULL);
+
-        screen->gl.GenerateMipmap(GL_TEXTURE_2D);
+    return sc_display_set_texture_size(&screen->display, screen->frame_size);
-        SDL_GL_UnbindTexture(screen->texture);
-    }
 }
 
 static bool
@@ -731,7 +618,10 @@ sc_screen_update_frame(struct sc_screen *screen) {
     if (!prepare_for_frame(screen, new_frame_size)) {
         return false;
     }
-    update_texture(screen, frame);
+
+    if (!sc_display_update_texture(&screen->display, frame)) {
+        return false;
+    }
 
     if (!screen->has_frame) {
         screen->has_frame = true;
@@ -812,7 +702,7 @@ sc_screen_is_mouse_capture_key(SDL_Keycode key) {
 }
 
 bool
-sc_screen_handle_event(struct sc_screen *screen, SDL_Event *event) {
+sc_screen_handle_event(struct sc_screen *screen, const SDL_Event *event) {
     bool relative_mode = sc_screen_is_relative_mode(screen);
 
     switch (event->type) {

app/src/screen.h

@@ -9,6 +9,7 @@
 
 #include "controller.h"
 #include "coords.h"
+#include "display.h"
 #include "fps_counter.h"
 #include "frame_buffer.h"
 #include "input_manager.h"
@@ -24,6 +25,7 @@ struct sc_screen {
     bool open; // track the open/close state to assert correct behavior
 #endif
 
+    struct sc_display display;
     struct sc_input_manager im;
     struct sc_frame_buffer fb;
     struct sc_fps_counter fps_counter;
@@ -39,9 +41,6 @@ struct sc_screen {
     } req;
 
     SDL_Window *window;
-    SDL_Renderer *renderer;
-    SDL_Texture *texture;
-    struct sc_opengl gl;
     struct sc_size frame_size;
     struct sc_size content_size; // rotated frame_size
 
@@ -57,7 +56,6 @@ struct sc_screen {
     bool has_frame;
     bool fullscreen;
     bool maximized;
-    bool mipmaps;
 
     // To enable/disable mouse capture, a mouse capture key (LALT, LGUI or
     // RGUI) must be pressed. This variable tracks the pressed capture key.
@@ -137,7 +135,7 @@ sc_screen_set_rotation(struct sc_screen *screen, unsigned rotation);
 // react to SDL events
 // If this function returns false, scrcpy must exit with an error.
 bool
-sc_screen_handle_event(struct sc_screen *screen, SDL_Event *event);
+sc_screen_handle_event(struct sc_screen *screen, const SDL_Event *event);
 
 // convert point from window coordinates to frame coordinates
 // x and y are expressed in pixels

app/tests/test_adb_parser.c

@@ -217,6 +217,18 @@ static void test_get_ip_multiline_second_ok(void) {
     free(ip);
 }
 
+static void test_get_ip_multiline_second_ok_without_cr(void) {
+    char ip_route[] = "10.0.0.0/24 dev rmnet  proto kernel  scope link  src "
+                      "10.0.0.3\n"
+                      "192.168.1.0/24 dev wlan0  proto kernel  scope link  src "
+                      "192.168.1.3\n";
+
+    char *ip = sc_adb_parse_device_ip(ip_route);
+    assert(ip);
+    assert(!strcmp(ip, "192.168.1.3"));
+    free(ip);
+}
+
 static void test_get_ip_no_wlan(void) {
     char ip_route[] = "192.168.1.0/24 dev rmnet  proto kernel  scope link  src "
                       "192.168.12.34\r\r\n";
@@ -259,6 +271,7 @@ int main(int argc, char *argv[]) {
     test_get_ip_single_line_with_trailing_space();
     test_get_ip_multiline_first_ok();
     test_get_ip_multiline_second_ok();
+    test_get_ip_multiline_second_ok_without_cr();
     test_get_ip_no_wlan();
     test_get_ip_no_wlan_without_eol();
     test_get_ip_truncated();

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

@@ -86,8 +86,8 @@ public final class AudioCapture {
             } catch (UnsupportedOperationException e) {
                 if (attempts == 0) {
                     Ln.e("Failed to start audio capture");
-                    Ln.e("On Android 11, audio capture must be started in the foreground, make sure that the device is unlocked when starting " +
+                    Ln.e("On Android 11, audio capture must be started in the foreground, make sure that the device is unlocked when starting "
-                            "scrcpy.");
+                            + "scrcpy.");
                     throw new AudioCaptureForegroundException();
                 } else {
                     Ln.d("Failed to start audio capture, retrying...");

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

@@ -1,6 +1,7 @@
 package com.genymobile.scrcpy;
 
 import android.media.MediaCodec;
+import android.os.Build;
 
 import java.io.IOException;
 import java.nio.ByteBuffer;
@@ -19,6 +20,12 @@ public final class AudioRawRecorder implements AsyncProcessor {
     }
 
     private void record() throws IOException, AudioCaptureForegroundException {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
+            Ln.w("Audio disabled: it is not supported before Android 11");
+            streamer.writeDisableStream(false);
+            return;
+        }
+
         final ByteBuffer buffer = ByteBuffer.allocateDirect(READ_SIZE);
         final MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
 

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

@@ -3,6 +3,7 @@ package com.genymobile.scrcpy;
 import android.graphics.Rect;
 
 import java.util.List;
+import java.util.Locale;
 
 public class Options {
 
@@ -46,166 +47,82 @@ public class Options {
         return logLevel;
     }
 
-    public void setLogLevel(Ln.Level logLevel) {
-        this.logLevel = logLevel;
-    }
-
     public int getScid() {
         return scid;
     }
 
-    public void setScid(int scid) {
-        this.scid = scid;
-    }
-
     public boolean getAudio() {
         return audio;
     }
 
-    public void setAudio(boolean audio) {
-        this.audio = audio;
-    }
-
     public int getMaxSize() {
         return maxSize;
     }
 
-    public void setMaxSize(int maxSize) {
-        this.maxSize = maxSize;
-    }
-
     public VideoCodec getVideoCodec() {
         return videoCodec;
     }
 
-    public void setVideoCodec(VideoCodec videoCodec) {
-        this.videoCodec = videoCodec;
-    }
-
     public AudioCodec getAudioCodec() {
         return audioCodec;
     }
 
-    public void setAudioCodec(AudioCodec audioCodec) {
-        this.audioCodec = audioCodec;
-    }
-
     public int getVideoBitRate() {
         return videoBitRate;
     }
 
-    public void setVideoBitRate(int videoBitRate) {
-        this.videoBitRate = videoBitRate;
-    }
-
     public int getAudioBitRate() {
         return audioBitRate;
     }
 
-    public void setAudioBitRate(int audioBitRate) {
-        this.audioBitRate = audioBitRate;
-    }
-
     public int getMaxFps() {
         return maxFps;
     }
 
-    public void setMaxFps(int maxFps) {
-        this.maxFps = maxFps;
-    }
-
     public int getLockVideoOrientation() {
         return lockVideoOrientation;
     }
 
-    public void setLockVideoOrientation(int lockVideoOrientation) {
-        this.lockVideoOrientation = lockVideoOrientation;
-    }
-
     public boolean isTunnelForward() {
         return tunnelForward;
     }
 
-    public void setTunnelForward(boolean tunnelForward) {
-        this.tunnelForward = tunnelForward;
-    }
-
     public Rect getCrop() {
         return crop;
     }
 
-    public void setCrop(Rect crop) {
-        this.crop = crop;
-    }
-
     public boolean getControl() {
         return control;
     }
 
-    public void setControl(boolean control) {
-        this.control = control;
-    }
-
     public int getDisplayId() {
         return displayId;
     }
 
-    public void setDisplayId(int displayId) {
-        this.displayId = displayId;
-    }
-
     public boolean getShowTouches() {
         return showTouches;
     }
 
-    public void setShowTouches(boolean showTouches) {
-        this.showTouches = showTouches;
-    }
-
     public boolean getStayAwake() {
         return stayAwake;
     }
 
-    public void setStayAwake(boolean stayAwake) {
-        this.stayAwake = stayAwake;
-    }
-
     public List<CodecOption> getVideoCodecOptions() {
         return videoCodecOptions;
     }
 
-    public void setVideoCodecOptions(List<CodecOption> videoCodecOptions) {
-        this.videoCodecOptions = videoCodecOptions;
-    }
-
     public List<CodecOption> getAudioCodecOptions() {
         return audioCodecOptions;
     }
 
-    public void setAudioCodecOptions(List<CodecOption> audioCodecOptions) {
-        this.audioCodecOptions = audioCodecOptions;
-    }
-
     public String getVideoEncoder() {
         return videoEncoder;
     }
 
-    public void setVideoEncoder(String videoEncoder) {
-        this.videoEncoder = videoEncoder;
-    }
-
     public String getAudioEncoder() {
         return audioEncoder;
     }
 
-    public void setAudioEncoder(String audioEncoder) {
-        this.audioEncoder = audioEncoder;
-    }
-
-    public void setPowerOffScreenOnClose(boolean powerOffScreenOnClose) {
-        this.powerOffScreenOnClose = powerOffScreenOnClose;
-    }
-
     public boolean getPowerOffScreenOnClose() {
         return this.powerOffScreenOnClose;
     }
@@ -214,79 +131,204 @@ public class Options {
         return clipboardAutosync;
     }
 
-    public void setClipboardAutosync(boolean clipboardAutosync) {
-        this.clipboardAutosync = clipboardAutosync;
-    }
-
     public boolean getDownsizeOnError() {
         return downsizeOnError;
     }
 
-    public void setDownsizeOnError(boolean downsizeOnError) {
-        this.downsizeOnError = downsizeOnError;
-    }
-
     public boolean getCleanup() {
         return cleanup;
     }
 
-    public void setCleanup(boolean cleanup) {
-        this.cleanup = cleanup;
-    }
-
     public boolean getPowerOn() {
         return powerOn;
     }
 
-    public void setPowerOn(boolean powerOn) {
-        this.powerOn = powerOn;
-    }
-
     public boolean getListEncoders() {
         return listEncoders;
     }
 
-    public void setListEncoders(boolean listEncoders) {
-        this.listEncoders = listEncoders;
-    }
-
     public boolean getListDisplays() {
         return listDisplays;
     }
 
-    public void setListDisplays(boolean listDisplays) {
-        this.listDisplays = listDisplays;
-    }
-
     public boolean getSendDeviceMeta() {
         return sendDeviceMeta;
     }
 
-    public void setSendDeviceMeta(boolean sendDeviceMeta) {
-        this.sendDeviceMeta = sendDeviceMeta;
-    }
-
     public boolean getSendFrameMeta() {
         return sendFrameMeta;
     }
 
-    public void setSendFrameMeta(boolean sendFrameMeta) {
-        this.sendFrameMeta = sendFrameMeta;
-    }
-
     public boolean getSendDummyByte() {
         return sendDummyByte;
     }
 
-    public void setSendDummyByte(boolean sendDummyByte) {
-        this.sendDummyByte = sendDummyByte;
-    }
-
     public boolean getSendCodecMeta() {
         return sendCodecMeta;
     }
 
-    public void setSendCodecMeta(boolean sendCodecMeta) {
+    @SuppressWarnings("MethodLength")
-        this.sendCodecMeta = sendCodecMeta;
+    public static Options parse(String... args) {
+        if (args.length < 1) {
+            throw new IllegalArgumentException("Missing client version");
+        }
+
+        String clientVersion = args[0];
+        if (!clientVersion.equals(BuildConfig.VERSION_NAME)) {
+            throw new IllegalArgumentException(
+                    "The server version (" + BuildConfig.VERSION_NAME + ") does not match the client " + "(" + clientVersion + ")");
+        }
+
+        Options options = new Options();
+
+        for (int i = 1; i < args.length; ++i) {
+            String arg = args[i];
+            int equalIndex = arg.indexOf('=');
+            if (equalIndex == -1) {
+                throw new IllegalArgumentException("Invalid key=value pair: \"" + arg + "\"");
+            }
+            String key = arg.substring(0, equalIndex);
+            String value = arg.substring(equalIndex + 1);
+            switch (key) {
+                case "scid":
+                    int scid = Integer.parseInt(value, 0x10);
+                    if (scid < -1) {
+                        throw new IllegalArgumentException("scid may not be negative (except -1 for 'none'): " + scid);
+                    }
+                    options.scid = scid;
+                    break;
+                case "log_level":
+                    options.logLevel = Ln.Level.valueOf(value.toUpperCase(Locale.ENGLISH));
+                    break;
+                case "audio":
+                    options.audio = Boolean.parseBoolean(value);
+                    break;
+                case "video_codec":
+                    VideoCodec videoCodec = VideoCodec.findByName(value);
+                    if (videoCodec == null) {
+                        throw new IllegalArgumentException("Video codec " + value + " not supported");
+                    }
+                    options.videoCodec = videoCodec;
+                    break;
+                case "audio_codec":
+                    AudioCodec audioCodec = AudioCodec.findByName(value);
+                    if (audioCodec == null) {
+                        throw new IllegalArgumentException("Audio codec " + value + " not supported");
+                    }
+                    options.audioCodec = audioCodec;
+                    break;
+                case "max_size":
+                    options.maxSize = Integer.parseInt(value) & ~7; // multiple of 8
+                    break;
+                case "video_bit_rate":
+                    options.videoBitRate = Integer.parseInt(value);
+                    break;
+                case "audio_bit_rate":
+                    options.audioBitRate = Integer.parseInt(value);
+                    break;
+                case "max_fps":
+                    options.maxFps = Integer.parseInt(value);
+                    break;
+                case "lock_video_orientation":
+                    options.lockVideoOrientation = Integer.parseInt(value);
+                    break;
+                case "tunnel_forward":
+                    options.tunnelForward = Boolean.parseBoolean(value);
+                    break;
+                case "crop":
+                    options.crop = parseCrop(value);
+                    break;
+                case "control":
+                    options.control = Boolean.parseBoolean(value);
+                    break;
+                case "display_id":
+                    options.displayId = Integer.parseInt(value);
+                    break;
+                case "show_touches":
+                    options.showTouches = Boolean.parseBoolean(value);
+                    break;
+                case "stay_awake":
+                    options.stayAwake = Boolean.parseBoolean(value);
+                    break;
+                case "video_codec_options":
+                    options.videoCodecOptions = CodecOption.parse(value);
+                    break;
+                case "audio_codec_options":
+                    options.audioCodecOptions = CodecOption.parse(value);
+                    break;
+                case "video_encoder":
+                    if (!value.isEmpty()) {
+                        options.videoEncoder = value;
+                    }
+                    break;
+                case "audio_encoder":
+                    if (!value.isEmpty()) {
+                        options.audioEncoder = value;
+                    }
+                case "power_off_on_close":
+                    options.powerOffScreenOnClose = Boolean.parseBoolean(value);
+                    break;
+                case "clipboard_autosync":
+                    options.clipboardAutosync = Boolean.parseBoolean(value);
+                    break;
+                case "downsize_on_error":
+                    options.downsizeOnError = Boolean.parseBoolean(value);
+                    break;
+                case "cleanup":
+                    options.cleanup = Boolean.parseBoolean(value);
+                    break;
+                case "power_on":
+                    options.powerOn = Boolean.parseBoolean(value);
+                    break;
+                case "list_encoders":
+                    options.listEncoders = Boolean.parseBoolean(value);
+                    break;
+                case "list_displays":
+                    options.listDisplays = Boolean.parseBoolean(value);
+                    break;
+                case "send_device_meta":
+                    options.sendDeviceMeta = Boolean.parseBoolean(value);
+                    break;
+                case "send_frame_meta":
+                    options.sendFrameMeta = Boolean.parseBoolean(value);
+                    break;
+                case "send_dummy_byte":
+                    options.sendDummyByte = Boolean.parseBoolean(value);
+                    break;
+                case "send_codec_meta":
+                    options.sendCodecMeta = Boolean.parseBoolean(value);
+                    break;
+                case "raw_video_stream":
+                    boolean rawVideoStream = Boolean.parseBoolean(value);
+                    if (rawVideoStream) {
+                        options.sendDeviceMeta = false;
+                        options.sendFrameMeta = false;
+                        options.sendDummyByte = false;
+                        options.sendCodecMeta = false;
+                    }
+                    break;
+                default:
+                    Ln.w("Unknown server option: " + key);
+                    break;
+            }
+        }
+
+        return options;
+    }
+
+    private static Rect parseCrop(String crop) {
+        if (crop.isEmpty()) {
+            return null;
+        }
+        // input format: "width:height:x:y"
+        String[] tokens = crop.split(":");
+        if (tokens.length != 4) {
+            throw new IllegalArgumentException("Crop must contains 4 values separated by colons: \"" + crop + "\"");
+        }
+        int width = Integer.parseInt(tokens[0]);
+        int height = Integer.parseInt(tokens[1]);
+        int x = Integer.parseInt(tokens[2]);
+        int y = Integer.parseInt(tokens[3]);
+        return new Rect(x, y, x + width, y + height);
     }
 }

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

@@ -1,13 +1,11 @@
 package com.genymobile.scrcpy;
 
-import android.graphics.Rect;
 import android.os.BatteryManager;
 import android.os.Build;
 
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Locale;
 
 public final class Server {
 
@@ -161,203 +159,12 @@ public final class Server {
         return thread;
     }
 
-    @SuppressWarnings("MethodLength")
-    private static Options createOptions(String... args) {
-        if (args.length < 1) {
-            throw new IllegalArgumentException("Missing client version");
-        }
-
-        String clientVersion = args[0];
-        if (!clientVersion.equals(BuildConfig.VERSION_NAME)) {
-            throw new IllegalArgumentException(
-                    "The server version (" + BuildConfig.VERSION_NAME + ") does not match the client " + "(" + clientVersion + ")");
-        }
-
-        Options options = new Options();
-
-        for (int i = 1; i < args.length; ++i) {
-            String arg = args[i];
-            int equalIndex = arg.indexOf('=');
-            if (equalIndex == -1) {
-                throw new IllegalArgumentException("Invalid key=value pair: \"" + arg + "\"");
-            }
-            String key = arg.substring(0, equalIndex);
-            String value = arg.substring(equalIndex + 1);
-            switch (key) {
-                case "scid":
-                    int scid = Integer.parseInt(value, 0x10);
-                    if (scid < -1) {
-                        throw new IllegalArgumentException("scid may not be negative (except -1 for 'none'): " + scid);
-                    }
-                    options.setScid(scid);
-                    break;
-                case "log_level":
-                    Ln.Level level = Ln.Level.valueOf(value.toUpperCase(Locale.ENGLISH));
-                    options.setLogLevel(level);
-                    break;
-                case "audio":
-                    boolean audio = Boolean.parseBoolean(value);
-                    options.setAudio(audio);
-                    break;
-                case "video_codec":
-                    VideoCodec videoCodec = VideoCodec.findByName(value);
-                    if (videoCodec == null) {
-                        throw new IllegalArgumentException("Video codec " + value + " not supported");
-                    }
-                    options.setVideoCodec(videoCodec);
-                    break;
-                case "audio_codec":
-                    AudioCodec audioCodec = AudioCodec.findByName(value);
-                    if (audioCodec == null) {
-                        throw new IllegalArgumentException("Audio codec " + value + " not supported");
-                    }
-                    options.setAudioCodec(audioCodec);
-                    break;
-                case "max_size":
-                    int maxSize = Integer.parseInt(value) & ~7; // multiple of 8
-                    options.setMaxSize(maxSize);
-                    break;
-                case "video_bit_rate":
-                    int videoBitRate = Integer.parseInt(value);
-                    options.setVideoBitRate(videoBitRate);
-                    break;
-                case "audio_bit_rate":
-                    int audioBitRate = Integer.parseInt(value);
-                    options.setAudioBitRate(audioBitRate);
-                    break;
-                case "max_fps":
-                    int maxFps = Integer.parseInt(value);
-                    options.setMaxFps(maxFps);
-                    break;
-                case "lock_video_orientation":
-                    int lockVideoOrientation = Integer.parseInt(value);
-                    options.setLockVideoOrientation(lockVideoOrientation);
-                    break;
-                case "tunnel_forward":
-                    boolean tunnelForward = Boolean.parseBoolean(value);
-                    options.setTunnelForward(tunnelForward);
-                    break;
-                case "crop":
-                    Rect crop = parseCrop(value);
-                    options.setCrop(crop);
-                    break;
-                case "control":
-                    boolean control = Boolean.parseBoolean(value);
-                    options.setControl(control);
-                    break;
-                case "display_id":
-                    int displayId = Integer.parseInt(value);
-                    options.setDisplayId(displayId);
-                    break;
-                case "show_touches":
-                    boolean showTouches = Boolean.parseBoolean(value);
-                    options.setShowTouches(showTouches);
-                    break;
-                case "stay_awake":
-                    boolean stayAwake = Boolean.parseBoolean(value);
-                    options.setStayAwake(stayAwake);
-                    break;
-                case "video_codec_options":
-                    List<CodecOption> videoCodecOptions = CodecOption.parse(value);
-                    options.setVideoCodecOptions(videoCodecOptions);
-                    break;
-                case "audio_codec_options":
-                    List<CodecOption> audioCodecOptions = CodecOption.parse(value);
-                    options.setAudioCodecOptions(audioCodecOptions);
-                    break;
-                case "video_encoder":
-                    if (!value.isEmpty()) {
-                        options.setVideoEncoder(value);
-                    }
-                    break;
-                case "audio_encoder":
-                    if (!value.isEmpty()) {
-                        options.setAudioEncoder(value);
-                    }
-                case "power_off_on_close":
-                    boolean powerOffScreenOnClose = Boolean.parseBoolean(value);
-                    options.setPowerOffScreenOnClose(powerOffScreenOnClose);
-                    break;
-                case "clipboard_autosync":
-                    boolean clipboardAutosync = Boolean.parseBoolean(value);
-                    options.setClipboardAutosync(clipboardAutosync);
-                    break;
-                case "downsize_on_error":
-                    boolean downsizeOnError = Boolean.parseBoolean(value);
-                    options.setDownsizeOnError(downsizeOnError);
-                    break;
-                case "cleanup":
-                    boolean cleanup = Boolean.parseBoolean(value);
-                    options.setCleanup(cleanup);
-                    break;
-                case "power_on":
-                    boolean powerOn = Boolean.parseBoolean(value);
-                    options.setPowerOn(powerOn);
-                    break;
-                case "list_encoders":
-                    boolean listEncoders = Boolean.parseBoolean(value);
-                    options.setListEncoders(listEncoders);
-                    break;
-                case "list_displays":
-                    boolean listDisplays = Boolean.parseBoolean(value);
-                    options.setListDisplays(listDisplays);
-                    break;
-                case "send_device_meta":
-                    boolean sendDeviceMeta = Boolean.parseBoolean(value);
-                    options.setSendDeviceMeta(sendDeviceMeta);
-                    break;
-                case "send_frame_meta":
-                    boolean sendFrameMeta = Boolean.parseBoolean(value);
-                    options.setSendFrameMeta(sendFrameMeta);
-                    break;
-                case "send_dummy_byte":
-                    boolean sendDummyByte = Boolean.parseBoolean(value);
-                    options.setSendDummyByte(sendDummyByte);
-                    break;
-                case "send_codec_meta":
-                    boolean sendCodecMeta = Boolean.parseBoolean(value);
-                    options.setSendCodecMeta(sendCodecMeta);
-                    break;
-                case "raw_video_stream":
-                    boolean rawVideoStream = Boolean.parseBoolean(value);
-                    if (rawVideoStream) {
-                        options.setSendDeviceMeta(false);
-                        options.setSendFrameMeta(false);
-                        options.setSendDummyByte(false);
-                        options.setSendCodecMeta(false);
-                    }
-                    break;
-                default:
-                    Ln.w("Unknown server option: " + key);
-                    break;
-            }
-        }
-
-        return options;
-    }
-
-    private static Rect parseCrop(String crop) {
-        if (crop.isEmpty()) {
-            return null;
-        }
-        // input format: "width:height:x:y"
-        String[] tokens = crop.split(":");
-        if (tokens.length != 4) {
-            throw new IllegalArgumentException("Crop must contains 4 values separated by colons: \"" + crop + "\"");
-        }
-        int width = Integer.parseInt(tokens[0]);
-        int height = Integer.parseInt(tokens[1]);
-        int x = Integer.parseInt(tokens[2]);
-        int y = Integer.parseInt(tokens[3]);
-        return new Rect(x, y, x + width, y + height);
-    }
-
     public static void main(String... args) throws Exception {
         Thread.setDefaultUncaughtExceptionHandler((t, e) -> {
             Ln.e("Exception on thread " + t, e);
         });
 
-        Options options = createOptions(args);
+        Options options = Options.parse(args);
 
         Ln.initLogLevel(options.getLogLevel());
 

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

@@ -37,8 +37,13 @@ public class ClipboardManager {
                         getPrimaryClipMethod = manager.getClass().getMethod("getPrimaryClip", String.class, String.class, int.class);
                         getMethodVersion = 1;
                     } catch (NoSuchMethodException e2) {
-                        getPrimaryClipMethod = manager.getClass().getMethod("getPrimaryClip", String.class, String.class, int.class, int.class);
+                        try {
-                        getMethodVersion = 2;
+                            getPrimaryClipMethod = manager.getClass().getMethod("getPrimaryClip", String.class, String.class, int.class, int.class);
+                            getMethodVersion = 2;
+                        } catch (NoSuchMethodException e3) {
+                            getPrimaryClipMethod = manager.getClass().getMethod("getPrimaryClip", String.class, int.class, String.class);
+                            getMethodVersion = 3;
+                        }
                     }
                 }
             }
@@ -80,8 +85,10 @@ public class ClipboardManager {
                 return (ClipData) method.invoke(manager, FakeContext.PACKAGE_NAME, FakeContext.ROOT_UID);
             case 1:
                 return (ClipData) method.invoke(manager, FakeContext.PACKAGE_NAME, null, FakeContext.ROOT_UID);
-            default:
+            case 2:
                 return (ClipData) method.invoke(manager, FakeContext.PACKAGE_NAME, null, FakeContext.ROOT_UID, 0);
+            default:
+                return (ClipData) method.invoke(manager, FakeContext.PACKAGE_NAME, FakeContext.ROOT_UID, null);
         }
     }