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/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/display.c

@@ -23,6 +23,22 @@ sc_display_init(struct sc_display *display, SDL_Window *window, bool mipmaps) {
     // 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);
 
@@ -51,6 +67,9 @@ sc_display_init(struct sc_display *display, SDL_Window *window, bool mipmaps) {
 
 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);
     }

app/src/display.h

@@ -10,11 +10,19 @@
 #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;
 };
 

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...");
 

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 " +
-                            "scrcpy.");
+                    Ln.e("On Android 11, audio capture must be started in the foreground, make sure that the device is unlocked when starting "
+                            + "scrcpy.");
                     throw new AudioCaptureForegroundException();
                 } else {
                     Ln.d("Failed to start audio capture, retrying...");

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) {
-        this.sendCodecMeta = sendCodecMeta;
+    @SuppressWarnings("MethodLength")
+    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());