Adapt to display API changes

The method SurfaceControl.createDisplay() has been removed in AOSP. Use DisplayManager to create a VirtualDisplay object instead. Fixes #4646 <https://github.com/Genymobile/scrcpy/issues/4646> Fixes #4656 <https://github.com/Genymobile/scrcpy/issues/4656> PR #4657 <https://github.com/Genymobile/scrcpy/pull/4657> Signed-off-by: Romain Vimont <rom@rom1v.com>
Add note about official website
2024-02-09 18:31:20 +01:00 · 2023-12-13 12:55:14 +01:00
52 changed files with 993 additions and 958 deletions
--- a/README.md
+++ b/README.md
@ -1,3 +1,7 @@
+**This GitHub repo (<https://github.com/Genymobile/scrcpy>) is the only official
+source for the project. Do not download releases from random websites, even if
+their name contains `scrcpy`.**
+
 # scrcpy (v2.3.1)

 <img src="app/data/icon.svg" width="128" height="128" alt="scrcpy" align="right" />
--- a/app/data/bash-completion/scrcpy
+++ b/app/data/bash-completion/scrcpy
@ -115,12 +115,13 @@ _scrcpy() {
            COMPREPLY=($(compgen -W 'front back external' -- "$cur"))
            return
            ;;
-        --orientation|--display-orientation)
-            COMPREPLY=($(compgen -W '0 90 180 270 flip0 flip90 flip180 flip270' -- "$cur"))
+        --orientation
+        --display-orientation)
+            COMPREPLY=($(compgen -> '0 90 180 270 flip0 flip90 flip180 flip270' -- "$cur"))
            return
            ;;
        --record-orientation)
-            COMPREPLY=($(compgen -W '0 90 180 270' -- "$cur"))
+            COMPREPLY=($(compgen -> '0 90 180 270' -- "$cur"))
            return
            ;;
        --lock-video-orientation)
--- a/app/meson.build
+++ b/app/meson.build
@ -34,8 +34,8 @@ src = [
    'src/trait/frame_source.c',
    'src/trait/packet_source.c',
    'src/util/acksync.c',
-    'src/util/audiobuf.c',
    'src/util/average.c',
+    'src/util/bytebuf.c',
    'src/util/file.c',
    'src/util/intmap.c',
    'src/util/intr.c',
@ -212,10 +212,9 @@ if get_option('buildtype') == 'debug'
        ['test_binary', [
            'tests/test_binary.c',
        ]],
-        ['test_audiobuf', [
-            'tests/test_audiobuf.c',
-            'src/util/audiobuf.c',
-            'src/util/memory.c',
+        ['test_bytebuf', [
+            'tests/test_bytebuf.c',
+            'src/util/bytebuf.c',
        ]],
        ['test_cli', [
            'tests/test_cli.c',
--- a/app/scrcpy.1
+++ b/app/scrcpy.1
@ -124,7 +124,7 @@ Use USB device (if there is exactly one, like adb -d).
 Also see \fB\-e\fR (\fB\-\-select\-tcpip\fR).

 .TP
-.BI "\-\-disable\-screensaver"
+.BI "\-\-disable-screensaver"
 Disable screensaver while scrcpy is running.

 .TP
@ -642,11 +642,7 @@ Enable/disable FPS counter (print frames/second in logs)

 .TP
 .B Ctrl+click-and-move
-Pinch-to-zoom and rotate from the center of the screen
-
-.TP
-.B Shift+click-and-move
-Tilt (slide vertically with two fingers)
+Pinch-to-zoom from the center of the screen

 .TP
 .B Drag & drop APK file
--- a/app/src/adb/adb.c
+++ b/app/src/adb/adb.c
@ -458,7 +458,6 @@ sc_adb_list_devices(struct sc_intr *intr, unsigned flags,
        // in the buffer in a single pass
        LOGW("Result of \"adb devices -l\" does not fit in 64Kb. "
             "Please report an issue.");
-        free(buf);
        return false;
    }

--- a/app/src/audio_player.c
+++ b/app/src/audio_player.c
@ -66,7 +66,8 @@ static void SDLCALL
 sc_audio_player_sdl_callback(void *userdata, uint8_t *stream, int len_int) {
    struct sc_audio_player *ap = userdata;

-    // This callback is called with the lock used by SDL_LockAudioDevice()
+    // This callback is called with the lock used by SDL_AudioDeviceLock(), so
+    // the audiobuf is protected

    assert(len_int > 0);
    size_t len = len_int;
@ -76,12 +77,12 @@ sc_audio_player_sdl_callback(void *userdata, uint8_t *stream, int len_int) {
    LOGD("[Audio] SDL callback requests %" PRIu32 " samples", count);
 #endif

-    bool played = atomic_load_explicit(&ap->played, memory_order_relaxed);
-    if (!played) {
-        uint32_t buffered_samples = sc_audiobuf_can_read(&ap->buf);
-        // Wait until the buffer is filled up to at least target_buffering
-        // before playing
-        if (buffered_samples < ap->target_buffering) {
+    uint32_t buffered_samples = sc_audiobuf_can_read(&ap->buf);
+    if (!ap->played) {
+        // Part of the buffering is handled by inserting initial silence. The
+        // remaining (margin) last samples will be handled by compensation.
+        uint32_t margin = 30 * ap->sample_rate / 1000; // 30ms
+        if (buffered_samples + margin < ap->target_buffering) {
            LOGV("[Audio] Inserting initial buffering silence: %" PRIu32
                 " samples", count);
            // Delay playback starting to reach the target buffering. Fill the
@ -92,7 +93,10 @@ sc_audio_player_sdl_callback(void *userdata, uint8_t *stream, int len_int) {
        }
    }

-    uint32_t read = sc_audiobuf_read(&ap->buf, stream, count);
+    uint32_t read = MIN(buffered_samples, count);
+    if (read) {
+        sc_audiobuf_read(&ap->buf, stream, read);
+    }

    if (read < count) {
        uint32_t silence = count - read;
@ -105,16 +109,13 @@ sc_audio_player_sdl_callback(void *userdata, uint8_t *stream, int len_int) {
             silence);
        memset(stream + TO_BYTES(read), 0, TO_BYTES(silence));

-        bool received = atomic_load_explicit(&ap->received,
-                                             memory_order_relaxed);
-        if (received) {
+        if (ap->received) {
            // Inserting additional samples immediately increases buffering
-            atomic_fetch_add_explicit(&ap->underflow, silence,
-                                      memory_order_relaxed);
+            ap->underflow += silence;
        }
    }

-    atomic_store_explicit(&ap->played, true, memory_order_relaxed);
+    ap->played = true;
 }

 static uint8_t *
@ -161,168 +162,155 @@ sc_audio_player_frame_sink_push(struct sc_frame_sink *sink,

    // swr_convert() returns the number of samples which would have been
    // written if the buffer was big enough.
-    uint32_t samples = MIN(ret, dst_nb_samples);
+    uint32_t samples_written = MIN(ret, dst_nb_samples);
 #ifndef SC_AUDIO_PLAYER_NDEBUG
-    LOGD("[Audio] %" PRIu32 " samples written to buffer", samples);
+    LOGD("[Audio] %" PRIu32 " samples written to buffer", samples_written);
 #endif

-    uint32_t cap = sc_audiobuf_capacity(&ap->buf);
-    if (samples > cap) {
-        // Very very unlikely: a single resampled frame should never
-        // exceed the audio buffer size (or something is very wrong).
-        // Ignore the first bytes in swr_buf to avoid memory corruption anyway.
-        swr_buf += TO_BYTES(samples - cap);
-        samples = cap;
+    // Since this function is the only writer, the current available space is
+    // at least the previous available space. In practice, it should almost
+    // always be possible to write without lock.
+    bool lockless_write = samples_written <= ap->previous_can_write;
+    if (lockless_write) {
+        sc_audiobuf_prepare_write(&ap->buf, swr_buf, samples_written);
    }

-    uint32_t skipped_samples = 0;
+    SDL_LockAudioDevice(ap->device);

-    uint32_t written = sc_audiobuf_write(&ap->buf, swr_buf, samples);
-    if (written < samples) {
-        uint32_t remaining = samples - written;
+    uint32_t buffered_samples = sc_audiobuf_can_read(&ap->buf);

-        // All samples that could be written without locking have been written,
-        // now we need to lock to drop/consume old samples
-        SDL_LockAudioDevice(ap->device);
+    if (lockless_write) {
+        sc_audiobuf_commit_write(&ap->buf, samples_written);
+    } else {
+        uint32_t can_write = sc_audiobuf_can_write(&ap->buf);
+        if (samples_written > can_write) {
+            // Entering this branch is very unlikely, the audio buffer is
+            // allocated with a size sufficient to store 1 second more than the
+            // target buffering. If this happens, though, we have to skip old
+            // samples.
+            uint32_t cap = sc_audiobuf_capacity(&ap->buf);
+            if (samples_written > cap) {
+                // Very very unlikely: a single resampled frame should never
+                // exceed the audio buffer size (or something is very wrong).
+                // Ignore the first bytes in swr_buf
+                swr_buf += TO_BYTES(samples_written - cap);
+                // This change in samples_written will impact the
+                // instant_compensation below
+                samples_written = cap;
+            }

-        // Retry with the lock
-        written += sc_audiobuf_write(&ap->buf,
-                                     swr_buf + TO_BYTES(written),
-                                     remaining);
-        if (written < samples) {
-            remaining = samples - written;
-            // Still insufficient, drop old samples to make space
-            skipped_samples = sc_audiobuf_read(&ap->buf, NULL, remaining);
-            assert(skipped_samples == remaining);
+            assert(samples_written >= can_write);
+            if (samples_written > can_write) {
+                uint32_t skip_samples = samples_written - can_write;
+                assert(buffered_samples >= skip_samples);
+                sc_audiobuf_skip(&ap->buf, skip_samples);
+                buffered_samples -= skip_samples;
+                if (ap->played) {
+                    // Dropping input samples instantly decreases buffering
+                    ap->avg_buffering.avg -= skip_samples;
+                }
+            }

-            // Now there is enough space
-            uint32_t w = sc_audiobuf_write(&ap->buf,
-                                           swr_buf + TO_BYTES(written),
-                                           remaining);
-            assert(w == remaining);
-            (void) w;
+            // It should remain exactly the expected size to write the new
+            // samples.
+            assert(sc_audiobuf_can_write(&ap->buf) == samples_written);
        }

-        SDL_UnlockAudioDevice(ap->device);
+        sc_audiobuf_write(&ap->buf, swr_buf, samples_written);
    }

-    uint32_t underflow = 0;
-    uint32_t max_buffered_samples;
-    bool played = atomic_load_explicit(&ap->played, memory_order_relaxed);
-    if (played) {
-        underflow = atomic_exchange_explicit(&ap->underflow, 0,
-                                             memory_order_relaxed);
+    buffered_samples += samples_written;
+    assert(buffered_samples == sc_audiobuf_can_read(&ap->buf));

-        max_buffered_samples = ap->target_buffering
-                               + 12 * ap->output_buffer
-                               + ap->target_buffering / 10;
+    // Read with lock held, to be used after unlocking
+    bool played = ap->played;
+    uint32_t underflow = ap->underflow;
+
+    if (played) {
+        uint32_t max_buffered_samples = ap->target_buffering
+                                      + 12 * ap->output_buffer
+                                      + ap->target_buffering / 10;
+        if (buffered_samples > max_buffered_samples) {
+            uint32_t skip_samples = buffered_samples - max_buffered_samples;
+            sc_audiobuf_skip(&ap->buf, skip_samples);
+            LOGD("[Audio] Buffering threshold exceeded, skipping %" PRIu32
+                 " samples", skip_samples);
+        }
+
+        // reset (the current value was copied to a local variable)
+        ap->underflow = 0;
    } else {
        // SDL playback not started yet, do not accumulate more than
        // max_initial_buffering samples, this would cause unnecessary delay
        // (and glitches to compensate) on start.
-        max_buffered_samples = ap->target_buffering + 2 * ap->output_buffer;
+        uint32_t max_initial_buffering = ap->target_buffering
+                                       + 2 * ap->output_buffer;
+        if (buffered_samples > max_initial_buffering) {
+            uint32_t skip_samples = buffered_samples - max_initial_buffering;
+            sc_audiobuf_skip(&ap->buf, skip_samples);
+#ifndef SC_AUDIO_PLAYER_NDEBUG
+            LOGD("[Audio] Playback not started, skipping %" PRIu32 " samples",
+                 skip_samples);
+#endif
+        }
    }

-    uint32_t can_read = sc_audiobuf_can_read(&ap->buf);
-    if (can_read > max_buffered_samples) {
-        uint32_t skip_samples = 0;
+    ap->previous_can_write = sc_audiobuf_can_write(&ap->buf);
+    ap->received = true;

-        SDL_LockAudioDevice(ap->device);
-        can_read = sc_audiobuf_can_read(&ap->buf);
-        if (can_read > max_buffered_samples) {
-            skip_samples = can_read - max_buffered_samples;
-            uint32_t r = sc_audiobuf_read(&ap->buf, NULL, skip_samples);
-            assert(r == skip_samples);
-            (void) r;
-            skipped_samples += skip_samples;
-        }
-        SDL_UnlockAudioDevice(ap->device);
+    SDL_UnlockAudioDevice(ap->device);
+
+    if (played) {
+        // Number of samples added (or removed, if negative) for compensation
+        int32_t instant_compensation =
+            (int32_t) samples_written - frame->nb_samples;
+        int32_t inserted_silence = (int32_t) underflow;
+
+        // The compensation must apply instantly, it must not be smoothed
+        ap->avg_buffering.avg += instant_compensation + inserted_silence;
+
+
+        // However, the buffering level must be smoothed
+        sc_average_push(&ap->avg_buffering, buffered_samples);

-        if (skip_samples) {
-            if (played) {
-                LOGD("[Audio] Buffering threshold exceeded, skipping %" PRIu32
-                     " samples", skip_samples);
 #ifndef SC_AUDIO_PLAYER_NDEBUG
-            } else {
-                LOGD("[Audio] Playback not started, skipping %" PRIu32
-                     " samples", skip_samples);
+        LOGD("[Audio] buffered_samples=%" PRIu32 " avg_buffering=%f",
+             buffered_samples, sc_average_get(&ap->avg_buffering));
 #endif
+
+        ap->samples_since_resync += samples_written;
+        if (ap->samples_since_resync >= ap->sample_rate) {
+            // Recompute compensation every second
+            ap->samples_since_resync = 0;
+
+            float avg = sc_average_get(&ap->avg_buffering);
+            int diff = ap->target_buffering - avg;
+            if (abs(diff) < (int) ap->sample_rate / 1000) {
+                // Do not compensate for less than 1ms, the error is just noise
+                diff = 0;
+            } else if (diff < 0 && buffered_samples < ap->target_buffering) {
+                // Do not accelerate if the instant buffering level is below
+                // the average, this would increase underflow
+                diff = 0;
            }
-        }
-    }
+            // Compensate the diff over 4 seconds (but will be recomputed after
+            // 1 second)
+            int distance = 4 * ap->sample_rate;
+            // Limit compensation rate to 2%
+            int abs_max_diff = distance / 50;
+            diff = CLAMP(diff, -abs_max_diff, abs_max_diff);
+            LOGV("[Audio] Buffering: target=%" PRIu32 " avg=%f cur=%" PRIu32
+                 " compensation=%d", ap->target_buffering, avg,
+                 buffered_samples, diff);

-    atomic_store_explicit(&ap->received, true, memory_order_relaxed);
-    if (!played) {
-        // Nothing more to do
-        return true;
-    }
-
-    // Number of samples added (or removed, if negative) for compensation
-    int32_t instant_compensation = (int32_t) written - frame->nb_samples;
-    // Inserting silence instantly increases buffering
-    int32_t inserted_silence = (int32_t) underflow;
-    // Dropping input samples instantly decreases buffering
-    int32_t dropped = (int32_t) skipped_samples;
-
-    // The compensation must apply instantly, it must not be smoothed
-    ap->avg_buffering.avg += instant_compensation + inserted_silence - dropped;
-    if (ap->avg_buffering.avg < 0) {
-        // Since dropping samples instantly reduces buffering, the difference
-        // is applied immediately to the average value, assuming that the delay
-        // between the producer and the consumer will be caught up.
-        //
-        // However, when this assumption is not valid, the average buffering
-        // may decrease indefinitely. Prevent it to become negative to limit
-        // the consequences.
-        ap->avg_buffering.avg = 0;
-    }
-
-    // However, the buffering level must be smoothed
-    sc_average_push(&ap->avg_buffering, can_read);
-
-#ifndef SC_AUDIO_PLAYER_NDEBUG
-    LOGD("[Audio] can_read=%" PRIu32 " avg_buffering=%f",
-         can_read, sc_average_get(&ap->avg_buffering));
-#endif
-
-    ap->samples_since_resync += written;
-    if (ap->samples_since_resync >= ap->sample_rate) {
-        // Recompute compensation every second
-        ap->samples_since_resync = 0;
-
-        float avg = sc_average_get(&ap->avg_buffering);
-        int diff = ap->target_buffering - avg;
-
-        // Enable compensation when the difference exceeds +/- 4ms.
-        // Disable compensation when the difference is lower than +/- 1ms.
-        int threshold = ap->compensation != 0
-                      ? ap->sample_rate     / 1000  /* 1ms */
-                      : ap->sample_rate * 4 / 1000; /* 4ms */
-
-        if (abs(diff) < threshold) {
-            // Do not compensate for small values, the error is just noise
-            diff = 0;
-        } else if (diff < 0 && can_read < ap->target_buffering) {
-            // Do not accelerate if the instant buffering level is below the
-            // target, this would increase underflow
-            diff = 0;
-        }
-        // Compensate the diff over 4 seconds (but will be recomputed after 1
-        // second)
-        int distance = 4 * ap->sample_rate;
-        // Limit compensation rate to 2%
-        int abs_max_diff = distance / 50;
-        diff = CLAMP(diff, -abs_max_diff, abs_max_diff);
-        LOGV("[Audio] Buffering: target=%" PRIu32 " avg=%f cur=%" PRIu32
-             " compensation=%d", ap->target_buffering, avg, can_read, diff);
-
-        if (diff != ap->compensation) {
-            int ret = swr_set_compensation(swr_ctx, diff, distance);
-            if (ret < 0) {
-                LOGW("Resampling compensation failed: %d", ret);
-                // not fatal
-            } else {
-                ap->compensation = diff;
+            if (diff != ap->compensation) {
+                int ret = swr_set_compensation(swr_ctx, diff, distance);
+                if (ret < 0) {
+                    LOGW("Resampling compensation failed: %d", ret);
+                    // not fatal
+                } else {
+                    ap->compensation = diff;
+                }
            }
        }
    }
@ -409,7 +397,7 @@ sc_audio_player_frame_sink_open(struct sc_frame_sink *sink,
    // producer and the consumer. It's too big on purpose, to guarantee that
    // the producer and the consumer will be able to access it in parallel
    // without locking.
-    uint32_t audiobuf_samples = ap->target_buffering + ap->sample_rate;
+    size_t audiobuf_samples = ap->target_buffering + ap->sample_rate;

    size_t sample_size = ap->nb_channels * ap->out_bytes_per_sample;
    bool ok = sc_audiobuf_init(&ap->buf, sample_size, audiobuf_samples);
@ -425,15 +413,16 @@ sc_audio_player_frame_sink_open(struct sc_frame_sink *sink,
    }
    ap->swr_buf_alloc_size = initial_swr_buf_size;

+    ap->previous_can_write = sc_audiobuf_can_write(&ap->buf);
+
    // Samples are produced and consumed by blocks, so the buffering must be
    // smoothed to get a relatively stable value.
-    sc_average_init(&ap->avg_buffering, 128);
+    sc_average_init(&ap->avg_buffering, 32);
    ap->samples_since_resync = 0;

    ap->received = false;
-    atomic_init(&ap->played, false);
-    atomic_init(&ap->received, false);
-    atomic_init(&ap->underflow, 0);
+    ap->played = false;
+    ap->underflow = 0;
    ap->compensation = 0;

    // The thread calling open() is the thread calling push(), which fills the
--- a/app/src/audio_player.h
+++ b/app/src/audio_player.h
@ -3,18 +3,17 @@

 #include "common.h"

-#include <stdatomic.h>
 #include <stdbool.h>
+#include "trait/frame_sink.h"
+#include <util/audiobuf.h>
+#include <util/average.h>
+#include <util/thread.h>
+#include <util/tick.h>
+
 #include <libavformat/avformat.h>
 #include <libswresample/swresample.h>
 #include <SDL2/SDL.h>

-#include "trait/frame_sink.h"
-#include "util/audiobuf.h"
-#include "util/average.h"
-#include "util/thread.h"
-#include "util/tick.h"
-
 struct sc_audio_player {
    struct sc_frame_sink frame_sink;

@ -33,9 +32,13 @@ struct sc_audio_player {
    uint16_t output_buffer;

    // Audio buffer to communicate between the receiver and the SDL audio
-    // callback
+    // callback (protected by SDL_AudioDeviceLock())
    struct sc_audiobuf buf;

+    // The previous empty space in the buffer (only used by the receiver
+    // thread)
+    uint32_t previous_can_write;
+
    // Resampler (only used from the receiver thread)
    struct SwrContext *swr_ctx;

@ -44,7 +47,7 @@ struct sc_audio_player {
    // The number of channels is the same for input and output
    unsigned nb_channels;
    // The number of bytes per sample for a single channel
-    size_t out_bytes_per_sample;
+    unsigned out_bytes_per_sample;

    // Target buffer for resampling (only used by the receiver thread)
    uint8_t *swr_buf;
@ -58,16 +61,19 @@ struct sc_audio_player {
    uint32_t samples_since_resync;

    // Number of silence samples inserted since the last received packet
-    atomic_uint_least32_t underflow;
+    // (protected by SDL_AudioDeviceLock())
+    uint32_t underflow;

    // Current applied compensation value (only used by the receiver thread)
    int compensation;

-    // Set to true the first time a sample is received
-    atomic_bool received;
+    // Set to true the first time a sample is received (protected by
+    // SDL_AudioDeviceLock())
+    bool received;

-    // Set to true the first time the SDL callback is called
-    atomic_bool played;
+    // Set to true the first time the SDL callback is called (protected by
+    // SDL_AudioDeviceLock())
+    bool played;

    const struct sc_audio_player_callbacks *cbs;
    void *cbs_userdata;
--- a/app/src/cli.c
+++ b/app/src/cli.c
@ -947,11 +947,7 @@ static const struct sc_shortcut shortcuts[] = {
    },
    {
        .shortcuts = { "Ctrl+click-and-move" },
-        .text = "Pinch-to-zoom and rotate from the center of the screen",
-    },
-    {
-        .shortcuts = { "Shift+click-and-move" },
-        .text = "Tilt (slide vertically with two fingers)",
+        .text = "Pinch-to-zoom from the center of the screen",
    },
    {
        .shortcuts = { "Drag & drop APK file" },
@ -1385,11 +1381,7 @@ parse_max_fps(const char *s, uint16_t *max_fps) {
 static bool
 parse_buffering_time(const char *s, sc_tick *tick) {
    long value;
-    // In practice, buffering time should not exceed a few seconds.
-    // Limit it to some arbitrary value (1 hour) to prevent 32-bit overflow
-    // when multiplied by the audio sample size and the number of samples per
-    // millisecond.
-    bool ok = parse_integer_arg(s, &value, false, 0, 60 * 60 * 1000,
+    bool ok = parse_integer_arg(s, &value, false, 0, 0x7FFFFFFF,
                                "buffering time");
    if (!ok) {
        return false;
@ -2402,8 +2394,6 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],

    if (!opts->video) {
        opts->video_playback = false;
-        // Do not power on the device on start if video capture is disabled
-        opts->power_on = false;
    }

    if (!opts->audio) {
--- a/app/src/control_msg.c
+++ b/app/src/control_msg.c
@ -87,7 +87,7 @@ write_position(uint8_t *buf, const struct sc_position *position) {

 // write length (4 bytes) + string (non null-terminated)
 static size_t
-write_string(const char *utf8, size_t max_len, uint8_t *buf) {
+write_string(const char *utf8, size_t max_len, unsigned char *buf) {
    size_t len = sc_str_utf8_truncation_index(utf8, max_len);
    sc_write32be(buf, len);
    memcpy(&buf[4], utf8, len);
@ -95,7 +95,7 @@ write_string(const char *utf8, size_t max_len, uint8_t *buf) {
 }

 size_t
-sc_control_msg_serialize(const struct sc_control_msg *msg, uint8_t *buf) {
+sc_control_msg_serialize(const struct sc_control_msg *msg, unsigned char *buf) {
    buf[0] = msg->type;
    switch (msg->type) {
        case SC_CONTROL_MSG_TYPE_INJECT_KEYCODE:
--- a/app/src/control_msg.h
+++ b/app/src/control_msg.h
@ -98,7 +98,7 @@ struct sc_control_msg {
 // buf size must be at least CONTROL_MSG_MAX_SIZE
 // return the number of bytes written
 size_t
-sc_control_msg_serialize(const struct sc_control_msg *msg, uint8_t *buf);
+sc_control_msg_serialize(const struct sc_control_msg *msg, unsigned char *buf);

 void
 sc_control_msg_log(const struct sc_control_msg *msg);
--- a/app/src/controller.c
+++ b/app/src/controller.c
@ -84,7 +84,7 @@ sc_controller_push_msg(struct sc_controller *controller,
 static bool
 process_msg(struct sc_controller *controller,
            const struct sc_control_msg *msg) {
-    static uint8_t serialized_msg[SC_CONTROL_MSG_MAX_SIZE];
+    static unsigned char serialized_msg[SC_CONTROL_MSG_MAX_SIZE];
    size_t length = sc_control_msg_serialize(msg, serialized_msg);
    if (!length) {
        return false;
--- a/app/src/device_msg.c
+++ b/app/src/device_msg.c
@ -8,22 +8,19 @@
 #include "util/log.h"

 ssize_t
-sc_device_msg_deserialize(const uint8_t *buf, size_t len,
-                          struct sc_device_msg *msg) {
-    if (!len) {
-        return 0; // no message
+device_msg_deserialize(const unsigned char *buf, size_t len,
+                       struct device_msg *msg) {
+    if (len < 5) {
+        // at least type + empty string length
+        return 0; // not available
    }

    msg->type = buf[0];
    switch (msg->type) {
        case DEVICE_MSG_TYPE_CLIPBOARD: {
-            if (len < 5) {
-                // at least type + empty string length
-                return 0; // no complete message
-            }
            size_t clipboard_len = sc_read32be(&buf[1]);
            if (clipboard_len > len - 5) {
-                return 0; // no complete message
+                return 0; // not available
            }
            char *text = malloc(clipboard_len + 1);
            if (!text) {
@ -39,9 +36,6 @@ sc_device_msg_deserialize(const uint8_t *buf, size_t len,
            return 5 + clipboard_len;
        }
        case DEVICE_MSG_TYPE_ACK_CLIPBOARD: {
-            if (len < 9) {
-                return 0; // no complete message
-            }
            uint64_t sequence = sc_read64be(&buf[1]);
            msg->ack_clipboard.sequence = sequence;
            return 9;
@ -53,7 +47,7 @@ sc_device_msg_deserialize(const uint8_t *buf, size_t len,
 }

 void
-sc_device_msg_destroy(struct sc_device_msg *msg) {
+device_msg_destroy(struct device_msg *msg) {
    if (msg->type == DEVICE_MSG_TYPE_CLIPBOARD) {
        free(msg->clipboard.text);
    }
--- a/app/src/device_msg.h
+++ b/app/src/device_msg.h
@ -11,13 +11,13 @@
 // type: 1 byte; length: 4 bytes
 #define DEVICE_MSG_TEXT_MAX_LENGTH (DEVICE_MSG_MAX_SIZE - 5)

-enum sc_device_msg_type {
+enum device_msg_type {
    DEVICE_MSG_TYPE_CLIPBOARD,
    DEVICE_MSG_TYPE_ACK_CLIPBOARD,
 };

-struct sc_device_msg {
-    enum sc_device_msg_type type;
+struct device_msg {
+    enum device_msg_type type;
    union {
        struct {
            char *text; // owned, to be freed by free()
@ -30,10 +30,10 @@ struct sc_device_msg {

 // return the number of bytes consumed (0 for no msg available, -1 on error)
 ssize_t
-sc_device_msg_deserialize(const uint8_t *buf, size_t len,
-                          struct sc_device_msg *msg);
+device_msg_deserialize(const unsigned char *buf, size_t len,
+                       struct device_msg *msg);

 void
-sc_device_msg_destroy(struct sc_device_msg *msg);
+device_msg_destroy(struct device_msg *msg);

 #endif
--- a/app/src/input_manager.c
+++ b/app/src/input_manager.c
@ -76,8 +76,6 @@ sc_input_manager_init(struct sc_input_manager *im,
    im->sdl_shortcut_mods.count = shortcut_mods->count;

    im->vfinger_down = false;
-    im->vfinger_invert_x = false;
-    im->vfinger_invert_y = false;

    im->last_keycode = SDLK_UNKNOWN;
    im->last_mod = 0;
@ -349,14 +347,9 @@ simulate_virtual_finger(struct sc_input_manager *im,
 }

 static struct sc_point
-inverse_point(struct sc_point point, struct sc_size size,
-              bool invert_x, bool invert_y) {
-    if (invert_x) {
-        point.x = size.width - point.x;
-    }
-    if (invert_y) {
-        point.y = size.height - point.y;
-    }
+inverse_point(struct sc_point point, struct sc_size size) {
+    point.x = size.width - point.x;
+    point.y = size.height - point.y;
    return point;
 }

@ -612,9 +605,7 @@ sc_input_manager_process_mouse_motion(struct sc_input_manager *im,
        struct sc_point mouse =
           sc_screen_convert_window_to_frame_coords(im->screen, event->x,
                                                    event->y);
-        struct sc_point vfinger = inverse_point(mouse, im->screen->frame_size,
-                                                im->vfinger_invert_x,
-                                                im->vfinger_invert_y);
+        struct sc_point vfinger = inverse_point(mouse, im->screen->frame_size);
        simulate_virtual_finger(im, AMOTION_EVENT_ACTION_MOVE, vfinger);
    }
 }
@ -735,7 +726,7 @@ sc_input_manager_process_mouse_button(struct sc_input_manager *im,
        return;
    }

-    // Pinch-to-zoom, rotate and tilt simulation.
+    // Pinch-to-zoom simulation.
    //
    // If Ctrl is hold when the left-click button is pressed, then
    // pinch-to-zoom mode is enabled: on every mouse event until the left-click
@ -744,29 +735,14 @@ sc_input_manager_process_mouse_button(struct sc_input_manager *im,
    //
    // In other words, the center of the rotation/scaling is the center of the
    // screen.
-    //
-    // To simulate a tilt gesture (a vertical slide with two fingers), Shift
-    // can be used instead of Ctrl. The "virtual finger" has a position
-    // inverted with respect to the vertical axis of symmetry in the middle of
-    // the screen.
-    const SDL_Keymod keymod = SDL_GetModState();
-    const bool ctrl_pressed = keymod & KMOD_CTRL;
-    const bool shift_pressed = keymod & KMOD_SHIFT;
+#define CTRL_PRESSED (SDL_GetModState() & (KMOD_LCTRL | KMOD_RCTRL))
    if (event->button == SDL_BUTTON_LEFT &&
-            ((down && !im->vfinger_down &&
-              ((ctrl_pressed && !shift_pressed) ||
-               (!ctrl_pressed && shift_pressed))) ||
+            ((down && !im->vfinger_down && CTRL_PRESSED) ||
             (!down && im->vfinger_down))) {
        struct sc_point mouse =
            sc_screen_convert_window_to_frame_coords(im->screen, event->x,
                                                                 event->y);
-        if (down) {
-            im->vfinger_invert_x = ctrl_pressed || shift_pressed;
-            im->vfinger_invert_y = ctrl_pressed;
-        }
-        struct sc_point vfinger = inverse_point(mouse, im->screen->frame_size,
-                                                im->vfinger_invert_x,
-                                                im->vfinger_invert_y);
+        struct sc_point vfinger = inverse_point(mouse, im->screen->frame_size);
        enum android_motionevent_action action = down
                                               ? AMOTION_EVENT_ACTION_DOWN
                                               : AMOTION_EVENT_ACTION_UP;
--- a/app/src/input_manager.h
+++ b/app/src/input_manager.h
@ -32,8 +32,6 @@ struct sc_input_manager {
    } sdl_shortcut_mods;

    bool vfinger_down;
-    bool vfinger_invert_x;
-    bool vfinger_invert_y;

    // Tracks the number of identical consecutive shortcut key down events.
    // Not to be confused with event->repeat, which counts the number of
--- a/app/src/receiver.c
+++ b/app/src/receiver.c
@ -1,7 +1,6 @@
 #include "receiver.h"

 #include <assert.h>
-#include <stdint.h>
 #include <SDL2/SDL_clipboard.h>

 #include "device_msg.h"
@ -27,7 +26,7 @@ sc_receiver_destroy(struct sc_receiver *receiver) {
 }

 static void
-process_msg(struct sc_receiver *receiver, struct sc_device_msg *msg) {
+process_msg(struct sc_receiver *receiver, struct device_msg *msg) {
    switch (msg->type) {
        case DEVICE_MSG_TYPE_CLIPBOARD: {
            char *current = SDL_GetClipboardText();
@ -52,11 +51,11 @@ process_msg(struct sc_receiver *receiver, struct sc_device_msg *msg) {
 }

 static ssize_t
-process_msgs(struct sc_receiver *receiver, const uint8_t *buf, size_t len) {
+process_msgs(struct sc_receiver *receiver, const unsigned char *buf, size_t len) {
    size_t head = 0;
    for (;;) {
-        struct sc_device_msg msg;
-        ssize_t r = sc_device_msg_deserialize(&buf[head], len - head, &msg);
+        struct device_msg msg;
+        ssize_t r = device_msg_deserialize(&buf[head], len - head, &msg);
        if (r == -1) {
            return -1;
        }
@ -65,7 +64,7 @@ process_msgs(struct sc_receiver *receiver, const uint8_t *buf, size_t len) {
        }

        process_msg(receiver, &msg);
-        sc_device_msg_destroy(&msg);
+        device_msg_destroy(&msg);

        head += r;
        assert(head <= len);
@ -79,7 +78,7 @@ static int
 run_receiver(void *data) {
    struct sc_receiver *receiver = data;

-    static uint8_t buf[DEVICE_MSG_MAX_SIZE];
+    static unsigned char buf[DEVICE_MSG_MAX_SIZE];
    size_t head = 0;

    for (;;) {
--- a/app/src/server.c
+++ b/app/src/server.c
@ -498,7 +498,7 @@ sc_server_init(struct sc_server *server, const struct sc_server_params *params,
 static bool
 device_read_info(struct sc_intr *intr, sc_socket device_socket,
                 struct sc_server_info *info) {
-    uint8_t buf[SC_DEVICE_NAME_FIELD_LENGTH];
+    unsigned char buf[SC_DEVICE_NAME_FIELD_LENGTH];
    ssize_t r = net_recv_all_intr(intr, device_socket, buf, sizeof(buf));
    if (r < SC_DEVICE_NAME_FIELD_LENGTH) {
        LOGE("Could not retrieve device information");
--- a/app/src/usb/aoa_hid.c
+++ b/app/src/usb/aoa_hid.c
@ -113,7 +113,7 @@ sc_aoa_register_hid(struct sc_aoa *aoa, uint16_t accessory_id,

 static bool
 sc_aoa_set_hid_report_desc(struct sc_aoa *aoa, uint16_t accessory_id,
-                           const uint8_t *report_desc,
+                           const unsigned char *report_desc,
                           uint16_t report_desc_size) {
    uint8_t request_type = LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR;
    uint8_t request = ACCESSORY_SET_HID_REPORT_DESC;
@ -150,7 +150,7 @@ sc_aoa_set_hid_report_desc(struct sc_aoa *aoa, uint16_t accessory_id,

 bool
 sc_aoa_setup_hid(struct sc_aoa *aoa, uint16_t accessory_id,
-                 const uint8_t *report_desc, uint16_t report_desc_size) {
+                 const unsigned char *report_desc, uint16_t report_desc_size) {
    bool ok = sc_aoa_register_hid(aoa, accessory_id, report_desc_size);
    if (!ok) {
        return false;
--- a/app/src/usb/aoa_hid.h
+++ b/app/src/usb/aoa_hid.h
@ -57,7 +57,7 @@ sc_aoa_join(struct sc_aoa *aoa);

 bool
 sc_aoa_setup_hid(struct sc_aoa *aoa, uint16_t accessory_id,
-              const uint8_t *report_desc, uint16_t report_desc_size);
+              const unsigned char *report_desc, uint16_t report_desc_size);

 bool
 sc_aoa_unregister_hid(struct sc_aoa *aoa, uint16_t accessory_id);
--- a/app/src/usb/scrcpy_otg.c
+++ b/app/src/usb/scrcpy_otg.c
@ -62,7 +62,7 @@ scrcpy_otg(struct scrcpy_options *options) {
    // Minimal SDL initialization
    if (SDL_Init(SDL_INIT_EVENTS)) {
        LOGE("Could not initialize SDL: %s", SDL_GetError());
-        return SCRCPY_EXIT_FAILURE;
+        return false;
    }

    atexit(SDL_Quit);
--- a/app/src/util/audiobuf.c
+++ b/app/src/util/audiobuf.c
@ -1,112 +0,0 @@
-#include "audiobuf.h"
-
-#include <stdlib.h>
-#include <string.h>
-#include <util/log.h>
-#include <util/memory.h>
-
-bool
-sc_audiobuf_init(struct sc_audiobuf *buf, size_t sample_size,
-                 uint32_t capacity) {
-    assert(sample_size);
-    assert(capacity);
-
-    // The actual capacity is (alloc_size - 1) so that head == tail is
-    // non-ambiguous
-    buf->alloc_size = capacity + 1;
-    buf->data = sc_allocarray(buf->alloc_size, sample_size);
-    if (!buf->data) {
-        LOG_OOM();
-        return false;
-    }
-
-    buf->sample_size = sample_size;
-    atomic_init(&buf->head, 0);
-    atomic_init(&buf->tail, 0);
-
-    return true;
-}
-
-void
-sc_audiobuf_destroy(struct sc_audiobuf *buf) {
-    free(buf->data);
-}
-
-uint32_t
-sc_audiobuf_read(struct sc_audiobuf *buf, void *to_, uint32_t samples_count) {
-    assert(samples_count);
-
-    uint8_t *to = to_;
-
-    // Only the reader thread can write tail without synchronization, so
-    // memory_order_relaxed is sufficient
-    uint32_t tail = atomic_load_explicit(&buf->tail, memory_order_relaxed);
-
-    // The head cursor is updated after the data is written to the array
-    uint32_t head = atomic_load_explicit(&buf->head, memory_order_acquire);
-
-    uint32_t can_read = (buf->alloc_size + head - tail) % buf->alloc_size;
-    if (samples_count > can_read) {
-        samples_count = can_read;
-    }
-
-    if (to) {
-        uint32_t right_count = buf->alloc_size - tail;
-        if (right_count > samples_count) {
-            right_count = samples_count;
-        }
-        memcpy(to,
-               buf->data + (tail * buf->sample_size),
-               right_count * buf->sample_size);
-
-        if (samples_count > right_count) {
-            uint32_t left_count = samples_count - right_count;
-            memcpy(to + (right_count * buf->sample_size),
-                   buf->data,
-                   left_count * buf->sample_size);
-        }
-    }
-
-    uint32_t new_tail = (tail + samples_count) % buf->alloc_size;
-    atomic_store_explicit(&buf->tail, new_tail, memory_order_release);
-
-    return samples_count;
-}
-
-uint32_t
-sc_audiobuf_write(struct sc_audiobuf *buf, const void *from_,
-                  uint32_t samples_count) {
-    const uint8_t *from = from_;
-
-    // Only the writer thread can write head, so memory_order_relaxed is
-    // sufficient
-    uint32_t head = atomic_load_explicit(&buf->head, memory_order_relaxed);
-
-    // The tail cursor is updated after the data is consumed by the reader
-    uint32_t tail = atomic_load_explicit(&buf->tail, memory_order_acquire);
-
-    uint32_t can_write = (buf->alloc_size + tail - head - 1) % buf->alloc_size;
-    if (samples_count > can_write) {
-        samples_count = can_write;
-    }
-
-    uint32_t right_count = buf->alloc_size - head;
-    if (right_count > samples_count) {
-        right_count = samples_count;
-    }
-    memcpy(buf->data + (head * buf->sample_size),
-           from,
-           right_count * buf->sample_size);
-
-    if (samples_count > right_count) {
-        uint32_t left_count = samples_count - right_count;
-        memcpy(buf->data,
-               from + (right_count * buf->sample_size),
-               left_count * buf->sample_size);
-    }
-
-    uint32_t new_head = (head + samples_count) % buf->alloc_size;
-    atomic_store_explicit(&buf->head, new_head, memory_order_release);
-
-    return samples_count;
-}
--- a/app/src/util/audiobuf.h
+++ b/app/src/util/audiobuf.h
@ -3,25 +3,19 @@

 #include "common.h"

-#include <assert.h>
-#include <stdatomic.h>
 #include <stdbool.h>
 #include <stdint.h>

+#include "util/bytebuf.h"
+
 /**
 * Wrapper around bytebuf to read and write samples
 *
 * Each sample takes sample_size bytes.
 */
 struct sc_audiobuf {
-    uint8_t *data;
-    uint32_t alloc_size; // in samples
+    struct sc_bytebuf buf;
    size_t sample_size;
-
-    atomic_uint_least32_t head; // writer cursor, in samples
-    atomic_uint_least32_t tail; // reader cursor, in samples
-    // empty: tail == head
-    // full: ((tail + 1) % alloc_size) == head
 };

 static inline uint32_t
@ -35,31 +29,66 @@ sc_audiobuf_to_bytes(struct sc_audiobuf *buf, uint32_t samples) {
    return samples * buf->sample_size;
 }

-bool
+static inline bool
 sc_audiobuf_init(struct sc_audiobuf *buf, size_t sample_size,
-                 uint32_t capacity);
+                 uint32_t capacity) {
+    buf->sample_size = sample_size;
+    return sc_bytebuf_init(&buf->buf, capacity * sample_size + 1);
+}

-void
-sc_audiobuf_destroy(struct sc_audiobuf *buf);
+static inline void
+sc_audiobuf_read(struct sc_audiobuf *buf, uint8_t *to, uint32_t samples) {
+    size_t bytes = sc_audiobuf_to_bytes(buf, samples);
+    sc_bytebuf_read(&buf->buf, to, bytes);
+}

-uint32_t
-sc_audiobuf_read(struct sc_audiobuf *buf, void *to, uint32_t samples_count);
+static inline void
+sc_audiobuf_skip(struct sc_audiobuf *buf, uint32_t samples) {
+    size_t bytes = sc_audiobuf_to_bytes(buf, samples);
+    sc_bytebuf_skip(&buf->buf, bytes);
+}

-uint32_t
-sc_audiobuf_write(struct sc_audiobuf *buf, const void *from,
-                  uint32_t samples_count);
+static inline void
+sc_audiobuf_write(struct sc_audiobuf *buf, const uint8_t *from,
+                  uint32_t samples) {
+    size_t bytes = sc_audiobuf_to_bytes(buf, samples);
+    sc_bytebuf_write(&buf->buf, from, bytes);
+}

-static inline uint32_t
-sc_audiobuf_capacity(struct sc_audiobuf *buf) {
-    assert(buf->alloc_size);
-    return buf->alloc_size - 1;
+static inline void
+sc_audiobuf_prepare_write(struct sc_audiobuf *buf, const uint8_t *from,
+                          uint32_t samples) {
+    size_t bytes = sc_audiobuf_to_bytes(buf, samples);
+    sc_bytebuf_prepare_write(&buf->buf, from, bytes);
+}
+
+static inline void
+sc_audiobuf_commit_write(struct sc_audiobuf *buf, uint32_t samples) {
+    size_t bytes = sc_audiobuf_to_bytes(buf, samples);
+    sc_bytebuf_commit_write(&buf->buf, bytes);
 }

 static inline uint32_t
 sc_audiobuf_can_read(struct sc_audiobuf *buf) {
-    uint32_t head = atomic_load_explicit(&buf->head, memory_order_acquire);
-    uint32_t tail = atomic_load_explicit(&buf->tail, memory_order_acquire);
-    return (buf->alloc_size + head - tail) % buf->alloc_size;
+    size_t bytes = sc_bytebuf_can_read(&buf->buf);
+    return sc_audiobuf_to_samples(buf, bytes);
+}
+
+static inline uint32_t
+sc_audiobuf_can_write(struct sc_audiobuf *buf) {
+    size_t bytes = sc_bytebuf_can_write(&buf->buf);
+    return sc_audiobuf_to_samples(buf, bytes);
+}
+
+static inline uint32_t
+sc_audiobuf_capacity(struct sc_audiobuf *buf) {
+    size_t bytes = sc_bytebuf_capacity(&buf->buf);
+    return sc_audiobuf_to_samples(buf, bytes);
+}
+
+static inline void
+sc_audiobuf_destroy(struct sc_audiobuf *buf) {
+    sc_bytebuf_destroy(&buf->buf);
 }

 #endif
--- a/app/src/util/bytebuf.c
+++ b/app/src/util/bytebuf.c
@ -0,0 +1,104 @@
+#include "bytebuf.h"
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "util/log.h"
+
+bool
+sc_bytebuf_init(struct sc_bytebuf *buf, size_t alloc_size) {
+    assert(alloc_size);
+    buf->data = malloc(alloc_size);
+    if (!buf->data) {
+        LOG_OOM();
+        return false;
+    }
+
+    buf->alloc_size = alloc_size;
+    buf->head = 0;
+    buf->tail = 0;
+
+    return true;
+}
+
+void
+sc_bytebuf_destroy(struct sc_bytebuf *buf) {
+    free(buf->data);
+}
+
+void
+sc_bytebuf_read(struct sc_bytebuf *buf, uint8_t *to, size_t len) {
+    assert(len);
+    assert(len <= sc_bytebuf_can_read(buf));
+    assert(buf->tail != buf->head); // the buffer could not be empty
+
+    size_t right_limit = buf->tail < buf->head ? buf->head : buf->alloc_size;
+    size_t right_len = right_limit - buf->tail;
+    if (len < right_len) {
+        right_len = len;
+    }
+    memcpy(to, buf->data + buf->tail, right_len);
+
+    if (len > right_len) {
+        memcpy(to + right_len, buf->data, len - right_len);
+    }
+
+    buf->tail = (buf->tail + len) % buf->alloc_size;
+}
+
+void
+sc_bytebuf_skip(struct sc_bytebuf *buf, size_t len) {
+    assert(len);
+    assert(len <= sc_bytebuf_can_read(buf));
+    assert(buf->tail != buf->head); // the buffer could not be empty
+
+    buf->tail = (buf->tail + len) % buf->alloc_size;
+}
+
+static inline void
+sc_bytebuf_write_step0(struct sc_bytebuf *buf, const uint8_t *from,
+                       size_t len) {
+    size_t right_len = buf->alloc_size - buf->head;
+    if (len < right_len) {
+        right_len = len;
+    }
+    memcpy(buf->data + buf->head, from, right_len);
+
+    if (len > right_len) {
+        memcpy(buf->data, from + right_len, len - right_len);
+    }
+}
+
+static inline void
+sc_bytebuf_write_step1(struct sc_bytebuf *buf, size_t len) {
+    buf->head = (buf->head + len) % buf->alloc_size;
+}
+
+void
+sc_bytebuf_write(struct sc_bytebuf *buf, const uint8_t *from, size_t len) {
+    assert(len);
+    assert(len <= sc_bytebuf_can_write(buf));
+
+    sc_bytebuf_write_step0(buf, from, len);
+    sc_bytebuf_write_step1(buf, len);
+}
+
+void
+sc_bytebuf_prepare_write(struct sc_bytebuf *buf, const uint8_t *from,
+                         size_t len) {
+    // *This function MUST NOT access buf->tail (even in assert()).*
+    // The purpose of this function is to allow a reader and a writer to access
+    // different parts of the buffer in parallel simultaneously. It is intended
+    // to be called without lock (only sc_bytebuf_commit_write() is intended to
+    // be called with lock held).
+
+    assert(len < buf->alloc_size - 1);
+    sc_bytebuf_write_step0(buf, from, len);
+}
+
+void
+sc_bytebuf_commit_write(struct sc_bytebuf *buf, size_t len) {
+    assert(len <= sc_bytebuf_can_write(buf));
+    sc_bytebuf_write_step1(buf, len);
+}
--- a/app/src/util/bytebuf.h
+++ b/app/src/util/bytebuf.h
@ -0,0 +1,114 @@
+#ifndef SC_BYTEBUF_H
+#define SC_BYTEBUF_H
+
+#include "common.h"
+
+#include <stdbool.h>
+#include <stdint.h>
+
+struct sc_bytebuf {
+    uint8_t *data;
+    // The actual capacity is (allocated - 1) so that head == tail is
+    // non-ambiguous
+    size_t alloc_size;
+    size_t head; // writter cursor
+    size_t tail; // reader cursor
+    // empty: tail == head
+    // full: ((tail + 1) % alloc_size) == head
+};
+
+bool
+sc_bytebuf_init(struct sc_bytebuf *buf, size_t alloc_size);
+
+/**
+ * Copy from the bytebuf to a user-provided array
+ *
+ * The caller must check that len <= sc_bytebuf_read_available() (it is an
+ * error to attempt to read more bytes than available).
+ *
+ * This function is guaranteed not to write to buf->head.
+ */
+void
+sc_bytebuf_read(struct sc_bytebuf *buf, uint8_t *to, size_t len);
+
+/**
+ * Drop len bytes from the buffer
+ *
+ * The caller must check that len <= sc_bytebuf_read_available() (it is an
+ * error to attempt to skip more bytes than available).
+ *
+ * This function is guaranteed not to write to buf->head.
+ *
+ * It is equivalent to call sc_bytebuf_read() to some array and discard the
+ * array (but this function is more efficient since there is no copy).
+ */
+void
+sc_bytebuf_skip(struct sc_bytebuf *buf, size_t len);
+
+/**
+ * Copy the user-provided array to the bytebuf
+ *
+ * The caller must check that len <= sc_bytebuf_write_available() (it is an
+ * error to write more bytes than the remaining available space).
+ *
+ * This function is guaranteed not to write to buf->tail.
+ */
+void
+sc_bytebuf_write(struct sc_bytebuf *buf, const uint8_t *from, size_t len);
+
+/**
+ * Copy the user-provided array to the bytebuf, but do not advance the cursor
+ *
+ * The caller must check that len <= sc_bytebuf_write_available() (it is an
+ * error to write more bytes than the remaining available space).
+ *
+ * After this function is called, the write must be committed with
+ * sc_bytebuf_commit_write().
+ *
+ * The purpose of this mechanism is to acquire a lock only to commit the write,
+ * but not to perform the actual copy.
+ *
+ * This function is guaranteed not to access buf->tail.
+ */
+void
+sc_bytebuf_prepare_write(struct sc_bytebuf *buf, const uint8_t *from,
+                         size_t len);
+
+/**
+ * Commit a prepared write
+ */
+void
+sc_bytebuf_commit_write(struct sc_bytebuf *buf, size_t len);
+
+/**
+ * Return the number of bytes which can be read
+ *
+ * It is an error to read more bytes than available.
+ */
+static inline size_t
+sc_bytebuf_can_read(struct sc_bytebuf *buf) {
+    return (buf->alloc_size + buf->head - buf->tail) % buf->alloc_size;
+}
+
+/**
+ * Return the number of bytes which can be written
+ *
+ * It is an error to write more bytes than available.
+ */
+static inline size_t
+sc_bytebuf_can_write(struct sc_bytebuf *buf) {
+    return (buf->alloc_size + buf->tail - buf->head - 1) % buf->alloc_size;
+}
+
+/**
+ * Return the actual capacity of the buffer (can_read() + can_write())
+ */
+static inline size_t
+sc_bytebuf_capacity(struct sc_bytebuf *buf) {
+    return buf->alloc_size - 1;
+}
+
+void
+sc_bytebuf_destroy(struct sc_bytebuf *buf);
+
+#endif
--- a/app/tests/test_audiobuf.c
+++ b/app/tests/test_audiobuf.c
@ -1,128 +0,0 @@
-#include "common.h"
-
-#include <assert.h>
-#include <string.h>
-
-#include "util/audiobuf.h"
-
-static void test_audiobuf_simple(void) {
-    struct sc_audiobuf buf;
-    uint32_t data[20];
-
-    bool ok = sc_audiobuf_init(&buf, 4, 20);
-    assert(ok);
-
-    uint32_t samples[] = {1, 2, 3, 4, 5};
-    uint32_t w = sc_audiobuf_write(&buf, samples, 5);
-    assert(w == 5);
-
-    uint32_t r = sc_audiobuf_read(&buf, data, 4);
-    assert(r == 4);
-    assert(!memcmp(data, samples, 16));
-
-    uint32_t samples2[] = {6, 7, 8};
-    w = sc_audiobuf_write(&buf, samples2, 3);
-    assert(w == 3);
-
-    uint32_t single = 9;
-    w = sc_audiobuf_write(&buf, &single, 1);
-    assert(w == 1);
-
-    r = sc_audiobuf_read(&buf, &data[4], 8);
-    assert(r == 5);
-
-    uint32_t expected[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
-    assert(!memcmp(data, expected, 36));
-
-    sc_audiobuf_destroy(&buf);
-}
-
-static void test_audiobuf_boundaries(void) {
-    struct sc_audiobuf buf;
-    uint32_t data[20];
-
-    bool ok = sc_audiobuf_init(&buf, 4, 20);
-    assert(ok);
-
-    uint32_t samples[] = {1, 2, 3, 4, 5, 6};
-    uint32_t w = sc_audiobuf_write(&buf, samples, 6);
-    assert(w == 6);
-
-    w = sc_audiobuf_write(&buf, samples, 6);
-    assert(w == 6);
-
-    w = sc_audiobuf_write(&buf, samples, 6);
-    assert(w == 6);
-
-    uint32_t r = sc_audiobuf_read(&buf, data, 9);
-    assert(r == 9);
-
-    uint32_t expected[] = {1, 2, 3, 4, 5, 6, 1, 2, 3};
-    assert(!memcmp(data, expected, 36));
-
-    uint32_t samples2[] = {7, 8, 9, 10, 11};
-    w = sc_audiobuf_write(&buf, samples2, 5);
-    assert(w == 5);
-
-    uint32_t single = 12;
-    w = sc_audiobuf_write(&buf, &single, 1);
-    assert(w == 1);
-
-    w = sc_audiobuf_read(&buf, NULL, 3);
-    assert(w == 3);
-
-    assert(sc_audiobuf_can_read(&buf) == 12);
-
-    r = sc_audiobuf_read(&buf, data, 12);
-    assert(r == 12);
-
-    uint32_t expected2[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
-    assert(!memcmp(data, expected2, 48));
-
-    sc_audiobuf_destroy(&buf);
-}
-
-static void test_audiobuf_partial_read_write(void) {
-    struct sc_audiobuf buf;
-    uint32_t data[15];
-
-    bool ok = sc_audiobuf_init(&buf, 4, 10);
-    assert(ok);
-
-    uint32_t samples[] = {1, 2, 3, 4, 5, 6};
-    uint32_t w = sc_audiobuf_write(&buf, samples, 6);
-    assert(w == 6);
-
-    w = sc_audiobuf_write(&buf, samples, 6);
-    assert(w == 4);
-
-    w = sc_audiobuf_write(&buf, samples, 6);
-    assert(w == 0);
-
-    uint32_t r = sc_audiobuf_read(&buf, data, 3);
-    assert(r == 3);
-
-    uint32_t expected[] = {1, 2, 3};
-    assert(!memcmp(data, expected, 12));
-
-    w = sc_audiobuf_write(&buf, samples, 6);
-    assert(w == 3);
-
-    r = sc_audiobuf_read(&buf, data, 15);
-    assert(r == 10);
-    uint32_t expected2[] = {4, 5, 6, 1, 2, 3, 4, 1, 2, 3};
-    assert(!memcmp(data, expected2, 12));
-
-    sc_audiobuf_destroy(&buf);
-}
-
-int main(int argc, char *argv[]) {
-    (void) argc;
-    (void) argv;
-
-    test_audiobuf_simple();
-    test_audiobuf_boundaries();
-    test_audiobuf_partial_read_write();
-
-    return 0;
-}
--- a/app/tests/test_bytebuf.c
+++ b/app/tests/test_bytebuf.c
@ -0,0 +1,126 @@
+#include "common.h"
+
+#include <assert.h>
+#include <string.h>
+
+#include "util/bytebuf.h"
+
+static void test_bytebuf_simple(void) {
+    struct sc_bytebuf buf;
+    uint8_t data[20];
+
+    bool ok = sc_bytebuf_init(&buf, 20);
+    assert(ok);
+
+    sc_bytebuf_write(&buf, (uint8_t *) "hello", sizeof("hello") - 1);
+    assert(sc_bytebuf_can_read(&buf) == 5);
+
+    sc_bytebuf_read(&buf, data, 4);
+    assert(!strncmp((char *) data, "hell", 4));
+
+    sc_bytebuf_write(&buf, (uint8_t *) " world", sizeof(" world") - 1);
+    assert(sc_bytebuf_can_read(&buf) == 7);
+
+    sc_bytebuf_write(&buf, (uint8_t *) "!", 1);
+    assert(sc_bytebuf_can_read(&buf) == 8);
+
+    sc_bytebuf_read(&buf, &data[4], 8);
+    assert(sc_bytebuf_can_read(&buf) == 0);
+
+    data[12] = '\0';
+    assert(!strcmp((char *) data, "hello world!"));
+    assert(sc_bytebuf_can_read(&buf) == 0);
+
+    sc_bytebuf_destroy(&buf);
+}
+
+static void test_bytebuf_boundaries(void) {
+    struct sc_bytebuf buf;
+    uint8_t data[20];
+
+    bool ok = sc_bytebuf_init(&buf, 20);
+    assert(ok);
+
+    sc_bytebuf_write(&buf, (uint8_t *) "hello ", sizeof("hello ") - 1);
+    assert(sc_bytebuf_can_read(&buf) == 6);
+
+    sc_bytebuf_write(&buf, (uint8_t *) "hello ", sizeof("hello ") - 1);
+    assert(sc_bytebuf_can_read(&buf) == 12);
+
+    sc_bytebuf_write(&buf, (uint8_t *) "hello ", sizeof("hello ") - 1);
+    assert(sc_bytebuf_can_read(&buf) == 18);
+
+    sc_bytebuf_read(&buf, data, 9);
+    assert(!strncmp((char *) data, "hello hel", 9));
+    assert(sc_bytebuf_can_read(&buf) == 9);
+
+    sc_bytebuf_write(&buf, (uint8_t *) "world", sizeof("world") - 1);
+    assert(sc_bytebuf_can_read(&buf) == 14);
+
+    sc_bytebuf_write(&buf, (uint8_t *) "!", 1);
+    assert(sc_bytebuf_can_read(&buf) == 15);
+
+    sc_bytebuf_skip(&buf, 3);
+    assert(sc_bytebuf_can_read(&buf) == 12);
+
+    sc_bytebuf_read(&buf, data, 12);
+    data[12] = '\0';
+    assert(!strcmp((char *) data, "hello world!"));
+    assert(sc_bytebuf_can_read(&buf) == 0);
+
+    sc_bytebuf_destroy(&buf);
+}
+
+static void test_bytebuf_two_steps_write(void) {
+    struct sc_bytebuf buf;
+    uint8_t data[20];
+
+    bool ok = sc_bytebuf_init(&buf, 20);
+    assert(ok);
+
+    sc_bytebuf_write(&buf, (uint8_t *) "hello ", sizeof("hello ") - 1);
+    assert(sc_bytebuf_can_read(&buf) == 6);
+
+    sc_bytebuf_write(&buf, (uint8_t *) "hello ", sizeof("hello ") - 1);
+    assert(sc_bytebuf_can_read(&buf) == 12);
+
+    sc_bytebuf_prepare_write(&buf, (uint8_t *) "hello ", sizeof("hello ") - 1);
+    assert(sc_bytebuf_can_read(&buf) == 12); // write not committed yet
+
+    sc_bytebuf_read(&buf, data, 9);
+    assert(!strncmp((char *) data, "hello hel", 3));
+    assert(sc_bytebuf_can_read(&buf) == 3);
+
+    sc_bytebuf_commit_write(&buf, sizeof("hello ") - 1);
+    assert(sc_bytebuf_can_read(&buf) == 9);
+
+    sc_bytebuf_prepare_write(&buf, (uint8_t *) "world", sizeof("world") - 1);
+    assert(sc_bytebuf_can_read(&buf) == 9); // write not committed yet
+
+    sc_bytebuf_commit_write(&buf, sizeof("world") - 1);
+    assert(sc_bytebuf_can_read(&buf) == 14);
+
+    sc_bytebuf_write(&buf, (uint8_t *) "!", 1);
+    assert(sc_bytebuf_can_read(&buf) == 15);
+
+    sc_bytebuf_skip(&buf, 3);
+    assert(sc_bytebuf_can_read(&buf) == 12);
+
+    sc_bytebuf_read(&buf, data, 12);
+    data[12] = '\0';
+    assert(!strcmp((char *) data, "hello world!"));
+    assert(sc_bytebuf_can_read(&buf) == 0);
+
+    sc_bytebuf_destroy(&buf);
+}
+
+int main(int argc, char *argv[]) {
+    (void) argc;
+    (void) argv;
+
+    test_bytebuf_simple();
+    test_bytebuf_boundaries();
+    test_bytebuf_two_steps_write();
+
+    return 0;
+}
--- a/app/tests/test_control_msg_serialize.c
+++ b/app/tests/test_control_msg_serialize.c
@ -1,7 +1,6 @@
 #include "common.h"

 #include <assert.h>
-#include <stdint.h>
 #include <string.h>

 #include "control_msg.h"
@ -17,11 +16,11 @@ static void test_serialize_inject_keycode(void) {
        },
    };

-    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
    size_t size = sc_control_msg_serialize(&msg, buf);
    assert(size == 14);

-    const uint8_t expected[] = {
+    const unsigned char expected[] = {
        SC_CONTROL_MSG_TYPE_INJECT_KEYCODE,
        0x01, // AKEY_EVENT_ACTION_UP
        0x00, 0x00, 0x00, 0x42, // AKEYCODE_ENTER
@ -39,11 +38,11 @@ static void test_serialize_inject_text(void) {
        },
    };

-    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
    size_t size = sc_control_msg_serialize(&msg, buf);
    assert(size == 18);

-    const uint8_t expected[] = {
+    const unsigned char expected[] = {
        SC_CONTROL_MSG_TYPE_INJECT_TEXT,
        0x00, 0x00, 0x00, 0x0d, // text length
        'h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!', // text
@ -59,11 +58,11 @@ static void test_serialize_inject_text_long(void) {
    text[SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH] = '\0';
    msg.inject_text.text = text;

-    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
    size_t size = sc_control_msg_serialize(&msg, buf);
    assert(size == 5 + SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH);

-    uint8_t expected[5 + SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH];
+    unsigned char expected[5 + SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH];
    expected[0] = SC_CONTROL_MSG_TYPE_INJECT_TEXT;
    expected[1] = 0x00;
    expected[2] = 0x00;
@ -96,11 +95,11 @@ static void test_serialize_inject_touch_event(void) {
        },
    };

-    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
    size_t size = sc_control_msg_serialize(&msg, buf);
    assert(size == 32);

-    const uint8_t expected[] = {
+    const unsigned char expected[] = {
        SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
        0x00, // AKEY_EVENT_ACTION_DOWN
        0x12, 0x34, 0x56, 0x78, 0x87, 0x65, 0x43, 0x21, // pointer id
@ -133,11 +132,11 @@ static void test_serialize_inject_scroll_event(void) {
        },
    };

-    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
    size_t size = sc_control_msg_serialize(&msg, buf);
    assert(size == 21);

-    const uint8_t expected[] = {
+    const unsigned char expected[] = {
        SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
        0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x04, 0x02, // 260 1026
        0x04, 0x38, 0x07, 0x80, // 1080 1920
@ -156,11 +155,11 @@ static void test_serialize_back_or_screen_on(void) {
        },
    };

-    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
    size_t size = sc_control_msg_serialize(&msg, buf);
    assert(size == 2);

-    const uint8_t expected[] = {
+    const unsigned char expected[] = {
        SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
        0x01, // AKEY_EVENT_ACTION_UP
    };
@ -172,11 +171,11 @@ static void test_serialize_expand_notification_panel(void) {
        .type = SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL,
    };

-    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
    size_t size = sc_control_msg_serialize(&msg, buf);
    assert(size == 1);

-    const uint8_t expected[] = {
+    const unsigned char expected[] = {
        SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL,
    };
    assert(!memcmp(buf, expected, sizeof(expected)));
@ -187,11 +186,11 @@ static void test_serialize_expand_settings_panel(void) {
        .type = SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL,
    };

-    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
    size_t size = sc_control_msg_serialize(&msg, buf);
    assert(size == 1);

-    const uint8_t expected[] = {
+    const unsigned char expected[] = {
        SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL,
    };
    assert(!memcmp(buf, expected, sizeof(expected)));
@ -202,11 +201,11 @@ static void test_serialize_collapse_panels(void) {
        .type = SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS,
    };

-    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
    size_t size = sc_control_msg_serialize(&msg, buf);
    assert(size == 1);

-    const uint8_t expected[] = {
+    const unsigned char expected[] = {
        SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS,
    };
    assert(!memcmp(buf, expected, sizeof(expected)));
@ -220,11 +219,11 @@ static void test_serialize_get_clipboard(void) {
        },
    };

-    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
    size_t size = sc_control_msg_serialize(&msg, buf);
    assert(size == 2);

-    const uint8_t expected[] = {
+    const unsigned char expected[] = {
        SC_CONTROL_MSG_TYPE_GET_CLIPBOARD,
        SC_COPY_KEY_COPY,
    };
@ -241,11 +240,11 @@ static void test_serialize_set_clipboard(void) {
        },
    };

-    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
    size_t size = sc_control_msg_serialize(&msg, buf);
    assert(size == 27);

-    const uint8_t expected[] = {
+    const unsigned char expected[] = {
        SC_CONTROL_MSG_TYPE_SET_CLIPBOARD,
        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // sequence
        1, // paste
@ -270,11 +269,11 @@ static void test_serialize_set_clipboard_long(void) {
    text[SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH] = '\0';
    msg.set_clipboard.text = text;

-    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
    size_t size = sc_control_msg_serialize(&msg, buf);
    assert(size == SC_CONTROL_MSG_MAX_SIZE);

-    uint8_t expected[SC_CONTROL_MSG_MAX_SIZE] = {
+    unsigned char expected[SC_CONTROL_MSG_MAX_SIZE] = {
        SC_CONTROL_MSG_TYPE_SET_CLIPBOARD,
        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // sequence
        1, // paste
@ -297,11 +296,11 @@ static void test_serialize_set_screen_power_mode(void) {
        },
    };

-    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
    size_t size = sc_control_msg_serialize(&msg, buf);
    assert(size == 2);

-    const uint8_t expected[] = {
+    const unsigned char expected[] = {
        SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE,
        0x02, // SC_SCREEN_POWER_MODE_NORMAL
    };
@ -313,11 +312,11 @@ static void test_serialize_rotate_device(void) {
        .type = SC_CONTROL_MSG_TYPE_ROTATE_DEVICE,
    };

-    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
    size_t size = sc_control_msg_serialize(&msg, buf);
    assert(size == 1);

-    const uint8_t expected[] = {
+    const unsigned char expected[] = {
        SC_CONTROL_MSG_TYPE_ROTATE_DEVICE,
    };
    assert(!memcmp(buf, expected, sizeof(expected)));
--- a/app/tests/test_device_msg_deserialize.c
+++ b/app/tests/test_device_msg_deserialize.c
@ -1,32 +1,32 @@
 #include "common.h"

 #include <assert.h>
-#include <stdint.h>
-#include <stdio.h>
 #include <string.h>

 #include "device_msg.h"

+#include <stdio.h>
+
 static void test_deserialize_clipboard(void) {
-    const uint8_t input[] = {
+    const unsigned char input[] = {
        DEVICE_MSG_TYPE_CLIPBOARD,
        0x00, 0x00, 0x00, 0x03, // text length
        0x41, 0x42, 0x43, // "ABC"
    };

-    struct sc_device_msg msg;
-    ssize_t r = sc_device_msg_deserialize(input, sizeof(input), &msg);
+    struct device_msg msg;
+    ssize_t r = device_msg_deserialize(input, sizeof(input), &msg);
    assert(r == 8);

    assert(msg.type == DEVICE_MSG_TYPE_CLIPBOARD);
    assert(msg.clipboard.text);
    assert(!strcmp("ABC", msg.clipboard.text));

-    sc_device_msg_destroy(&msg);
+    device_msg_destroy(&msg);
 }

 static void test_deserialize_clipboard_big(void) {
-    uint8_t input[DEVICE_MSG_MAX_SIZE];
+    unsigned char input[DEVICE_MSG_MAX_SIZE];
    input[0] = DEVICE_MSG_TYPE_CLIPBOARD;
    input[1] = (DEVICE_MSG_TEXT_MAX_LENGTH & 0xff000000u) >> 24;
    input[2] = (DEVICE_MSG_TEXT_MAX_LENGTH & 0x00ff0000u) >> 16;
@ -35,8 +35,8 @@ static void test_deserialize_clipboard_big(void) {

    memset(input + 5, 'a', DEVICE_MSG_TEXT_MAX_LENGTH);

-    struct sc_device_msg msg;
-    ssize_t r = sc_device_msg_deserialize(input, sizeof(input), &msg);
+    struct device_msg msg;
+    ssize_t r = device_msg_deserialize(input, sizeof(input), &msg);
    assert(r == DEVICE_MSG_MAX_SIZE);

    assert(msg.type == DEVICE_MSG_TYPE_CLIPBOARD);
@ -44,17 +44,17 @@ static void test_deserialize_clipboard_big(void) {
    assert(strlen(msg.clipboard.text) == DEVICE_MSG_TEXT_MAX_LENGTH);
    assert(msg.clipboard.text[0] == 'a');

-    sc_device_msg_destroy(&msg);
+    device_msg_destroy(&msg);
 }

 static void test_deserialize_ack_set_clipboard(void) {
-    const uint8_t input[] = {
+    const unsigned char input[] = {
        DEVICE_MSG_TYPE_ACK_CLIPBOARD,
        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // sequence
    };

-    struct sc_device_msg msg;
-    ssize_t r = sc_device_msg_deserialize(input, sizeof(input), &msg);
+    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);
--- a/doc/control.md
+++ b/doc/control.md
@ -85,7 +85,7 @@ way as <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>).
 To disable automatic clipboard synchronization, use
 `--no-clipboard-autosync`.

-## Pinch-to-zoom, rotate and tilt simulation
+## Pinch-to-zoom

 To simulate "pinch-to-zoom": <kbd>Ctrl</kbd>+_click-and-move_.

@ -93,12 +93,8 @@ More precisely, hold down <kbd>Ctrl</kbd> while pressing the left-click button.
 Until the left-click button is released, all mouse movements scale and rotate
 the content (if supported by the app) relative to the center of the screen.

-To simulate a tilt gesture: <kbd>Shift</kbd>+_click-and-move-up-or-down_.
-
 Technically, _scrcpy_ generates additional touch events from a "virtual finger"
-at a location inverted through the center of the screen. When pressing
-<kbd>Ctrl</kbd> the x and y coordinates are inverted. Using <kbd>Shift</kbd>
-only inverts x.
+at a location inverted through the center of the screen.


 ## Key repeat
--- a/doc/shortcuts.md
+++ b/doc/shortcuts.md
@ -49,8 +49,7 @@ _<kbd>[Super]</kbd> is typically the <kbd>Windows</kbd> or <kbd>Cmd</kbd> key._
 | Synchronize clipboards and paste⁵           | <kbd>MOD</kbd>+<kbd>v</kbd>
 | Inject computer clipboard text              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
 | Enable/disable FPS counter (on stdout)      | <kbd>MOD</kbd>+<kbd>i</kbd>
- | Pinch-to-zoom/rotate                        | <kbd>Ctrl</kbd>+_click-and-move_
- | Tilt (slide vertically with 2 fingers)      | <kbd>Shift</kbd>+_click-and-move_
+ | Pinch-to-zoom                               | <kbd>Ctrl</kbd>+_click-and-move_
 | Drag & drop APK file                        | Install APK from computer
 | Drag & drop non-APK file                    | [Push file to device](control.md#push-file-to-device)

--- a/meson.build
+++ b/meson.build
@ -16,3 +16,5 @@ endif
 if get_option('compile_server')
    subdir('server')
 endif
+
+run_target('run', command: ['scripts/run-scrcpy.sh'])
--- a/scripts/run-scrcpy.sh
+++ b/scripts/run-scrcpy.sh
@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+SCRCPY_SERVER_PATH="$MESON_BUILD_ROOT/server/scrcpy-server" "$MESON_BUILD_ROOT/app/scrcpy"
--- a/server/src/main/java/com/genymobile/scrcpy/AudioCapture.java
+++ b/server/src/main/java/com/genymobile/scrcpy/AudioCapture.java
@ -153,14 +153,13 @@ public final class AudioCapture {
            previousRecorderTimestamp = timestamp.nanoTime;
        } else {
            if (nextPts == 0) {
-                Ln.w("Could not get initial audio timestamp");
-                nextPts = System.nanoTime() / 1000;
+                Ln.w("Could not get any audio timestamp");
            }
            // compute from previous timestamp and packet size
            pts = nextPts;
        }

-        long durationUs = r * 1000000L / (CHANNELS * BYTES_PER_SAMPLE * SAMPLE_RATE);
+        long durationUs = r * 1000000 / (CHANNELS * BYTES_PER_SAMPLE * SAMPLE_RATE);
        nextPts = pts + durationUs;

        if (previousPts != 0 && pts < previousPts + ONE_SAMPLE_US) {
--- a/server/src/main/java/com/genymobile/scrcpy/CleanUp.java
+++ b/server/src/main/java/com/genymobile/scrcpy/CleanUp.java
@ -1,8 +1,11 @@
 package com.genymobile.scrcpy;

+import android.os.Parcel;
+import android.os.Parcelable;
+import android.util.Base64;
+
 import java.io.File;
 import java.io.IOException;
-import java.io.OutputStream;

 /**
 * Handle the cleanup of scrcpy, even if the main process is killed.
@ -11,59 +14,127 @@ import java.io.OutputStream;
 */
 public final class CleanUp {

-    private static final int MSG_TYPE_MASK = 0b11;
-    private static final int MSG_TYPE_RESTORE_STAY_ON = 0;
-    private static final int MSG_TYPE_DISABLE_SHOW_TOUCHES = 1;
-    private static final int MSG_TYPE_RESTORE_NORMAL_POWER_MODE = 2;
-    private static final int MSG_TYPE_POWER_OFF_SCREEN = 3;
+    // A simple struct to be passed from the main process to the cleanup process
+    public static class Config implements Parcelable {

-    private static final int MSG_PARAM_SHIFT = 2;
+        public static final Creator<Config> CREATOR = new Creator<Config>() {
+            @Override
+            public Config createFromParcel(Parcel in) {
+                return new Config(in);
+            }

-    private final OutputStream out;
+            @Override
+            public Config[] newArray(int size) {
+                return new Config[size];
+            }
+        };

-    public CleanUp(OutputStream out) {
-        this.out = out;
-    }
+        private static final int FLAG_DISABLE_SHOW_TOUCHES = 1;
+        private static final int FLAG_RESTORE_NORMAL_POWER_MODE = 2;
+        private static final int FLAG_POWER_OFF_SCREEN = 4;

-    public static CleanUp configure(int displayId) throws IOException {
-        String[] cmd = {"app_process", "/", CleanUp.class.getName(), String.valueOf(displayId)};
+        private int displayId;

-        ProcessBuilder builder = new ProcessBuilder(cmd);
-        builder.environment().put("CLASSPATH", Server.SERVER_PATH);
-        Process process = builder.start();
-        return new CleanUp(process.getOutputStream());
-    }
+        // Restore the value (between 0 and 7), -1 to not restore
+        // <https://developer.android.com/reference/android/provider/Settings.Global#STAY_ON_WHILE_PLUGGED_IN>
+        private int restoreStayOn = -1;

-    private boolean sendMessage(int type, int param) {
-        assert (type & ~MSG_TYPE_MASK) == 0;
-        int msg = type | param << MSG_PARAM_SHIFT;
-        try {
-            out.write(msg);
-            out.flush();
-            return true;
-        } catch (IOException e) {
-            Ln.w("Could not configure cleanup (type=" + type + ", param=" + param + ")", e);
-            return false;
+        private boolean disableShowTouches;
+        private boolean restoreNormalPowerMode;
+        private boolean powerOffScreen;
+
+        public Config() {
+            // Default constructor, the fields are initialized by CleanUp.configure()
+        }
+
+        protected Config(Parcel in) {
+            displayId = in.readInt();
+            restoreStayOn = in.readInt();
+            byte options = in.readByte();
+            disableShowTouches = (options & FLAG_DISABLE_SHOW_TOUCHES) != 0;
+            restoreNormalPowerMode = (options & FLAG_RESTORE_NORMAL_POWER_MODE) != 0;
+            powerOffScreen = (options & FLAG_POWER_OFF_SCREEN) != 0;
+        }
+
+        @Override
+        public void writeToParcel(Parcel dest, int flags) {
+            dest.writeInt(displayId);
+            dest.writeInt(restoreStayOn);
+            byte options = 0;
+            if (disableShowTouches) {
+                options |= FLAG_DISABLE_SHOW_TOUCHES;
+            }
+            if (restoreNormalPowerMode) {
+                options |= FLAG_RESTORE_NORMAL_POWER_MODE;
+            }
+            if (powerOffScreen) {
+                options |= FLAG_POWER_OFF_SCREEN;
+            }
+            dest.writeByte(options);
+        }
+
+        private boolean hasWork() {
+            return disableShowTouches || restoreStayOn != -1 || restoreNormalPowerMode || powerOffScreen;
+        }
+
+        @Override
+        public int describeContents() {
+            return 0;
+        }
+
+        byte[] serialize() {
+            Parcel parcel = Parcel.obtain();
+            writeToParcel(parcel, 0);
+            byte[] bytes = parcel.marshall();
+            parcel.recycle();
+            return bytes;
+        }
+
+        static Config deserialize(byte[] bytes) {
+            Parcel parcel = Parcel.obtain();
+            parcel.unmarshall(bytes, 0, bytes.length);
+            parcel.setDataPosition(0);
+            return CREATOR.createFromParcel(parcel);
+        }
+
+        static Config fromBase64(String base64) {
+            byte[] bytes = Base64.decode(base64, Base64.NO_WRAP);
+            return deserialize(bytes);
+        }
+
+        String toBase64() {
+            byte[] bytes = serialize();
+            return Base64.encodeToString(bytes, Base64.NO_WRAP);
        }
    }

-    public boolean setRestoreStayOn(int restoreValue) {
-        // Restore the value (between 0 and 7), -1 to not restore
-        // <https://developer.android.com/reference/android/provider/Settings.Global#STAY_ON_WHILE_PLUGGED_IN>
-        assert restoreValue >= -1 && restoreValue <= 7;
-        return sendMessage(MSG_TYPE_RESTORE_STAY_ON, restoreValue & 0b1111);
+    private CleanUp() {
+        // not instantiable
    }

-    public boolean setDisableShowTouches(boolean disableOnExit) {
-        return sendMessage(MSG_TYPE_DISABLE_SHOW_TOUCHES, disableOnExit ? 1 : 0);
+    public static void configure(int displayId, int restoreStayOn, boolean disableShowTouches, boolean restoreNormalPowerMode, boolean powerOffScreen)
+            throws IOException {
+        Config config = new Config();
+        config.displayId = displayId;
+        config.disableShowTouches = disableShowTouches;
+        config.restoreStayOn = restoreStayOn;
+        config.restoreNormalPowerMode = restoreNormalPowerMode;
+        config.powerOffScreen = powerOffScreen;
+
+        if (config.hasWork()) {
+            startProcess(config);
+        } else {
+            // There is no additional clean up to do when scrcpy dies
+            unlinkSelf();
+        }
    }

-    public boolean setRestoreNormalPowerMode(boolean restoreOnExit) {
-        return sendMessage(MSG_TYPE_RESTORE_NORMAL_POWER_MODE, restoreOnExit ? 1 : 0);
-    }
+    private static void startProcess(Config config) throws IOException {
+        String[] cmd = {"app_process", "/", CleanUp.class.getName(), config.toBase64()};

-    public boolean setPowerOffScreen(boolean powerOffScreenOnExit) {
-        return sendMessage(MSG_TYPE_POWER_OFF_SCREEN, powerOffScreenOnExit ? 1 : 0);
+        ProcessBuilder builder = new ProcessBuilder(cmd);
+        builder.environment().put("CLASSPATH", Server.SERVER_PATH);
+        builder.start();
    }

    public static void unlinkSelf() {
@ -77,71 +148,44 @@ public final class CleanUp {
    public static void main(String... args) {
        unlinkSelf();

-        int displayId = Integer.parseInt(args[0]);
-
-        int restoreStayOn = -1;
-        boolean disableShowTouches = false;
-        boolean restoreNormalPowerMode = false;
-        boolean powerOffScreen = false;
-
        try {
            // Wait for the server to die
-            int msg;
-            while ((msg = System.in.read()) != -1) {
-                int type = msg & MSG_TYPE_MASK;
-                int param = msg >> MSG_PARAM_SHIFT;
-                switch (type) {
-                    case MSG_TYPE_RESTORE_STAY_ON:
-                        restoreStayOn = param > 7 ? -1 : param;
-                        break;
-                    case MSG_TYPE_DISABLE_SHOW_TOUCHES:
-                        disableShowTouches = param != 0;
-                        break;
-                    case MSG_TYPE_RESTORE_NORMAL_POWER_MODE:
-                        restoreNormalPowerMode = param != 0;
-                        break;
-                    case MSG_TYPE_POWER_OFF_SCREEN:
-                        powerOffScreen = param != 0;
-                        break;
-                    default:
-                        Ln.w("Unexpected msg type: " + type);
-                        break;
-                }
-            }
+            System.in.read();
        } catch (IOException e) {
            // Expected when the server is dead
        }

        Ln.i("Cleaning up");

-        if (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);
-            }
-        }
+        Config config = Config.fromBase64(args[0]);

-        if (restoreStayOn != -1) {
-            Ln.i("Restoring \"stay awake\"");
-            try {
-                Settings.putValue(Settings.TABLE_GLOBAL, "stay_on_while_plugged_in", String.valueOf(restoreStayOn));
-            } catch (SettingsException e) {
-                Ln.e("Could not restore \"stay_on_while_plugged_in\"", e);
+        if (config.disableShowTouches || config.restoreStayOn != -1) {
+            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);
+                }
+            }
+            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 (Device.isScreenOn()) {
-            if (powerOffScreen) {
+            if (config.powerOffScreen) {
                Ln.i("Power off screen");
-                Device.powerOffScreen(displayId);
-            } else if (restoreNormalPowerMode) {
+                Device.powerOffScreen(config.displayId);
+            } else if (config.restoreNormalPowerMode) {
                Ln.i("Restoring normal power mode");
                Device.setScreenPowerMode(Device.POWER_MODE_NORMAL);
            }
        }
-
-        System.exit(0);
    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/ControlChannel.java
+++ b/server/src/main/java/com/genymobile/scrcpy/ControlChannel.java
@ -1,33 +0,0 @@
-package com.genymobile.scrcpy;
-
-import android.net.LocalSocket;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
-
-public final class ControlChannel {
-    private final InputStream inputStream;
-    private final OutputStream outputStream;
-
-    private final ControlMessageReader reader = new ControlMessageReader();
-    private final DeviceMessageWriter writer = new DeviceMessageWriter();
-
-    public ControlChannel(LocalSocket controlSocket) throws IOException {
-        this.inputStream = controlSocket.getInputStream();
-        this.outputStream = controlSocket.getOutputStream();
-    }
-
-    public ControlMessage recv() throws IOException {
-        ControlMessage msg = reader.next();
-        while (msg == null) {
-            reader.readFrom(inputStream);
-            msg = reader.next();
-        }
-        return msg;
-    }
-
-    public void send(DeviceMessage msg) throws IOException {
-        writer.writeTo(msg, outputStream);
-    }
-}
--- a/server/src/main/java/com/genymobile/scrcpy/Controller.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Controller.java
@ -27,8 +27,7 @@ public class Controller implements AsyncProcessor {
    private Thread thread;

    private final Device device;
-    private final ControlChannel controlChannel;
-    private final CleanUp cleanUp;
+    private final DesktopConnection connection;
    private final DeviceMessageSender sender;
    private final boolean clipboardAutosync;
    private final boolean powerOn;
@ -42,14 +41,13 @@ public class Controller implements AsyncProcessor {

    private boolean keepPowerModeOff;

-    public Controller(Device device, ControlChannel controlChannel, CleanUp cleanUp, boolean clipboardAutosync, boolean powerOn) {
+    public Controller(Device device, DesktopConnection connection, boolean clipboardAutosync, boolean powerOn) {
        this.device = device;
-        this.controlChannel = controlChannel;
-        this.cleanUp = cleanUp;
+        this.connection = connection;
        this.clipboardAutosync = clipboardAutosync;
        this.powerOn = powerOn;
        initPointers();
-        sender = new DeviceMessageSender(controlChannel);
+        sender = new DeviceMessageSender(connection);
    }

    private void initPointers() {
@ -123,7 +121,7 @@ public class Controller implements AsyncProcessor {
    }

    private void handleEvent() throws IOException {
-        ControlMessage msg = controlChannel.recv();
+        ControlMessage msg = connection.receiveControlMessage();
        switch (msg.getType()) {
            case ControlMessage.TYPE_INJECT_KEYCODE:
                if (device.supportsInputEvents()) {
@ -172,10 +170,6 @@ public class Controller implements AsyncProcessor {
                    if (setPowerModeOk) {
                        keepPowerModeOff = mode == Device.POWER_MODE_OFF;
                        Ln.i("Device screen turned " + (mode == Device.POWER_MODE_OFF ? "off" : "on"));
-                        if (cleanUp != null) {
-                            boolean mustRestoreOnExit = mode != Device.POWER_MODE_NORMAL;
-                            cleanUp.setRestoreNormalPowerMode(mustRestoreOnExit);
-                        }
                    }
                }
                break;
--- a/server/src/main/java/com/genymobile/scrcpy/DesktopConnection.java
+++ b/server/src/main/java/com/genymobile/scrcpy/DesktopConnection.java
@ -7,6 +7,8 @@ import android.net.LocalSocketAddress;
 import java.io.Closeable;
 import java.io.FileDescriptor;
 import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
 import java.nio.charset.StandardCharsets;

 public final class DesktopConnection implements Closeable {
@ -22,16 +24,25 @@ public final class DesktopConnection implements Closeable {
    private final FileDescriptor audioFd;

    private final LocalSocket controlSocket;
-    private final ControlChannel controlChannel;
+    private final InputStream controlInputStream;
+    private final OutputStream controlOutputStream;
+
+    private final ControlMessageReader reader = new ControlMessageReader();
+    private final DeviceMessageWriter writer = new DeviceMessageWriter();

    private DesktopConnection(LocalSocket videoSocket, LocalSocket audioSocket, LocalSocket controlSocket) throws IOException {
        this.videoSocket = videoSocket;
-        this.audioSocket = audioSocket;
        this.controlSocket = controlSocket;
-
+        this.audioSocket = audioSocket;
+        if (controlSocket != null) {
+            controlInputStream = controlSocket.getInputStream();
+            controlOutputStream = controlSocket.getOutputStream();
+        } else {
+            controlInputStream = null;
+            controlOutputStream = null;
+        }
        videoFd = videoSocket != null ? videoSocket.getFileDescriptor() : null;
        audioFd = audioSocket != null ? audioSocket.getFileDescriptor() : null;
-        controlChannel = controlSocket != null ? new ControlChannel(controlSocket) : null;
    }

    private static LocalSocket connect(String abstractName) throws IOException {
@ -168,7 +179,16 @@ public final class DesktopConnection implements Closeable {
        return audioFd;
    }

-    public ControlChannel getControlChannel() {
-        return controlChannel;
+    public ControlMessage receiveControlMessage() throws IOException {
+        ControlMessage msg = reader.next();
+        while (msg == null) {
+            reader.readFrom(controlInputStream);
+            msg = reader.next();
+        }
+        return msg;
+    }
+
+    public void sendDeviceMessage(DeviceMessage msg) throws IOException {
+        writer.writeTo(msg, controlOutputStream);
    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/Device.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Device.java
@ -45,11 +45,11 @@ public final class Device {
        void onClipboardTextChanged(String text);
    }

+    private final Size deviceSize;
    private final Rect crop;
    private int maxSize;
    private final int lockVideoOrientation;

-    private Size deviceSize;
    private ScreenInfo screenInfo;
    private RotationListener rotationListener;
    private FoldListener foldListener;
@ -116,8 +116,8 @@ public final class Device {
                            return;
                        }

-                        deviceSize = displayInfo.getSize();
-                        screenInfo = ScreenInfo.computeScreenInfo(displayInfo.getRotation(), deviceSize, crop, maxSize, lockVideoOrientation);
+                        screenInfo = ScreenInfo.computeScreenInfo(displayInfo.getRotation(), displayInfo.getSize(), options.getCrop(),
+                                options.getMaxSize(), options.getLockVideoOrientation());
                        // notify
                        if (foldListener != null) {
                            foldListener.onFoldChanged(displayId, folded);
--- a/server/src/main/java/com/genymobile/scrcpy/DeviceMessageSender.java
+++ b/server/src/main/java/com/genymobile/scrcpy/DeviceMessageSender.java
@ -4,7 +4,7 @@ import java.io.IOException;

 public final class DeviceMessageSender {

-    private final ControlChannel controlChannel;
+    private final DesktopConnection connection;

    private Thread thread;

@ -12,8 +12,8 @@ public final class DeviceMessageSender {

    private long ack;

-    public DeviceMessageSender(ControlChannel controlChannel) {
-        this.controlChannel = controlChannel;
+    public DeviceMessageSender(DesktopConnection connection) {
+        this.connection = connection;
    }

    public synchronized void pushClipboardText(String text) {
@ -43,11 +43,11 @@ public final class DeviceMessageSender {

            if (sequence != DeviceMessage.SEQUENCE_INVALID) {
                DeviceMessage event = DeviceMessage.createAckClipboard(sequence);
-                controlChannel.send(event);
+                connection.sendDeviceMessage(event);
            }
            if (text != null) {
                DeviceMessage event = DeviceMessage.createClipboard(text);
-                controlChannel.send(event);
+                connection.sendDeviceMessage(event);
            }
        }
    }
--- a/server/src/main/java/com/genymobile/scrcpy/Server.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Server.java
@ -51,47 +51,46 @@ public final class Server {
        // not instantiable
    }

-    private static void initAndCleanUp(Options options, CleanUp cleanUp) {
-        // This method is called from its own thread, so it may only configure cleanup actions which are NOT dynamic (i.e. they are configured once
-        // and for all, they cannot be changed from another thread)
-
-        if (options.getShowTouches()) {
-            try {
-                String oldValue = Settings.getAndPutValue(Settings.TABLE_SYSTEM, "show_touches", "1");
-                // If "show touches" was disabled, it must be disabled back on clean up
-                if (!"1".equals(oldValue)) {
-                    if (!cleanUp.setDisableShowTouches(true)) {
-                        Ln.e("Could not disable show touch on exit");
-                    }
-                }
-            } 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));
+    private static void initAndCleanUp(Options options) {
+        boolean mustDisableShowTouchesOnCleanUp = false;
+        int restoreStayOn = -1;
+        boolean restoreNormalPowerMode = options.getControl(); // only restore power mode if control is enabled
+        if (options.getShowTouches() || options.getStayAwake()) {
+            if (options.getShowTouches()) {
                try {
-                    int restoreStayOn = Integer.parseInt(oldValue);
-                    if (restoreStayOn != stayOn) {
-                        // Restore only if the current value is different
-                        if (!cleanUp.setRestoreStayOn(restoreStayOn)) {
-                            Ln.e("Could not restore stay on on exit");
-                        }
-                    }
-                } catch (NumberFormatException e) {
-                    // ignore
+                    String oldValue = Settings.getAndPutValue(Settings.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));
+                    try {
+                        restoreStayOn = Integer.parseInt(oldValue);
+                        if (restoreStayOn == stayOn) {
+                            // No need to restore
+                            restoreStayOn = -1;
+                        }
+                    } catch (NumberFormatException e) {
+                        restoreStayOn = 0;
+                    }
+                } catch (SettingsException e) {
+                    Ln.e("Could not change \"stay_on_while_plugged_in\"", e);
                }
-            } catch (SettingsException e) {
-                Ln.e("Could not change \"stay_on_while_plugged_in\"", e);
            }
        }

-        if (options.getPowerOffScreenOnClose()) {
-            if (!cleanUp.setPowerOffScreen(true)) {
-                Ln.e("Could not power off screen on exit");
+        if (options.getCleanup()) {
+            try {
+                CleanUp.configure(options.getDisplayId(), restoreStayOn, mustDisableShowTouchesOnCleanUp, restoreNormalPowerMode,
+                        options.getPowerOffScreenOnClose());
+            } catch (IOException e) {
+                Ln.e("Could not configure cleanup", e);
            }
        }
    }
@ -102,13 +101,7 @@ public final class Server {
            throw new ConfigurationException("Camera mirroring is not supported");
        }

-        CleanUp cleanUp = null;
-        Thread initThread = null;
-
-        if (options.getCleanup()) {
-            cleanUp = CleanUp.configure(options.getDisplayId());
-            initThread = startInitThread(options, cleanUp);
-        }
+        Thread initThread = startInitThread(options);

        int scid = options.getScid();
        boolean tunnelForward = options.isTunnelForward();
@ -131,8 +124,7 @@ public final class Server {
            }

            if (control) {
-                ControlChannel controlChannel = connection.getControlChannel();
-                Controller controller = new Controller(device, controlChannel, cleanUp, options.getClipboardAutosync(), options.getPowerOn());
+                Controller controller = new Controller(device, connection, options.getClipboardAutosync(), options.getPowerOn());
                device.setClipboardListener(text -> controller.getSender().pushClipboardText(text));
                asyncProcessors.add(controller);
            }
@ -175,9 +167,7 @@ public final class Server {

            completion.await();
        } finally {
-            if (initThread != null) {
-                initThread.interrupt();
-            }
+            initThread.interrupt();
            for (AsyncProcessor asyncProcessor : asyncProcessors) {
                asyncProcessor.stop();
            }
@ -185,9 +175,7 @@ public final class Server {
            connection.shutdown();

            try {
-                if (initThread != null) {
-                    initThread.join();
-                }
+                initThread.join();
                for (AsyncProcessor asyncProcessor : asyncProcessors) {
                    asyncProcessor.join();
                }
@ -199,8 +187,8 @@ public final class Server {
        }
    }

-    private static Thread startInitThread(final Options options, final CleanUp cleanUp) {
-        Thread thread = new Thread(() -> initAndCleanUp(options, cleanUp), "init-cleanup");
+    private static Thread startInitThread(final Options options) {
+        Thread thread = new Thread(() -> initAndCleanUp(options), "init-cleanup");
        thread.start();
        return thread;
    }
--- a/server/src/main/java/com/genymobile/scrcpy/Workarounds.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Workarounds.java
@ -285,28 +285,16 @@ public final class Workarounds {
                    Method getParcelMethod = attributionSourceState.getClass().getDeclaredMethod("getParcel");
                    Parcel attributionSourceParcel = (Parcel) getParcelMethod.invoke(attributionSourceState);

-                    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
-                        // private native int native_setup(Object audiorecordThis,
-                        // Object /*AudioAttributes*/ attributes,
-                        // int[] sampleRate, int channelMask, int channelIndexMask, int audioFormat,
-                        // int buffSizeInBytes, int[] sessionId, @NonNull Parcel attributionSource,
-                        // long nativeRecordInJavaObj, int maxSharedAudioHistoryMs);
-                        Method nativeSetupMethod = AudioRecord.class.getDeclaredMethod("native_setup", Object.class, Object.class, int[].class,
-                                int.class, int.class, int.class, int.class, int[].class, Parcel.class, long.class, int.class);
-                        nativeSetupMethod.setAccessible(true);
-                        initResult = (int) nativeSetupMethod.invoke(audioRecord, new WeakReference<AudioRecord>(audioRecord), attributes,
-                                sampleRateArray, channelMask, channelIndexMask, audioRecord.getAudioFormat(), bufferSizeInBytes, session,
-                                attributionSourceParcel, 0L, 0);
-                    } else {
-                        // Android 14 added a new int parameter "halInputFlags"
-                        // <https://github.com/aosp-mirror/platform_frameworks_base/commit/f6135d75db79b1d48fad3a3b3080d37be20a2313>
-                        Method nativeSetupMethod = AudioRecord.class.getDeclaredMethod("native_setup", Object.class, Object.class, int[].class,
-                                int.class, int.class, int.class, int.class, int[].class, Parcel.class, long.class, int.class, int.class);
-                        nativeSetupMethod.setAccessible(true);
-                        initResult = (int) nativeSetupMethod.invoke(audioRecord, new WeakReference<AudioRecord>(audioRecord), attributes,
-                                sampleRateArray, channelMask, channelIndexMask, audioRecord.getAudioFormat(), bufferSizeInBytes, session,
-                                attributionSourceParcel, 0L, 0, 0);
-                    }
+                    // private native int native_setup(Object audiorecordThis,
+                    // Object /*AudioAttributes*/ attributes,
+                    // int[] sampleRate, int channelMask, int channelIndexMask, int audioFormat,
+                    // int buffSizeInBytes, int[] sessionId, @NonNull Parcel attributionSource,
+                    // long nativeRecordInJavaObj, int maxSharedAudioHistoryMs);
+                    Method nativeSetupMethod = AudioRecord.class.getDeclaredMethod("native_setup", Object.class, Object.class, int[].class, int.class,
+                            int.class, int.class, int.class, int[].class, Parcel.class, long.class, int.class);
+                    nativeSetupMethod.setAccessible(true);
+                    initResult = (int) nativeSetupMethod.invoke(audioRecord, new WeakReference<AudioRecord>(audioRecord), attributes, sampleRateArray,
+                            channelMask, channelIndexMask, audioRecord.getAudioFormat(), bufferSizeInBytes, session, attributionSourceParcel, 0L, 0);
                }
            }

--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/ActivityManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/ActivityManager.java
@ -13,6 +13,7 @@ import android.os.IBinder;
 import android.os.IInterface;

 import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;

@SuppressLint("PrivateApi,DiscouragedPrivateApi")
@ -25,20 +26,7 @@ public final class ActivityManager {
    private Method startActivityAsUserWithFeatureMethod;
    private Method forceStopPackageMethod;

-    static ActivityManager create() {
-        try {
-            // On old Android versions, the ActivityManager is not exposed via AIDL,
-            // so use ActivityManagerNative.getDefault()
-            Class<?> cls = Class.forName("android.app.ActivityManagerNative");
-            Method getDefaultMethod = cls.getDeclaredMethod("getDefault");
-            IInterface am = (IInterface) getDefaultMethod.invoke(null);
-            return new ActivityManager(am);
-        } catch (ReflectiveOperationException e) {
-            throw new AssertionError(e);
-        }
-    }
-
-    private ActivityManager(IInterface manager) {
+    public ActivityManager(IInterface manager) {
        this.manager = manager;
    }

@ -88,7 +76,7 @@ public final class ActivityManager {
                return null;
            }
            return new ContentProvider(this, provider, name, token);
-        } catch (ReflectiveOperationException e) {
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException | NoSuchFieldException e) {
            Ln.e("Could not invoke method", e);
            return null;
        }
@ -98,7 +86,7 @@ public final class ActivityManager {
        try {
            Method method = getRemoveContentProviderExternalMethod();
            method.invoke(manager, name, token);
-        } catch (ReflectiveOperationException e) {
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
            Ln.e("Could not invoke method", e);
        }
    }
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/ClipboardManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/ClipboardManager.java
@ -8,6 +8,7 @@ import android.content.IOnPrimaryClipChangedListener;
 import android.os.Build;
 import android.os.IInterface;

+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;

 public final class ClipboardManager {
@ -19,18 +20,7 @@ public final class ClipboardManager {
    private int setMethodVersion;
    private int addListenerMethodVersion;

-    static ClipboardManager create() {
-        IInterface clipboard = ServiceManager.getService("clipboard", "android.content.IClipboard");
-        if (clipboard == null) {
-            // Some devices have no clipboard manager
-            // <https://github.com/Genymobile/scrcpy/issues/1440>
-            // <https://github.com/Genymobile/scrcpy/issues/1556>
-            return null;
-        }
-        return new ClipboardManager(clipboard);
-    }
-
-    private ClipboardManager(IInterface manager) {
+    public ClipboardManager(IInterface manager) {
        this.manager = manager;
    }

@ -51,21 +41,8 @@ public final class ClipboardManager {
                            getPrimaryClipMethod = manager.getClass().getMethod("getPrimaryClip", String.class, String.class, int.class, int.class);
                            getMethodVersion = 2;
                        } catch (NoSuchMethodException e3) {
-                            try {
-                                getPrimaryClipMethod = manager.getClass().getMethod("getPrimaryClip", String.class, int.class, String.class);
-                                getMethodVersion = 3;
-                            } catch (NoSuchMethodException e4) {
-                                try {
-                                    getPrimaryClipMethod = manager.getClass()
-                                            .getMethod("getPrimaryClip", String.class, String.class, int.class, int.class, boolean.class);
-                                    getMethodVersion = 4;
-                                } catch (NoSuchMethodException e5) {
-                                    getPrimaryClipMethod = manager.getClass()
-                                            .getMethod("getPrimaryClip", String.class, String.class, String.class, String.class, int.class, int.class,
-                                                    boolean.class);
-                                    getMethodVersion = 5;
-                                }
-                            }
+                            getPrimaryClipMethod = manager.getClass().getMethod("getPrimaryClip", String.class, int.class, String.class);
+                            getMethodVersion = 3;
                        }
                    }
                }
@ -87,15 +64,9 @@ public final class ClipboardManager {
                        setPrimaryClipMethod = manager.getClass().getMethod("setPrimaryClip", ClipData.class, String.class, String.class, int.class);
                        setMethodVersion = 1;
                    } catch (NoSuchMethodException e2) {
-                        try {
-                            setPrimaryClipMethod = manager.getClass()
-                                    .getMethod("setPrimaryClip", ClipData.class, String.class, String.class, int.class, int.class);
-                            setMethodVersion = 2;
-                        } catch (NoSuchMethodException e3) {
-                            setPrimaryClipMethod = manager.getClass()
-                                    .getMethod("setPrimaryClip", ClipData.class, String.class, String.class, int.class, int.class, boolean.class);
-                            setMethodVersion = 3;
-                        }
+                        setPrimaryClipMethod = manager.getClass()
+                                .getMethod("setPrimaryClip", ClipData.class, String.class, String.class, int.class, int.class);
+                        setMethodVersion = 2;
                    }
                }
            }
@ -103,7 +74,8 @@ public final class ClipboardManager {
        return setPrimaryClipMethod;
    }

-    private static ClipData getPrimaryClip(Method method, int methodVersion, IInterface manager) throws ReflectiveOperationException {
+    private static ClipData getPrimaryClip(Method method, int methodVersion, IInterface manager)
+            throws InvocationTargetException, IllegalAccessException {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
            return (ClipData) method.invoke(manager, FakeContext.PACKAGE_NAME);
        }
@ -115,17 +87,13 @@ public final class ClipboardManager {
                return (ClipData) method.invoke(manager, FakeContext.PACKAGE_NAME, null, FakeContext.ROOT_UID);
            case 2:
                return (ClipData) method.invoke(manager, FakeContext.PACKAGE_NAME, null, FakeContext.ROOT_UID, 0);
-            case 3:
-                return (ClipData) method.invoke(manager, FakeContext.PACKAGE_NAME, FakeContext.ROOT_UID, null);
-            case 4:
-                // The last boolean parameter is "userOperate"
-                return (ClipData) method.invoke(manager, FakeContext.PACKAGE_NAME, null, FakeContext.ROOT_UID, 0, true);
            default:
-                return (ClipData) method.invoke(manager, FakeContext.PACKAGE_NAME, null, null, null, FakeContext.ROOT_UID, 0, true);
+                return (ClipData) method.invoke(manager, FakeContext.PACKAGE_NAME, FakeContext.ROOT_UID, null);
        }
    }

-    private static void setPrimaryClip(Method method, int methodVersion, IInterface manager, ClipData clipData) throws ReflectiveOperationException {
+    private static void setPrimaryClip(Method method, int methodVersion, IInterface manager, ClipData clipData)
+            throws InvocationTargetException, IllegalAccessException {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
            method.invoke(manager, clipData, FakeContext.PACKAGE_NAME);
            return;
@ -138,12 +106,9 @@ public final class ClipboardManager {
            case 1:
                method.invoke(manager, clipData, FakeContext.PACKAGE_NAME, null, FakeContext.ROOT_UID);
                break;
-            case 2:
+            default:
                method.invoke(manager, clipData, FakeContext.PACKAGE_NAME, null, FakeContext.ROOT_UID, 0);
                break;
-            default:
-                // The last boolean parameter is "userOperate"
-                method.invoke(manager, clipData, FakeContext.PACKAGE_NAME, null, FakeContext.ROOT_UID, 0, true);
        }
    }

@ -155,7 +120,7 @@ public final class ClipboardManager {
                return null;
            }
            return clipData.getItemAt(0).getText();
-        } catch (ReflectiveOperationException e) {
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
            Ln.e("Could not invoke method", e);
            return null;
        }
@ -167,14 +132,14 @@ public final class ClipboardManager {
            ClipData clipData = ClipData.newPlainText(null, text);
            setPrimaryClip(method, setMethodVersion, manager, clipData);
            return true;
-        } catch (ReflectiveOperationException e) {
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
            Ln.e("Could not invoke method", e);
            return false;
        }
    }

    private static void addPrimaryClipChangedListener(Method method, int methodVersion, IInterface manager, IOnPrimaryClipChangedListener listener)
-            throws ReflectiveOperationException {
+            throws InvocationTargetException, IllegalAccessException {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
            method.invoke(manager, listener, FakeContext.PACKAGE_NAME);
            return;
@ -226,7 +191,7 @@ public final class ClipboardManager {
            Method method = getAddPrimaryClipChangedListener();
            addPrimaryClipChangedListener(method, addListenerMethodVersion, manager, listener);
            return true;
-        } catch (ReflectiveOperationException e) {
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
            Ln.e("Could not invoke method", e);
            return false;
        }
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/ContentProvider.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/ContentProvider.java
@ -11,6 +11,7 @@ import android.os.Bundle;
 import android.os.IBinder;

 import java.io.Closeable;
+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;

 public final class ContentProvider implements Closeable {
@ -41,6 +42,8 @@ public final class ContentProvider implements Closeable {
    private Method callMethod;
    private int callMethodVersion;

+    private Object attributionSource;
+
    ContentProvider(ActivityManager manager, Object provider, String name, IBinder token) {
        this.manager = manager;
        this.provider = provider;
@ -74,7 +77,8 @@ public final class ContentProvider implements Closeable {
        return callMethod;
    }

-    private Bundle call(String callMethod, String arg, Bundle extras) throws ReflectiveOperationException {
+    private Bundle call(String callMethod, String arg, Bundle extras)
+            throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        try {
            Method method = getCallMethod();
            Object[] args;
@ -95,7 +99,7 @@ public final class ContentProvider implements Closeable {
                }
            }
            return (Bundle) method.invoke(provider, args);
-        } catch (ReflectiveOperationException e) {
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
            Ln.e("Could not invoke method", e);
            throw e;
        }
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/DisplayControl.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/DisplayControl.java
@ -7,6 +7,7 @@ import android.annotation.TargetApi;
 import android.os.Build;
 import android.os.IBinder;

+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;

@SuppressLint({"PrivateApi", "SoonBlockedPrivateApi", "BlockedPrivateApi"})
@ -54,7 +55,7 @@ public final class DisplayControl {
        try {
            Method method = getGetPhysicalDisplayTokenMethod();
            return (IBinder) method.invoke(null, physicalDisplayId);
-        } catch (ReflectiveOperationException e) {
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
            Ln.e("Could not invoke method", e);
            return null;
        }
@ -71,7 +72,7 @@ public final class DisplayControl {
        try {
            Method method = getGetPhysicalDisplayIdsMethod();
            return (long[]) method.invoke(null);
-        } catch (ReflectiveOperationException e) {
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
            Ln.e("Could not invoke method", e);
            return null;
        }
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/DisplayManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/DisplayManager.java
@ -5,7 +5,6 @@ import com.genymobile.scrcpy.DisplayInfo;
 import com.genymobile.scrcpy.Ln;
 import com.genymobile.scrcpy.Size;

-import android.annotation.SuppressLint;
 import android.hardware.display.VirtualDisplay;
 import android.view.Display;
 import android.view.Surface;
@ -15,23 +14,11 @@ import java.lang.reflect.Method;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;

-@SuppressLint("PrivateApi,DiscouragedPrivateApi")
 public final class DisplayManager {
    private final Object manager; // instance of hidden class android.hardware.display.DisplayManagerGlobal
    private Method createVirtualDisplayMethod;

-    static DisplayManager create() {
-        try {
-            Class<?> clazz = Class.forName("android.hardware.display.DisplayManagerGlobal");
-            Method getInstanceMethod = clazz.getDeclaredMethod("getInstance");
-            Object dmg = getInstanceMethod.invoke(null);
-            return new DisplayManager(dmg);
-        } catch (ReflectiveOperationException e) {
-            throw new AssertionError(e);
-        }
-    }
-
-    private DisplayManager(Object manager) {
+    public DisplayManager(Object manager) {
        this.manager = manager;
    }

@ -77,7 +64,7 @@ public final class DisplayManager {
            try {
                Field filed = Display.class.getDeclaredField(flagString);
                flags |= filed.getInt(null);
-            } catch (ReflectiveOperationException e) {
+            } catch (NoSuchFieldException | IllegalAccessException e) {
                // Silently ignore, some flags reported by "dumpsys display" are @TestApi
            }
        }
@ -99,7 +86,7 @@ public final class DisplayManager {
            int layerStack = cls.getDeclaredField("layerStack").getInt(displayInfo);
            int flags = cls.getDeclaredField("flags").getInt(displayInfo);
            return new DisplayInfo(displayId, new Size(width, height), rotation, layerStack, flags);
-        } catch (ReflectiveOperationException e) {
+        } catch (Exception e) {
            throw new AssertionError(e);
        }
    }
@ -107,7 +94,7 @@ public final class DisplayManager {
    public int[] getDisplayIds() {
        try {
            return (int[]) manager.getClass().getMethod("getDisplayIds").invoke(manager);
-        } catch (ReflectiveOperationException e) {
+        } catch (Exception e) {
            throw new AssertionError(e);
        }
    }
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/InputManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/InputManager.java
@ -2,13 +2,12 @@ package com.genymobile.scrcpy.wrappers;

 import com.genymobile.scrcpy.Ln;

-import android.annotation.SuppressLint;
 import android.view.InputEvent;
 import android.view.MotionEvent;

+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;

-@SuppressLint("PrivateApi,DiscouragedPrivateApi")
 public final class InputManager {

    public static final int INJECT_INPUT_EVENT_MODE_ASYNC = 0;
@ -21,27 +20,7 @@ public final class InputManager {
    private static Method setDisplayIdMethod;
    private static Method setActionButtonMethod;

-    static InputManager create() {
-        try {
-            Class<?> inputManagerClass = getInputManagerClass();
-            Method getInstanceMethod = inputManagerClass.getDeclaredMethod("getInstance");
-            Object im = getInstanceMethod.invoke(null);
-            return new InputManager(im);
-        } catch (ReflectiveOperationException e) {
-            throw new AssertionError(e);
-        }
-    }
-
-    private static Class<?> getInputManagerClass() {
-        try {
-            // Parts of the InputManager class have been moved to a new InputManagerGlobal class in Android 14 preview
-            return Class.forName("android.hardware.input.InputManagerGlobal");
-        } catch (ClassNotFoundException e) {
-            return android.hardware.input.InputManager.class;
-        }
-    }
-
-    private InputManager(Object manager) {
+    public InputManager(Object manager) {
        this.manager = manager;
    }

@ -56,7 +35,7 @@ public final class InputManager {
        try {
            Method method = getInjectInputEventMethod();
            return (boolean) method.invoke(manager, inputEvent, mode);
-        } catch (ReflectiveOperationException e) {
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
            Ln.e("Could not invoke method", e);
            return false;
        }
@ -74,7 +53,7 @@ public final class InputManager {
            Method method = getSetDisplayIdMethod();
            method.invoke(inputEvent, displayId);
            return true;
-        } catch (ReflectiveOperationException e) {
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
            Ln.e("Cannot associate a display id to the input event", e);
            return false;
        }
@ -92,7 +71,7 @@ public final class InputManager {
            Method method = getSetActionButtonMethod();
            method.invoke(motionEvent, actionButton);
            return true;
-        } catch (ReflectiveOperationException e) {
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
            Ln.e("Cannot set action button on MotionEvent", e);
            return false;
        }
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/PowerManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/PowerManager.java
@ -6,18 +6,14 @@ import android.annotation.SuppressLint;
 import android.os.Build;
 import android.os.IInterface;

+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;

 public final class PowerManager {
    private final IInterface manager;
    private Method isScreenOnMethod;

-    static PowerManager create() {
-        IInterface manager = ServiceManager.getService("power", "android.os.IPowerManager");
-        return new PowerManager(manager);
-    }
-
-    private PowerManager(IInterface manager) {
+    public PowerManager(IInterface manager) {
        this.manager = manager;
    }

@ -34,7 +30,7 @@ public final class PowerManager {
        try {
            Method method = getIsScreenOnMethod();
            return (boolean) method.invoke(manager);
-        } catch (ReflectiveOperationException e) {
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
            Ln.e("Could not invoke method", e);
            return false;
        }
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/ServiceManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/ServiceManager.java
@ -9,6 +9,7 @@ import android.os.IBinder;
 import android.os.IInterface;

 import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;

@SuppressLint("PrivateApi,DiscouragedPrivateApi")
@ -37,7 +38,7 @@ public final class ServiceManager {
        /* not instantiable */
    }

-    static IInterface getService(String service, String type) {
+    private static IInterface getService(String service, String type) {
        try {
            IBinder binder = (IBinder) GET_SERVICE_METHOD.invoke(null, service);
            Method asInterfaceMethod = Class.forName(type + "$Stub").getMethod("asInterface", IBinder.class);
@ -49,51 +50,90 @@ public final class ServiceManager {

    public static WindowManager getWindowManager() {
        if (windowManager == null) {
-            windowManager = WindowManager.create();
+            windowManager = new WindowManager(getService("window", "android.view.IWindowManager"));
        }
        return windowManager;
    }

    public static DisplayManager getDisplayManager() {
        if (displayManager == null) {
-            displayManager = DisplayManager.create();
+            try {
+                Class<?> clazz = Class.forName("android.hardware.display.DisplayManagerGlobal");
+                Method getInstanceMethod = clazz.getDeclaredMethod("getInstance");
+                Object dmg = getInstanceMethod.invoke(null);
+                displayManager = new DisplayManager(dmg);
+            } catch (ClassNotFoundException | NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
+                throw new AssertionError(e);
+            }
        }
        return displayManager;
    }

+    public static Class<?> getInputManagerClass() {
+        try {
+            // Parts of the InputManager class have been moved to a new InputManagerGlobal class in Android 14 preview
+            return Class.forName("android.hardware.input.InputManagerGlobal");
+        } catch (ClassNotFoundException e) {
+            return android.hardware.input.InputManager.class;
+        }
+    }
+
    public static InputManager getInputManager() {
        if (inputManager == null) {
-            inputManager = InputManager.create();
+            try {
+                Class<?> inputManagerClass = getInputManagerClass();
+                Method getInstanceMethod = inputManagerClass.getDeclaredMethod("getInstance");
+                Object im = getInstanceMethod.invoke(null);
+                inputManager = new InputManager(im);
+            } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
+                throw new AssertionError(e);
+            }
        }
        return inputManager;
    }

    public static PowerManager getPowerManager() {
        if (powerManager == null) {
-            powerManager = PowerManager.create();
+            powerManager = new PowerManager(getService("power", "android.os.IPowerManager"));
        }
        return powerManager;
    }

    public static StatusBarManager getStatusBarManager() {
        if (statusBarManager == null) {
-            statusBarManager = StatusBarManager.create();
+            statusBarManager = new StatusBarManager(getService("statusbar", "com.android.internal.statusbar.IStatusBarService"));
        }
        return statusBarManager;
    }

    public static ClipboardManager getClipboardManager() {
        if (clipboardManager == null) {
-            // May be null, some devices have no clipboard manager
-            clipboardManager = ClipboardManager.create();
+            IInterface clipboard = getService("clipboard", "android.content.IClipboard");
+            if (clipboard == null) {
+                // Some devices have no clipboard manager
+                // <https://github.com/Genymobile/scrcpy/issues/1440>
+                // <https://github.com/Genymobile/scrcpy/issues/1556>
+                return null;
+            }
+            clipboardManager = new ClipboardManager(clipboard);
        }
        return clipboardManager;
    }

    public static ActivityManager getActivityManager() {
        if (activityManager == null) {
-            activityManager = ActivityManager.create();
+            try {
+                // On old Android versions, the ActivityManager is not exposed via AIDL,
+                // so use ActivityManagerNative.getDefault()
+                Class<?> cls = Class.forName("android.app.ActivityManagerNative");
+                Method getDefaultMethod = cls.getDeclaredMethod("getDefault");
+                IInterface am = (IInterface) getDefaultMethod.invoke(null);
+                activityManager = new ActivityManager(am);
+            } catch (Exception e) {
+                throw new AssertionError(e);
+            }
        }
+
        return activityManager;
    }

--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/StatusBarManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/StatusBarManager.java
@ -4,6 +4,7 @@ import com.genymobile.scrcpy.Ln;

 import android.os.IInterface;

+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;

 public final class StatusBarManager {
@ -15,12 +16,7 @@ public final class StatusBarManager {
    private boolean expandSettingsPanelMethodNewVersion = true;
    private Method collapsePanelsMethod;

-    static StatusBarManager create() {
-        IInterface manager = ServiceManager.getService("statusbar", "com.android.internal.statusbar.IStatusBarService");
-        return new StatusBarManager(manager);
-    }
-
-    private StatusBarManager(IInterface manager) {
+    public StatusBarManager(IInterface manager) {
        this.manager = manager;
    }

@ -66,7 +62,7 @@ public final class StatusBarManager {
            } else {
                method.invoke(manager);
            }
-        } catch (ReflectiveOperationException e) {
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
            Ln.e("Could not invoke method", e);
        }
    }
@ -81,7 +77,7 @@ public final class StatusBarManager {
                // old version
                method.invoke(manager);
            }
-        } catch (ReflectiveOperationException e) {
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
            Ln.e("Could not invoke method", e);
        }
    }
@ -90,7 +86,7 @@ public final class StatusBarManager {
        try {
            Method method = getCollapsePanelsMethod();
            method.invoke(manager);
-        } catch (ReflectiveOperationException e) {
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
            Ln.e("Could not invoke method", e);
        }
    }
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/SurfaceControl.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/SurfaceControl.java
@ -8,6 +8,7 @@ import android.os.Build;
 import android.os.IBinder;
 import android.view.Surface;

+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;

@SuppressLint("PrivateApi")
@ -104,7 +105,7 @@ public final class SurfaceControl {

            // call getInternalDisplayToken()
            return (IBinder) method.invoke(null);
-        } catch (ReflectiveOperationException e) {
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
            Ln.e("Could not invoke method", e);
            return null;
        }
@ -121,7 +122,7 @@ public final class SurfaceControl {
        try {
            Method method = getGetPhysicalDisplayTokenMethod();
            return (IBinder) method.invoke(null, physicalDisplayId);
-        } catch (ReflectiveOperationException e) {
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
            Ln.e("Could not invoke method", e);
            return null;
        }
@ -147,7 +148,7 @@ public final class SurfaceControl {
        try {
            Method method = getGetPhysicalDisplayIdsMethod();
            return (long[]) method.invoke(null);
-        } catch (ReflectiveOperationException e) {
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
            Ln.e("Could not invoke method", e);
            return null;
        }
@ -165,7 +166,7 @@ public final class SurfaceControl {
            Method method = getSetDisplayPowerModeMethod();
            method.invoke(null, displayToken, mode);
            return true;
-        } catch (ReflectiveOperationException e) {
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
            Ln.e("Could not invoke method", e);
            return false;
        }
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/WindowManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/WindowManager.java
@ -7,6 +7,7 @@ import android.os.IInterface;
 import android.view.IDisplayFoldListener;
 import android.view.IRotationWatcher;

+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;

 public final class WindowManager {
@ -16,12 +17,7 @@ public final class WindowManager {
    private Method isRotationFrozenMethod;
    private Method thawRotationMethod;

-    static WindowManager create() {
-        IInterface manager = ServiceManager.getService("window", "android.view.IWindowManager");
-        return new WindowManager(manager);
-    }
-
-    private WindowManager(IInterface manager) {
+    public WindowManager(IInterface manager) {
        this.manager = manager;
    }

@ -65,7 +61,7 @@ public final class WindowManager {
        try {
            Method method = getGetRotationMethod();
            return (int) method.invoke(manager);
-        } catch (ReflectiveOperationException e) {
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
            Ln.e("Could not invoke method", e);
            return 0;
        }
@ -75,7 +71,7 @@ public final class WindowManager {
        try {
            Method method = getFreezeRotationMethod();
            method.invoke(manager, rotation);
-        } catch (ReflectiveOperationException e) {
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
            Ln.e("Could not invoke method", e);
        }
    }
@ -84,7 +80,7 @@ public final class WindowManager {
        try {
            Method method = getIsRotationFrozenMethod();
            return (boolean) method.invoke(manager);
-        } catch (ReflectiveOperationException e) {
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
            Ln.e("Could not invoke method", e);
            return false;
        }
@ -94,7 +90,7 @@ public final class WindowManager {
        try {
            Method method = getThawRotationMethod();
            method.invoke(manager);
-        } catch (ReflectiveOperationException e) {
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
            Ln.e("Could not invoke method", e);
        }
    }