Name server parameters

The options values to configure the server were identified by their
command-line argument index.

Now that there are a lot of arguments, many of them being booleans, it
became unreadable and error-prone.

Identify the arguments by a key string instead.

app/src/scrcpy.c

@@ -109,10 +109,10 @@ static int
 event_watcher(void *data, SDL_Event *event) {
     (void) data;
     if (event->type == SDL_WINDOWEVENT
-            && event->window.event == SDL_WINDOWEVENT_RESIZED) {
+            && event->window.event == SDL_WINDOWEVENT_SIZE_CHANGED) {
         // In practice, it seems to always be called from the same thread in
         // that specific case. Anyway, it's just a workaround.
-        screen_render(&screen);
+        screen_handle_window_event(&screen, &event->window);
     }
     return 0;
 }

app/src/screen.c

@@ -15,18 +15,6 @@
 
 #define DISPLAY_MARGINS 96
 
-static bool
-is_maximized(const struct screen *screen) {
-    uint32_t flags = SDL_GetWindowFlags(screen->window);
-    return !!(flags & SDL_WINDOW_MAXIMIZED);
-}
-
-static bool
-is_fullscreen(const struct screen *screen) {
-    uint32_t flags = SDL_GetWindowFlags(screen->window);
-    return !!(flags & (SDL_WINDOW_FULLSCREEN | SDL_WINDOW_FULLSCREEN_DESKTOP));
-}
-
 static inline struct size
 get_rotated_size(struct size size, int rotation) {
     struct size rotated_size;
@@ -56,7 +44,7 @@ get_window_size(SDL_Window *window) {
 // get the windowed window size
 static struct size
 get_windowed_window_size(const struct screen *screen) {
-    if (is_fullscreen(screen) || is_maximized(screen)) {
+    if (screen->fullscreen || screen->maximized) {
         return screen->windowed_window_size;
     }
     return get_window_size(screen->window);
@@ -65,7 +53,7 @@ get_windowed_window_size(const struct screen *screen) {
 // apply the windowed window size if fullscreen and maximized are disabled
 static void
 apply_windowed_size(struct screen *screen) {
-    if (!is_fullscreen(screen) && !is_maximized(screen)) {
+    if (!screen->fullscreen && !screen->maximized) {
         SDL_SetWindowSize(screen->window, screen->windowed_window_size.width,
                                           screen->windowed_window_size.height);
     }
@@ -483,27 +471,28 @@ screen_render(struct screen *screen) {
 
 void
 screen_switch_fullscreen(struct screen *screen) {
-    bool was_fullscreen = is_fullscreen(screen);
+    uint32_t new_mode = screen->fullscreen ? 0 : SDL_WINDOW_FULLSCREEN_DESKTOP;
-    uint32_t new_mode = was_fullscreen ? 0 : SDL_WINDOW_FULLSCREEN_DESKTOP;
     if (SDL_SetWindowFullscreen(screen->window, new_mode)) {
         LOGW("Could not switch fullscreen mode: %s", SDL_GetError());
         return;
     }
 
+    screen->fullscreen = !screen->fullscreen;
     apply_windowed_size(screen);
 
-    LOGD("Switched to %s mode", was_fullscreen ? "windowed" : "fullscreen");
+    LOGD("Switched to %s mode", screen->fullscreen ? "fullscreen" : "windowed");
     screen_render(screen);
 }
 
 void
 screen_resize_to_fit(struct screen *screen) {
-    if (is_fullscreen(screen)) {
+    if (screen->fullscreen) {
         return;
     }
 
-    if (is_maximized(screen)) {
+    if (screen->maximized) {
         SDL_RestoreWindow(screen->window);
+        screen->maximized = false;
     }
 
     struct size optimal_size =
@@ -515,12 +504,13 @@ screen_resize_to_fit(struct screen *screen) {
 
 void
 screen_resize_to_pixel_perfect(struct screen *screen) {
-    if (is_fullscreen(screen)) {
+    if (screen->fullscreen) {
         return;
     }
 
-    if (is_maximized(screen)) {
+    if (screen->maximized) {
         SDL_RestoreWindow(screen->window);
+        screen->maximized = false;
     }
 
     struct size content_size = screen->content_size;
@@ -537,7 +527,7 @@ screen_handle_window_event(struct screen *screen,
             screen_render(screen);
             break;
         case SDL_WINDOWEVENT_SIZE_CHANGED:
-            if (!is_fullscreen(screen) && !is_maximized(screen)) {
+            if (!screen->fullscreen && !screen->maximized) {
                 // Backup the previous size: if we receive the MAXIMIZED event,
                 // then the new size must be ignored (it's the maximized size).
                 // We could not rely on the window flags due to race conditions
@@ -562,8 +552,10 @@ screen_handle_window_event(struct screen *screen,
             screen->windowed_window_size_backup.width = 0;
             screen->windowed_window_size_backup.height = 0;
 #endif
+            screen->maximized = true;
             break;
         case SDL_WINDOWEVENT_RESTORED:
+            screen->maximized = false;
             apply_windowed_size(screen);
             break;
     }

app/src/screen.h

@@ -29,6 +29,8 @@ struct screen {
     // client rotation: 0, 1, 2 or 3 (x90 degrees counterclockwise)
     unsigned rotation;
     bool has_frame;
+    bool fullscreen;
+    bool maximized;
     bool no_window;
     bool mipmaps;
 };
@@ -57,6 +59,8 @@ struct screen {
     }, \
     .rotation = 0, \
     .has_frame = false, \
+    .fullscreen = false, \
+    .maximized = false, \
     .no_window = false, \
     .mipmaps = false, \
 }

app/src/server.c

@@ -231,22 +231,17 @@ enable_tunnel_any_port(struct server *server, struct port_range port_range) {
 
 static process_t
 execute_server(struct server *server, const struct server_params *params) {
-    char max_size_string[6];
+    process_t result = PROCESS_NONE;
-    char bit_rate_string[11];
+
-    char max_fps_string[6];
+    char *cmd[128];
-    char lock_video_orientation_string[3];
+    int i = 0;
-    char display_id_string[6];
+    cmd[i++] = "shell";
-    sprintf(max_size_string, "%"PRIu16, params->max_size);
+    cmd[i++] = "CLASSPATH=" DEVICE_SERVER_PATH;
-    sprintf(bit_rate_string, "%"PRIu32, params->bit_rate);
+    cmd[i++] = "app_process";
-    sprintf(max_fps_string, "%"PRIu16, params->max_fps);
+
-    sprintf(lock_video_orientation_string, "%"PRIi8, params->lock_video_orientation);
-    sprintf(display_id_string, "%"PRIu16, params->display_id);
-    const char *const cmd[] = {
-        "shell",
-        "CLASSPATH=" DEVICE_SERVER_PATH,
-        "app_process",
 #ifdef SERVER_DEBUGGER
 # define SERVER_DEBUGGER_PORT "5005"
+    cmd[i++] =
 # ifdef SERVER_DEBUGGER_METHOD_NEW
         /* Android 9 and above */
         "-XjdwpProvider:internal -XjdwpOptions:transport=dt_socket,suspend=y,server=y,address="
@@ -254,23 +249,38 @@ execute_server(struct server *server, const struct server_params *params) {
         /* Android 8 and below */
         "-agentlib:jdwp=transport=dt_socket,suspend=y,server=y,address="
 # endif
-            SERVER_DEBUGGER_PORT,
+            SERVER_DEBUGGER_PORT;
 #endif
-        "/", // unused
+
-        "com.genymobile.scrcpy.Server",
+    cmd[i++] = "/"; // unused
-        SCRCPY_VERSION,
+    cmd[i++] = "com.genymobile.scrcpy.Server";
-        max_size_string,
+    cmd[i++] = SCRCPY_VERSION;
-        bit_rate_string,
+
-        max_fps_string,
+    int dyn_index = i; // from there, the strings are allocated
-        lock_video_orientation_string,
+#define ADD_PARAM(fmt, ...) \
-        server->tunnel_forward ? "true" : "false",
+    cmd[i] = sc_asprintf(fmt, ## __VA_ARGS__); \
-        params->crop ? params->crop : "-",
+    if (!cmd[i++]) { \
-        "true", // always send frame meta (packet boundaries + timestamp)
+        goto end; \
-        params->control ? "true" : "false",
+    }
-        display_id_string,
+
-        params->show_touches ? "true" : "false",
+#define STRBOOL(p) (p ? "true" : "false")
-        params->stay_awake ? "true" : "false",
+
-    };
+    ADD_PARAM("max_size=%"PRIu16, params->max_size);
+    ADD_PARAM("bit_rate=%"PRIu32, params->bit_rate);
+    ADD_PARAM("max_fps=%"PRIu16, params->max_fps);
+    ADD_PARAM("lock_video_orientation=%"PRIi8, params->lock_video_orientation);
+    ADD_PARAM("tunnel_forward=%s", STRBOOL(server->tunnel_forward));
+    ADD_PARAM("crop=%s", params->crop ? params->crop : "");
+    // always send frame meta (packet boundaries + timestamp)
+    ADD_PARAM("send_frame_meta=true");
+    ADD_PARAM("control=%s", STRBOOL(params->control));
+    ADD_PARAM("display_id=%"PRIu16, params->display_id);
+    ADD_PARAM("show_touches=%s", STRBOOL(params->show_touches));
+    ADD_PARAM("stay_awake=%s", STRBOOL(params->stay_awake));
+
+#undef ADD_PARAM
+#undef STRBOOL
+
 #ifdef SERVER_DEBUGGER
     LOGI("Server debugger waiting for a client on device port "
          SERVER_DEBUGGER_PORT "...");
@@ -282,7 +292,14 @@ execute_server(struct server *server, const struct server_params *params) {
     //     Port: 5005
     // Then click on "Debug"
 #endif
-    return adb_execute(server->serial, cmd, sizeof(cmd) / sizeof(cmd[0]));
+    result = adb_execute(server->serial, (const char **) cmd, i);
+
+end:
+    for (int j = i; j > dyn_index; --j) {
+        free(cmd[j - 1]);
+    }
+
+    return result;
 }
 
 static socket_t

app/src/util/str_util.c

@@ -1,7 +1,9 @@
 #include "str_util.h"
 
+#include <assert.h>
 #include <errno.h>
 #include <limits.h>
+#include <stdarg.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -195,3 +197,33 @@ utf8_from_wide_char(const wchar_t *ws) {
 }
 
 #endif
+
+char *
+sc_asprintf(const char *fmt, ...) {
+    va_list va;
+    va_start(va, fmt);
+    char *s = sc_vasprintf(fmt, va);
+    va_end(va);
+    return s;
+}
+
+char *
+sc_vasprintf(const char *fmt, va_list ap) {
+    va_list va;
+    va_copy(va, ap);
+    int len = vsnprintf(NULL, 0, fmt, va);
+    va_end(va);
+
+    char *str = malloc(len + 1);
+    if (!str) {
+        return NULL;
+    }
+
+    va_copy(va, ap);
+    int len2 = vsprintf(str, fmt, va);
+    (void) len2;
+    assert(len == len2);
+    va_end(va);
+
+    return str;
+}

app/src/util/str_util.h

@@ -1,8 +1,10 @@
 #ifndef STRUTIL_H
 #define STRUTIL_H
 
+#include <stdarg.h>
 #include <stdbool.h>
 #include <stddef.h>
+#include <stdio.h>
 
 #include "config.h"
 
@@ -57,4 +59,13 @@ char *
 utf8_from_wide_char(const wchar_t *s);
 #endif
 
+// compatibility function similar to asprintf()
+// (but returning the resulting string for convenience)
+char *
+sc_asprintf(const char *fmt, ...)
+__attribute__((format(printf, 1, 2)));
+
+char *
+sc_vasprintf(const char *fmt, va_list ap);
+
 #endif

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

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

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

@@ -6,7 +6,7 @@ public class Options {
     private int maxSize;
     private int bitRate;
     private int maxFps;
-    private int lockedVideoOrientation;
+    private int lockedVideoOrientation = -1;
     private boolean tunnelForward;
     private Rect crop;
     private boolean sendFrameMeta; // send PTS so that the client may record properly

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

@@ -109,52 +109,73 @@ public final class Server {
                     "The server version (" + BuildConfig.VERSION_NAME + ") does not match the client " + "(" + clientVersion + ")");
         }
 
-        final int expectedParameters = 12;
-        if (args.length != expectedParameters) {
-            throw new IllegalArgumentException("Expecting " + expectedParameters + " parameters");
-        }
-
         Options options = new Options();
 
-        int maxSize = Integer.parseInt(args[1]) & ~7; // multiple of 8
+        for (int i = 1; i < args.length; ++i) {
-        options.setMaxSize(maxSize);
+            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);
 
-        int bitRate = Integer.parseInt(args[2]);
+            switch (key) {
-        options.setBitRate(bitRate);
+                case "max_size":
-
+                    int maxSize = Integer.parseInt(value) & ~7; // multiple of 8
-        int maxFps = Integer.parseInt(args[3]);
+                    options.setMaxSize(maxSize);
-        options.setMaxFps(maxFps);
+                    break;
-
+                case "bit_rate":
-        int lockedVideoOrientation = Integer.parseInt(args[4]);
+                    int bitRate = Integer.parseInt(value);
-        options.setLockedVideoOrientation(lockedVideoOrientation);
+                    options.setBitRate(bitRate);
-
+                    break;
-        // use "adb forward" instead of "adb tunnel"? (so the server must listen)
+                case "max_fps":
-        boolean tunnelForward = Boolean.parseBoolean(args[5]);
+                    int maxFps = Integer.parseInt(value);
-        options.setTunnelForward(tunnelForward);
+                    options.setMaxFps(maxFps);
-
+                    break;
-        Rect crop = parseCrop(args[6]);
+                case "lock_video_orientation":
-        options.setCrop(crop);
+                    int lockedVideoOrientation = Integer.parseInt(value);
-
+                    options.setLockedVideoOrientation(lockedVideoOrientation);
-        boolean sendFrameMeta = Boolean.parseBoolean(args[7]);
+                    break;
-        options.setSendFrameMeta(sendFrameMeta);
+                case "tunnel_forward":
-
+                    // use "adb forward" instead of "adb tunnel"? (so the server must listen)
-        boolean control = Boolean.parseBoolean(args[8]);
+                    boolean tunnelForward = Boolean.parseBoolean(value);
-        options.setControl(control);
+                    options.setTunnelForward(tunnelForward);
-
+                    break;
-        int displayId = Integer.parseInt(args[9]);
+                case "crop":
-        options.setDisplayId(displayId);
+                    Rect crop = parseCrop(value);
-
+                    options.setCrop(crop);
-        boolean showTouches = Boolean.parseBoolean(args[10]);
+                    break;
-        options.setShowTouches(showTouches);
+                case "send_frame_meta":
-
+                    boolean sendFrameMeta = Boolean.parseBoolean(value);
-        boolean stayAwake = Boolean.parseBoolean(args[11]);
+                    options.setSendFrameMeta(sendFrameMeta);
-        options.setStayAwake(stayAwake);
+                    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;
+                default:
+                    throw new IllegalArgumentException("Unknown parameter: " + key);
+            }
+        }
 
         return options;
     }
 
     private static Rect parseCrop(String crop) {
-        if ("-".equals(crop)) {
+        if (crop.isEmpty()) {
             return null;
         }
         // input format: "width:height:x:y"