Inherit handles only if necessary on Windows

Refs #2779 <https://github.com/Genymobile/scrcpy/issues/2779>

README.md

@@ -412,66 +412,21 @@ autoadb scrcpy -s '{}'
 
 [AutoAdb]: https://github.com/rom1v/autoadb
 
-#### Tunnels
+#### SSH tunnel
 
 To connect to a remote device, it is possible to connect a local `adb` client to
 a remote `adb` server (provided they use the same version of the _adb_
-protocol).
-
-##### Remote ADB server
-
-To connect to a remote ADB server, make the server listen on all interfaces:
+protocol):
 
 ```bash
-adb kill-server
-adb -a nodaemon server start
+adb kill-server    # kill the local adb server on 5037
+ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
 # keep this open
 ```
 
-**Warning: all communications between clients and ADB server are unencrypted.**
-
-Suppose that this server is accessible at 192.168.1.2. Then, from another
-terminal, run scrcpy:
+From another terminal:
 
 ```bash
-export ADB_SERVER_SOCKET=tcp:192.168.1.2:5037
-scrcpy --tunnel-host=192.168.1.2
-```
-
-By default, scrcpy uses the local port used for `adb forward` tunnel
-establishment (typically `27183`, see `--port`). It is also possible to force a
-different tunnel port (it may be useful in more complex situations, when more
-redirections are involved):
-
-```
-scrcpy --tunnel-port=1234
-```
-
-
-##### SSH tunnel
-
-To communicate with a remote ADB server securely, it is preferable to use a SSH
-tunnel.
-
-First, make sure the ADB server is running on the remote computer:
-
-```bash
-adb start-server
-```
-
-Then, establish a SSH tunnel:
-
-```bash
-# local  5038 --> remote  5037
-# local 27183 <-- remote 27183
-ssh -CN -L5038:localhost:5037 -R27183:localhost:27183 your_remote_computer
-# keep this open
-```
-
-From another terminal, run scrcpy:
-
-```bash
-export ADB_SERVER_SOCKET=tcp:localhost:5038
 scrcpy
 ```
 
@@ -479,16 +434,14 @@ To avoid enabling remote port forwarding, you could force a forward connection
 instead (notice the `-L` instead of `-R`):
 
 ```bash
-# local  5038 --> remote  5037
-# local 27183 --> remote 27183
-ssh -CN -L5038:localhost:5037 -L27183:localhost:27183 your_remote_computer
+adb kill-server    # kill the local adb server on 5037
+ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer
 # keep this open
 ```
 
-From another terminal, run scrcpy:
+From another terminal:
 
 ```bash
-export ADB_SERVER_SOCKET=tcp:localhost:5038
 scrcpy --force-adb-forward
 ```
 
@@ -730,9 +683,6 @@ of <kbd>Ctrl</kbd>+<kbd>v</kbd> and <kbd>MOD</kbd>+<kbd>v</kbd> so that they
 also inject the computer clipboard text as a sequence of key events (the same
 way as <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>).
 
-To disable automatic clipboard synchronization, use
-`--no-clipboard-autosync`.
-
 #### Pinch-to-zoom
 
 To simulate "pinch-to-zoom": <kbd>Ctrl</kbd>+_click-and-move_.

app/meson.build

@@ -25,7 +25,6 @@ src = [
     'src/server.c',
     'src/stream.c',
     'src/video_buffer.c',
-    'src/util/acksync.c',
     'src/util/file.c',
     'src/util/intr.c',
     'src/util/log.c',
@@ -40,26 +39,16 @@ src = [
     'src/util/tick.c',
 ]
 
-conf = configuration_data()
-
 if host_machine.system() == 'windows'
     src += [
         'src/sys/win/file.c',
         'src/sys/win/process.c',
     ]
-    conf.set('_WIN32_WINNT', '0x0600')
-    conf.set('WINVER', '0x0600')
 else
     src += [
         'src/sys/unix/file.c',
         'src/sys/unix/process.c',
     ]
-    conf.set('_POSIX_C_SOURCE', '200809L')
-    conf.set('_XOPEN_SOURCE', '700')
-    conf.set('_GNU_SOURCE', true)
-    if host_machine.system() == 'darwin'
-        conf.set('_DARWIN_C_SOURCE', true)
-    endif
 endif
 
 v4l2_support = host_machine.system() == 'linux'
@@ -139,6 +128,8 @@ if host_machine.system() == 'windows'
     dependencies += cc.find_library('ws2_32')
 endif
 
+conf = configuration_data()
+
 foreach f : check_functions
   if cc.has_function(f)
     define = 'HAVE_' + f.underscorify().to_upper()
@@ -208,7 +199,6 @@ if get_option('buildtype') == 'debug'
             'tests/test_cli.c',
             'src/cli.c',
             'src/options.c',
-            'src/util/net.c',
             'src/util/str.c',
             'src/util/strbuf.c',
             'src/util/term.c',

app/scrcpy.1

@@ -114,12 +114,6 @@ Limit both the width and height of the video to \fIvalue\fR. The other dimension
 
 Default is 0 (unlimited).
 
-.TP
-.B \-\-no\-clipboard\-autosync
-By default, scrcpy automatically synchronizes the computer clipboard to the device clipboard before injecting Ctrl+v, and the device clipboard to the computer clipboard whenever it changes.
-
-This option disables this automatic synchronization.
-
 .TP
 .B \-n, \-\-no\-control
 Disable device control (mirror the device in read\-only).
@@ -209,18 +203,6 @@ Enable "show touches" on start, restore the initial value on exit.
 
 It only shows physical touches (not clicks from scrcpy).
 
-.TP
-.BI "\-\-tunnel\-host " ip
-Set the IP address of the adb tunnel to reach the scrcpy server. This option automatically enables --force-adb-forward.
-
-Default is localhost.
-
-.TP
-.BI "\-\-tunnel\-port " port
-Set the TCP port of the adb tunnel to reach the scrcpy server. This option automatically enables --force-adb-forward.
-
-Default is 0 (not forced): the local port used for establishing the tunnel will be used.
-
 .TP
 .BI "\-\-v4l2-sink " /dev/videoN
 Output to v4l2loopback device.

app/src/adb.c

@@ -7,7 +7,6 @@
 
 #include "util/file.h"
 #include "util/log.h"
-#include "util/process_intr.h"
 #include "util/str.h"
 
 static const char *adb_command;
@@ -110,9 +109,9 @@ show_adb_err_msg(enum sc_process_result err, const char *const argv[]) {
     free(buf);
 }
 
-static sc_pid
+sc_pid
 adb_execute_p(const char *serial, const char *const adb_cmd[],
-              size_t len, sc_pipe *pout) {
+              size_t len, sc_pipe *pin, sc_pipe *pout, sc_pipe *perr) {
     int i;
     sc_pid pid;
 
@@ -133,7 +132,7 @@ adb_execute_p(const char *serial, const char *const adb_cmd[],
     memcpy(&argv[i], adb_cmd, len * sizeof(const char *));
     argv[len + i] = NULL;
     enum sc_process_result r =
-        sc_process_execute_p(argv, &pid, NULL, pout, NULL);
+        sc_process_execute_p(argv, &pid, pin, pout, perr);
     if (r != SC_PROCESS_SUCCESS) {
         show_adb_err_msg(r, argv);
         pid = SC_PROCESS_NONE;
@@ -145,12 +144,12 @@ adb_execute_p(const char *serial, const char *const adb_cmd[],
 
 sc_pid
 adb_execute(const char *serial, const char *const adb_cmd[], size_t len) {
-    return adb_execute_p(serial, adb_cmd, len, NULL);
+    return adb_execute_p(serial, adb_cmd, len, NULL, NULL, NULL);
 }
 
-static sc_pid
-adb_exec_forward(const char *serial, uint16_t local_port,
-                 const char *device_socket_name) {
+sc_pid
+adb_forward(const char *serial, uint16_t local_port,
+            const char *device_socket_name) {
     char local[4 + 5 + 1]; // tcp:PORT
     char remote[108 + 14 + 1]; // localabstract:NAME
     sprintf(local, "tcp:%" PRIu16, local_port);
@@ -159,17 +158,17 @@ adb_exec_forward(const char *serial, uint16_t local_port,
     return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 }
 
-static sc_pid
-adb_exec_forward_remove(const char *serial, uint16_t local_port) {
+sc_pid
+adb_forward_remove(const char *serial, uint16_t local_port) {
     char local[4 + 5 + 1]; // tcp:PORT
     sprintf(local, "tcp:%" PRIu16, local_port);
     const char *const adb_cmd[] = {"forward", "--remove", local};
     return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 }
 
-static sc_pid
-adb_exec_reverse(const char *serial, const char *device_socket_name,
-                 uint16_t local_port) {
+sc_pid
+adb_reverse(const char *serial, const char *device_socket_name,
+            uint16_t local_port) {
     char local[4 + 5 + 1]; // tcp:PORT
     char remote[108 + 14 + 1]; // localabstract:NAME
     sprintf(local, "tcp:%" PRIu16, local_port);
@@ -178,16 +177,16 @@ adb_exec_reverse(const char *serial, const char *device_socket_name,
     return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 }
 
-static sc_pid
-adb_exec_reverse_remove(const char *serial, const char *device_socket_name) {
+sc_pid
+adb_reverse_remove(const char *serial, const char *device_socket_name) {
     char remote[108 + 14 + 1]; // localabstract:NAME
     snprintf(remote, sizeof(remote), "localabstract:%s", device_socket_name);
     const char *const adb_cmd[] = {"reverse", "--remove", remote};
     return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 }
 
-static sc_pid
-adb_exec_push(const char *serial, const char *local, const char *remote) {
+sc_pid
+adb_push(const char *serial, const char *local, const char *remote) {
 #ifdef __WINDOWS__
     // Windows will parse the string, so the paths must be quoted
     // (see sys/win/command.c)
@@ -213,8 +212,8 @@ adb_exec_push(const char *serial, const char *local, const char *remote) {
     return pid;
 }
 
-static sc_pid
-adb_exec_install(const char *serial, const char *local) {
+sc_pid
+adb_install(const char *serial, const char *local) {
 #ifdef __WINDOWS__
     // Windows will parse the string, so the local name must be quoted
     // (see sys/win/command.c)
@@ -234,75 +233,45 @@ adb_exec_install(const char *serial, const char *local) {
     return pid;
 }
 
-static sc_pid
-adb_exec_get_serialno(sc_pipe *pout) {
-    const char *const adb_cmd[] = {"get-serialno"};
-    return adb_execute_p(NULL, adb_cmd, ARRAY_LEN(adb_cmd), pout);
+static ssize_t
+adb_execute_for_output(const char *serial, const char *const adb_cmd[],
+                       size_t adb_cmd_len, char *buf, size_t buf_len,
+                       const char *name) {
+    sc_pipe pout;
+    sc_pid pid = adb_execute_p(serial, adb_cmd, adb_cmd_len, NULL, &pout, NULL);
+
+    ssize_t r = sc_pipe_read_all(pout, buf, buf_len);
+    sc_pipe_close(pout);
+
+    if (!sc_process_check_success(pid, name, true)) {
+        return -1;
+    }
+
+    return r;
 }
 
-bool
-adb_forward(struct sc_intr *intr, const char *serial, uint16_t local_port,
-            const char *device_socket_name) {
-    sc_pid pid = adb_exec_forward(serial, local_port, device_socket_name);
-    return sc_process_check_success_intr(intr, pid, "adb forward", true);
-}
-
-bool
-adb_forward_remove(struct sc_intr *intr, const char *serial,
-                   uint16_t local_port) {
-    sc_pid pid = adb_exec_forward_remove(serial, local_port);
-    return sc_process_check_success_intr(intr, pid, "adb forward --remove",
-                                         true);
-}
-
-bool
-adb_reverse(struct sc_intr *intr, const char *serial,
-            const char *device_socket_name, uint16_t local_port) {
-    sc_pid pid = adb_exec_reverse(serial, device_socket_name, local_port);
-    return sc_process_check_success_intr(intr, pid, "adb reverse", true);
-}
-
-bool
-adb_reverse_remove(struct sc_intr *intr, const char *serial,
-                   const char *device_socket_name) {
-    sc_pid pid = adb_exec_reverse_remove(serial, device_socket_name);
-    return sc_process_check_success_intr(intr, pid, "adb reverse --remove",
-                                         true);
-}
-
-bool
-adb_push(struct sc_intr *intr, const char *serial, const char *local,
-         const char *remote) {
-    sc_pid pid = adb_exec_push(serial, local, remote);
-    return sc_process_check_success_intr(intr, pid, "adb push", true);
-}
-
-bool
-adb_install(struct sc_intr *intr, const char *serial, const char *local) {
-    sc_pid pid = adb_exec_install(serial, local);
-    return sc_process_check_success_intr(intr, pid, "adb install", true);
+static size_t
+truncate_first_line(char *data, size_t len) {
+    data[len - 1] = '\0';
+    char *eol = strpbrk(data, "\r\n");
+    if (eol) {
+        *eol = '\0';
+        len = eol - data;
+    }
+    return len;
 }
 
 char *
-adb_get_serialno(struct sc_intr *intr) {
-    sc_pipe pout;
-    sc_pid pid = adb_exec_get_serialno(&pout);
-    if (pid == SC_PROCESS_NONE) {
-        LOGE("Could not execute \"adb get-serialno\"");
-        return NULL;
-    }
-
+adb_get_serialno(void) {
     char buf[128];
-    ssize_t r = sc_pipe_read_all_intr(intr, pid, pout, buf, sizeof(buf));
-    sc_pipe_close(pout);
 
-    bool ok =
-        sc_process_check_success_intr(intr, pid, "adb get-serialno", true);
-    if (!ok) {
+    const char *const adb_cmd[] = {"get-serialno"};
+    ssize_t r = adb_execute_for_output(NULL, adb_cmd, ARRAY_LEN(adb_cmd),
+                                       buf, sizeof(buf), "get-serialno");
+    if (r <= 0) {
         return NULL;
     }
 
-    sc_str_truncate(buf, r, " \r\n");
-
+    truncate_first_line(buf, r);
     return strdup(buf);
 }

app/src/adb.h

@@ -6,40 +6,37 @@
 #include <stdbool.h>
 #include <inttypes.h>
 
-#include "util/intr.h"
+#include "util/process.h"
 
 sc_pid
 adb_execute(const char *serial, const char *const adb_cmd[], size_t len);
 
-bool
-adb_forward(struct sc_intr *intr, const char *serial, uint16_t local_port,
+sc_pid
+adb_execute_p(const char *serial, const char *const adb_cmd[],
+              size_t len, sc_pipe *pin, sc_pipe *pout, sc_pipe *perr);
+
+sc_pid
+adb_forward(const char *serial, uint16_t local_port,
             const char *device_socket_name);
 
-bool
-adb_forward_remove(struct sc_intr *intr, const char *serial,
-                   uint16_t local_port);
+sc_pid
+adb_forward_remove(const char *serial, uint16_t local_port);
 
-bool
-adb_reverse(struct sc_intr *intr, const char *serial,
-            const char *device_socket_name, uint16_t local_port);
+sc_pid
+adb_reverse(const char *serial, const char *device_socket_name,
+            uint16_t local_port);
 
-bool
-adb_reverse_remove(struct sc_intr *intr, const char *serial,
-                   const char *device_socket_name);
+sc_pid
+adb_reverse_remove(const char *serial, const char *device_socket_name);
 
-bool
-adb_push(struct sc_intr *intr, const char *serial, const char *local,
-         const char *remote);
+sc_pid
+adb_push(const char *serial, const char *local, const char *remote);
 
-bool
-adb_install(struct sc_intr *intr, const char *serial, const char *local);
+sc_pid
+adb_install(const char *serial, const char *local);
 
-/**
- * Execute `adb get-serialno`
- *
- * Return the result, to be freed by the caller, or NULL on error.
- */
+// Return the result of "adb get-serialno".
 char *
-adb_get_serialno(struct sc_intr *intr);
+adb_get_serialno(void);
 
 #endif

app/src/adb_tunnel.c

@@ -9,6 +9,33 @@
 
 #define SC_SOCKET_NAME "scrcpy"
 
+static bool
+enable_tunnel_reverse(struct sc_intr *intr, const char *serial,
+                      uint16_t local_port) {
+    sc_pid pid = adb_reverse(serial, SC_SOCKET_NAME, local_port);
+    return sc_process_check_success_intr(intr, pid, "adb reverse");
+}
+
+static bool
+disable_tunnel_reverse(struct sc_intr *intr, const char *serial) {
+    sc_pid pid = adb_reverse_remove(serial, SC_SOCKET_NAME);
+    return sc_process_check_success_intr(intr, pid, "adb reverse --remove");
+}
+
+static bool
+enable_tunnel_forward(struct sc_intr *intr, const char *serial,
+                      uint16_t local_port) {
+    sc_pid pid = adb_forward(serial, local_port, SC_SOCKET_NAME);
+    return sc_process_check_success_intr(intr, pid, "adb forward");
+}
+
+static bool
+disable_tunnel_forward(struct sc_intr *intr, const char *serial,
+                       uint16_t local_port) {
+    sc_pid pid = adb_forward_remove(serial, local_port);
+    return sc_process_check_success_intr(intr, pid, "adb forward --remove");
+}
+
 static bool
 listen_on_port(struct sc_intr *intr, sc_socket socket, uint16_t port) {
     return net_listen_intr(intr, socket, IPV4_LOCALHOST, port, 1);
@@ -20,7 +47,7 @@ enable_tunnel_reverse_any_port(struct sc_adb_tunnel *tunnel,
                                struct sc_port_range port_range) {
     uint16_t port = port_range.first;
     for (;;) {
-        if (!adb_reverse(intr, serial, SC_SOCKET_NAME, port)) {
+        if (!enable_tunnel_reverse(intr, serial, port)) {
             // the command itself failed, it will fail on any port
             return false;
         }
@@ -51,7 +78,7 @@ enable_tunnel_reverse_any_port(struct sc_adb_tunnel *tunnel,
         }
 
         // failure, disable tunnel and try another port
-        if (!adb_reverse_remove(intr, serial, SC_SOCKET_NAME)) {
+        if (!disable_tunnel_reverse(intr, serial)) {
             LOGW("Could not remove reverse tunnel on port %" PRIu16, port);
         }
 
@@ -81,7 +108,7 @@ enable_tunnel_forward_any_port(struct sc_adb_tunnel *tunnel,
 
     uint16_t port = port_range.first;
     for (;;) {
-        if (adb_forward(intr, serial, port, SC_SOCKET_NAME)) {
+        if (enable_tunnel_forward(intr, serial, port)) {
             // success
             tunnel->local_port = port;
             tunnel->enabled = true;
@@ -146,9 +173,9 @@ sc_adb_tunnel_close(struct sc_adb_tunnel *tunnel, struct sc_intr *intr,
 
     bool ret;
     if (tunnel->forward) {
-        ret = adb_forward_remove(intr, serial, tunnel->local_port);
+        ret = disable_tunnel_forward(intr, serial, tunnel->local_port);
     } else {
-        ret = adb_reverse_remove(intr, serial, SC_SOCKET_NAME);
+        ret = disable_tunnel_reverse(intr, serial);
 
         assert(tunnel->server_socket != SC_SOCKET_NONE);
         if (!net_close(tunnel->server_socket)) {

app/src/aoa_hid.c

@@ -35,7 +35,7 @@ sc_hid_event_init(struct sc_hid_event *hid_event, uint16_t accessory_id,
     hid_event->accessory_id = accessory_id;
     hid_event->buffer = buffer;
     hid_event->size = buffer_size;
-    hid_event->ack_to_wait = SC_SEQUENCE_INVALID;
+    hid_event->delay = 0;
 }
 
 void
@@ -118,10 +118,7 @@ sc_aoa_open_usb_handle(libusb_device *device, libusb_device_handle **handle) {
 }
 
 bool
-sc_aoa_init(struct sc_aoa *aoa, const char *serial,
-            struct sc_acksync *acksync) {
-    assert(acksync);
-
+sc_aoa_init(struct sc_aoa *aoa, const char *serial) {
     cbuf_init(&aoa->queue);
 
     if (!sc_mutex_init(&aoa->mutex)) {
@@ -158,7 +155,6 @@ sc_aoa_init(struct sc_aoa *aoa, const char *serial,
     }
 
     aoa->stopped = false;
-    aoa->acksync = acksync;
 
     return true;
 }
@@ -336,28 +332,23 @@ run_aoa_thread(void *data) {
         assert(non_empty);
         (void) non_empty;
 
-        uint64_t ack_to_wait = event.ack_to_wait;
-        sc_mutex_unlock(&aoa->mutex);
-
-        if (ack_to_wait != SC_SEQUENCE_INVALID) {
-            LOGD("Waiting ack from server sequence=%" PRIu64_, ack_to_wait);
-            // Do not block the loop indefinitely if the ack never comes (it should
-            // never happen)
-            sc_tick deadline = sc_tick_now() + SC_TICK_FROM_MS(500);
-            enum sc_acksync_wait_result result =
-                sc_acksync_wait(aoa->acksync, ack_to_wait, deadline);
-
-            if (result == SC_ACKSYNC_WAIT_TIMEOUT) {
-                LOGW("Ack not received after 500ms, discarding HID event");
-                sc_hid_event_destroy(&event);
-                continue;
-            } else if (result == SC_ACKSYNC_WAIT_INTR) {
-                // stopped
-                sc_hid_event_destroy(&event);
+        assert(event.delay >= 0);
+        if (event.delay) {
+            // Wait during the specified delay before injecting the HID event
+            sc_tick deadline = sc_tick_now() + event.delay;
+            bool timed_out = false;
+            while (!aoa->stopped && !timed_out) {
+                timed_out = !sc_cond_timedwait(&aoa->event_cond, &aoa->mutex,
+                                               deadline);
+            }
+            if (aoa->stopped) {
+                sc_mutex_unlock(&aoa->mutex);
                 break;
             }
         }
 
+        sc_mutex_unlock(&aoa->mutex);
+
         bool ok = sc_aoa_send_hid_event(aoa, &event);
         sc_hid_event_destroy(&event);
         if (!ok) {
@@ -386,8 +377,6 @@ sc_aoa_stop(struct sc_aoa *aoa) {
     aoa->stopped = true;
     sc_cond_signal(&aoa->event_cond);
     sc_mutex_unlock(&aoa->mutex);
-
-    sc_acksync_interrupt(aoa->acksync);
 }
 
 void

app/src/aoa_hid.h

@@ -6,7 +6,6 @@
 
 #include <libusb-1.0/libusb.h>
 
-#include "util/acksync.h"
 #include "util/cbuf.h"
 #include "util/thread.h"
 #include "util/tick.h"
@@ -15,7 +14,7 @@ struct sc_hid_event {
     uint16_t accessory_id;
     unsigned char *buffer;
     uint16_t size;
-    uint64_t ack_to_wait;
+    sc_tick delay;
 };
 
 // Takes ownership of buffer
@@ -37,12 +36,10 @@ struct sc_aoa {
     sc_cond event_cond;
     bool stopped;
     struct sc_hid_event_queue queue;
-
-    struct sc_acksync *acksync;
 };
 
 bool
-sc_aoa_init(struct sc_aoa *aoa, const char *serial, struct sc_acksync *acksync);
+sc_aoa_init(struct sc_aoa *aoa, const char *serial);
 
 void
 sc_aoa_destroy(struct sc_aoa *aoa);

app/src/cli.c

@@ -9,7 +9,6 @@
 
 #include "options.h"
 #include "util/log.h"
-#include "util/net.h"
 #include "util/str.h"
 #include "util/strbuf.h"
 #include "util/term.h"
@@ -47,9 +46,6 @@
 #define OPT_V4L2_SINK              1027
 #define OPT_DISPLAY_BUFFER         1028
 #define OPT_V4L2_BUFFER            1029
-#define OPT_TUNNEL_HOST            1030
-#define OPT_TUNNEL_PORT            1031
-#define OPT_NO_CLIPBOARD_AUTOSYNC  1032
 
 struct sc_option {
     char shortopt;
@@ -209,15 +205,6 @@ static const struct sc_option options[] = {
                 "is preserved.\n"
                 "Default is 0 (unlimited).",
     },
-    {
-        .longopt_id = OPT_NO_CLIPBOARD_AUTOSYNC,
-        .longopt = "no-clipboard-autosync",
-        .text = "By default, scrcpy automatically synchronizes the computer "
-                "clipboard to the device clipboard before injecting Ctrl+v, "
-                "and the device clipboard to the computer clipboard whenever "
-                "it changes.\n"
-                "This option disables this automatic synchronization."
-    },
     {
         .shortopt = 'n',
         .longopt = "no-control",
@@ -343,25 +330,6 @@ static const struct sc_option options[] = {
                 "on exit.\n"
                 "It only shows physical touches (not clicks from scrcpy).",
     },
-    {
-        .longopt_id = OPT_TUNNEL_HOST,
-        .longopt = "tunnel-host",
-        .argdesc = "ip",
-        .text = "Set the IP address of the adb tunnel to reach the scrcpy "
-                "server. This option automatically enables "
-                "--force-adb-forward.\n"
-                "Default is localhost.",
-    },
-    {
-        .longopt_id = OPT_TUNNEL_PORT,
-        .longopt = "tunnel-port",
-        .argdesc = "port",
-        .text = "Set the TCP port of the adb tunnel to reach the scrcpy "
-                "server. This option automatically enables "
-                "--force-adb-forward.\n"
-                "Default is 0 (not forced): the local port used for "
-                "establishing the tunnel will be used.",
-    },
 #ifdef HAVE_V4L2
     {
         .longopt_id = OPT_V4L2_SINK,
@@ -601,10 +569,6 @@ sc_getopt_adapter_create_longopts(void) {
     size_t out_idx = 0;
     for (size_t i = 0; i < ARRAY_LEN(options); ++i) {
         const struct sc_option *in = &options[i];
-
-        // If longopt_id is set, then longopt must be set
-        assert(!in->longopt_id || in->longopt);
-
         if (!in->longopt) {
             // The longopts array must only contain long options
             continue;
@@ -707,12 +671,12 @@ print_option_usage_header(const struct sc_option *opt) {
         }
     }
 
-    printf("\n    %s\n", buf.s);
+    fprintf(stderr, "\n    %s\n", buf.s);
     free(buf.s);
     return;
 
 error:
-    printf("<ERROR>\n");
+    fprintf(stderr, "<ERROR>\n");
 }
 
 static void
@@ -728,11 +692,11 @@ print_option_usage(const struct sc_option *opt, unsigned cols) {
 
     char *text = sc_str_wrap_lines(opt->text, cols, 8);
     if (!text) {
-        printf("<ERROR>\n");
+        fprintf(stderr, "<ERROR>\n");
         return;
     }
 
-    printf("%s\n", text);
+    fprintf(stderr, "%s\n", text);
     free(text);
 }
 
@@ -743,11 +707,11 @@ print_shortcuts_intro(unsigned cols) {
         "(left) Alt or (left) Super, but it can be configured by "
         "--shortcut-mod (see above).", cols, 4);
     if (!intro) {
-        printf("<ERROR>\n");
+        fprintf(stderr, "<ERROR>\n");
         return;
     }
 
-    printf("%s\n", intro);
+    fprintf(stderr, "%s\n", intro);
     free(intro);
 }
 
@@ -757,21 +721,21 @@ print_shortcut(const struct sc_shortcut *shortcut, unsigned cols) {
     assert(shortcut->shortcuts[0]); // At least one shortcut
     assert(shortcut->text);
 
-    printf("\n");
+    fprintf(stderr, "\n");
 
     unsigned i = 0;
     while (shortcut->shortcuts[i]) {
-        printf("    %s\n", shortcut->shortcuts[i]);
+        fprintf(stderr, "    %s\n", shortcut->shortcuts[i]);
         ++i;
     };
 
     char *text = sc_str_wrap_lines(shortcut->text, cols, 8);
     if (!text) {
-        printf("<ERROR>\n");
+        fprintf(stderr, "<ERROR>\n");
         return;
     }
 
-    printf("%s\n", text);
+    fprintf(stderr, "%s\n", text);
     free(text);
 }
 
@@ -795,14 +759,14 @@ scrcpy_print_usage(const char *arg0) {
         }
     }
 
-    printf("Usage: %s [options]\n\n"
-            "Options:\n", arg0);
+    fprintf(stderr, "Usage: %s [options]\n\n"
+                    "Options:\n", arg0);
     for (size_t i = 0; i < ARRAY_LEN(options); ++i) {
         print_option_usage(&options[i], cols);
     }
 
     // Print shortcuts section
-    printf("\nShortcuts:\n\n");
+    fprintf(stderr, "\nShortcuts:\n\n");
     print_shortcuts_intro(cols);
     for (size_t i = 0; i < ARRAY_LEN(shortcuts); ++i) {
         print_shortcut(&shortcuts[i], cols);
@@ -1159,21 +1123,6 @@ parse_record_format(const char *optarg, enum sc_record_format *format) {
     return false;
 }
 
-static bool
-parse_ip(const char *optarg, uint32_t *ipv4) {
-    return net_parse_ipv4(optarg, ipv4);
-}
-
-static bool
-parse_port(const char *optarg, uint16_t *port) {
-    long value;
-    if (!parse_integer_arg(optarg, &value, false, 0, 0xFFFF, "port")) {
-        return false;
-    }
-    *port = (uint16_t) value;
-    return true;
-}
-
 static enum sc_record_format
 guess_record_format(const char *filename) {
     size_t len = strlen(filename);
@@ -1246,16 +1195,6 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
                     return false;
                 }
                 break;
-            case OPT_TUNNEL_HOST:
-                if (!parse_ip(optarg, &opts->tunnel_host)) {
-                    return false;
-                }
-                break;
-            case OPT_TUNNEL_PORT:
-                if (!parse_port(optarg, &opts->tunnel_port)) {
-                    return false;
-                }
-                break;
             case 'n':
                 opts->control = false;
                 break;
@@ -1374,9 +1313,6 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
                     return false;
                 }
                 break;
-            case OPT_NO_CLIPBOARD_AUTOSYNC:
-                opts->clipboard_autosync = false;
-                break;
 #ifdef HAVE_V4L2
             case OPT_V4L2_SINK:
                 opts->v4l2_device = optarg;
@@ -1418,12 +1354,6 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
     }
 #endif
 
-    if ((opts->tunnel_host || opts->tunnel_port) && !opts->force_adb_forward) {
-        LOGI("Tunnel host/port is set, "
-             "--force-adb-forward automatically enabled.");
-        opts->force_adb_forward = true;
-    }
-
     int index = optind;
     if (index < argc) {
         LOGE("Unexpected additional argument: %s", argv[index]);

app/src/compat.h

@@ -1,17 +1,16 @@
 #ifndef COMPAT_H
 #define COMPAT_H
 
-#include "config.h"
+#define _POSIX_C_SOURCE 200809L
+#define _XOPEN_SOURCE 700
+#define _GNU_SOURCE
+#ifdef __APPLE__
+# define _DARWIN_C_SOURCE
+#endif
 
 #include <libavformat/version.h>
 #include <SDL2/SDL_version.h>
 
-#ifndef __WIN32
-# define PRIu64_ PRIu64
-#else
-# define PRIu64_ "I64u"  // Windows...
-#endif
-
 // In ffmpeg/doc/APIchanges:
 // 2018-02-06 - 0694d87024 - lavf 58.9.100 - avformat.h
 //   Deprecate use of av_register_input_format(), av_register_output_format(),

app/src/control_msg.c

@@ -118,12 +118,11 @@ control_msg_serialize(const struct control_msg *msg, unsigned char *buf) {
             buf[1] = msg->inject_keycode.action;
             return 2;
         case CONTROL_MSG_TYPE_SET_CLIPBOARD: {
-            buffer_write64be(&buf[1], msg->set_clipboard.sequence);
-            buf[9] = !!msg->set_clipboard.paste;
+            buf[1] = !!msg->set_clipboard.paste;
             size_t len = write_string(msg->set_clipboard.text,
                                       CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH,
-                                      &buf[10]);
-            return 10 + len;
+                                      &buf[2]);
+            return 2 + len;
         }
         case CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE:
             buf[1] = msg->set_screen_power_mode.mode;
@@ -171,6 +170,11 @@ control_msg_log(const struct control_msg *msg) {
                          (long) msg->inject_touch_event.buttons);
             } else {
                 // numeric pointer id
+#ifndef __WIN32
+# define PRIu64_ PRIu64
+#else
+# define PRIu64_ "I64u"  // Windows...
+#endif
                 LOG_CMSG("touch [id=%" PRIu64_ "] %-4s position=%" PRIi32 ",%"
                              PRIi32 " pressure=%g buttons=%06lx",
                          id,
@@ -195,8 +199,7 @@ control_msg_log(const struct control_msg *msg) {
                      KEYEVENT_ACTION_LABEL(msg->inject_keycode.action));
             break;
         case CONTROL_MSG_TYPE_SET_CLIPBOARD:
-            LOG_CMSG("clipboard %" PRIu64_ " %s \"%s\"",
-                     msg->set_clipboard.sequence,
+            LOG_CMSG("clipboard %s \"%s\"",
                      msg->set_clipboard.paste ? "paste" : "copy",
                      msg->set_clipboard.text);
             break;

app/src/control_msg.h

@@ -70,7 +70,6 @@ struct control_msg {
             // screen may only be turned on on ACTION_DOWN
         } back_or_screen_on;
         struct {
-            uint64_t sequence;
             char *text; // owned, to be freed by free()
             bool paste;
         } set_clipboard;

app/src/controller.c

@@ -5,11 +5,10 @@
 #include "util/log.h"
 
 bool
-controller_init(struct controller *controller, sc_socket control_socket,
-                struct sc_acksync *acksync) {
+controller_init(struct controller *controller, sc_socket control_socket) {
     cbuf_init(&controller->queue);
 
-    bool ok = receiver_init(&controller->receiver, control_socket, acksync);
+    bool ok = receiver_init(&controller->receiver, control_socket);
     if (!ok) {
         return false;
     }

app/src/controller.h

@@ -7,7 +7,6 @@
 
 #include "control_msg.h"
 #include "receiver.h"
-#include "util/acksync.h"
 #include "util/cbuf.h"
 #include "util/net.h"
 #include "util/thread.h"
@@ -25,8 +24,7 @@ struct controller {
 };
 
 bool
-controller_init(struct controller *controller, sc_socket control_socket,
-                struct sc_acksync *acksync);
+controller_init(struct controller *controller, sc_socket control_socket);
 
 void
 controller_destroy(struct controller *controller);

app/src/device_msg.c

@@ -1,6 +1,5 @@
 #include "device_msg.h"
 
-#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -35,11 +34,6 @@ device_msg_deserialize(const unsigned char *buf, size_t len,
             msg->clipboard.text = text;
             return 5 + clipboard_len;
         }
-        case DEVICE_MSG_TYPE_ACK_CLIPBOARD: {
-            uint64_t sequence = buffer_read64be(&buf[1]);
-            msg->ack_clipboard.sequence = sequence;
-            return 9;
-        }
         default:
             LOGW("Unknown device message type: %d", (int) msg->type);
             return -1; // error, we cannot recover

app/src/device_msg.h

@@ -13,7 +13,6 @@
 
 enum device_msg_type {
     DEVICE_MSG_TYPE_CLIPBOARD,
-    DEVICE_MSG_TYPE_ACK_CLIPBOARD,
 };
 
 struct device_msg {
@@ -22,9 +21,6 @@ struct device_msg {
         struct {
             char *text; // owned, to be freed by free()
         } clipboard;
-        struct {
-            uint64_t sequence;
-        } ack_clipboard;
     };
 };
 

app/src/file_handler.c

@@ -5,7 +5,6 @@
 
 #include "adb.h"
 #include "util/log.h"
-#include "util/process_intr.h"
 
 #define DEFAULT_PUSH_TARGET "/sdcard/Download/"
 
@@ -17,7 +16,6 @@ file_handler_request_destroy(struct file_handler_request *req) {
 bool
 file_handler_init(struct file_handler *file_handler, const char *serial,
                   const char *push_target) {
-    assert(serial);
 
     cbuf_init(&file_handler->queue);
 
@@ -32,26 +30,23 @@ file_handler_init(struct file_handler *file_handler, const char *serial,
         return false;
     }
 
-    ok = sc_intr_init(&file_handler->intr);
-    if (!ok) {
-        LOGE("Could not create intr");
-        sc_cond_destroy(&file_handler->event_cond);
-        sc_mutex_destroy(&file_handler->mutex);
-    }
-
-    file_handler->serial = strdup(serial);
-    if (!file_handler->serial) {
-        LOGE("Could not strdup serial");
-        sc_intr_destroy(&file_handler->intr);
-        sc_cond_destroy(&file_handler->event_cond);
-        sc_mutex_destroy(&file_handler->mutex);
-        return false;
+    if (serial) {
+        file_handler->serial = strdup(serial);
+        if (!file_handler->serial) {
+            LOGW("Could not strdup serial");
+            sc_cond_destroy(&file_handler->event_cond);
+            sc_mutex_destroy(&file_handler->mutex);
+            return false;
+        }
+    } else {
+        file_handler->serial = NULL;
     }
 
     // lazy initialization
     file_handler->initialized = false;
 
     file_handler->stopped = false;
+    file_handler->current_process = SC_PROCESS_NONE;
 
     file_handler->push_target = push_target ? push_target : DEFAULT_PUSH_TARGET;
 
@@ -62,7 +57,6 @@ void
 file_handler_destroy(struct file_handler *file_handler) {
     sc_cond_destroy(&file_handler->event_cond);
     sc_mutex_destroy(&file_handler->mutex);
-    sc_intr_destroy(&file_handler->intr);
     free(file_handler->serial);
 
     struct file_handler_request req;
@@ -71,6 +65,16 @@ file_handler_destroy(struct file_handler *file_handler) {
     }
 }
 
+static sc_pid
+install_apk(const char *serial, const char *file) {
+    return adb_install(serial, file);
+}
+
+static sc_pid
+push_file(const char *serial, const char *file, const char *push_target) {
+    return adb_push(serial, file, push_target);
+}
+
 bool
 file_handler_request(struct file_handler *file_handler,
                      file_handler_action_t action, char *file) {
@@ -102,16 +106,10 @@ file_handler_request(struct file_handler *file_handler,
 static int
 run_file_handler(void *data) {
     struct file_handler *file_handler = data;
-    struct sc_intr *intr = &file_handler->intr;
-
-    const char *serial = file_handler->serial;
-    assert(serial);
-
-    const char *push_target = file_handler->push_target;
-    assert(push_target);
 
     for (;;) {
         sc_mutex_lock(&file_handler->mutex);
+        file_handler->current_process = SC_PROCESS_NONE;
         while (!file_handler->stopped && cbuf_is_empty(&file_handler->queue)) {
             sc_cond_wait(&file_handler->event_cond, &file_handler->mutex);
         }
@@ -124,26 +122,43 @@ run_file_handler(void *data) {
         bool non_empty = cbuf_take(&file_handler->queue, &req);
         assert(non_empty);
         (void) non_empty;
+
+        sc_pid pid;
+        if (req.action == ACTION_INSTALL_APK) {
+            LOGI("Installing %s...", req.file);
+            pid = install_apk(file_handler->serial, req.file);
+        } else {
+            LOGI("Pushing %s...", req.file);
+            pid = push_file(file_handler->serial, req.file,
+                            file_handler->push_target);
+        }
+        file_handler->current_process = pid;
         sc_mutex_unlock(&file_handler->mutex);
 
         if (req.action == ACTION_INSTALL_APK) {
-            LOGI("Installing %s...", req.file);
-            bool ok = adb_install(intr, serial, req.file);
-            if (ok) {
+            if (sc_process_check_success(pid, "adb install", false)) {
                 LOGI("%s successfully installed", req.file);
             } else {
                 LOGE("Failed to install %s", req.file);
             }
         } else {
-            LOGI("Pushing %s...", req.file);
-            bool ok = adb_push(intr, serial, req.file, push_target);
-            if (ok) {
-                LOGI("%s successfully pushed to %s", req.file, push_target);
+            if (sc_process_check_success(pid, "adb push", false)) {
+                LOGI("%s successfully pushed to %s", req.file,
+                                                     file_handler->push_target);
             } else {
-                LOGE("Failed to push %s to %s", req.file, push_target);
+                LOGE("Failed to push %s to %s", req.file,
+                                                file_handler->push_target);
             }
         }
 
+        sc_mutex_lock(&file_handler->mutex);
+        // Close the process (it is necessarily already terminated)
+        // Execute this call with mutex locked to avoid race conditions with
+        // file_handler_stop()
+        sc_process_close(file_handler->current_process);
+        file_handler->current_process = SC_PROCESS_NONE;
+        sc_mutex_unlock(&file_handler->mutex);
+
         file_handler_request_destroy(&req);
     }
     return 0;
@@ -168,7 +183,11 @@ file_handler_stop(struct file_handler *file_handler) {
     sc_mutex_lock(&file_handler->mutex);
     file_handler->stopped = true;
     sc_cond_signal(&file_handler->event_cond);
-    sc_intr_interrupt(&file_handler->intr);
+    if (file_handler->current_process != SC_PROCESS_NONE) {
+        if (!sc_process_terminate(file_handler->current_process)) {
+            LOGW("Could not terminate push/install process");
+        }
+    }
     sc_mutex_unlock(&file_handler->mutex);
 }
 

app/src/file_handler.h

@@ -8,7 +8,6 @@
 #include "adb.h"
 #include "util/cbuf.h"
 #include "util/thread.h"
-#include "util/intr.h"
 
 typedef enum {
     ACTION_INSTALL_APK,
@@ -30,9 +29,8 @@ struct file_handler {
     sc_cond event_cond;
     bool stopped;
     bool initialized;
+    sc_pid current_process;
     struct file_handler_request_queue queue;
-
-    struct sc_intr intr;
 };
 
 bool

app/src/hid_keyboard.c

@@ -278,8 +278,7 @@ push_mod_lock_state(struct sc_hid_keyboard *kb, uint16_t sdl_mod) {
 
 static void
 sc_key_processor_process_key(struct sc_key_processor *kp,
-                             const SDL_KeyboardEvent *event,
-                             uint64_t ack_to_wait) {
+                             const SDL_KeyboardEvent *event) {
     if (event->repeat) {
         // In USB HID protocol, key repeat is handled by the host (Android), so
         // just ignore key repeat here.
@@ -299,12 +298,16 @@ sc_key_processor_process_key(struct sc_key_processor *kp,
             }
         }
 
-        if (ack_to_wait) {
+        SDL_Keycode keycode = event->keysym.sym;
+        bool down = event->type == SDL_KEYDOWN;
+        bool ctrl = event->keysym.mod & KMOD_CTRL;
+        bool shift = event->keysym.mod & KMOD_SHIFT;
+        if (ctrl && !shift && keycode == SDLK_v && down) {
             // Ctrl+v is pressed, so clipboard synchronization has been
-            // requested. Wait until clipboard synchronization is acknowledged
-            // by the server, otherwise it could paste the old clipboard
-            // content.
-            hid_event.ack_to_wait = ack_to_wait;
+            // requested. Wait a bit so that the clipboard is set before
+            // injecting Ctrl+v via HID, otherwise it would paste the old
+            // clipboard content.
+            hid_event.delay = SC_TICK_FROM_MS(5);
         }
 
         if (!sc_aoa_push_hid_event(kb->aoa, &hid_event)) {
@@ -345,10 +348,6 @@ sc_hid_keyboard_init(struct sc_hid_keyboard *kb, struct sc_aoa *aoa) {
         .process_text = sc_key_processor_process_text,
     };
 
-    // Clipboard synchronization is requested over the control socket, while HID
-    // events are sent over AOA, so it must wait for clipboard synchronization
-    // to be acknowledged by the device before injecting Ctrl+v.
-    kb->key_processor.async_paste = true;
     kb->key_processor.ops = &ops;
 
     return true;

app/src/input_manager.c

@@ -66,7 +66,6 @@ input_manager_init(struct input_manager *im, struct controller *controller,
     im->control = options->control;
     im->forward_all_clicks = options->forward_all_clicks;
     im->legacy_paste = options->legacy_paste;
-    im->clipboard_autosync = options->clipboard_autosync;
 
     const struct sc_shortcut_mods *shortcut_mods = &options->shortcut_mods;
     assert(shortcut_mods->count);
@@ -83,8 +82,6 @@ input_manager_init(struct input_manager *im, struct controller *controller,
     im->last_keycode = SDLK_UNKNOWN;
     im->last_mod = 0;
     im->key_repeat = 0;
-
-    im->next_sequence = 1; // 0 is reserved for SC_SEQUENCE_INVALID
 }
 
 static void
@@ -211,35 +208,35 @@ collapse_panels(struct controller *controller) {
     }
 }
 
-static bool
-set_device_clipboard(struct controller *controller, bool paste,
-                     uint64_t sequence) {
+static void
+set_device_clipboard(struct controller *controller, bool paste) {
     char *text = SDL_GetClipboardText();
     if (!text) {
         LOGW("Could not get clipboard text: %s", SDL_GetError());
-        return false;
+        return;
+    }
+    if (!*text) {
+        // empty text
+        SDL_free(text);
+        return;
     }
 
     char *text_dup = strdup(text);
     SDL_free(text);
     if (!text_dup) {
         LOGW("Could not strdup input text");
-        return false;
+        return;
     }
 
     struct control_msg msg;
     msg.type = CONTROL_MSG_TYPE_SET_CLIPBOARD;
-    msg.set_clipboard.sequence = sequence;
     msg.set_clipboard.text = text_dup;
     msg.set_clipboard.paste = paste;
 
     if (!controller_push_msg(controller, &msg)) {
         free(text_dup);
         LOGW("Could not request 'set device clipboard'");
-        return false;
     }
-
-    return true;
 }
 
 static void
@@ -465,10 +462,8 @@ input_manager_process_key(struct input_manager *im,
                         // inject the text as input events
                         clipboard_paste(controller);
                     } else {
-                        // store the text in the device clipboard and paste,
-                        // without requesting an acknowledgment
-                        set_device_clipboard(controller, true,
-                                             SC_SEQUENCE_INVALID);
+                        // store the text in the device clipboard and paste
+                        set_device_clipboard(controller, true);
                     }
                 }
                 return;
@@ -517,36 +512,18 @@ input_manager_process_key(struct input_manager *im,
         return;
     }
 
-    uint64_t ack_to_wait = SC_SEQUENCE_INVALID;
-    bool is_ctrl_v = ctrl && !shift && keycode == SDLK_v && down && !repeat;
-    if (im->clipboard_autosync && is_ctrl_v) {
+    if (ctrl && !shift && keycode == SDLK_v && down && !repeat) {
         if (im->legacy_paste) {
             // inject the text as input events
             clipboard_paste(controller);
             return;
         }
-
-        // Request an acknowledgement only if necessary
-        uint64_t sequence = im->kp->async_paste ? im->next_sequence
-                                                : SC_SEQUENCE_INVALID;
-
         // Synchronize the computer clipboard to the device clipboard before
         // sending Ctrl+v, to allow seamless copy-paste.
-        bool ok = set_device_clipboard(controller, false, sequence);
-        if (!ok) {
-            LOGW("Clipboard could not be synchronized, Ctrl+v not injected");
-            return;
-        }
-
-        if (im->kp->async_paste) {
-            // The key processor must wait for this ack before injecting Ctrl+v
-            ack_to_wait = sequence;
-            // Increment only when the request succeeded
-            ++im->next_sequence;
-        }
+        set_device_clipboard(controller, false);
     }
 
-    im->kp->ops->process_key(im->kp, event, ack_to_wait);
+    im->kp->ops->process_key(im->kp, event);
 }
 
 static void

app/src/input_manager.h

@@ -24,7 +24,6 @@ struct input_manager {
     bool control;
     bool forward_all_clicks;
     bool legacy_paste;
-    bool clipboard_autosync;
 
     struct {
         unsigned data[SC_MAX_SHORTCUT_MODS];
@@ -39,8 +38,6 @@ struct input_manager {
     unsigned key_repeat;
     SDL_Keycode last_keycode;
     uint16_t last_mod;
-
-    uint64_t next_sequence; // used for request acknowledgements
 };
 
 void

app/src/keyboard_inject.c

@@ -188,13 +188,7 @@ convert_input_key(const SDL_KeyboardEvent *from, struct control_msg *to,
 
 static void
 sc_key_processor_process_key(struct sc_key_processor *kp,
-                             const SDL_KeyboardEvent *event,
-                             uint64_t ack_to_wait) {
-    // The device clipboard synchronization and the key event messages are
-    // serialized, there is nothing special to do to ensure that the clipboard
-    // is set before injecting Ctrl+v.
-    (void) ack_to_wait;
-
+                             const SDL_KeyboardEvent *event) {
     struct sc_keyboard_inject *ki = DOWNCAST(kp);
 
     if (event->repeat) {
@@ -256,7 +250,5 @@ sc_keyboard_inject_init(struct sc_keyboard_inject *ki,
         .process_text = sc_key_processor_process_text,
     };
 
-    // Key injection and clipboard synchronization are serialized
-    ki->key_processor.async_paste = false;
     ki->key_processor.ops = &ops;
 }

app/src/main.c

@@ -47,9 +47,6 @@ main(int argc, char *argv[]) {
     setbuf(stderr, NULL);
 #endif
 
-    printf("scrcpy " SCRCPY_VERSION
-           " <https://github.com/Genymobile/scrcpy>\n");
-
     struct scrcpy_cli_args args = {
         .opts = scrcpy_options_default,
         .help = false,
@@ -76,6 +73,8 @@ main(int argc, char *argv[]) {
         return 0;
     }
 
+    LOGI("scrcpy " SCRCPY_VERSION " <https://github.com/Genymobile/scrcpy>");
+
 #ifdef SCRCPY_LAVF_REQUIRES_REGISTER_ALL
     av_register_all();
 #endif

app/src/options.c

@@ -19,8 +19,6 @@ const struct scrcpy_options scrcpy_options_default = {
         .first = DEFAULT_LOCAL_PORT_RANGE_FIRST,
         .last = DEFAULT_LOCAL_PORT_RANGE_LAST,
     },
-    .tunnel_host = 0,
-    .tunnel_port = 0,
     .shortcut_mods = {
         .data = {SC_MOD_LALT, SC_MOD_LSUPER},
         .count = 2,
@@ -53,5 +51,4 @@ const struct scrcpy_options scrcpy_options_default = {
     .forward_all_clicks = false,
     .legacy_paste = false,
     .power_off_on_close = false,
-    .clipboard_autosync = true,
 };

app/src/options.h

@@ -77,8 +77,6 @@ struct scrcpy_options {
     enum sc_record_format record_format;
     enum sc_keyboard_input_mode keyboard_input_mode;
     struct sc_port_range port_range;
-    uint32_t tunnel_host;
-    uint16_t tunnel_port;
     struct sc_shortcut_mods shortcut_mods;
     uint16_t max_size;
     uint32_t bit_rate;
@@ -108,7 +106,6 @@ struct scrcpy_options {
     bool forward_all_clicks;
     bool legacy_paste;
     bool power_off_on_close;
-    bool clipboard_autosync;
 };
 
 extern const struct scrcpy_options scrcpy_options_default;

app/src/receiver.c

@@ -7,16 +7,12 @@
 #include "util/log.h"
 
 bool
-receiver_init(struct receiver *receiver, sc_socket control_socket,
-              struct sc_acksync *acksync) {
+receiver_init(struct receiver *receiver, sc_socket control_socket) {
     bool ok = sc_mutex_init(&receiver->mutex);
     if (!ok) {
         return false;
     }
-
     receiver->control_socket = control_socket;
-    receiver->acksync = acksync;
-
     return true;
 }
 
@@ -26,7 +22,7 @@ receiver_destroy(struct receiver *receiver) {
 }
 
 static void
-process_msg(struct receiver *receiver, struct device_msg *msg) {
+process_msg(struct device_msg *msg) {
     switch (msg->type) {
         case DEVICE_MSG_TYPE_CLIPBOARD: {
             char *current = SDL_GetClipboardText();
@@ -41,17 +37,11 @@ process_msg(struct receiver *receiver, struct device_msg *msg) {
             SDL_SetClipboardText(msg->clipboard.text);
             break;
         }
-        case DEVICE_MSG_TYPE_ACK_CLIPBOARD:
-            assert(receiver->acksync);
-            LOGD("Ack device clipboard sequence=%" PRIu64_,
-                 msg->ack_clipboard.sequence);
-            sc_acksync_ack(receiver->acksync, msg->ack_clipboard.sequence);
-            break;
     }
 }
 
 static ssize_t
-process_msgs(struct receiver *receiver, const unsigned char *buf, size_t len) {
+process_msgs(const unsigned char *buf, size_t len) {
     size_t head = 0;
     for (;;) {
         struct device_msg msg;
@@ -63,7 +53,7 @@ process_msgs(struct receiver *receiver, const unsigned char *buf, size_t len) {
             return head;
         }
 
-        process_msg(receiver, &msg);
+        process_msg(&msg);
         device_msg_destroy(&msg);
 
         head += r;
@@ -91,7 +81,7 @@ run_receiver(void *data) {
         }
 
         head += r;
-        ssize_t consumed = process_msgs(receiver, buf, head);
+        ssize_t consumed = process_msgs(buf, head);
         if (consumed == -1) {
             // an error occurred
             break;

app/src/receiver.h

@@ -5,7 +5,6 @@
 
 #include <stdbool.h>
 
-#include "util/acksync.h"
 #include "util/net.h"
 #include "util/thread.h"
 
@@ -15,13 +14,10 @@ struct receiver {
     sc_socket control_socket;
     sc_thread thread;
     sc_mutex mutex;
-
-    struct sc_acksync *acksync;
 };
 
 bool
-receiver_init(struct receiver *receiver, sc_socket control_socket,
-              struct sc_acksync *acksync);
+receiver_init(struct receiver *receiver, sc_socket control_socket);
 
 void
 receiver_destroy(struct receiver *receiver);

app/src/scrcpy.c

@@ -27,7 +27,6 @@
 #include "screen.h"
 #include "server.h"
 #include "stream.h"
-#include "util/acksync.h"
 #include "util/log.h"
 #include "util/net.h"
 #ifdef HAVE_V4L2
@@ -47,8 +46,6 @@ struct scrcpy {
     struct file_handler file_handler;
 #ifdef HAVE_AOA_HID
     struct sc_aoa aoa;
-    // sequence/ack helper to synchronize clipboard and Ctrl+v via HID
-    struct sc_acksync acksync;
 #endif
     union {
         struct sc_keyboard_inject keyboard_inject;
@@ -343,15 +340,11 @@ scrcpy(struct scrcpy_options *options) {
     bool controller_started = false;
     bool screen_initialized = false;
 
-    struct sc_acksync *acksync = NULL;
-
     struct sc_server_params params = {
         .serial = options->serial,
         .log_level = options->log_level,
         .crop = options->crop,
         .port_range = options->port_range,
-        .tunnel_host = options->tunnel_host,
-        .tunnel_port = options->tunnel_port,
         .max_size = options->max_size,
         .bit_rate = options->bit_rate,
         .max_fps = options->max_fps,
@@ -364,7 +357,6 @@ scrcpy(struct scrcpy_options *options) {
         .encoder_name = options->encoder_name,
         .force_adb_forward = options->force_adb_forward,
         .power_off_on_close = options->power_off_on_close,
-        .clipboard_autosync = options->clipboard_autosync,
     };
 
     static const struct sc_server_callbacks cbs = {
@@ -402,11 +394,8 @@ scrcpy(struct scrcpy_options *options) {
     // It is necessarily initialized here, since the device is connected
     struct sc_server_info *info = &s->server.info;
 
-    const char *serial = s->server.params.serial;
-    assert(serial);
-
     if (options->display && options->control) {
-        if (!file_handler_init(&s->file_handler, serial,
+        if (!file_handler_init(&s->file_handler, options->serial,
                                options->push_target)) {
             goto end;
         }
@@ -451,18 +440,7 @@ scrcpy(struct scrcpy_options *options) {
     }
 
     if (options->control) {
-#ifdef HAVE_AOA_HID
-        if (options->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_HID) {
-            bool ok = sc_acksync_init(&s->acksync);
-            if (!ok) {
-                goto end;
-            }
-
-            acksync = &s->acksync;
-        }
-#endif
-        if (!controller_init(&s->controller, s->server.control_socket,
-                             acksync)) {
+        if (!controller_init(&s->controller, s->server.control_socket)) {
             goto end;
         }
         controller_initialized = true;
@@ -538,7 +516,21 @@ scrcpy(struct scrcpy_options *options) {
 #ifdef HAVE_AOA_HID
             bool aoa_hid_ok = false;
 
-            bool ok = sc_aoa_init(&s->aoa, serial, acksync);
+            char *serialno = NULL;
+
+            const char *serial = options->serial;
+            if (!serial) {
+                serialno = adb_get_serialno();
+                if (!serialno) {
+                    LOGE("Could not get device serial");
+                    goto aoa_hid_end;
+                }
+                serial = serialno;
+                LOGI("Device serial: %s", serial);
+            }
+
+            bool ok = sc_aoa_init(&s->aoa, serial);
+            free(serialno);
             if (!ok) {
                 goto aoa_hid_end;
             }
@@ -603,9 +595,6 @@ end:
         sc_hid_keyboard_destroy(&s->keyboard_hid);
         sc_aoa_stop(&s->aoa);
     }
-    if (acksync) {
-        sc_acksync_destroy(acksync);
-    }
 #endif
     if (controller_started) {
         controller_stop(&s->controller);

app/src/server.c

@@ -112,9 +112,9 @@ push_server(struct sc_intr *intr, const char *serial) {
         free(server_path);
         return false;
     }
-    bool ok = adb_push(intr, serial, server_path, SC_DEVICE_SERVER_PATH);
+    sc_pid pid = adb_push(serial, server_path, SC_DEVICE_SERVER_PATH);
     free(server_path);
-    return ok;
+    return sc_process_check_success_intr(intr, pid, "adb push");
 }
 
 static const char *
@@ -186,7 +186,6 @@ execute_server(struct sc_server *server,
         params->codec_options ? params->codec_options : "-",
         params->encoder_name ? params->encoder_name : "-",
         params->power_off_on_close ? "true" : "false",
-        params->clipboard_autosync ? "true" : "false",
     };
 #ifdef SERVER_DEBUGGER
     LOGI("Server debugger waiting for a client on device port "
@@ -203,9 +202,8 @@ execute_server(struct sc_server *server,
 }
 
 static bool
-connect_and_read_byte(struct sc_intr *intr, sc_socket socket,
-                      uint32_t tunnel_host, uint16_t tunnel_port) {
-    bool ok = net_connect_intr(intr, socket, tunnel_host, tunnel_port);
+connect_and_read_byte(struct sc_intr *intr, sc_socket socket, uint16_t port) {
+    bool ok = net_connect_intr(intr, socket, IPV4_LOCALHOST, port);
     if (!ok) {
         return false;
     }
@@ -222,13 +220,13 @@ connect_and_read_byte(struct sc_intr *intr, sc_socket socket,
 }
 
 static sc_socket
-connect_to_server(struct sc_server *server, uint32_t attempts, sc_tick delay,
-                  uint32_t host, uint16_t port) {
+connect_to_server(struct sc_server *server, uint32_t attempts, sc_tick delay) {
+    uint16_t port = server->tunnel.local_port;
     do {
         LOGD("Remaining connection attempts: %d", (int) attempts);
         sc_socket socket = net_socket();
         if (socket != SC_SOCKET_NONE) {
-            bool ok = connect_and_read_byte(&server->intr, socket, host, port);
+            bool ok = connect_and_read_byte(&server->intr, socket, port);
             if (ok) {
                 // it worked!
                 return socket;
@@ -354,20 +352,9 @@ sc_server_connect_to(struct sc_server *server, struct sc_server_info *info) {
             goto fail;
         }
     } else {
-        uint32_t tunnel_host = server->params.tunnel_host;
-        if (!tunnel_host) {
-            tunnel_host = IPV4_LOCALHOST;
-        }
-
-        uint16_t tunnel_port = server->params.tunnel_port;
-        if (!tunnel_port) {
-            tunnel_port = tunnel->local_port;
-        }
-
         uint32_t attempts = 100;
         sc_tick delay = SC_TICK_FROM_MS(100);
-        video_socket = connect_to_server(server, attempts, delay, tunnel_host,
-                                         tunnel_port);
+        video_socket = connect_to_server(server, attempts, delay);
         if (video_socket == SC_SOCKET_NONE) {
             goto fail;
         }
@@ -377,8 +364,8 @@ sc_server_connect_to(struct sc_server *server, struct sc_server_info *info) {
         if (control_socket == SC_SOCKET_NONE) {
             goto fail;
         }
-        bool ok = net_connect_intr(&server->intr, control_socket, tunnel_host,
-                                   tunnel_port);
+        bool ok = net_connect_intr(&server->intr, control_socket,
+                                   IPV4_LOCALHOST, tunnel->local_port);
         if (!ok) {
             goto fail;
         }
@@ -435,36 +422,12 @@ sc_server_on_terminated(void *userdata) {
     LOGD("Server terminated");
 }
 
-static bool
-sc_server_fill_serial(struct sc_server *server) {
-    // Retrieve the actual device immediately if not provided, so that all
-    // future adb commands are executed for this specific device, even if other
-    // devices are connected afterwards (without "more than one
-    // device/emulator" error)
-    if (!server->params.serial) {
-        // The serial is owned by sc_server_params, and will be freed on destroy
-        server->params.serial = adb_get_serialno(&server->intr);
-        if (!server->params.serial) {
-            LOGE("Could not get device serial");
-            return false;
-        }
-    }
-
-    return true;
-}
-
 static int
 run_server(void *data) {
     struct sc_server *server = data;
 
-    if (!sc_server_fill_serial(server)) {
-        goto error_connection_failed;
-    }
-
     const struct sc_server_params *params = &server->params;
 
-    LOGD("Device serial: %s", params->serial);
-
     bool ok = push_server(&server->intr, params->serial);
     if (!ok) {
         goto error_connection_failed;

app/src/server.h

@@ -29,8 +29,6 @@ struct sc_server_params {
     const char *codec_options;
     const char *encoder_name;
     struct sc_port_range port_range;
-    uint32_t tunnel_host;
-    uint16_t tunnel_port;
     uint16_t max_size;
     uint32_t bit_rate;
     uint16_t max_fps;
@@ -41,7 +39,6 @@ struct sc_server_params {
     bool stay_awake;
     bool force_adb_forward;
     bool power_off_on_close;
-    bool clipboard_autosync;
 };
 
 struct sc_server {

app/src/sys/win/process.c

@@ -1,7 +1,5 @@
 #include "util/process.h"
 
-#include <processthreadsapi.h>
-
 #include <assert.h>
 
 #include "util/log.h"
@@ -28,8 +26,7 @@ sc_process_execute_p(const char *const argv[], HANDLE *handle,
                      HANDLE *pin, HANDLE *pout, HANDLE *perr) {
     enum sc_process_result ret = SC_PROCESS_ERROR_GENERIC;
 
-    // Add 1 per non-NULL pointer
-    unsigned handle_count = !!pin + !!pout + !!perr;
+    bool inherit_handles = pin || pout || perr;
 
     SECURITY_ATTRIBUTES sa;
     sa.nLength = sizeof(SECURITY_ATTRIBUTES);
@@ -70,94 +67,45 @@ sc_process_execute_p(const char *const argv[], HANDLE *handle,
         }
     }
 
-    STARTUPINFOEXW si;
+    STARTUPINFOW si;
     PROCESS_INFORMATION pi;
     memset(&si, 0, sizeof(si));
-    si.StartupInfo.cb = sizeof(si);
-    HANDLE handles[3];
-
-    LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList = NULL;
-    if (handle_count) {
-        si.StartupInfo.dwFlags = STARTF_USESTDHANDLES;
+    si.cb = sizeof(si);
+    if (inherit_handles) {
+        si.dwFlags = STARTF_USESTDHANDLES;
         if (pin) {
-            si.StartupInfo.hStdInput = stdin_read_handle;
+            si.hStdInput = stdin_read_handle;
         }
         if (pout) {
-            si.StartupInfo.hStdOutput = stdout_write_handle;
+            si.hStdOutput = stdout_write_handle;
         }
         if (perr) {
-            si.StartupInfo.hStdError = stderr_write_handle;
+            si.hStdError = stderr_write_handle;
         }
-
-        SIZE_T size;
-        // Call it once to know the required buffer size
-        BOOL ok =
-            InitializeProcThreadAttributeList(NULL, 1, 0, &size)
-                || GetLastError() == ERROR_INSUFFICIENT_BUFFER;
-        if (!ok) {
-            goto error_close_stderr;
-        }
-
-        lpAttributeList = malloc(size);
-        if (!lpAttributeList) {
-            goto error_close_stderr;
-        }
-
-        ok = InitializeProcThreadAttributeList(lpAttributeList, 1, 0, &size);
-        if (!ok) {
-            free(lpAttributeList);
-            goto error_close_stderr;
-        }
-
-        // Explicitly pass the HANDLEs that must be inherited
-        unsigned i = 0;
-        if (pin) {
-            handles[i++] = stdin_read_handle;
-        }
-        if (pout) {
-            handles[i++] = stdout_write_handle;
-        }
-        if (perr) {
-            handles[i++] = stderr_write_handle;
-        }
-        ok = UpdateProcThreadAttribute(lpAttributeList, 0,
-                                       PROC_THREAD_ATTRIBUTE_HANDLE_LIST,
-                                       handles, handle_count * sizeof(HANDLE),
-                                       NULL, NULL);
-        if (!ok) {
-            goto error_free_attribute_list;
-        }
-
-        si.lpAttributeList = lpAttributeList;
     }
 
     char *cmd = malloc(CMD_MAX_LEN);
     if (!cmd || !build_cmd(cmd, CMD_MAX_LEN, argv)) {
-        goto error_free_attribute_list;
+        *handle = NULL;
+        goto error_close_stderr;
     }
 
     wchar_t *wide = sc_str_to_wchars(cmd);
     free(cmd);
     if (!wide) {
         LOGC("Could not allocate wide char string");
-        goto error_free_attribute_list;
+        goto error_close_stderr;
     }
 
-    BOOL bInheritHandles = handle_count > 0;
-    DWORD dwCreationFlags = handle_count > 0 ? EXTENDED_STARTUPINFO_PRESENT : 0;
-    BOOL ok = CreateProcessW(NULL, wide, NULL, NULL, bInheritHandles,
-                             dwCreationFlags, NULL, NULL, &si.StartupInfo, &pi);
-    free(wide);
-    if (!ok) {
+    if (!CreateProcessW(NULL, wide, NULL, NULL, inherit_handles, 0, NULL, NULL,
+                        &si, &pi)) {
+        free(wide);
+        *handle = NULL;
+
         if (GetLastError() == ERROR_FILE_NOT_FOUND) {
             ret = SC_PROCESS_ERROR_MISSING_BINARY;
         }
-        goto error_free_attribute_list;
-    }
-
-    if (lpAttributeList) {
-        DeleteProcThreadAttributeList(lpAttributeList);
-        free(lpAttributeList);
+        goto error_close_stderr;
     }
 
     // These handles are used by the child process, close them for this process
@@ -171,15 +119,11 @@ sc_process_execute_p(const char *const argv[], HANDLE *handle,
         CloseHandle(stderr_write_handle);
     }
 
+    free(wide);
     *handle = pi.hProcess;
 
     return SC_PROCESS_SUCCESS;
 
-error_free_attribute_list:
-    if (lpAttributeList) {
-        DeleteProcThreadAttributeList(lpAttributeList);
-        free(lpAttributeList);
-    }
 error_close_stderr:
     if (perr) {
         CloseHandle(*perr);
@@ -226,7 +170,7 @@ sc_process_close(HANDLE handle) {
 }
 
 ssize_t
-sc_pipe_read(HANDLE pipe, char *data, size_t len) {
+sc_read_pipe(HANDLE pipe, char *data, size_t len) {
     DWORD r;
     if (!ReadFile(pipe, data, len, &r, NULL)) {
         return -1;
@@ -235,7 +179,7 @@ sc_pipe_read(HANDLE pipe, char *data, size_t len) {
 }
 
 void
-sc_pipe_close(HANDLE pipe) {
+sc_close_pipe(HANDLE pipe) {
     if (!CloseHandle(pipe)) {
         LOGW("Cannot close pipe");
     }

app/src/trait/key_processor.h

@@ -14,31 +14,12 @@
  * Component able to process and inject keys should implement this trait.
  */
 struct sc_key_processor {
-    /**
-     * Set by the implementation to indicate that it must explicitly wait for
-     * the clipboard to be set on the device before injecting Ctrl+v to avoid
-     * race conditions. If it is set, the input_manager will pass a valid
-     * ack_to_wait to process_key() in case of clipboard synchronization
-     * resulting of the key event.
-     */
-    bool async_paste;
-
     const struct sc_key_processor_ops *ops;
 };
 
 struct sc_key_processor_ops {
-
-    /**
-     * Process the keyboard event
-     *
-     * The `sequence` number (if different from `SC_SEQUENCE_INVALID`) indicates
-     * the acknowledgement number to wait for before injecting this event.
-     * This allows to ensure that the device clipboard is set before injecting
-     * Ctrl+v on the device.
-     */
     void
-    (*process_key)(struct sc_key_processor *kp, const SDL_KeyboardEvent *event,
-                   uint64_t ack_to_wait);
+    (*process_key)(struct sc_key_processor *kp, const SDL_KeyboardEvent *event);
 
     void
     (*process_text)(struct sc_key_processor *kp,

app/src/util/acksync.c

@@ -1,76 +0,0 @@
-#include "acksync.h"
-
-#include <assert.h>
-#include "util/log.h"
-
-bool
-sc_acksync_init(struct sc_acksync *as) {
-    bool ok = sc_mutex_init(&as->mutex);
-    if (!ok) {
-        return false;
-    }
-
-    ok = sc_cond_init(&as->cond);
-    if (!ok) {
-        sc_mutex_destroy(&as->mutex);
-        return false;
-    }
-
-    as->stopped = false;
-    as->ack = SC_SEQUENCE_INVALID;
-
-    return true;
-}
-
-void
-sc_acksync_destroy(struct sc_acksync *as) {
-    sc_cond_destroy(&as->cond);
-    sc_mutex_destroy(&as->mutex);
-}
-
-void
-sc_acksync_ack(struct sc_acksync *as, uint64_t sequence) {
-    sc_mutex_lock(&as->mutex);
-
-    // Acknowledgements must be monotonic
-    assert(sequence >= as->ack);
-
-    as->ack = sequence;
-    sc_cond_signal(&as->cond);
-
-    sc_mutex_unlock(&as->mutex);
-}
-
-enum sc_acksync_wait_result
-sc_acksync_wait(struct sc_acksync *as, uint64_t ack, sc_tick deadline) {
-    sc_mutex_lock(&as->mutex);
-
-    bool timed_out = false;
-    while (!as->stopped && as->ack < ack && !timed_out) {
-        timed_out = !sc_cond_timedwait(&as->cond, &as->mutex, deadline);
-    }
-
-    enum sc_acksync_wait_result ret;
-    if (as->stopped) {
-        ret = SC_ACKSYNC_WAIT_INTR;
-    } else if (as->ack >= ack) {
-        ret = SC_ACKSYNC_WAIT_OK;
-    } else {
-        assert(timed_out);
-        ret = SC_ACKSYNC_WAIT_TIMEOUT;
-    }
-    sc_mutex_unlock(&as->mutex);
-
-    return ret;
-}
-
-/**
- * Interrupt any `sc_acksync_wait()`
- */
-void
-sc_acksync_interrupt(struct sc_acksync *as) {
-    sc_mutex_lock(&as->mutex);
-    as->stopped = true;
-    sc_cond_signal(&as->cond);
-    sc_mutex_unlock(&as->mutex);
-}

app/src/util/acksync.h

@@ -1,66 +0,0 @@
-#ifndef SC_ACK_SYNC_H
-#define SC_ACK_SYNC_H
-
-#include "common.h"
-
-#include "thread.h"
-
-#define SC_SEQUENCE_INVALID 0
-
-/**
- * Helper to wait for acknowledgments
- *
- * In practice, it is used to wait for device clipboard acknowledgement from the
- * server before injecting Ctrl+v via AOA HID, in order to avoid pasting the
- * content of the old device clipboard (if Ctrl+v was injected before the
- * clipboard content was actually set).
- */
-struct sc_acksync {
-    sc_mutex mutex;
-    sc_cond cond;
-
-    bool stopped;
-
-    // Last acked value, initially SC_SEQUENCE_INVALID
-    uint64_t ack;
-};
-
-enum sc_acksync_wait_result {
-    // Acknowledgment received
-    SC_ACKSYNC_WAIT_OK,
-
-    // Timeout expired
-    SC_ACKSYNC_WAIT_TIMEOUT,
-
-    // Interrupted from another thread by sc_acksync_interrupt()
-    SC_ACKSYNC_WAIT_INTR,
-};
-
-bool
-sc_acksync_init(struct sc_acksync *as);
-
-void
-sc_acksync_destroy(struct sc_acksync *as);
-
-/**
- * Acknowledge `sequence`
- *
- * The `sequence` must be greater than (or equal to) any previous acknowledged
- * sequence.
- */
-void
-sc_acksync_ack(struct sc_acksync *as, uint64_t sequence);
-
-/**
- * Wait for acknowledgment of sequence `ack` (or higher)
- */
-enum sc_acksync_wait_result
-sc_acksync_wait(struct sc_acksync *as, uint64_t ack, sc_tick deadline);
-
-/**
- * Interrupt any `sc_acksync_wait()`
- */
-void
-sc_acksync_interrupt(struct sc_acksync *as);
-
-#endif

app/src/util/net.c

@@ -7,7 +7,6 @@
 #include "log.h"
 
 #ifdef __WINDOWS__
-# include <ws2tcpip.h>
   typedef int socklen_t;
   typedef SOCKET sc_raw_socket;
 #else
@@ -97,6 +96,27 @@ net_perror(const char *s) {
 sc_socket
 net_socket(void) {
     sc_raw_socket raw_sock = socket(AF_INET, SOCK_STREAM, 0);
+
+#ifdef _WIN32
+    /* To be able to communicate with a child process via stdin, stdout and
+     * stderr, the CreateProcess() parameter bInheritHandles must be set to
+     * TRUE. But this causes *all* handles to be inherited, including sockets.
+     *
+     * One possibility could be to use an extended API to set extra attributes
+     * on process creation:
+     *  - <https://stackoverflow.com/a/28185363/1987178>
+     *  - <https://devblogs.microsoft.com/oldnewthing/20111216-00/?p=8873>
+     * But it seems that this API is not available on MinGW (it does not
+     * compile).
+     *
+     * As an alternative, explicitly mark all sockets as non-inheritable.
+     */
+    if (!SetHandleInformation((HANDLE) raw_sock, HANDLE_FLAG_INHERIT, 0)) {
+        closesocket(raw_sock);
+        return SC_SOCKET_NONE;
+    }
+#endif
+
     sc_socket sock = wrap(raw_sock);
     if (sock == SC_SOCKET_NONE) {
         net_perror("socket");
@@ -226,15 +246,3 @@ net_close(sc_socket socket) {
     return !close(raw_sock);
 #endif
 }
-
-bool
-net_parse_ipv4(const char *s, uint32_t *ipv4) {
-    struct in_addr addr;
-    if (!inet_pton(AF_INET, s, &addr)) {
-        LOGE("Invalid IPv4 address: %s", s);
-        return false;
-    }
-
-    *ipv4 = ntohl(addr.s_addr);
-    return true;
-}

app/src/util/net.h

@@ -68,10 +68,4 @@ net_interrupt(sc_socket socket);
 bool
 net_close(sc_socket socket);
 
-/**
- * Parse `ip` "xxx.xxx.xxx.xxx" to an IPv4 host representation
- */
-bool
-net_parse_ipv4(const char *ip, uint32_t *ipv4);
-
 #endif

app/src/util/process_intr.c

@@ -2,7 +2,7 @@
 
 bool
 sc_process_check_success_intr(struct sc_intr *intr, sc_pid pid,
-                              const char *name, bool close) {
+                              const char *name) {
     if (!sc_intr_set_process(intr, pid)) {
         // Already interrupted
         return false;
@@ -11,40 +11,6 @@ sc_process_check_success_intr(struct sc_intr *intr, sc_pid pid,
     // Always pass close=false, interrupting would be racy otherwise
     bool ret = sc_process_check_success(pid, name, false);
 
-    sc_intr_set_process(intr, SC_PROCESS_NONE);
-
-    if (close) {
-        // Close separately
-        sc_process_close(pid);
-    }
-
-    return ret;
-}
-
-ssize_t
-sc_pipe_read_intr(struct sc_intr *intr, sc_pid pid, sc_pipe pipe, char *data,
-                  size_t len) {
-    if (!sc_intr_set_process(intr, pid)) {
-        // Already interrupted
-        return false;
-    }
-
-    ssize_t ret = sc_pipe_read(pipe, data, len);
-
-    sc_intr_set_process(intr, SC_PROCESS_NONE);
-    return ret;
-}
-
-ssize_t
-sc_pipe_read_all_intr(struct sc_intr *intr, sc_pid pid, sc_pipe pipe,
-                      char *data, size_t len) {
-    if (!sc_intr_set_process(intr, pid)) {
-        // Already interrupted
-        return false;
-    }
-
-    ssize_t ret = sc_pipe_read_all(pipe, data, len);
-
     sc_intr_set_process(intr, SC_PROCESS_NONE);
     return ret;
 }

app/src/util/process_intr.h

@@ -8,14 +8,6 @@
 
 bool
 sc_process_check_success_intr(struct sc_intr *intr, sc_pid pid,
-                              const char *name, bool close);
-
-ssize_t
-sc_pipe_read_intr(struct sc_intr *intr, sc_pid pid, sc_pipe pipe, char *data,
-                  size_t len);
-
-ssize_t
-sc_pipe_read_all_intr(struct sc_intr *intr, sc_pid pid, sc_pipe pipe,
-                      char *data, size_t len);
+                              const char *name);
 
 #endif

app/src/util/str.c

@@ -291,11 +291,3 @@ error:
     free(buf.s);
     return NULL;
 }
-
-size_t
-sc_str_truncate(char *data, size_t len, const char *endchars) {
-    data[len - 1] = '\0';
-    size_t idx = strcspn(data, endchars);
-    data[idx] = '\0';
-    return idx;
-}

app/src/util/str.h

@@ -103,15 +103,4 @@ sc_str_from_wchars(const wchar_t *s);
 char *
 sc_str_wrap_lines(const char *input, unsigned columns, unsigned indent);
 
-/**
- * Truncate the data after any of the characters from `endchars`
- *
- * An '\0' is always written at the end of the data, even if no newline
- * character is encountered.
- *
- * Return the size of the resulting line.
- */
-size_t
-sc_str_truncate(char *data, size_t len, const char *endchars);
-
 #endif

app/tests/test_control_msg_serialize.c

@@ -78,7 +78,7 @@ static void test_serialize_inject_touch_event(void) {
         .type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
         .inject_touch_event = {
             .action = AMOTION_EVENT_ACTION_DOWN,
-            .pointer_id = UINT64_C(0x1234567887654321),
+            .pointer_id = 0x1234567887654321L,
             .position = {
                 .point = {
                     .x = 100,
@@ -226,7 +226,6 @@ static void test_serialize_set_clipboard(void) {
     struct control_msg msg = {
         .type = CONTROL_MSG_TYPE_SET_CLIPBOARD,
         .set_clipboard = {
-            .sequence = UINT64_C(0x0102030405060708),
             .paste = true,
             .text = "hello, world!",
         },
@@ -234,11 +233,10 @@ static void test_serialize_set_clipboard(void) {
 
     unsigned char buf[CONTROL_MSG_MAX_SIZE];
     size_t size = control_msg_serialize(&msg, buf);
-    assert(size == 27);
+    assert(size == 19);
 
     const unsigned char expected[] = {
         CONTROL_MSG_TYPE_SET_CLIPBOARD,
-        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // sequence
         1, // paste
         0x00, 0x00, 0x00, 0x0d, // text length
         'h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!', // text

app/tests/test_device_msg_deserialize.c

@@ -47,26 +47,11 @@ static void test_deserialize_clipboard_big(void) {
     device_msg_destroy(&msg);
 }
 
-static void test_deserialize_ack_set_clipboard(void) {
-    const unsigned char input[] = {
-        DEVICE_MSG_TYPE_ACK_CLIPBOARD,
-        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // sequence
-    };
-
-    struct device_msg msg;
-    ssize_t r = device_msg_deserialize(input, sizeof(input), &msg);
-    assert(r == 9);
-
-    assert(msg.type == DEVICE_MSG_TYPE_ACK_CLIPBOARD);
-    assert(msg.ack_clipboard.sequence == UINT64_C(0x0102030405060708));
-}
-
 int main(int argc, char *argv[]) {
     (void) argc;
     (void) argv;
 
     test_deserialize_clipboard();
     test_deserialize_clipboard_big();
-    test_deserialize_ack_set_clipboard();
     return 0;
 }

app/tests/test_str.c

@@ -337,32 +337,6 @@ static void test_wrap_lines(void) {
     free(formatted);
 }
 
-static void test_truncate(void) {
-    char s[] = "hello\nworld\n!";
-    size_t len = sc_str_truncate(s, sizeof(s), "\n");
-
-    assert(len == 5);
-    assert(!strcmp("hello", s));
-
-    char s2[] = "hello\r\nworkd\r\n!";
-    len = sc_str_truncate(s2, sizeof(s2), "\n\r");
-
-    assert(len == 5);
-    assert(!strcmp("hello", s));
-
-    char s3[] = "hello world\n!";
-    len = sc_str_truncate(s3, sizeof(s3), " \n\r");
-
-    assert(len == 5);
-    assert(!strcmp("hello", s3));
-
-    char s4[] = "hello ";
-    len = sc_str_truncate(s4, sizeof(s4), " \n\r");
-
-    assert(len == 5);
-    assert(!strcmp("hello", s4));
-}
-
 int main(int argc, char *argv[]) {
     (void) argc;
     (void) argv;
@@ -382,6 +356,5 @@ int main(int argc, char *argv[]) {
     test_parse_integer_with_suffix();
     test_strlist_contains();
     test_wrap_lines();
-    test_truncate();
     return 0;
 }

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

@@ -1,5 +1,6 @@
 package com.genymobile.scrcpy;
 
+import com.genymobile.scrcpy.wrappers.ContentProvider;
 import com.genymobile.scrcpy.wrappers.ServiceManager;
 
 import android.os.Parcel;
@@ -165,21 +166,14 @@ public final class CleanUp {
 
         if (config.disableShowTouches || config.restoreStayOn != -1) {
             ServiceManager serviceManager = new ServiceManager();
-            Settings settings = new Settings(serviceManager);
-            if (config.disableShowTouches) {
-                Ln.i("Disabling \"show touches\"");
-                try {
-                    settings.putValue(Settings.TABLE_SYSTEM, "show_touches", "0");
-                } catch (SettingsException e) {
-                    Ln.e("Could not restore \"show_touches\"", e);
+            try (ContentProvider settings = serviceManager.getActivityManager().createSettingsProvider()) {
+                if (config.disableShowTouches) {
+                    Ln.i("Disabling \"show touches\"");
+                    settings.putValue(ContentProvider.TABLE_SYSTEM, "show_touches", "0");
                 }
-            }
-            if (config.restoreStayOn != -1) {
-                Ln.i("Restoring \"stay awake\"");
-                try {
-                    settings.putValue(Settings.TABLE_GLOBAL, "stay_on_while_plugged_in", String.valueOf(config.restoreStayOn));
-                } catch (SettingsException e) {
-                    Ln.e("Could not restore \"stay_on_while_plugged_in\"", e);
+                if (config.restoreStayOn != -1) {
+                    Ln.i("Restoring \"stay awake\"");
+                    settings.putValue(ContentProvider.TABLE_GLOBAL, "stay_on_while_plugged_in", String.valueOf(config.restoreStayOn));
                 }
             }
         }

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

@@ -1,33 +0,0 @@
-package com.genymobile.scrcpy;
-
-import java.io.IOException;
-import java.util.Arrays;
-import java.util.Scanner;
-
-public final class Command {
-    private Command() {
-        // not instantiable
-    }
-
-    public static void exec(String... cmd) throws IOException, InterruptedException {
-        Process process = Runtime.getRuntime().exec(cmd);
-        int exitCode = process.waitFor();
-        if (exitCode != 0) {
-            throw new IOException("Command " + Arrays.toString(cmd) + " returned with value " + exitCode);
-        }
-    }
-
-    public static String execReadLine(String... cmd) throws IOException, InterruptedException {
-        String result = null;
-        Process process = Runtime.getRuntime().exec(cmd);
-        Scanner scanner = new Scanner(process.getInputStream());
-        if (scanner.hasNextLine()) {
-            result = scanner.nextLine();
-        }
-        int exitCode = process.waitFor();
-        if (exitCode != 0) {
-            throw new IOException("Command " + Arrays.toString(cmd) + " returned with value " + exitCode);
-        }
-        return result;
-    }
-}

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

@@ -18,8 +18,6 @@ public final class ControlMessage {
     public static final int TYPE_SET_SCREEN_POWER_MODE = 10;
     public static final int TYPE_ROTATE_DEVICE = 11;
 
-    public static final long SEQUENCE_INVALID = 0;
-
     private int type;
     private String text;
     private int metaState; // KeyEvent.META_*
@@ -33,7 +31,6 @@ public final class ControlMessage {
     private int vScroll;
     private boolean paste;
     private int repeat;
-    private long sequence;
 
     private ControlMessage() {
     }
@@ -82,10 +79,9 @@ public final class ControlMessage {
         return msg;
     }
 
-    public static ControlMessage createSetClipboard(long sequence, String text, boolean paste) {
+    public static ControlMessage createSetClipboard(String text, boolean paste) {
         ControlMessage msg = new ControlMessage();
         msg.type = TYPE_SET_CLIPBOARD;
-        msg.sequence = sequence;
         msg.text = text;
         msg.paste = paste;
         return msg;
@@ -158,8 +154,4 @@ public final class ControlMessage {
     public int getRepeat() {
         return repeat;
     }
-
-    public long getSequence() {
-        return sequence;
-    }
 }

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

@@ -13,11 +13,11 @@ public class ControlMessageReader {
     static final int INJECT_SCROLL_EVENT_PAYLOAD_LENGTH = 20;
     static final int BACK_OR_SCREEN_ON_LENGTH = 1;
     static final int SET_SCREEN_POWER_MODE_PAYLOAD_LENGTH = 1;
-    static final int SET_CLIPBOARD_FIXED_PAYLOAD_LENGTH = 9;
+    static final int SET_CLIPBOARD_FIXED_PAYLOAD_LENGTH = 1;
 
     private static final int MESSAGE_MAX_SIZE = 1 << 18; // 256k
 
-    public static final int CLIPBOARD_TEXT_MAX_LENGTH = MESSAGE_MAX_SIZE - 14; // type: 1 byte; sequence: 8 bytes; paste flag: 1 byte; length: 4 bytes
+    public static final int CLIPBOARD_TEXT_MAX_LENGTH = MESSAGE_MAX_SIZE - 6; // type: 1 byte; paste flag: 1 byte; length: 4 bytes
     public static final int INJECT_TEXT_MAX_LENGTH = 300;
 
     private final byte[] rawBuffer = new byte[MESSAGE_MAX_SIZE];
@@ -166,13 +166,12 @@ public class ControlMessageReader {
         if (buffer.remaining() < SET_CLIPBOARD_FIXED_PAYLOAD_LENGTH) {
             return null;
         }
-        long sequence = buffer.getLong();
         boolean paste = buffer.get() != 0;
         String text = parseString();
         if (text == null) {
             return null;
         }
-        return ControlMessage.createSetClipboard(sequence, text, paste);
+        return ControlMessage.createSetClipboard(text, paste);
     }
 
     private ControlMessage parseSetScreenPowerMode() {

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

@@ -120,12 +120,7 @@ public class Controller {
                 }
                 break;
             case ControlMessage.TYPE_SET_CLIPBOARD:
-                long sequence = msg.getSequence();
                 setClipboard(msg.getText(), msg.getPaste());
-                if (sequence != ControlMessage.SEQUENCE_INVALID) {
-                    // Acknowledgement requested
-                    sender.pushAckClipboard(sequence);
-                }
                 break;
             case ControlMessage.TYPE_SET_SCREEN_POWER_MODE:
                 if (device.supportsInputEvents()) {

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

@@ -1,6 +1,7 @@
 package com.genymobile.scrcpy;
 
 import com.genymobile.scrcpy.wrappers.ClipboardManager;
+import com.genymobile.scrcpy.wrappers.ContentProvider;
 import com.genymobile.scrcpy.wrappers.InputManager;
 import com.genymobile.scrcpy.wrappers.ServiceManager;
 import com.genymobile.scrcpy.wrappers.SurfaceControl;
@@ -28,7 +29,6 @@ public final class Device {
     public static final int LOCK_VIDEO_ORIENTATION_INITIAL = -2;
 
     private static final ServiceManager SERVICE_MANAGER = new ServiceManager();
-    private static final Settings SETTINGS = new Settings(SERVICE_MANAGER);
 
     public interface RotationListener {
         void onRotationChanged(int rotation);
@@ -82,8 +82,8 @@ public final class Device {
             }
         }, displayId);
 
-        if (options.getControl() && options.getClipboardAutosync()) {
-            // If control and autosync are enabled, synchronize Android clipboard to the computer automatically
+        if (options.getControl()) {
+            // If control is enabled, synchronize Android clipboard to the computer automatically
             ClipboardManager clipboardManager = SERVICE_MANAGER.getClipboardManager();
             if (clipboardManager != null) {
                 clipboardManager.addPrimaryClipChangedListener(new IOnPrimaryClipChangedListener.Stub() {
@@ -296,7 +296,7 @@ public final class Device {
         }
     }
 
-    public static Settings getSettings() {
-        return SETTINGS;
+    public static ContentProvider createSettingsProvider() {
+        return SERVICE_MANAGER.getActivityManager().createSettingsProvider();
     }
 }

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

@@ -3,13 +3,9 @@ package com.genymobile.scrcpy;
 public final class DeviceMessage {
 
     public static final int TYPE_CLIPBOARD = 0;
-    public static final int TYPE_ACK_CLIPBOARD = 1;
-
-    public static final long SEQUENCE_INVALID = ControlMessage.SEQUENCE_INVALID;
 
     private int type;
     private String text;
-    private long sequence;
 
     private DeviceMessage() {
     }
@@ -21,13 +17,6 @@ public final class DeviceMessage {
         return event;
     }
 
-    public static DeviceMessage createAckClipboard(long sequence) {
-        DeviceMessage event = new DeviceMessage();
-        event.type = TYPE_ACK_CLIPBOARD;
-        event.sequence = sequence;
-        return event;
-    }
-
     public int getType() {
         return type;
     }
@@ -35,8 +24,4 @@ public final class DeviceMessage {
     public String getText() {
         return text;
     }
-
-    public long getSequence() {
-        return sequence;
-    }
 }

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

@@ -8,8 +8,6 @@ public final class DeviceMessageSender {
 
     private String clipboardText;
 
-    private long ack;
-
     public DeviceMessageSender(DesktopConnection connection) {
         this.connection = connection;
     }
@@ -19,34 +17,18 @@ public final class DeviceMessageSender {
         notify();
     }
 
-    public synchronized void pushAckClipboard(long sequence) {
-        ack = sequence;
-        notify();
-    }
-
     public void loop() throws IOException, InterruptedException {
         while (true) {
             String text;
-            long sequence;
             synchronized (this) {
-                while (ack == DeviceMessage.SEQUENCE_INVALID && clipboardText == null) {
+                while (clipboardText == null) {
                     wait();
                 }
                 text = clipboardText;
                 clipboardText = null;
-
-                sequence = ack;
-                ack = DeviceMessage.SEQUENCE_INVALID;
-            }
-
-            if (sequence != DeviceMessage.SEQUENCE_INVALID) {
-                DeviceMessage event = DeviceMessage.createAckClipboard(sequence);
-                connection.sendDeviceMessage(event);
-            }
-            if (text != null) {
-                DeviceMessage event = DeviceMessage.createClipboard(text);
-                connection.sendDeviceMessage(event);
             }
+            DeviceMessage event = DeviceMessage.createClipboard(text);
+            connection.sendDeviceMessage(event);
         }
     }
 }

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

@@ -15,7 +15,7 @@ public class DeviceMessageWriter {
 
     public void writeTo(DeviceMessage msg, OutputStream output) throws IOException {
         buffer.clear();
-        buffer.put((byte) msg.getType());
+        buffer.put((byte) DeviceMessage.TYPE_CLIPBOARD);
         switch (msg.getType()) {
             case DeviceMessage.TYPE_CLIPBOARD:
                 String text = msg.getText();
@@ -25,10 +25,6 @@ public class DeviceMessageWriter {
                 buffer.put(raw, 0, len);
                 output.write(rawBuffer, 0, buffer.position());
                 break;
-            case DeviceMessage.TYPE_ACK_CLIPBOARD:
-                buffer.putLong(msg.getSequence());
-                output.write(rawBuffer, 0, buffer.position());
-                break;
             default:
                 Ln.w("Unknown device message: " + msg.getType());
                 break;

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

@@ -57,18 +57,11 @@ public final class Ln {
         }
     }
 
-    public static void w(String message, Throwable throwable) {
-        if (isEnabled(Level.WARN)) {
-            Log.w(TAG, message, throwable);
-            System.out.println(PREFIX + "WARN: " + message);
-            if (throwable != null) {
-                throwable.printStackTrace();
-            }
-        }
-    }
-
     public static void w(String message) {
-        w(message, null);
+        if (isEnabled(Level.WARN)) {
+            Log.w(TAG, message);
+            System.out.println(PREFIX + "WARN: " + message);
+        }
     }
 
     public static void e(String message, Throwable throwable) {

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

@@ -18,7 +18,6 @@ public class Options {
     private String codecOptions;
     private String encoderName;
     private boolean powerOffScreenOnClose;
-    private boolean clipboardAutosync;
 
     public Ln.Level getLogLevel() {
         return logLevel;
@@ -139,12 +138,4 @@ public class Options {
     public boolean getPowerOffScreenOnClose() {
         return this.powerOffScreenOnClose;
     }
-
-    public boolean getClipboardAutosync() {
-        return clipboardAutosync;
-    }
-
-    public void setClipboardAutosync(boolean clipboardAutosync) {
-        this.clipboardAutosync = clipboardAutosync;
-    }
 }

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

@@ -1,5 +1,7 @@
 package com.genymobile.scrcpy;
 
+import com.genymobile.scrcpy.wrappers.ContentProvider;
+
 import android.graphics.Rect;
 import android.media.MediaCodec;
 import android.media.MediaCodecInfo;
@@ -17,25 +19,24 @@ public final class Server {
         // not instantiable
     }
 
-    private static void initAndCleanUp(Options options) {
+    private static void scrcpy(Options options) throws IOException {
+        Ln.i("Device: " + Build.MANUFACTURER + " " + Build.MODEL + " (Android " + Build.VERSION.RELEASE + ")");
+        final Device device = new Device(options);
+        List<CodecOption> codecOptions = CodecOption.parse(options.getCodecOptions());
+
         boolean mustDisableShowTouchesOnCleanUp = false;
         int restoreStayOn = -1;
         if (options.getShowTouches() || options.getStayAwake()) {
-            Settings settings = Device.getSettings();
-            if (options.getShowTouches()) {
-                try {
-                    String oldValue = settings.getAndPutValue(Settings.TABLE_SYSTEM, "show_touches", "1");
+            try (ContentProvider settings = Device.createSettingsProvider()) {
+                if (options.getShowTouches()) {
+                    String oldValue = settings.getAndPutValue(ContentProvider.TABLE_SYSTEM, "show_touches", "1");
                     // If "show touches" was disabled, it must be disabled back on clean up
                     mustDisableShowTouchesOnCleanUp = !"1".equals(oldValue);
-                } catch (SettingsException e) {
-                    Ln.e("Could not change \"show_touches\"", e);
                 }
-            }
 
-            if (options.getStayAwake()) {
-                int stayOn = BatteryManager.BATTERY_PLUGGED_AC | BatteryManager.BATTERY_PLUGGED_USB | BatteryManager.BATTERY_PLUGGED_WIRELESS;
-                try {
-                    String oldValue = settings.getAndPutValue(Settings.TABLE_GLOBAL, "stay_on_while_plugged_in", String.valueOf(stayOn));
+                if (options.getStayAwake()) {
+                    int stayOn = BatteryManager.BATTERY_PLUGGED_AC | BatteryManager.BATTERY_PLUGGED_USB | BatteryManager.BATTERY_PLUGGED_WIRELESS;
+                    String oldValue = settings.getAndPutValue(ContentProvider.TABLE_GLOBAL, "stay_on_while_plugged_in", String.valueOf(stayOn));
                     try {
                         restoreStayOn = Integer.parseInt(oldValue);
                         if (restoreStayOn == stayOn) {
@@ -45,25 +46,11 @@ public final class Server {
                     } catch (NumberFormatException e) {
                         restoreStayOn = 0;
                     }
-                } catch (SettingsException e) {
-                    Ln.e("Could not change \"stay_on_while_plugged_in\"", e);
                 }
             }
         }
 
-        try {
-            CleanUp.configure(options.getDisplayId(), restoreStayOn, mustDisableShowTouchesOnCleanUp, true, options.getPowerOffScreenOnClose());
-        } catch (IOException e) {
-            Ln.e("Could not configure cleanup", e);
-        }
-    }
-
-    private static void scrcpy(Options options) throws IOException {
-        Ln.i("Device: " + Build.MANUFACTURER + " " + Build.MODEL + " (Android " + Build.VERSION.RELEASE + ")");
-        final Device device = new Device(options);
-        List<CodecOption> codecOptions = CodecOption.parse(options.getCodecOptions());
-
-        Thread initThread = startInitThread(options);
+        CleanUp.configure(options.getDisplayId(), restoreStayOn, mustDisableShowTouchesOnCleanUp, true, options.getPowerOffScreenOnClose());
 
         boolean tunnelForward = options.isTunnelForward();
 
@@ -95,7 +82,6 @@ public final class Server {
                 // this is expected on close
                 Ln.d("Screen streaming stopped");
             } finally {
-                initThread.interrupt();
                 if (controllerThread != null) {
                     controllerThread.interrupt();
                 }
@@ -106,17 +92,6 @@ public final class Server {
         }
     }
 
-    private static Thread startInitThread(final Options options) {
-        Thread thread = new Thread(new Runnable() {
-            @Override
-            public void run() {
-                initAndCleanUp(options);
-            }
-        });
-        thread.start();
-        return thread;
-    }
-
     private static Thread startController(final Controller controller) {
         Thread thread = new Thread(new Runnable() {
             @Override
@@ -160,7 +135,7 @@ public final class Server {
                     "The server version (" + BuildConfig.VERSION_NAME + ") does not match the client " + "(" + clientVersion + ")");
         }
 
-        final int expectedParameters = 17;
+        final int expectedParameters = 16;
         if (args.length != expectedParameters) {
             throw new IllegalArgumentException("Expecting " + expectedParameters + " parameters");
         }
@@ -213,9 +188,6 @@ public final class Server {
         boolean powerOffScreenOnClose = Boolean.parseBoolean(args[15]);
         options.setPowerOffScreenOnClose(powerOffScreenOnClose);
 
-        boolean clipboardAutosync = Boolean.parseBoolean(args[16]);
-        options.setClipboardAutosync(clipboardAutosync);
-
         return options;
     }
 

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

@@ -1,84 +0,0 @@
-package com.genymobile.scrcpy;
-
-import com.genymobile.scrcpy.wrappers.ContentProvider;
-import com.genymobile.scrcpy.wrappers.ServiceManager;
-
-import android.os.Build;
-
-import java.io.IOException;
-
-public class Settings {
-
-    public static final String TABLE_SYSTEM = ContentProvider.TABLE_SYSTEM;
-    public static final String TABLE_SECURE = ContentProvider.TABLE_SECURE;
-    public static final String TABLE_GLOBAL = ContentProvider.TABLE_GLOBAL;
-
-    private final ServiceManager serviceManager;
-
-    public Settings(ServiceManager serviceManager) {
-        this.serviceManager = serviceManager;
-    }
-
-    private static void execSettingsPut(String table, String key, String value) throws SettingsException {
-        try {
-            Command.exec("settings", "put", table, key, value);
-        } catch (IOException | InterruptedException e) {
-            throw new SettingsException("put", table, key, value, e);
-        }
-    }
-
-    private static String execSettingsGet(String table, String key) throws SettingsException {
-        try {
-            return Command.execReadLine("settings", "get", table, key);
-        } catch (IOException | InterruptedException e) {
-            throw new SettingsException("get", table, key, null, e);
-        }
-    }
-
-    public String getValue(String table, String key) throws SettingsException {
-        if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.R) {
-            // on Android >= 12, it always fails: <https://github.com/Genymobile/scrcpy/issues/2788>
-            try (ContentProvider provider = serviceManager.getActivityManager().createSettingsProvider()) {
-                return provider.getValue(table, key);
-            } catch (SettingsException e) {
-                Ln.w("Could not get settings value via ContentProvider, fallback to settings process", e);
-            }
-        }
-
-        return execSettingsGet(table, key);
-    }
-
-    public void putValue(String table, String key, String value) throws SettingsException {
-        if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.R) {
-            // on Android >= 12, it always fails: <https://github.com/Genymobile/scrcpy/issues/2788>
-            try (ContentProvider provider = serviceManager.getActivityManager().createSettingsProvider()) {
-                provider.putValue(table, key, value);
-            } catch (SettingsException e) {
-                Ln.w("Could not put settings value via ContentProvider, fallback to settings process", e);
-            }
-        }
-
-        execSettingsPut(table, key, value);
-    }
-
-    public String getAndPutValue(String table, String key, String value) throws SettingsException {
-        if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.R) {
-            // on Android >= 12, it always fails: <https://github.com/Genymobile/scrcpy/issues/2788>
-            try (ContentProvider provider = serviceManager.getActivityManager().createSettingsProvider()) {
-                String oldValue = provider.getValue(table, key);
-                if (!value.equals(oldValue)) {
-                    provider.putValue(table, key, value);
-                }
-                return oldValue;
-            } catch (SettingsException e) {
-                Ln.w("Could not get and put settings value via ContentProvider, fallback to settings process", e);
-            }
-        }
-
-        String oldValue = getValue(table, key);
-        if (!value.equals(oldValue)) {
-             putValue(table, key, value);
-        }
-        return oldValue;
-    }
-}

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

@@ -1,11 +0,0 @@
-package com.genymobile.scrcpy;
-
-public class SettingsException extends Exception {
-    private static String createMessage(String method, String table, String key, String value) {
-        return "Could not access settings: " + method + " " + table + " " + key + (value != null ? " " + value : "");
-    }
-
-    public SettingsException(String method, String table, String key, String value, Throwable cause) {
-        super(createMessage(method, table, key, value), cause);
-    }
-}

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

@@ -1,7 +1,6 @@
 package com.genymobile.scrcpy.wrappers;
 
 import com.genymobile.scrcpy.Ln;
-import com.genymobile.scrcpy.SettingsException;
 
 import android.annotation.SuppressLint;
 import android.os.Bundle;
@@ -88,8 +87,7 @@ public class ContentProvider implements Closeable {
         return attributionSource;
     }
 
-    private Bundle call(String callMethod, String arg, Bundle extras)
-            throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
+    private Bundle call(String callMethod, String arg, Bundle extras) {
         try {
             Method method = getCallMethod();
             Object[] args;
@@ -110,7 +108,7 @@ public class ContentProvider implements Closeable {
             return (Bundle) method.invoke(provider, args);
         } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException | ClassNotFoundException | InstantiationException e) {
             Ln.e("Could not invoke method", e);
-            throw e;
+            return null;
         }
     }
 
@@ -144,31 +142,30 @@ public class ContentProvider implements Closeable {
         }
     }
 
-    public String getValue(String table, String key) throws SettingsException {
+    public String getValue(String table, String key) {
         String method = getGetMethod(table);
         Bundle arg = new Bundle();
         arg.putInt(CALL_METHOD_USER_KEY, ServiceManager.USER_ID);
-        try {
-            Bundle bundle = call(method, key, arg);
-            if (bundle == null) {
-                return null;
-            }
-            return bundle.getString("value");
-        } catch (Exception e) {
-            throw new SettingsException(table, "get", key, null, e);
+        Bundle bundle = call(method, key, arg);
+        if (bundle == null) {
+            return null;
         }
-
+        return bundle.getString("value");
     }
 
-    public void putValue(String table, String key, String value) throws SettingsException {
+    public void putValue(String table, String key, String value) {
         String method = getPutMethod(table);
         Bundle arg = new Bundle();
         arg.putInt(CALL_METHOD_USER_KEY, ServiceManager.USER_ID);
         arg.putString(NAME_VALUE_TABLE_VALUE, value);
-        try {
-            call(method, key, arg);
-        } catch (Exception e) {
-            throw new SettingsException(table, "put", key, value, e);
+        call(method, key, arg);
+    }
+
+    public String getAndPutValue(String table, String key, String value) {
+        String oldValue = getValue(table, key);
+        if (!value.equals(oldValue)) {
+            putValue(table, key, value);
         }
+        return oldValue;
     }
 }

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

@@ -235,7 +235,6 @@ public class ControlMessageReaderTest {
         ByteArrayOutputStream bos = new ByteArrayOutputStream();
         DataOutputStream dos = new DataOutputStream(bos);
         dos.writeByte(ControlMessage.TYPE_SET_CLIPBOARD);
-        dos.writeLong(0x0102030405060708L); // sequence
         dos.writeByte(1); // paste
         byte[] text = "testé".getBytes(StandardCharsets.UTF_8);
         dos.writeInt(text.length);
@@ -247,7 +246,6 @@ public class ControlMessageReaderTest {
         ControlMessage event = reader.next();
 
         Assert.assertEquals(ControlMessage.TYPE_SET_CLIPBOARD, event.getType());
-        Assert.assertEquals(0x0102030405060708L, event.getSequence());
         Assert.assertEquals("testé", event.getText());
         Assert.assertTrue(event.getPaste());
     }
@@ -261,7 +259,6 @@ public class ControlMessageReaderTest {
         dos.writeByte(ControlMessage.TYPE_SET_CLIPBOARD);
 
         byte[] rawText = new byte[ControlMessageReader.CLIPBOARD_TEXT_MAX_LENGTH];
-        dos.writeLong(0x0807060504030201L); // sequence
         dos.writeByte(1); // paste
         Arrays.fill(rawText, (byte) 'a');
         String text = new String(rawText, 0, rawText.length);
@@ -275,7 +272,6 @@ public class ControlMessageReaderTest {
         ControlMessage event = reader.next();
 
         Assert.assertEquals(ControlMessage.TYPE_SET_CLIPBOARD, event.getType());
-        Assert.assertEquals(0x0807060504030201L, event.getSequence());
         Assert.assertEquals(text, event.getText());
         Assert.assertTrue(event.getPaste());
     }

server/src/test/java/com/genymobile/scrcpy/DeviceMessageWriterTest.java

@@ -32,24 +32,4 @@ public class DeviceMessageWriterTest {
 
         Assert.assertArrayEquals(expected, actual);
     }
-
-    @Test
-    public void testSerializeAckSetClipboard() throws IOException {
-        DeviceMessageWriter writer = new DeviceMessageWriter();
-
-        ByteArrayOutputStream bos = new ByteArrayOutputStream();
-        DataOutputStream dos = new DataOutputStream(bos);
-        dos.writeByte(DeviceMessage.TYPE_ACK_CLIPBOARD);
-        dos.writeLong(0x0102030405060708L);
-
-        byte[] expected = bos.toByteArray();
-
-        DeviceMessage msg = DeviceMessage.createAckClipboard(0x0102030405060708L);
-        bos = new ByteArrayOutputStream();
-        writer.writeTo(msg, bos);
-
-        byte[] actual = bos.toByteArray();
-
-        Assert.assertArrayEquals(expected, actual);
-    }
 }