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>

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" />

app/data/bash-completion/scrcpy

@@ -27,9 +27,8 @@ _scrcpy() {
         --force-adb-forward
         --forward-all-clicks
         -h --help
-        -K
-        --keyboard
         --kill-adb-on-close
+        -K --hid-keyboard
         --legacy-paste
         --list-camera-sizes
         --list-cameras
@@ -38,9 +37,8 @@ _scrcpy() {
         --lock-video-orientation
         --lock-video-orientation=
         -m --max-size=
-        -M
+        -M --hid-mouse
         --max-fps=
-        --mouse=
         -n --no-control
         -N --no-playback
         --no-audio
@@ -117,20 +115,13 @@ _scrcpy() {
             COMPREPLY=($(compgen -W 'front back external' -- "$cur"))
             return
             ;;
-        --keyboard)
-            COMPREPLY=($(compgen -W 'disabled sdk aoa uhid' -- "$cur"))
-            return
-            ;;
-        --mouse)
-            COMPREPLY=($(compgen -W 'disabled sdk aoa uhid' -- "$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)

app/data/zsh-completion/_scrcpy

@@ -34,9 +34,8 @@ arguments=(
     '--force-adb-forward[Do not attempt to use \"adb reverse\" to connect to the device]'
     '--forward-all-clicks[Forward clicks to device]'
     {-h,--help}'[Print the help]'
-    '-K[Use UHID keyboard (same as --keyboard=uhid)]'
-    '--keyboard[Set the keyboard input mode]:mode:(disabled sdk aoa uhid)'
     '--kill-adb-on-close[Kill adb when scrcpy terminates]'
+    {-K,--hid-keyboard}'[Simulate a physical keyboard by using HID over AOAv2]'
     '--legacy-paste[Inject computer clipboard text as a sequence of key events on Ctrl+v]'
     '--list-camera-sizes[List the valid camera capture sizes]'
     '--list-cameras[List cameras available on the device]'
@@ -44,9 +43,8 @@ arguments=(
     '--list-encoders[List video and audio encoders available on the device]'
     '--lock-video-orientation=[Lock video orientation]:orientation:(unlocked initial 0 90 180 270)'
     {-m,--max-size=}'[Limit both the width and height of the video to value]'
-    '-M[Use UHID mouse (same as --mouse=uhid)]'
+    {-M,--hid-mouse}'[Simulate a physical mouse by using HID over AOAv2]'
     '--max-fps=[Limit the frame rate of screen capture]'
-    '--mouse[Set the mouse input mode]:mode:(disabled sdk aoa uhid)'
     {-n,--no-control}'[Disable device control \(mirror the device in read only\)]'
     {-N,--no-playback}'[Disable video and audio playback]'
     '--no-audio[Disable audio forwarding]'

app/meson.build

@@ -20,8 +20,8 @@ src = [
     'src/fps_counter.c',
     'src/frame_buffer.c',
     'src/input_manager.c',
-    'src/keyboard_sdk.c',
-    'src/mouse_sdk.c',
+    'src/keyboard_inject.c',
+    'src/mouse_inject.c',
     'src/opengl.c',
     'src/options.c',
     'src/packet_merger.c',
@@ -31,16 +31,11 @@ src = [
     'src/screen.c',
     'src/server.c',
     'src/version.c',
-    'src/hid/hid_keyboard.c',
-    'src/hid/hid_mouse.c',
     'src/trait/frame_source.c',
     'src/trait/packet_source.c',
-    'src/uhid/keyboard_uhid.c',
-    'src/uhid/mouse_uhid.c',
-    'src/uhid/uhid_output.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',
@@ -93,8 +88,8 @@ usb_support = get_option('usb')
 if usb_support
     src += [
         'src/usb/aoa_hid.c',
-        'src/usb/keyboard_aoa.c',
-        'src/usb/mouse_aoa.c',
+        'src/usb/hid_keyboard.c',
+        'src/usb/hid_mouse.c',
         'src/usb/scrcpy_otg.c',
         'src/usb/screen_otg.c',
         'src/usb/usb.c',
@@ -217,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',

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
@@ -172,33 +172,24 @@ By default, right-click triggers BACK (or POWER on) and middle-click triggers HO
 Print this help.
 
 .TP
-.B \-K
-Same as \fB\-\-keyboard=uhid\fR.
+.B \-\-kill\-adb\-on\-close
+Kill adb when scrcpy terminates.
 
 .TP
-.BI "\-\-keyboard " mode
-Select how to send keyboard inputs to the device.
+.B \-K, \-\-hid\-keyboard
+Simulate a physical keyboard by using HID over AOAv2.
 
-Possible values are "disabled", "sdk" and "aoa":
+This provides a better experience for IME users, and allows to generate non-ASCII characters, contrary to the default injection method.
 
- - "disabled" does not send keyboard inputs to the device.
- - "sdk" uses the Android system API to deliver keyboard events to applications.
- - "aoa" simulates a physical HID keyboard using the AOAv2 protocol. It may only work over USB.
- - "uhid" simulates a physical HID keyboard using the Linux HID kernel module on the device.
+It may only work over USB.
 
-For "aoa" and "uhid", the keyboard layout must be configured (once and for all) on the device, via Settings -> System -> Languages and input -> Physical keyboard. This settings page can be started directly using the shortcut MOD+k (except in OTG mode) or by executing:
+The keyboard layout must be configured (once and for all) on the device, via Settings -> System -> Languages and input -> Physical keyboard. This settings page can be started directly:
 
     adb shell am start -a android.settings.HARD_KEYBOARD_SETTINGS
 
-If mirroring is enabled, the shortcot MOD+k opens it.
+However, the option is only available when the HID keyboard is enabled (or a physical keyboard is connected).
 
-This option is only available when the HID keyboard is enabled (or a physical keyboard is connected).
-
-Also see \fB\-\-mouse\fR.
-
-.TP
-.B \-\-kill\-adb\-on\-close
-Kill adb when scrcpy terminates.
+Also see \fB\-\-hid\-mouse\fR.
 
 .TP
 .B \-\-legacy\-paste
@@ -239,31 +230,21 @@ Limit both the width and height of the video to \fIvalue\fR. The other dimension
 Default is 0 (unlimited).
 
 .TP
-.B \-M
-Same as \fB\-\-mouse=uhid\fR.
+.B \-M, \-\-hid\-mouse
+Simulate a physical mouse by using HID over AOAv2.
+
+In this mode, the computer mouse is captured to control the device directly (relative mouse mode).
+
+LAlt, LSuper or RSuper toggle the capture mode, to give control of the mouse back to the computer.
+
+It may only work over USB.
+
+Also see \fB\-\-hid\-keyboard\fR.
 
 .TP
 .BI "\-\-max\-fps " value
 Limit the framerate of screen capture (officially supported since Android 10, but may work on earlier versions).
 
-.TP
-.BI "\-\-mouse " mode
-Select how to send mouse inputs to the device.
-
-Possible values are "disabled", "sdk" and "aoa":
-
- - "disabled" does not send mouse inputs to the device.
- - "sdk" uses the Android system API to deliver mouse events to applications.
- - "aoa" simulates a physical mouse using the AOAv2 protocol. It may only work over USB.
- - "uhid" simulates a physical HID mouse using the Linux HID kernel module on the device.
-
-In "aoa" and "uhid" modes, the computer mouse is captured to control the device directly (relative mouse mode).
-
-LAlt, LSuper or RSuper toggle the capture mode, to give control of the mouse back to the computer.
-
-Also see \fB\-\-keyboard\fR.
-
-
 .TP
 .B \-n, \-\-no\-control
 Disable device control (mirror the device in read\-only).
@@ -655,21 +636,13 @@ Copy computer clipboard to device, then paste (inject PASTE keycode, Android >=
 .B MOD+Shift+v
 Inject computer clipboard text as a sequence of key events
 
-.TP
-.B MOD+k
-Open keyboard settings on the device (for HID keyboard only)
-
 .TP
 .B MOD+i
 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

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;
     }
 

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

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;

app/src/cli.c

@@ -93,10 +93,6 @@ enum {
     OPT_DISPLAY_ORIENTATION,
     OPT_RECORD_ORIENTATION,
     OPT_ORIENTATION,
-    OPT_KEYBOARD,
-    OPT_MOUSE,
-    OPT_HID_KEYBOARD_DEPRECATED,
-    OPT_HID_MOUSE_DEPRECATED,
 };
 
 struct sc_option {
@@ -362,44 +358,27 @@ static const struct sc_option options[] = {
         .longopt = "help",
         .text = "Print this help.",
     },
-    {
-        .shortopt = 'K',
-        .text = "Same as --keyboard=uhid.",
-    },
-    {
-        .longopt_id = OPT_KEYBOARD,
-        .longopt = "keyboard",
-        .argdesc = "mode",
-        .text = "Select how to send keyboard inputs to the device.\n"
-                "Possible values are \"disabled\", \"sdk\", \"aoa\" and "
-                "\"uhid\".\n"
-                "\"disabled\" does not send keyboard inputs to the device.\n"
-                "\"sdk\" uses the Android system API to deliver keyboard\n"
-                "events to applications.\n"
-                "\"aoa\" simulates a physical HID keyboard using the AOAv2\n"
-                "protocol. It may only work over USB.\n"
-                "\"uhid\" simulates a physical HID keyboard using the Linux "
-                "UHID kernel module on the device."
-                "For \"aoa\" and \"uhid\", the keyboard layout must be "
-                "configured (once and for all) on the device, via Settings -> "
-                "System -> Languages and input -> Physical keyboard. This "
-                "settings page can be started directly using the shortcut "
-                "MOD+k (except in OTG mode) or by executing: `adb shell am "
-                "start -a android.settings.HARD_KEYBOARD_SETTINGS`.\n"
-                "This option is only available when a HID keyboard is enabled "
-                "enabled (or a physical keyboard is connected).\n"
-                "Also see --mouse.",
-    },
     {
         .longopt_id = OPT_KILL_ADB_ON_CLOSE,
         .longopt = "kill-adb-on-close",
         .text = "Kill adb when scrcpy terminates.",
     },
     {
-        // deprecated
-        //.shortopt = 'K', // old, reassigned
-        .longopt_id = OPT_HID_KEYBOARD_DEPRECATED,
+        .shortopt = 'K',
         .longopt = "hid-keyboard",
+        .text = "Simulate a physical keyboard by using HID over AOAv2.\n"
+                "It provides a better experience for IME users, and allows to "
+                "generate non-ASCII characters, contrary to the default "
+                "injection method.\n"
+                "It may only work over USB.\n"
+                "The keyboard layout must be configured (once and for all) on "
+                "the device, via Settings -> System -> Languages and input -> "
+                "Physical keyboard. This settings page can be started "
+                "directly: `adb shell am start -a "
+                "android.settings.HARD_KEYBOARD_SETTINGS`.\n"
+                "However, the option is only available when the HID keyboard "
+                "is enabled (or a physical keyboard is connected).\n"
+                "Also see --hid-mouse.",
     },
     {
         .longopt_id = OPT_LEGACY_PASTE,
@@ -452,15 +431,16 @@ static const struct sc_option options[] = {
                 "is preserved.\n"
                 "Default is 0 (unlimited).",
     },
-    {
-        // deprecated
-        //.shortopt = 'M', // old, reassigned
-        .longopt_id = OPT_HID_MOUSE_DEPRECATED,
-        .longopt = "hid-mouse",
-    },
     {
         .shortopt = 'M',
-        .text = "Same as --mouse=uhid.",
+        .longopt = "hid-mouse",
+        .text = "Simulate a physical mouse by using HID over AOAv2.\n"
+                "In this mode, the computer mouse is captured to control the "
+                "device directly (relative mouse mode).\n"
+                "LAlt, LSuper or RSuper toggle the capture mode, to give "
+                "control of the mouse back to the computer.\n"
+                "It may only work over USB.\n"
+                "Also see --hid-keyboard.",
     },
     {
         .longopt_id = OPT_MAX_FPS,
@@ -469,25 +449,6 @@ static const struct sc_option options[] = {
         .text = "Limit the frame rate of screen capture (officially supported "
                 "since Android 10, but may work on earlier versions).",
     },
-    {
-        .longopt_id = OPT_MOUSE,
-        .longopt = "mouse",
-        .argdesc = "mode",
-        .text = "Select how to send mouse inputs to the device.\n"
-                "Possible values are \"disabled\", \"sdk\" and \"aoa\".\n"
-                "\"disabled\" does not send mouse inputs to the device.\n"
-                "\"sdk\" uses the Android system API to deliver mouse\n"
-                "events to applications.\n"
-                "\"aoa\" simulates a physical mouse using the AOAv2 protocol\n"
-                "It may only work over USB.\n"
-                "\"uhid\" simulates a physical HID mouse using the Linux UHID "
-                "kernel module on the device."
-                "In \"aoa\" and \"uhid\" modes, the computer mouse is captured "
-                "to control the device directly (relative mouse mode).\n"
-                "LAlt, LSuper or RSuper toggle the capture mode, to give "
-                "control of the mouse back to the computer.\n"
-                "Also see --keyboard.",
-    },
     {
         .shortopt = 'n',
         .longopt = "no-control",
@@ -582,10 +543,10 @@ static const struct sc_option options[] = {
                 "mirroring is disabled.\n"
                 "LAlt, LSuper or RSuper toggle the mouse capture mode, to give "
                 "control of the mouse back to the computer.\n"
-                "Keyboard and mouse may be disabled separately using\n"
-                "--keyboard=disabled and --mouse=disabled.\n"
+                "If any of --hid-keyboard or --hid-mouse is set, only enable "
+                "keyboard or mouse respectively, otherwise enable both.\n"
                 "It may only work over USB.\n"
-                "See --keyboard and --mouse.",
+                "See --hid-keyboard and --hid-mouse.",
     },
     {
         .shortopt = 'p',
@@ -980,21 +941,13 @@ static const struct sc_shortcut shortcuts[] = {
         .shortcuts = { "MOD+Shift+v" },
         .text = "Inject computer clipboard text as a sequence of key events",
     },
-    {
-        .shortcuts = { "MOD+k" },
-        .text = "Open keyboard settings on the device (for HID keyboard only)",
-    },
     {
         .shortcuts = { "MOD+i" },
         .text = "Enable/disable FPS counter (print frames/second in logs)",
     },
     {
         .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" },
@@ -1428,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;
@@ -1949,69 +1898,6 @@ parse_camera_fps(const char *s, uint16_t *camera_fps) {
     return true;
 }
 
-static bool
-parse_keyboard(const char *optarg, enum sc_keyboard_input_mode *mode) {
-    if (!strcmp(optarg, "disabled")) {
-        *mode = SC_KEYBOARD_INPUT_MODE_DISABLED;
-        return true;
-    }
-
-    if (!strcmp(optarg, "sdk")) {
-        *mode = SC_KEYBOARD_INPUT_MODE_SDK;
-        return true;
-    }
-
-    if (!strcmp(optarg, "aoa")) {
-#ifdef HAVE_USB
-        *mode = SC_KEYBOARD_INPUT_MODE_AOA;
-        return true;
-#else
-        LOGE("--keyboard=aoa is disabled.");
-        return false;
-#endif
-    }
-
-    if (!strcmp(optarg, "uhid")) {
-        *mode = SC_KEYBOARD_INPUT_MODE_UHID;
-        return true;
-    }
-
-    LOGE("Unsupported keyboard: %s (expected disabled, sdk, aoa or uhid)",
-         optarg);
-    return false;
-}
-
-static bool
-parse_mouse(const char *optarg, enum sc_mouse_input_mode *mode) {
-    if (!strcmp(optarg, "disabled")) {
-        *mode = SC_MOUSE_INPUT_MODE_DISABLED;
-        return true;
-    }
-
-    if (!strcmp(optarg, "sdk")) {
-        *mode = SC_MOUSE_INPUT_MODE_SDK;
-        return true;
-    }
-
-    if (!strcmp(optarg, "aoa")) {
-#ifdef HAVE_USB
-        *mode = SC_MOUSE_INPUT_MODE_AOA;
-        return true;
-#else
-        LOGE("--mouse=aoa is disabled.");
-        return false;
-#endif
-    }
-
-    if (!strcmp(optarg, "uhid")) {
-        *mode = SC_MOUSE_INPUT_MODE_UHID;
-        return true;
-    }
-
-    LOGE("Unsupported mouse: %s (expected disabled, sdk, aoa or uhid)", optarg);
-    return false;
-}
-
 static bool
 parse_time_limit(const char *s, sc_tick *tick) {
     long value;
@@ -2100,17 +1986,13 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
                 args->help = true;
                 break;
             case 'K':
-                opts->keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_UHID;
+#ifdef HAVE_USB
+                opts->keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_HID;
                 break;
-            case OPT_KEYBOARD:
-                if (!parse_keyboard(optarg, &opts->keyboard_input_mode)) {
-                    return false;
-                }
-                break;
-            case OPT_HID_KEYBOARD_DEPRECATED:
-                LOGE("--hid-keyboard has been removed, use --keyboard=aoa or "
-                     "--keyboard=uhid instead.");
+#else
+                LOGE("HID over AOA (-K/--hid-keyboard) is disabled.");
                 return false;
+#endif
             case OPT_MAX_FPS:
                 if (!parse_max_fps(optarg, &opts->max_fps)) {
                     return false;
@@ -2122,17 +2004,13 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
                 }
                 break;
             case 'M':
-                opts->mouse_input_mode = SC_MOUSE_INPUT_MODE_UHID;
+#ifdef HAVE_USB
+                opts->mouse_input_mode = SC_MOUSE_INPUT_MODE_HID;
                 break;
-            case OPT_MOUSE:
-                if (!parse_mouse(optarg, &opts->mouse_input_mode)) {
-                    return false;
-                }
-                break;
-            case OPT_HID_MOUSE_DEPRECATED:
-                LOGE("--hid-mouse has been removed, use --mouse=aoa or "
-                     "--mouse=uhid instead.");
+#else
+                LOGE("HID over AOA (-M/--hid-mouse) is disabled.");
                 return false;
+#endif
             case OPT_LOCK_VIDEO_ORIENTATION:
                 if (!parse_lock_video_orientation(optarg,
                         &opts->lock_video_orientation)) {
@@ -2516,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) {
@@ -2579,31 +2455,6 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
     }
 #endif
 
-    if (opts->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_AUTO) {
-        opts->keyboard_input_mode = otg ? SC_KEYBOARD_INPUT_MODE_AOA
-                                        : SC_KEYBOARD_INPUT_MODE_SDK;
-    }
-    if (opts->mouse_input_mode == SC_MOUSE_INPUT_MODE_AUTO) {
-        opts->mouse_input_mode = otg ? SC_MOUSE_INPUT_MODE_AOA
-                                     : SC_MOUSE_INPUT_MODE_SDK;
-    }
-
-    if (otg) {
-        enum sc_keyboard_input_mode kmode = opts->keyboard_input_mode;
-        if (kmode != SC_KEYBOARD_INPUT_MODE_AOA
-                && kmode != SC_KEYBOARD_INPUT_MODE_DISABLED) {
-            LOGE("In OTG mode, --keyboard only supports aoa or disabled.");
-            return false;
-        }
-
-        enum sc_mouse_input_mode mmode = opts->mouse_input_mode;
-        if (mmode != SC_MOUSE_INPUT_MODE_AOA
-                && mmode != SC_MOUSE_INPUT_MODE_DISABLED) {
-            LOGE("In OTG mode, --mouse only supports aoa or disabled.");
-            return false;
-        }
-    }
-
     if ((opts->tunnel_host || opts->tunnel_port) && !opts->force_adb_forward) {
         LOGI("Tunnel host/port is set, "
              "--force-adb-forward automatically enabled.");
@@ -2764,12 +2615,12 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
     }
 
 # ifdef _WIN32
-    if (!otg && (opts->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_AOA
-                || opts->mouse_input_mode == SC_MOUSE_INPUT_MODE_AOA)) {
+    if (!otg && (opts->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_HID
+                || opts->mouse_input_mode == SC_MOUSE_INPUT_MODE_HID)) {
         LOGE("On Windows, it is not possible to open a USB device already open "
              "by another process (like adb).");
-        LOGE("Therefore, --keyboard=aoa and --mouse=aoa may only work in OTG"
-             "mode (--otg).");
+        LOGE("Therefore, -K/--hid-keyboard and -M/--hid-mouse may only work in "
+             "OTG mode (--otg).");
         return false;
     }
 # endif

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:
@@ -146,25 +146,10 @@ sc_control_msg_serialize(const struct sc_control_msg *msg, uint8_t *buf) {
         case SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE:
             buf[1] = msg->set_screen_power_mode.mode;
             return 2;
-        case SC_CONTROL_MSG_TYPE_UHID_CREATE:
-            sc_write16be(&buf[1], msg->uhid_create.id);
-            sc_write16be(&buf[3], msg->uhid_create.report_desc_size);
-            memcpy(&buf[5], msg->uhid_create.report_desc,
-                            msg->uhid_create.report_desc_size);
-            return 5 + msg->uhid_create.report_desc_size;
-        case SC_CONTROL_MSG_TYPE_UHID_INPUT:
-            sc_write16be(&buf[1], msg->uhid_input.id);
-            sc_write16be(&buf[3], msg->uhid_input.size);
-            memcpy(&buf[5], msg->uhid_input.data, msg->uhid_input.size);
-            return 5 + msg->uhid_input.size;
-        case SC_CONTROL_MSG_TYPE_SET_CAMERA_TORCH:
-            buf[1] = msg->set_camera_torch.enabled ? 1 : 0;
-            return 2;
         case SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL:
         case SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL:
         case SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS:
         case SC_CONTROL_MSG_TYPE_ROTATE_DEVICE:
-        case SC_CONTROL_MSG_TYPE_OPEN_HARD_KEYBOARD_SETTINGS:
             // no additional data
             return 1;
         default:
@@ -257,30 +242,6 @@ sc_control_msg_log(const struct sc_control_msg *msg) {
         case SC_CONTROL_MSG_TYPE_ROTATE_DEVICE:
             LOG_CMSG("rotate device");
             break;
-        case SC_CONTROL_MSG_TYPE_UHID_CREATE:
-            LOG_CMSG("UHID create [%" PRIu16 "] report_desc_size=%" PRIu16,
-                     msg->uhid_create.id, msg->uhid_create.report_desc_size);
-            break;
-        case SC_CONTROL_MSG_TYPE_UHID_INPUT: {
-            char *hex = sc_str_to_hex_string(msg->uhid_input.data,
-                                             msg->uhid_input.size);
-            if (hex) {
-                LOG_CMSG("UHID input [%" PRIu16 "] %s",
-                         msg->uhid_input.id, hex);
-                free(hex);
-            } else {
-                LOG_CMSG("UHID input [%" PRIu16 "] size=%" PRIu16,
-                         msg->uhid_input.id, msg->uhid_input.size);
-            }
-            break;
-        }
-        case SC_CONTROL_MSG_TYPE_OPEN_HARD_KEYBOARD_SETTINGS:
-            LOG_CMSG("open hard keyboard settings");
-            break;
-        case SC_CONTROL_MSG_TYPE_SET_CAMERA_TORCH:
-            LOG_CMSG("%s camera torch",
-                     msg->set_camera_torch.enabled ? "enable" : "disable");
-            break;
         default:
             LOG_CMSG("unknown type: %u", (unsigned) msg->type);
             break;

app/src/control_msg.h

@@ -10,7 +10,6 @@
 #include "android/input.h"
 #include "android/keycodes.h"
 #include "coords.h"
-#include "hid/hid_event.h"
 
 #define SC_CONTROL_MSG_MAX_SIZE (1 << 18) // 256k
 
@@ -38,10 +37,6 @@ enum sc_control_msg_type {
     SC_CONTROL_MSG_TYPE_SET_CLIPBOARD,
     SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE,
     SC_CONTROL_MSG_TYPE_ROTATE_DEVICE,
-    SC_CONTROL_MSG_TYPE_UHID_CREATE,
-    SC_CONTROL_MSG_TYPE_UHID_INPUT,
-    SC_CONTROL_MSG_TYPE_OPEN_HARD_KEYBOARD_SETTINGS,
-    SC_CONTROL_MSG_TYPE_SET_CAMERA_TORCH,
 };
 
 enum sc_screen_power_mode {
@@ -97,26 +92,13 @@ struct sc_control_msg {
         struct {
             enum sc_screen_power_mode mode;
         } set_screen_power_mode;
-        struct {
-            uint16_t id;
-            uint16_t report_desc_size;
-            const uint8_t *report_desc; // pointer to static data
-        } uhid_create;
-        struct {
-            uint16_t id;
-            uint16_t size;
-            uint8_t data[SC_HID_MAX_SIZE];
-        } uhid_input;
-        struct {
-            bool enabled;
-        } set_camera_torch;
     };
 };
 
 // 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);

app/src/controller.c

@@ -7,7 +7,8 @@
 #define SC_CONTROL_MSG_QUEUE_MAX 64
 
 bool
-sc_controller_init(struct sc_controller *controller, sc_socket control_socket) {
+sc_controller_init(struct sc_controller *controller, sc_socket control_socket,
+                   struct sc_acksync *acksync) {
     sc_vecdeque_init(&controller->queue);
 
     bool ok = sc_vecdeque_reserve(&controller->queue, SC_CONTROL_MSG_QUEUE_MAX);
@@ -15,7 +16,7 @@ sc_controller_init(struct sc_controller *controller, sc_socket control_socket) {
         return false;
     }
 
-    ok = sc_receiver_init(&controller->receiver, control_socket);
+    ok = sc_receiver_init(&controller->receiver, control_socket, acksync);
     if (!ok) {
         sc_vecdeque_destroy(&controller->queue);
         return false;
@@ -42,14 +43,6 @@ sc_controller_init(struct sc_controller *controller, sc_socket control_socket) {
     return true;
 }
 
-void
-sc_controller_configure(struct sc_controller *controller,
-                        struct sc_acksync *acksync,
-                        struct sc_uhid_devices *uhid_devices) {
-    controller->receiver.acksync = acksync;
-    controller->receiver.uhid_devices = uhid_devices;
-}
-
 void
 sc_controller_destroy(struct sc_controller *controller) {
     sc_cond_destroy(&controller->msg_cond);
@@ -91,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;

app/src/controller.h

@@ -25,12 +25,8 @@ struct sc_controller {
 };
 
 bool
-sc_controller_init(struct sc_controller *controller, sc_socket control_socket);
-
-void
-sc_controller_configure(struct sc_controller *controller,
-                        struct sc_acksync *acksync,
-                        struct sc_uhid_devices *uhid_devices);
+sc_controller_init(struct sc_controller *controller, sc_socket control_socket,
+                   struct sc_acksync *acksync);
 
 void
 sc_controller_destroy(struct sc_controller *controller);

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,38 +36,10 @@ 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;
         }
-        case DEVICE_MSG_TYPE_UHID_OUTPUT: {
-            if (len < 5) {
-                // at least id + size
-                return 0; // not available
-            }
-            uint16_t id = sc_read16be(&buf[1]);
-            size_t size = sc_read16be(&buf[3]);
-            if (size < len - 5) {
-                return 0; // not available
-            }
-            uint8_t *data = malloc(size);
-            if (!data) {
-                LOG_OOM();
-                return -1;
-            }
-            if (size) {
-                memcpy(data, &buf[5], size);
-            }
-
-            msg->uhid_output.id = id;
-            msg->uhid_output.size = size;
-            msg->uhid_output.data = data;
-
-            return 5 + size;
-        }
         default:
             LOGW("Unknown device message type: %d", (int) msg->type);
             return -1; // error, we cannot recover
@@ -78,16 +47,8 @@ sc_device_msg_deserialize(const uint8_t *buf, size_t len,
 }
 
 void
-sc_device_msg_destroy(struct sc_device_msg *msg) {
-    switch (msg->type) {
-        case DEVICE_MSG_TYPE_CLIPBOARD:
-            free(msg->clipboard.text);
-            break;
-        case DEVICE_MSG_TYPE_UHID_OUTPUT:
-            free(msg->uhid_output.data);
-            break;
-        default:
-            // nothing to do
-            break;
+device_msg_destroy(struct device_msg *msg) {
+    if (msg->type == DEVICE_MSG_TYPE_CLIPBOARD) {
+        free(msg->clipboard.text);
     }
 }

app/src/device_msg.h

@@ -11,14 +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,
-    DEVICE_MSG_TYPE_UHID_OUTPUT,
 };
 
-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()
@@ -26,20 +25,15 @@ struct sc_device_msg {
         struct {
             uint64_t sequence;
         } ack_clipboard;
-        struct {
-            uint16_t id;
-            uint16_t size;
-            uint8_t *data; // owned, to be freed by free()
-        } uhid_output;
     };
 };
 
 // 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

app/src/hid/hid_event.h

@@ -1,18 +0,0 @@
-#ifndef SC_HID_EVENT_H
-#define SC_HID_EVENT_H
-
-#include "common.h"
-
-#include <stdint.h>
-
-#define SC_HID_MAX_SIZE 8
-
-struct sc_hid_event {
-    uint8_t data[SC_HID_MAX_SIZE];
-    uint8_t size;
-};
-
-char *
-sc_hid_event_to_string(const struct sc_hid_event *event, size_t max_data_bytes);
-
-#endif

app/src/hid/hid_mouse.c

@@ -1,192 +0,0 @@
-#include "hid_mouse.h"
-
-// 1 byte for buttons + padding, 1 byte for X position, 1 byte for Y position,
-// 1 byte for wheel motion
-#define HID_MOUSE_EVENT_SIZE 4
-
-/**
- * Mouse descriptor from the specification:
- * <https://www.usb.org/sites/default/files/hid1_11.pdf>
- *
- * Appendix E (p71): §E.10 Report Descriptor (Mouse)
- *
- * The usage tags (like Wheel) are listed in "HID Usage Tables":
- * <https://www.usb.org/sites/default/files/documents/hut1_12v2.pdf>
- * §4 Generic Desktop Page (0x01) (p26)
- */
-const uint8_t SC_HID_MOUSE_REPORT_DESC[] = {
-    // Usage Page (Generic Desktop)
-    0x05, 0x01,
-    // Usage (Mouse)
-    0x09, 0x02,
-
-    // Collection (Application)
-    0xA1, 0x01,
-
-    // Usage (Pointer)
-    0x09, 0x01,
-
-    // Collection (Physical)
-    0xA1, 0x00,
-
-    // Usage Page (Buttons)
-    0x05, 0x09,
-
-    // Usage Minimum (1)
-    0x19, 0x01,
-     // Usage Maximum (5)
-    0x29, 0x05,
-    // Logical Minimum (0)
-    0x15, 0x00,
-    // Logical Maximum (1)
-    0x25, 0x01,
-    // Report Count (5)
-    0x95, 0x05,
-    // Report Size (1)
-    0x75, 0x01,
-    // Input (Data, Variable, Absolute): 5 buttons bits
-    0x81, 0x02,
-
-    // Report Count (1)
-    0x95, 0x01,
-    // Report Size (3)
-    0x75, 0x03,
-    // Input (Constant): 3 bits padding
-    0x81, 0x01,
-
-    // Usage Page (Generic Desktop)
-    0x05, 0x01,
-    // Usage (X)
-    0x09, 0x30,
-    // Usage (Y)
-    0x09, 0x31,
-    // Usage (Wheel)
-    0x09, 0x38,
-    // Local Minimum (-127)
-    0x15, 0x81,
-    // Local Maximum (127)
-    0x25, 0x7F,
-    // Report Size (8)
-    0x75, 0x08,
-    // Report Count (3)
-    0x95, 0x03,
-    // Input (Data, Variable, Relative): 3 position bytes (X, Y, Wheel)
-    0x81, 0x06,
-
-    // End Collection
-    0xC0,
-
-    // End Collection
-    0xC0,
-};
-
-const size_t SC_HID_MOUSE_REPORT_DESC_LEN =
-    sizeof(SC_HID_MOUSE_REPORT_DESC);
-
-/**
- * A mouse HID event is 4 bytes long:
- *
- *  - byte 0: buttons state
- *  - byte 1: relative x motion (signed byte from -127 to 127)
- *  - byte 2: relative y motion (signed byte from -127 to 127)
- *  - byte 3: wheel motion (-1, 0 or 1)
- *
- *                   7 6 5 4 3 2 1 0
- *                  +---------------+
- *         byte 0:  |0 0 0 . . . . .| buttons state
- *                  +---------------+
- *                         ^ ^ ^ ^ ^
- *                         | | | | `- left button
- *                         | | | `--- right button
- *                         | | `----- middle button
- *                         | `------- button 4
- *                         `--------- button 5
- *
- *                  +---------------+
- *         byte 1:  |. . . . . . . .| relative x motion
- *                  +---------------+
- *         byte 2:  |. . . . . . . .| relative y motion
- *                  +---------------+
- *         byte 3:  |. . . . . . . .| wheel motion
- *                  +---------------+
- *
- * As an example, here is the report for a motion of (x=5, y=-4) with left
- * button pressed:
- *
- *                  +---------------+
- *                  |0 0 0 0 0 0 0 1| left button pressed
- *                  +---------------+
- *                  |0 0 0 0 0 1 0 1| horizontal motion (x = 5)
- *                  +---------------+
- *                  |1 1 1 1 1 1 0 0| relative y motion (y = -4)
- *                  +---------------+
- *                  |0 0 0 0 0 0 0 0| wheel motion
- *                  +---------------+
- */
-
-static void
-sc_hid_mouse_event_init(struct sc_hid_event *hid_event) {
-    hid_event->size = HID_MOUSE_EVENT_SIZE;
-    // Leave hid_event->data uninitialized, it will be fully initialized by
-    // callers
-}
-
-static uint8_t
-sc_hid_buttons_from_buttons_state(uint8_t buttons_state) {
-    uint8_t c = 0;
-    if (buttons_state & SC_MOUSE_BUTTON_LEFT) {
-        c |= 1 << 0;
-    }
-    if (buttons_state & SC_MOUSE_BUTTON_RIGHT) {
-        c |= 1 << 1;
-    }
-    if (buttons_state & SC_MOUSE_BUTTON_MIDDLE) {
-        c |= 1 << 2;
-    }
-    if (buttons_state & SC_MOUSE_BUTTON_X1) {
-        c |= 1 << 3;
-    }
-    if (buttons_state & SC_MOUSE_BUTTON_X2) {
-        c |= 1 << 4;
-    }
-    return c;
-}
-
-void
-sc_hid_mouse_event_from_motion(struct sc_hid_event *hid_event,
-                               const struct sc_mouse_motion_event *event) {
-    sc_hid_mouse_event_init(hid_event);
-
-    uint8_t *data = hid_event->data;
-    data[0] = sc_hid_buttons_from_buttons_state(event->buttons_state);
-    data[1] = CLAMP(event->xrel, -127, 127);
-    data[2] = CLAMP(event->yrel, -127, 127);
-    data[3] = 0; // wheel coordinates only used for scrolling
-}
-
-void
-sc_hid_mouse_event_from_click(struct sc_hid_event *hid_event,
-                              const struct sc_mouse_click_event *event) {
-    sc_hid_mouse_event_init(hid_event);
-
-    uint8_t *data = hid_event->data;
-    data[0] = sc_hid_buttons_from_buttons_state(event->buttons_state);
-    data[1] = 0; // no x motion
-    data[2] = 0; // no y motion
-    data[3] = 0; // wheel coordinates only used for scrolling
-}
-
-void
-sc_hid_mouse_event_from_scroll(struct sc_hid_event *hid_event,
-                               const struct sc_mouse_scroll_event *event) {
-    sc_hid_mouse_event_init(hid_event);
-
-    uint8_t *data = hid_event->data;
-    data[0] = 0; // buttons state irrelevant (and unknown)
-    data[1] = 0; // no x motion
-    data[2] = 0; // no y motion
-    // In practice, vscroll is always -1, 0 or 1, but in theory other values
-    // are possible
-    data[3] = CLAMP(event->vscroll, -127, 127);
-    // Horizontal scrolling ignored
-}

app/src/hid/hid_mouse.h

@@ -1,26 +0,0 @@
-#ifndef SC_HID_MOUSE_H
-#define SC_HID_MOUSE_H
-
-#endif
-
-#include "common.h"
-
-#include <stdbool.h>
-
-#include "hid/hid_event.h"
-#include "input_events.h"
-
-extern const uint8_t SC_HID_MOUSE_REPORT_DESC[];
-extern const size_t SC_HID_MOUSE_REPORT_DESC_LEN;
-
-void
-sc_hid_mouse_event_from_motion(struct sc_hid_event *hid_event,
-                               const struct sc_mouse_motion_event *event);
-
-void
-sc_hid_mouse_event_from_click(struct sc_hid_event *hid_event,
-                              const struct sc_mouse_click_event *event);
-
-void
-sc_hid_mouse_event_from_scroll(struct sc_hid_event *hid_event,
-                               const struct sc_mouse_scroll_event *event);

app/src/input_manager.c

@@ -52,11 +52,8 @@ is_shortcut_mod(struct sc_input_manager *im, uint16_t sdl_mod) {
 void
 sc_input_manager_init(struct sc_input_manager *im,
                       const struct sc_input_manager_params *params) {
-    // A key/mouse processor may not be present if there is no controller
-    assert((!params->kp && !params->mp) || params->controller);
-    // A processor must have ops initialized
-    assert(!params->kp || params->kp->ops);
-    assert(!params->mp || params->mp->ops);
+    assert(!params->controller || (params->kp && params->kp->ops));
+    assert(!params->controller || (params->mp && params->mp->ops));
 
     im->controller = params->controller;
     im->fp = params->fp;
@@ -79,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;
@@ -90,10 +85,8 @@ sc_input_manager_init(struct sc_input_manager *im,
 }
 
 static void
-send_keycode(struct sc_input_manager *im, enum android_keycode keycode,
+send_keycode(struct sc_controller *controller, enum android_keycode keycode,
              enum sc_action action, const char *name) {
-    assert(im->controller && im->kp);
-
     // send DOWN event
     struct sc_control_msg msg;
     msg.type = SC_CONTROL_MSG_TYPE_INJECT_KEYCODE;
@@ -104,109 +97,100 @@ send_keycode(struct sc_input_manager *im, enum android_keycode keycode,
     msg.inject_keycode.metastate = 0;
     msg.inject_keycode.repeat = 0;
 
-    if (!sc_controller_push_msg(im->controller, &msg)) {
+    if (!sc_controller_push_msg(controller, &msg)) {
         LOGW("Could not request 'inject %s'", name);
     }
 }
 
 static inline void
-action_home(struct sc_input_manager *im, enum sc_action action) {
-    send_keycode(im, AKEYCODE_HOME, action, "HOME");
+action_home(struct sc_controller *controller, enum sc_action action) {
+    send_keycode(controller, AKEYCODE_HOME, action, "HOME");
 }
 
 static inline void
-action_back(struct sc_input_manager *im, enum sc_action action) {
-    send_keycode(im, AKEYCODE_BACK, action, "BACK");
+action_back(struct sc_controller *controller, enum sc_action action) {
+    send_keycode(controller, AKEYCODE_BACK, action, "BACK");
 }
 
 static inline void
-action_app_switch(struct sc_input_manager *im, enum sc_action action) {
-    send_keycode(im, AKEYCODE_APP_SWITCH, action, "APP_SWITCH");
+action_app_switch(struct sc_controller *controller, enum sc_action action) {
+    send_keycode(controller, AKEYCODE_APP_SWITCH, action, "APP_SWITCH");
 }
 
 static inline void
-action_power(struct sc_input_manager *im, enum sc_action action) {
-    send_keycode(im, AKEYCODE_POWER, action, "POWER");
+action_power(struct sc_controller *controller, enum sc_action action) {
+    send_keycode(controller, AKEYCODE_POWER, action, "POWER");
 }
 
 static inline void
-action_volume_up(struct sc_input_manager *im, enum sc_action action) {
-    send_keycode(im, AKEYCODE_VOLUME_UP, action, "VOLUME_UP");
+action_volume_up(struct sc_controller *controller, enum sc_action action) {
+    send_keycode(controller, AKEYCODE_VOLUME_UP, action, "VOLUME_UP");
 }
 
 static inline void
-action_volume_down(struct sc_input_manager *im, enum sc_action action) {
-    send_keycode(im, AKEYCODE_VOLUME_DOWN, action, "VOLUME_DOWN");
+action_volume_down(struct sc_controller *controller, enum sc_action action) {
+    send_keycode(controller, AKEYCODE_VOLUME_DOWN, action, "VOLUME_DOWN");
 }
 
 static inline void
-action_menu(struct sc_input_manager *im, enum sc_action action) {
-    send_keycode(im, AKEYCODE_MENU, action, "MENU");
+action_menu(struct sc_controller *controller, enum sc_action action) {
+    send_keycode(controller, AKEYCODE_MENU, action, "MENU");
 }
 
 // turn the screen on if it was off, press BACK otherwise
 // If the screen is off, it is turned on only on ACTION_DOWN
 static void
-press_back_or_turn_screen_on(struct sc_input_manager *im,
+press_back_or_turn_screen_on(struct sc_controller *controller,
                              enum sc_action action) {
-    assert(im->controller && im->kp);
-
     struct sc_control_msg msg;
     msg.type = SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON;
     msg.back_or_screen_on.action = action == SC_ACTION_DOWN
                                  ? AKEY_EVENT_ACTION_DOWN
                                  : AKEY_EVENT_ACTION_UP;
 
-    if (!sc_controller_push_msg(im->controller, &msg)) {
+    if (!sc_controller_push_msg(controller, &msg)) {
         LOGW("Could not request 'press back or turn screen on'");
     }
 }
 
 static void
-expand_notification_panel(struct sc_input_manager *im) {
-    assert(im->controller);
-
+expand_notification_panel(struct sc_controller *controller) {
     struct sc_control_msg msg;
     msg.type = SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL;
 
-    if (!sc_controller_push_msg(im->controller, &msg)) {
+    if (!sc_controller_push_msg(controller, &msg)) {
         LOGW("Could not request 'expand notification panel'");
     }
 }
 
 static void
-expand_settings_panel(struct sc_input_manager *im) {
-    assert(im->controller);
-
+expand_settings_panel(struct sc_controller *controller) {
     struct sc_control_msg msg;
     msg.type = SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL;
 
-    if (!sc_controller_push_msg(im->controller, &msg)) {
+    if (!sc_controller_push_msg(controller, &msg)) {
         LOGW("Could not request 'expand settings panel'");
     }
 }
 
 static void
-collapse_panels(struct sc_input_manager *im) {
-    assert(im->controller);
-
+collapse_panels(struct sc_controller *controller) {
     struct sc_control_msg msg;
     msg.type = SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS;
 
-    if (!sc_controller_push_msg(im->controller, &msg)) {
+    if (!sc_controller_push_msg(controller, &msg)) {
         LOGW("Could not request 'collapse notification panel'");
     }
 }
 
 static bool
-get_device_clipboard(struct sc_input_manager *im, enum sc_copy_key copy_key) {
-    assert(im->controller && im->kp);
-
+get_device_clipboard(struct sc_controller *controller,
+                     enum sc_copy_key copy_key) {
     struct sc_control_msg msg;
     msg.type = SC_CONTROL_MSG_TYPE_GET_CLIPBOARD;
     msg.get_clipboard.copy_key = copy_key;
 
-    if (!sc_controller_push_msg(im->controller, &msg)) {
+    if (!sc_controller_push_msg(controller, &msg)) {
         LOGW("Could not request 'get device clipboard'");
         return false;
     }
@@ -215,10 +199,8 @@ get_device_clipboard(struct sc_input_manager *im, enum sc_copy_key copy_key) {
 }
 
 static bool
-set_device_clipboard(struct sc_input_manager *im, bool paste,
+set_device_clipboard(struct sc_controller *controller, bool paste,
                      uint64_t sequence) {
-    assert(im->controller && im->kp);
-
     char *text = SDL_GetClipboardText();
     if (!text) {
         LOGW("Could not get clipboard text: %s", SDL_GetError());
@@ -238,7 +220,7 @@ set_device_clipboard(struct sc_input_manager *im, bool paste,
     msg.set_clipboard.text = text_dup;
     msg.set_clipboard.paste = paste;
 
-    if (!sc_controller_push_msg(im->controller, &msg)) {
+    if (!sc_controller_push_msg(controller, &msg)) {
         free(text_dup);
         LOGW("Could not request 'set device clipboard'");
         return false;
@@ -248,23 +230,19 @@ set_device_clipboard(struct sc_input_manager *im, bool paste,
 }
 
 static void
-set_screen_power_mode(struct sc_input_manager *im,
+set_screen_power_mode(struct sc_controller *controller,
                       enum sc_screen_power_mode mode) {
-    assert(im->controller);
-
     struct sc_control_msg msg;
     msg.type = SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE;
     msg.set_screen_power_mode.mode = mode;
 
-    if (!sc_controller_push_msg(im->controller, &msg)) {
+    if (!sc_controller_push_msg(controller, &msg)) {
         LOGW("Could not request 'set screen power mode'");
     }
 }
 
 static void
-switch_fps_counter_state(struct sc_input_manager *im) {
-    struct sc_fps_counter *fps_counter = &im->screen->fps_counter;
-
+switch_fps_counter_state(struct sc_fps_counter *fps_counter) {
     // the started state can only be written from the current thread, so there
     // is no ToCToU issue
     if (sc_fps_counter_is_started(fps_counter)) {
@@ -276,9 +254,7 @@ switch_fps_counter_state(struct sc_input_manager *im) {
 }
 
 static void
-clipboard_paste(struct sc_input_manager *im) {
-    assert(im->controller && im->kp);
-
+clipboard_paste(struct sc_controller *controller) {
     char *text = SDL_GetClipboardText();
     if (!text) {
         LOGW("Could not get clipboard text: %s", SDL_GetError());
@@ -300,53 +276,25 @@ clipboard_paste(struct sc_input_manager *im) {
     struct sc_control_msg msg;
     msg.type = SC_CONTROL_MSG_TYPE_INJECT_TEXT;
     msg.inject_text.text = text_dup;
-    if (!sc_controller_push_msg(im->controller, &msg)) {
+    if (!sc_controller_push_msg(controller, &msg)) {
         free(text_dup);
         LOGW("Could not request 'paste clipboard'");
     }
 }
 
 static void
-rotate_device(struct sc_input_manager *im) {
-    assert(im->controller);
-
+rotate_device(struct sc_controller *controller) {
     struct sc_control_msg msg;
     msg.type = SC_CONTROL_MSG_TYPE_ROTATE_DEVICE;
 
-    if (!sc_controller_push_msg(im->controller, &msg)) {
+    if (!sc_controller_push_msg(controller, &msg)) {
         LOGW("Could not request device rotation");
     }
 }
 
 static void
-open_hard_keyboard_settings(struct sc_input_manager *im) {
-    assert(im->controller);
-
-    struct sc_control_msg msg;
-    msg.type = SC_CONTROL_MSG_TYPE_OPEN_HARD_KEYBOARD_SETTINGS;
-
-    if (!sc_controller_push_msg(im->controller, &msg)) {
-        LOGW("Could not request opening hard keyboard settings");
-    }
-}
-
-static void
-set_camera_torch(struct sc_input_manager *im, bool enabled) {
-    assert(im->controller);
-
-    struct sc_control_msg msg;
-    msg.type = SC_CONTROL_MSG_TYPE_SET_CAMERA_TORCH;
-    msg.set_camera_torch.enabled = enabled;
-
-    if (!sc_controller_push_msg(im->controller, &msg)) {
-        LOGW("Could not request setting camera torch");
-    }
-}
-
-static void
-apply_orientation_transform(struct sc_input_manager *im,
+apply_orientation_transform(struct sc_screen *screen,
                             enum sc_orientation transform) {
-    struct sc_screen *screen = im->screen;
     enum sc_orientation new_orientation =
         sc_orientation_apply(screen->orientation, transform);
     sc_screen_set_orientation(screen, new_orientation);
@@ -399,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;
 }
 
@@ -414,7 +357,7 @@ static void
 sc_input_manager_process_key(struct sc_input_manager *im,
                              const SDL_KeyboardEvent *event) {
     // controller is NULL if --no-control is requested
-    bool control = im->controller;
+    struct sc_controller *controller = im->controller;
 
     SDL_Keycode keycode = event->keysym.sym;
     uint16_t mod = event->keysym.mod;
@@ -440,68 +383,68 @@ sc_input_manager_process_key(struct sc_input_manager *im,
         enum sc_action action = down ? SC_ACTION_DOWN : SC_ACTION_UP;
         switch (keycode) {
             case SDLK_h:
-                if (im->kp && !shift && !repeat) {
-                    action_home(im, action);
+                if (controller && !shift && !repeat) {
+                    action_home(controller, action);
                 }
                 return;
             case SDLK_b: // fall-through
             case SDLK_BACKSPACE:
-                if (im->kp && !shift && !repeat) {
-                    action_back(im, action);
+                if (controller && !shift && !repeat) {
+                    action_back(controller, action);
                 }
                 return;
             case SDLK_s:
-                if (im->kp && !shift && !repeat) {
-                    action_app_switch(im, action);
+                if (controller && !shift && !repeat) {
+                    action_app_switch(controller, action);
                 }
                 return;
             case SDLK_m:
-                if (im->kp && !shift && !repeat) {
-                    action_menu(im, action);
+                if (controller && !shift && !repeat) {
+                    action_menu(controller, action);
                 }
                 return;
             case SDLK_p:
-                if (im->kp && !shift && !repeat) {
-                    action_power(im, action);
+                if (controller && !shift && !repeat) {
+                    action_power(controller, action);
                 }
                 return;
             case SDLK_o:
-                if (control && !repeat && down) {
+                if (controller && !repeat && down) {
                     enum sc_screen_power_mode mode = shift
                                                    ? SC_SCREEN_POWER_MODE_NORMAL
                                                    : SC_SCREEN_POWER_MODE_OFF;
-                    set_screen_power_mode(im, mode);
+                    set_screen_power_mode(controller, mode);
                 }
                 return;
             case SDLK_DOWN:
                 if (shift) {
                     if (!repeat & down) {
-                        apply_orientation_transform(im,
+                        apply_orientation_transform(im->screen,
                                                     SC_ORIENTATION_FLIP_180);
                     }
-                } else if (im->kp) {
+                } else if (controller) {
                     // forward repeated events
-                    action_volume_down(im, action);
+                    action_volume_down(controller, action);
                 }
                 return;
             case SDLK_UP:
                 if (shift) {
                     if (!repeat & down) {
-                        apply_orientation_transform(im,
+                        apply_orientation_transform(im->screen,
                                                     SC_ORIENTATION_FLIP_180);
                     }
-                } else if (im->kp) {
+                } else if (controller) {
                     // forward repeated events
-                    action_volume_up(im, action);
+                    action_volume_up(controller, action);
                 }
                 return;
             case SDLK_LEFT:
                 if (!repeat && down) {
                     if (shift) {
-                        apply_orientation_transform(im,
+                        apply_orientation_transform(im->screen,
                                                     SC_ORIENTATION_FLIP_0);
                     } else {
-                        apply_orientation_transform(im,
+                        apply_orientation_transform(im->screen,
                                                     SC_ORIENTATION_270);
                     }
                 }
@@ -509,33 +452,34 @@ sc_input_manager_process_key(struct sc_input_manager *im,
             case SDLK_RIGHT:
                 if (!repeat && down) {
                     if (shift) {
-                        apply_orientation_transform(im,
+                        apply_orientation_transform(im->screen,
                                                     SC_ORIENTATION_FLIP_0);
                     } else {
-                        apply_orientation_transform(im,
+                        apply_orientation_transform(im->screen,
                                                     SC_ORIENTATION_90);
                     }
                 }
                 return;
             case SDLK_c:
-                if (im->kp && !shift && !repeat && down) {
-                    get_device_clipboard(im, SC_COPY_KEY_COPY);
+                if (controller && !shift && !repeat && down) {
+                    get_device_clipboard(controller, SC_COPY_KEY_COPY);
                 }
                 return;
             case SDLK_x:
-                if (im->kp && !shift && !repeat && down) {
-                    get_device_clipboard(im, SC_COPY_KEY_CUT);
+                if (controller && !shift && !repeat && down) {
+                    get_device_clipboard(controller, SC_COPY_KEY_CUT);
                 }
                 return;
             case SDLK_v:
-                if (im->kp && !repeat && down) {
+                if (controller && !repeat && down) {
                     if (shift || im->legacy_paste) {
                         // inject the text as input events
-                        clipboard_paste(im);
+                        clipboard_paste(controller);
                     } else {
                         // store the text in the device clipboard and paste,
                         // without requesting an acknowledgment
-                        set_device_clipboard(im, true, SC_SEQUENCE_INVALID);
+                        set_device_clipboard(controller, true,
+                                             SC_SEQUENCE_INVALID);
                     }
                 }
                 return;
@@ -556,35 +500,23 @@ sc_input_manager_process_key(struct sc_input_manager *im,
                 return;
             case SDLK_i:
                 if (!shift && !repeat && down) {
-                    switch_fps_counter_state(im);
+                    switch_fps_counter_state(&im->screen->fps_counter);
                 }
                 return;
             case SDLK_n:
-                if (control && !repeat && down) {
+                if (controller && !repeat && down) {
                     if (shift) {
-                        collapse_panels(im);
+                        collapse_panels(controller);
                     } else if (im->key_repeat == 0) {
-                        expand_notification_panel(im);
+                        expand_notification_panel(controller);
                     } else {
-                        expand_settings_panel(im);
+                        expand_settings_panel(controller);
                     }
                 }
                 return;
             case SDLK_r:
-                if (control && !shift && !repeat && down) {
-                    rotate_device(im);
-                }
-                return;
-            case SDLK_k:
-                if (control && !shift && !repeat && down
-                        && im->kp && im->kp->hid) {
-                    // Only if the current keyboard is hid
-                    open_hard_keyboard_settings(im);
-                }
-                return;
-            case SDLK_l:
-                if (control && !repeat && down) {
-                    set_camera_torch(im, !shift);
+                if (controller && !shift && !repeat && down) {
+                    rotate_device(controller);
                 }
                 return;
         }
@@ -592,7 +524,7 @@ sc_input_manager_process_key(struct sc_input_manager *im,
         return;
     }
 
-    if (!im->kp) {
+    if (!controller) {
         return;
     }
 
@@ -601,7 +533,7 @@ sc_input_manager_process_key(struct sc_input_manager *im,
     if (im->clipboard_autosync && is_ctrl_v) {
         if (im->legacy_paste) {
             // inject the text as input events
-            clipboard_paste(im);
+            clipboard_paste(controller);
             return;
         }
 
@@ -611,7 +543,7 @@ sc_input_manager_process_key(struct sc_input_manager *im,
 
         // Synchronize the computer clipboard to the device clipboard before
         // sending Ctrl+v, to allow seamless copy-paste.
-        bool ok = set_device_clipboard(im, false, sequence);
+        bool ok = set_device_clipboard(controller, false, sequence);
         if (!ok) {
             LOGW("Clipboard could not be synchronized, Ctrl+v not injected");
             return;
@@ -673,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);
     }
 }
@@ -713,7 +643,7 @@ sc_input_manager_process_touch(struct sc_input_manager *im,
 static void
 sc_input_manager_process_mouse_button(struct sc_input_manager *im,
                                       const SDL_MouseButtonEvent *event) {
-    bool control = im->controller;
+    struct sc_controller *controller = im->controller;
 
     if (event->which == SDL_TOUCH_MOUSEID) {
         // simulated from touch events, so it's a duplicate
@@ -722,27 +652,27 @@ sc_input_manager_process_mouse_button(struct sc_input_manager *im,
 
     bool down = event->type == SDL_MOUSEBUTTONDOWN;
     if (!im->forward_all_clicks) {
-        if (control) {
+        if (controller) {
             enum sc_action action = down ? SC_ACTION_DOWN : SC_ACTION_UP;
 
-            if (im->kp && event->button == SDL_BUTTON_X1) {
-                action_app_switch(im, action);
+            if (event->button == SDL_BUTTON_X1) {
+                action_app_switch(controller, action);
                 return;
             }
             if (event->button == SDL_BUTTON_X2 && down) {
                 if (event->clicks < 2) {
-                    expand_notification_panel(im);
+                    expand_notification_panel(controller);
                 } else {
-                    expand_settings_panel(im);
+                    expand_settings_panel(controller);
                 }
                 return;
             }
-            if (im->kp && event->button == SDL_BUTTON_RIGHT) {
-                press_back_or_turn_screen_on(im, action);
+            if (event->button == SDL_BUTTON_RIGHT) {
+                press_back_or_turn_screen_on(controller, action);
                 return;
             }
-            if (im->kp && event->button == SDL_BUTTON_MIDDLE) {
-                action_home(im, action);
+            if (event->button == SDL_BUTTON_MIDDLE) {
+                action_home(controller, action);
                 return;
             }
         }
@@ -765,7 +695,7 @@ sc_input_manager_process_mouse_button(struct sc_input_manager *im,
         // otherwise, send the click event to the device
     }
 
-    if (!im->mp) {
+    if (!controller) {
         return;
     }
 
@@ -796,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
@@ -805,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;
@@ -905,7 +820,7 @@ sc_input_manager_handle_event(struct sc_input_manager *im,
     bool control = im->controller;
     switch (event->type) {
         case SDL_TEXTINPUT:
-            if (!im->kp) {
+            if (!control) {
                 break;
             }
             sc_input_manager_process_text_input(im, &event->text);
@@ -917,13 +832,13 @@ sc_input_manager_handle_event(struct sc_input_manager *im,
             sc_input_manager_process_key(im, &event->key);
             break;
         case SDL_MOUSEMOTION:
-            if (!im->mp) {
+            if (!control) {
                 break;
             }
             sc_input_manager_process_mouse_motion(im, &event->motion);
             break;
         case SDL_MOUSEWHEEL:
-            if (!im->mp) {
+            if (!control) {
                 break;
             }
             sc_input_manager_process_mouse_wheel(im, &event->wheel);
@@ -937,7 +852,7 @@ sc_input_manager_handle_event(struct sc_input_manager *im,
         case SDL_FINGERMOTION:
         case SDL_FINGERDOWN:
         case SDL_FINGERUP:
-            if (!im->mp) {
+            if (!control) {
                 break;
             }
             sc_input_manager_process_touch(im, &event->tfinger);

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

app/src/keyboard_inject.c

@@ -1,4 +1,4 @@
-#include "keyboard_sdk.h"
+#include "keyboard_inject.h"
 
 #include <assert.h>
 
@@ -9,8 +9,8 @@
 #include "util/intmap.h"
 #include "util/log.h"
 
-/** Downcast key processor to sc_keyboard_sdk */
-#define DOWNCAST(KP) container_of(KP, struct sc_keyboard_sdk, key_processor)
+/** Downcast key processor to sc_keyboard_inject */
+#define DOWNCAST(KP) container_of(KP, struct sc_keyboard_inject, key_processor)
 
 static enum android_keyevent_action
 convert_keycode_action(enum sc_action action) {
@@ -271,20 +271,20 @@ sc_key_processor_process_key(struct sc_key_processor *kp,
     // is set before injecting Ctrl+v.
     (void) ack_to_wait;
 
-    struct sc_keyboard_sdk *kb = DOWNCAST(kp);
+    struct sc_keyboard_inject *ki = DOWNCAST(kp);
 
     if (event->repeat) {
-        if (!kb->forward_key_repeat) {
+        if (!ki->forward_key_repeat) {
             return;
         }
-        ++kb->repeat;
+        ++ki->repeat;
     } else {
-        kb->repeat = 0;
+        ki->repeat = 0;
     }
 
     struct sc_control_msg msg;
-    if (convert_input_key(event, &msg, kb->key_inject_mode, kb->repeat)) {
-        if (!sc_controller_push_msg(kb->controller, &msg)) {
+    if (convert_input_key(event, &msg, ki->key_inject_mode, ki->repeat)) {
+        if (!sc_controller_push_msg(ki->controller, &msg)) {
             LOGW("Could not request 'inject keycode'");
         }
     }
@@ -293,14 +293,14 @@ sc_key_processor_process_key(struct sc_key_processor *kp,
 static void
 sc_key_processor_process_text(struct sc_key_processor *kp,
                               const struct sc_text_event *event) {
-    struct sc_keyboard_sdk *kb = DOWNCAST(kp);
+    struct sc_keyboard_inject *ki = DOWNCAST(kp);
 
-    if (kb->key_inject_mode == SC_KEY_INJECT_MODE_RAW) {
+    if (ki->key_inject_mode == SC_KEY_INJECT_MODE_RAW) {
         // Never inject text events
         return;
     }
 
-    if (kb->key_inject_mode == SC_KEY_INJECT_MODE_MIXED) {
+    if (ki->key_inject_mode == SC_KEY_INJECT_MODE_MIXED) {
         char c = event->text[0];
         if (isalpha(c) || c == ' ') {
             assert(event->text[1] == '\0');
@@ -316,22 +316,22 @@ sc_key_processor_process_text(struct sc_key_processor *kp,
         LOGW("Could not strdup input text");
         return;
     }
-    if (!sc_controller_push_msg(kb->controller, &msg)) {
+    if (!sc_controller_push_msg(ki->controller, &msg)) {
         free(msg.inject_text.text);
         LOGW("Could not request 'inject text'");
     }
 }
 
 void
-sc_keyboard_sdk_init(struct sc_keyboard_sdk *kb,
-                     struct sc_controller *controller,
-                     enum sc_key_inject_mode key_inject_mode,
-                     bool forward_key_repeat) {
-    kb->controller = controller;
-    kb->key_inject_mode = key_inject_mode;
-    kb->forward_key_repeat = forward_key_repeat;
+sc_keyboard_inject_init(struct sc_keyboard_inject *ki,
+                        struct sc_controller *controller,
+                        enum sc_key_inject_mode key_inject_mode,
+                        bool forward_key_repeat) {
+    ki->controller = controller;
+    ki->key_inject_mode = key_inject_mode;
+    ki->forward_key_repeat = forward_key_repeat;
 
-    kb->repeat = 0;
+    ki->repeat = 0;
 
     static const struct sc_key_processor_ops ops = {
         .process_key = sc_key_processor_process_key,
@@ -339,7 +339,6 @@ sc_keyboard_sdk_init(struct sc_keyboard_sdk *kb,
     };
 
     // Key injection and clipboard synchronization are serialized
-    kb->key_processor.async_paste = false;
-    kb->key_processor.hid = false;
-    kb->key_processor.ops = &ops;
+    ki->key_processor.async_paste = false;
+    ki->key_processor.ops = &ops;
 }

app/src/keyboard_inject.h

@@ -1,5 +1,5 @@
-#ifndef SC_KEYBOARD_SDK_H
-#define SC_KEYBOARD_SDK_H
+#ifndef SC_KEYBOARD_INJECT_H
+#define SC_KEYBOARD_INJECT_H
 
 #include "common.h"
 
@@ -9,7 +9,7 @@
 #include "options.h"
 #include "trait/key_processor.h"
 
-struct sc_keyboard_sdk {
+struct sc_keyboard_inject {
     struct sc_key_processor key_processor; // key processor trait
 
     struct sc_controller *controller;
@@ -23,9 +23,9 @@ struct sc_keyboard_sdk {
 };
 
 void
-sc_keyboard_sdk_init(struct sc_keyboard_sdk *kb,
-                     struct sc_controller *controller,
-                     enum sc_key_inject_mode key_inject_mode,
-                     bool forward_key_repeat);
+sc_keyboard_inject_init(struct sc_keyboard_inject *ki,
+                        struct sc_controller *controller,
+                        enum sc_key_inject_mode key_inject_mode,
+                        bool forward_key_repeat);
 
 #endif

app/src/mouse_inject.c

@@ -1,4 +1,4 @@
-#include "mouse_sdk.h"
+#include "mouse_inject.h"
 
 #include <assert.h>
 
@@ -9,8 +9,8 @@
 #include "util/intmap.h"
 #include "util/log.h"
 
-/** Downcast mouse processor to sc_mouse_sdk */
-#define DOWNCAST(MP) container_of(MP, struct sc_mouse_sdk, mouse_processor)
+/** Downcast mouse processor to sc_mouse_inject */
+#define DOWNCAST(MP) container_of(MP, struct sc_mouse_inject, mouse_processor)
 
 static enum android_motionevent_buttons
 convert_mouse_buttons(uint32_t state) {
@@ -63,7 +63,7 @@ sc_mouse_processor_process_mouse_motion(struct sc_mouse_processor *mp,
         return;
     }
 
-    struct sc_mouse_sdk *m = DOWNCAST(mp);
+    struct sc_mouse_inject *mi = DOWNCAST(mp);
 
     struct sc_control_msg msg = {
         .type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
@@ -76,7 +76,7 @@ sc_mouse_processor_process_mouse_motion(struct sc_mouse_processor *mp,
         },
     };
 
-    if (!sc_controller_push_msg(m->controller, &msg)) {
+    if (!sc_controller_push_msg(mi->controller, &msg)) {
         LOGW("Could not request 'inject mouse motion event'");
     }
 }
@@ -84,7 +84,7 @@ sc_mouse_processor_process_mouse_motion(struct sc_mouse_processor *mp,
 static void
 sc_mouse_processor_process_mouse_click(struct sc_mouse_processor *mp,
                                     const struct sc_mouse_click_event *event) {
-    struct sc_mouse_sdk *m = DOWNCAST(mp);
+    struct sc_mouse_inject *mi = DOWNCAST(mp);
 
     struct sc_control_msg msg = {
         .type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
@@ -98,7 +98,7 @@ sc_mouse_processor_process_mouse_click(struct sc_mouse_processor *mp,
         },
     };
 
-    if (!sc_controller_push_msg(m->controller, &msg)) {
+    if (!sc_controller_push_msg(mi->controller, &msg)) {
         LOGW("Could not request 'inject mouse click event'");
     }
 }
@@ -106,7 +106,7 @@ sc_mouse_processor_process_mouse_click(struct sc_mouse_processor *mp,
 static void
 sc_mouse_processor_process_mouse_scroll(struct sc_mouse_processor *mp,
                                    const struct sc_mouse_scroll_event *event) {
-    struct sc_mouse_sdk *m = DOWNCAST(mp);
+    struct sc_mouse_inject *mi = DOWNCAST(mp);
 
     struct sc_control_msg msg = {
         .type = SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
@@ -118,7 +118,7 @@ sc_mouse_processor_process_mouse_scroll(struct sc_mouse_processor *mp,
         },
     };
 
-    if (!sc_controller_push_msg(m->controller, &msg)) {
+    if (!sc_controller_push_msg(mi->controller, &msg)) {
         LOGW("Could not request 'inject mouse scroll event'");
     }
 }
@@ -126,7 +126,7 @@ sc_mouse_processor_process_mouse_scroll(struct sc_mouse_processor *mp,
 static void
 sc_mouse_processor_process_touch(struct sc_mouse_processor *mp,
                                  const struct sc_touch_event *event) {
-    struct sc_mouse_sdk *m = DOWNCAST(mp);
+    struct sc_mouse_inject *mi = DOWNCAST(mp);
 
     struct sc_control_msg msg = {
         .type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
@@ -139,14 +139,15 @@ sc_mouse_processor_process_touch(struct sc_mouse_processor *mp,
         },
     };
 
-    if (!sc_controller_push_msg(m->controller, &msg)) {
+    if (!sc_controller_push_msg(mi->controller, &msg)) {
         LOGW("Could not request 'inject touch event'");
     }
 }
 
 void
-sc_mouse_sdk_init(struct sc_mouse_sdk *m, struct sc_controller *controller) {
-    m->controller = controller;
+sc_mouse_inject_init(struct sc_mouse_inject *mi,
+                     struct sc_controller *controller) {
+    mi->controller = controller;
 
     static const struct sc_mouse_processor_ops ops = {
         .process_mouse_motion = sc_mouse_processor_process_mouse_motion,
@@ -155,7 +156,7 @@ sc_mouse_sdk_init(struct sc_mouse_sdk *m, struct sc_controller *controller) {
         .process_touch = sc_mouse_processor_process_touch,
     };
 
-    m->mouse_processor.ops = &ops;
+    mi->mouse_processor.ops = &ops;
 
-    m->mouse_processor.relative_mode = false;
+    mi->mouse_processor.relative_mode = false;
 }

app/src/mouse_inject.h

@@ -1,5 +1,5 @@
-#ifndef SC_MOUSE_SDK_H
-#define SC_MOUSE_SDK_H
+#ifndef SC_MOUSE_INJECT_H
+#define SC_MOUSE_INJECT_H
 
 #include "common.h"
 
@@ -9,13 +9,14 @@
 #include "screen.h"
 #include "trait/mouse_processor.h"
 
-struct sc_mouse_sdk {
+struct sc_mouse_inject {
     struct sc_mouse_processor mouse_processor; // mouse processor trait
 
     struct sc_controller *controller;
 };
 
 void
-sc_mouse_sdk_init(struct sc_mouse_sdk *m, struct sc_controller *controller);
+sc_mouse_inject_init(struct sc_mouse_inject *mi,
+                     struct sc_controller *controller);
 
 #endif

app/src/options.c

@@ -21,8 +21,8 @@ const struct scrcpy_options scrcpy_options_default = {
     .video_source = SC_VIDEO_SOURCE_DISPLAY,
     .audio_source = SC_AUDIO_SOURCE_AUTO,
     .record_format = SC_RECORD_FORMAT_AUTO,
-    .keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_AUTO,
-    .mouse_input_mode = SC_MOUSE_INPUT_MODE_AUTO,
+    .keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_INJECT,
+    .mouse_input_mode = SC_MOUSE_INPUT_MODE_INJECT,
     .camera_facing = SC_CAMERA_FACING_ANY,
     .port_range = {
         .first = DEFAULT_LOCAL_PORT_RANGE_FIRST,

app/src/options.h

@@ -140,19 +140,13 @@ enum sc_lock_video_orientation {
 };
 
 enum sc_keyboard_input_mode {
-    SC_KEYBOARD_INPUT_MODE_AUTO,
-    SC_KEYBOARD_INPUT_MODE_DISABLED,
-    SC_KEYBOARD_INPUT_MODE_SDK,
-    SC_KEYBOARD_INPUT_MODE_AOA,
-    SC_KEYBOARD_INPUT_MODE_UHID,
+    SC_KEYBOARD_INPUT_MODE_INJECT,
+    SC_KEYBOARD_INPUT_MODE_HID,
 };
 
 enum sc_mouse_input_mode {
-    SC_MOUSE_INPUT_MODE_AUTO,
-    SC_MOUSE_INPUT_MODE_DISABLED,
-    SC_MOUSE_INPUT_MODE_SDK,
-    SC_MOUSE_INPUT_MODE_AOA,
-    SC_MOUSE_INPUT_MODE_UHID,
+    SC_MOUSE_INPUT_MODE_INJECT,
+    SC_MOUSE_INPUT_MODE_HID,
 };
 
 enum sc_key_inject_mode {

app/src/receiver.c

@@ -1,24 +1,21 @@
 #include "receiver.h"
 
 #include <assert.h>
-#include <inttypes.h>
-#include <stdint.h>
 #include <SDL2/SDL_clipboard.h>
 
 #include "device_msg.h"
 #include "util/log.h"
-#include "util/str.h"
 
 bool
-sc_receiver_init(struct sc_receiver *receiver, sc_socket control_socket) {
+sc_receiver_init(struct sc_receiver *receiver, sc_socket control_socket,
+              struct sc_acksync *acksync) {
     bool ok = sc_mutex_init(&receiver->mutex);
     if (!ok) {
         return false;
     }
 
     receiver->control_socket = control_socket;
-    receiver->acksync = NULL;
-    receiver->uhid_devices = NULL;
+    receiver->acksync = acksync;
 
     return true;
 }
@@ -29,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();
@@ -45,65 +42,20 @@ process_msg(struct sc_receiver *receiver, struct sc_device_msg *msg) {
             break;
         }
         case DEVICE_MSG_TYPE_ACK_CLIPBOARD:
+            assert(receiver->acksync);
             LOGD("Ack device clipboard sequence=%" PRIu64_,
                  msg->ack_clipboard.sequence);
-
-            // This is a programming error to receive this message if there is
-            // no ACK synchronization mechanism
-            assert(receiver->acksync);
-
-            // Also check at runtime (do not trust the server)
-            if (!receiver->acksync) {
-                LOGE("Received unexpected ack");
-                return;
-            }
-
             sc_acksync_ack(receiver->acksync, msg->ack_clipboard.sequence);
             break;
-        case DEVICE_MSG_TYPE_UHID_OUTPUT:
-            if (sc_get_log_level() <= SC_LOG_LEVEL_VERBOSE) {
-                char *hex = sc_str_to_hex_string(msg->uhid_output.data,
-                                                 msg->uhid_output.size);
-                if (hex) {
-                    LOGV("UHID output [%" PRIu16 "] %s",
-                         msg->uhid_output.id, hex);
-                    free(hex);
-                } else {
-                    LOGV("UHID output [%" PRIu16 "] size=%" PRIu16,
-                         msg->uhid_output.id, msg->uhid_output.size);
-                }
-            }
-
-            // This is a programming error to receive this message if there is
-            // no uhid_devices instance
-            assert(receiver->uhid_devices);
-
-            // Also check at runtime (do not trust the server)
-            if (!receiver->uhid_devices) {
-                LOGE("Received unexpected HID output message");
-                return;
-            }
-
-            struct sc_uhid_receiver *uhid_receiver =
-                sc_uhid_devices_get_receiver(receiver->uhid_devices,
-                                             msg->uhid_output.id);
-            if (uhid_receiver) {
-                uhid_receiver->ops->process_output(uhid_receiver,
-                                                   msg->uhid_output.data,
-                                                   msg->uhid_output.size);
-            } else {
-                LOGW("No UHID receiver for id %" PRIu16, msg->uhid_output.id);
-            }
-            break;
     }
 }
 
 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;
         }
@@ -112,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);
@@ -126,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 (;;) {

app/src/receiver.h

@@ -5,7 +5,6 @@
 
 #include <stdbool.h>
 
-#include "uhid/uhid_output.h"
 #include "util/acksync.h"
 #include "util/net.h"
 #include "util/thread.h"
@@ -18,11 +17,11 @@ struct sc_receiver {
     sc_mutex mutex;
 
     struct sc_acksync *acksync;
-    struct sc_uhid_devices *uhid_devices;
 };
 
 bool
-sc_receiver_init(struct sc_receiver *receiver, sc_socket control_socket);
+sc_receiver_init(struct sc_receiver *receiver, sc_socket control_socket,
+                 struct sc_acksync *acksync);
 
 void
 sc_receiver_destroy(struct sc_receiver *receiver);

app/src/scrcpy.c

@@ -20,17 +20,15 @@
 #include "demuxer.h"
 #include "events.h"
 #include "file_pusher.h"
-#include "keyboard_sdk.h"
-#include "mouse_sdk.h"
+#include "keyboard_inject.h"
+#include "mouse_inject.h"
 #include "recorder.h"
 #include "screen.h"
 #include "server.h"
-#include "uhid/keyboard_uhid.h"
-#include "uhid/mouse_uhid.h"
 #ifdef HAVE_USB
 # include "usb/aoa_hid.h"
-# include "usb/keyboard_aoa.h"
-# include "usb/mouse_aoa.h"
+# include "usb/hid_keyboard.h"
+# include "usb/hid_mouse.h"
 # include "usb/usb.h"
 #endif
 #include "util/acksync.h"
@@ -63,21 +61,18 @@ struct scrcpy {
     struct sc_aoa aoa;
     // sequence/ack helper to synchronize clipboard and Ctrl+v via HID
     struct sc_acksync acksync;
-    struct sc_uhid_devices uhid_devices;
 #endif
     union {
-        struct sc_keyboard_sdk keyboard_sdk;
+        struct sc_keyboard_inject keyboard_inject;
 #ifdef HAVE_USB
-        struct sc_keyboard_aoa keyboard_aoa;
+        struct sc_hid_keyboard keyboard_hid;
 #endif
-        struct sc_keyboard_uhid keyboard_uhid;
     };
     union {
-        struct sc_mouse_sdk mouse_sdk;
+        struct sc_mouse_inject mouse_inject;
 #ifdef HAVE_USB
-        struct sc_mouse_aoa mouse_aoa;
+        struct sc_hid_mouse mouse_hid;
 #endif
-        struct sc_mouse_uhid mouse_uhid;
     };
     struct sc_timeout timeout;
 };
@@ -335,8 +330,8 @@ scrcpy(struct scrcpy_options *options) {
     bool audio_demuxer_started = false;
 #ifdef HAVE_USB
     bool aoa_hid_initialized = false;
-    bool keyboard_aoa_initialized = false;
-    bool mouse_aoa_initialized = false;
+    bool hid_keyboard_initialized = false;
+    bool hid_mouse_initialized = false;
 #endif
     bool controller_initialized = false;
     bool controller_started = false;
@@ -345,7 +340,6 @@ scrcpy(struct scrcpy_options *options) {
     bool timeout_started = false;
 
     struct sc_acksync *acksync = NULL;
-    struct sc_uhid_devices *uhid_devices = NULL;
 
     uint32_t scid = scrcpy_generate_scid();
 
@@ -548,19 +542,12 @@ scrcpy(struct scrcpy_options *options) {
     struct sc_mouse_processor *mp = NULL;
 
     if (options->control) {
-        if (!sc_controller_init(&s->controller, s->server.control_socket)) {
-            goto end;
-        }
-        controller_initialized = true;
-
-        controller = &s->controller;
-
 #ifdef HAVE_USB
-        bool use_keyboard_aoa =
-            options->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_AOA;
-        bool use_mouse_aoa =
-            options->mouse_input_mode == SC_MOUSE_INPUT_MODE_AOA;
-        if (use_keyboard_aoa || use_mouse_aoa) {
+        bool use_hid_keyboard =
+            options->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_HID;
+        bool use_hid_mouse =
+            options->mouse_input_mode == SC_MOUSE_INPUT_MODE_HID;
+        if (use_hid_keyboard || use_hid_mouse) {
             bool ok = sc_acksync_init(&s->acksync);
             if (!ok) {
                 goto end;
@@ -603,25 +590,25 @@ scrcpy(struct scrcpy_options *options) {
                 goto aoa_hid_end;
             }
 
-            if (use_keyboard_aoa) {
-                if (sc_keyboard_aoa_init(&s->keyboard_aoa, &s->aoa)) {
-                    keyboard_aoa_initialized = true;
-                    kp = &s->keyboard_aoa.key_processor;
+            if (use_hid_keyboard) {
+                if (sc_hid_keyboard_init(&s->keyboard_hid, &s->aoa)) {
+                    hid_keyboard_initialized = true;
+                    kp = &s->keyboard_hid.key_processor;
                 } else {
                     LOGE("Could not initialize HID keyboard");
                 }
             }
 
-            if (use_mouse_aoa) {
-                if (sc_mouse_aoa_init(&s->mouse_aoa, &s->aoa)) {
-                    mouse_aoa_initialized = true;
-                    mp = &s->mouse_aoa.mouse_processor;
+            if (use_hid_mouse) {
+                if (sc_hid_mouse_init(&s->mouse_hid, &s->aoa)) {
+                    hid_mouse_initialized = true;
+                    mp = &s->mouse_hid.mouse_processor;
                 } else {
                     LOGE("Could not initialized HID mouse");
                 }
             }
 
-            bool need_aoa = keyboard_aoa_initialized || mouse_aoa_initialized;
+            bool need_aoa = hid_keyboard_initialized || hid_mouse_initialized;
 
             if (!need_aoa || !sc_aoa_start(&s->aoa)) {
                 sc_acksync_destroy(&s->acksync);
@@ -637,66 +624,58 @@ scrcpy(struct scrcpy_options *options) {
 
 aoa_hid_end:
             if (!aoa_hid_initialized) {
-                if (keyboard_aoa_initialized) {
-                    sc_keyboard_aoa_destroy(&s->keyboard_aoa);
-                    keyboard_aoa_initialized = false;
+                if (hid_keyboard_initialized) {
+                    sc_hid_keyboard_destroy(&s->keyboard_hid);
+                    hid_keyboard_initialized = false;
                 }
-                if (mouse_aoa_initialized) {
-                    sc_mouse_aoa_destroy(&s->mouse_aoa);
-                    mouse_aoa_initialized = false;
+                if (hid_mouse_initialized) {
+                    sc_hid_mouse_destroy(&s->mouse_hid);
+                    hid_mouse_initialized = false;
                 }
             }
 
-            if (use_keyboard_aoa && !keyboard_aoa_initialized) {
-                LOGE("Fallback to --keyboard=sdk (--keyboard=aoa ignored)");
-                options->keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_SDK;
+            if (use_hid_keyboard && !hid_keyboard_initialized) {
+                LOGE("Fallback to default keyboard injection method "
+                     "(-K/--hid-keyboard ignored)");
+                options->keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_INJECT;
             }
 
-            if (use_mouse_aoa && !mouse_aoa_initialized) {
-                LOGE("Fallback to --keyboard=sdk (--keyboard=aoa ignored)");
-                options->mouse_input_mode = SC_MOUSE_INPUT_MODE_SDK;
+            if (use_hid_mouse && !hid_mouse_initialized) {
+                LOGE("Fallback to default mouse injection method "
+                     "(-M/--hid-mouse ignored)");
+                options->mouse_input_mode = SC_MOUSE_INPUT_MODE_INJECT;
             }
         }
 #else
-        assert(options->keyboard_input_mode != SC_KEYBOARD_INPUT_MODE_AOA);
-        assert(options->mouse_input_mode != SC_MOUSE_INPUT_MODE_AOA);
+        assert(options->keyboard_input_mode != SC_KEYBOARD_INPUT_MODE_HID);
+        assert(options->mouse_input_mode != SC_MOUSE_INPUT_MODE_HID);
 #endif
 
-        // keyboard_input_mode may have been reset if AOA mode failed
-        if (options->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_SDK) {
-            sc_keyboard_sdk_init(&s->keyboard_sdk, &s->controller,
-                                 options->key_inject_mode,
-                                 options->forward_key_repeat);
-            kp = &s->keyboard_sdk.key_processor;
-        } else if (options->keyboard_input_mode
-                == SC_KEYBOARD_INPUT_MODE_UHID) {
-            bool ok = sc_keyboard_uhid_init(&s->keyboard_uhid, &s->controller,
-                                            &s->uhid_devices);
-            if (!ok) {
-                goto end;
-            }
-            uhid_devices = &s->uhid_devices;
-            kp = &s->keyboard_uhid.key_processor;
+        // keyboard_input_mode may have been reset if HID mode failed
+        if (options->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_INJECT) {
+            sc_keyboard_inject_init(&s->keyboard_inject, &s->controller,
+                                    options->key_inject_mode,
+                                    options->forward_key_repeat);
+            kp = &s->keyboard_inject.key_processor;
         }
 
-        // mouse_input_mode may have been reset if AOA mode failed
-        if (options->mouse_input_mode == SC_MOUSE_INPUT_MODE_SDK) {
-            sc_mouse_sdk_init(&s->mouse_sdk, &s->controller);
-            mp = &s->mouse_sdk.mouse_processor;
-        } else if (options->mouse_input_mode == SC_MOUSE_INPUT_MODE_UHID) {
-            bool ok = sc_mouse_uhid_init(&s->mouse_uhid, &s->controller);
-            if (!ok) {
-                goto end;
-            }
-            mp = &s->mouse_uhid.mouse_processor;
+        // mouse_input_mode may have been reset if HID mode failed
+        if (options->mouse_input_mode == SC_MOUSE_INPUT_MODE_INJECT) {
+            sc_mouse_inject_init(&s->mouse_inject, &s->controller);
+            mp = &s->mouse_inject.mouse_processor;
         }
 
-        sc_controller_configure(&s->controller, acksync, uhid_devices);
+        if (!sc_controller_init(&s->controller, s->server.control_socket,
+                                acksync)) {
+            goto end;
+        }
+        controller_initialized = true;
 
         if (!sc_controller_start(&s->controller)) {
             goto end;
         }
         controller_started = true;
+        controller = &s->controller;
     }
 
     // There is a controller if and only if control is enabled
@@ -836,11 +815,11 @@ end:
     // end-of-stream
 #ifdef HAVE_USB
     if (aoa_hid_initialized) {
-        if (keyboard_aoa_initialized) {
-            sc_keyboard_aoa_destroy(&s->keyboard_aoa);
+        if (hid_keyboard_initialized) {
+            sc_hid_keyboard_destroy(&s->keyboard_hid);
         }
-        if (mouse_aoa_initialized) {
-            sc_mouse_aoa_destroy(&s->mouse_aoa);
+        if (hid_mouse_initialized) {
+            sc_hid_mouse_destroy(&s->mouse_hid);
         }
         sc_aoa_stop(&s->aoa);
         sc_usb_stop(&s->usb);

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

app/src/trait/key_processor.h

@@ -23,12 +23,6 @@ struct sc_key_processor {
      */
     bool async_paste;
 
-    /** Set by the implementation to indicate that the keyboard is HID. In
-     * practice, it is used to react on a shortcut to open the hard keyboard
-     * settings only if the keyboard is HID.
-     */
-    bool hid;
-
     const struct sc_key_processor_ops *ops;
 };
 

app/src/uhid/keyboard_uhid.c

@@ -1,162 +0,0 @@
-#include "keyboard_uhid.h"
-
-#include "util/log.h"
-
-/** Downcast key processor to keyboard_uhid */
-#define DOWNCAST(KP) container_of(KP, struct sc_keyboard_uhid, key_processor)
-
-/** Downcast uhid_receiver to keyboard_uhid */
-#define DOWNCAST_RECEIVER(UR) \
-    container_of(UR, struct sc_keyboard_uhid, uhid_receiver)
-
-#define UHID_KEYBOARD_ID 1
-
-static void
-sc_keyboard_uhid_send_input(struct sc_keyboard_uhid *kb,
-                            const struct sc_hid_event *event) {
-    struct sc_control_msg msg;
-    msg.type = SC_CONTROL_MSG_TYPE_UHID_INPUT;
-    msg.uhid_input.id = UHID_KEYBOARD_ID;
-
-    assert(event->size <= SC_HID_MAX_SIZE);
-    memcpy(msg.uhid_input.data, event->data, event->size);
-    msg.uhid_input.size = event->size;
-
-    if (!sc_controller_push_msg(kb->controller, &msg)) {
-        LOGE("Could not send UHID_INPUT message (key)");
-    }
-}
-
-static void
-sc_keyboard_uhid_synchronize_mod(struct sc_keyboard_uhid *kb) {
-    SDL_Keymod sdl_mod = SDL_GetModState();
-    uint16_t mod = sc_mods_state_from_sdl(sdl_mod) & (SC_MOD_CAPS | SC_MOD_NUM);
-
-    uint16_t device_mod =
-        atomic_load_explicit(&kb->device_mod, memory_order_relaxed);
-    uint16_t diff = mod ^ device_mod;
-
-    if (diff) {
-        // Inherently racy (the HID output reports arrive asynchronously in
-        // response to key presses), but will re-synchronize on next key press
-        // or HID output anyway
-        atomic_store_explicit(&kb->device_mod, mod, memory_order_relaxed);
-
-        struct sc_hid_event hid_event;
-        sc_hid_keyboard_event_from_mods(&hid_event, diff);
-
-        LOGV("HID keyboard state synchronized");
-
-        sc_keyboard_uhid_send_input(kb, &hid_event);
-    }
-}
-
-static void
-sc_key_processor_process_key(struct sc_key_processor *kp,
-                             const struct sc_key_event *event,
-                             uint64_t ack_to_wait) {
-    (void) ack_to_wait;
-
-    if (event->repeat) {
-        // In USB HID protocol, key repeat is handled by the host (Android), so
-        // just ignore key repeat here.
-        return;
-    }
-
-    struct sc_keyboard_uhid *kb = DOWNCAST(kp);
-
-    struct sc_hid_event hid_event;
-
-    // Not all keys are supported, just ignore unsupported keys
-    if (sc_hid_keyboard_event_from_key(&kb->hid, &hid_event, event)) {
-        if (event->scancode == SC_SCANCODE_CAPSLOCK) {
-            atomic_fetch_xor_explicit(&kb->device_mod, SC_MOD_CAPS,
-                                      memory_order_relaxed);
-        } else if (event->scancode == SC_SCANCODE_NUMLOCK) {
-            atomic_fetch_xor_explicit(&kb->device_mod, SC_MOD_NUM,
-                                      memory_order_relaxed);
-        } else {
-            // Synchronize modifiers (only if the scancode itself does not
-            // change the modifiers)
-            sc_keyboard_uhid_synchronize_mod(kb);
-        }
-        sc_keyboard_uhid_send_input(kb, &hid_event);
-    }
-}
-
-static unsigned
-sc_keyboard_uhid_to_sc_mod(uint8_t hid_led) {
-    // <https://www.usb.org/sites/default/files/documents/hut1_12v2.pdf>
-    // (chapter 11: LED page)
-    unsigned mod = 0;
-    if (hid_led & 0x01) {
-        mod |= SC_MOD_NUM;
-    }
-    if (hid_led & 0x02) {
-        mod |= SC_MOD_CAPS;
-    }
-    return mod;
-}
-
-static void
-sc_uhid_receiver_process_output(struct sc_uhid_receiver *receiver,
-                                const uint8_t *data, size_t len) {
-    // Called from the thread receiving device messages
-
-    assert(len);
-
-    // Also check at runtime (do not trust the server)
-    if (!len) {
-        LOGE("Unexpected empty HID output message");
-        return;
-    }
-
-    struct sc_keyboard_uhid *kb = DOWNCAST_RECEIVER(receiver);
-
-    uint8_t hid_led = data[0];
-    uint16_t device_mod = sc_keyboard_uhid_to_sc_mod(hid_led);
-    atomic_store_explicit(&kb->device_mod, device_mod, memory_order_relaxed);
-}
-
-bool
-sc_keyboard_uhid_init(struct sc_keyboard_uhid *kb,
-                      struct sc_controller *controller,
-                      struct sc_uhid_devices *uhid_devices) {
-    sc_hid_keyboard_init(&kb->hid);
-
-    kb->controller = controller;
-    atomic_init(&kb->device_mod, 0);
-
-    static const struct sc_key_processor_ops ops = {
-        .process_key = sc_key_processor_process_key,
-        // Never forward text input via HID (all the keys are injected
-        // separately)
-        .process_text = NULL,
-    };
-
-    // Clipboard synchronization is requested over the same control socket, so
-    // there is no need for a specific synchronization mechanism
-    kb->key_processor.async_paste = false;
-    kb->key_processor.hid = true;
-    kb->key_processor.ops = &ops;
-
-    static const struct sc_uhid_receiver_ops uhid_receiver_ops = {
-        .process_output = sc_uhid_receiver_process_output,
-    };
-
-    kb->uhid_receiver.id = UHID_KEYBOARD_ID;
-    kb->uhid_receiver.ops = &uhid_receiver_ops;
-    sc_uhid_devices_add_receiver(uhid_devices, &kb->uhid_receiver);
-
-    struct sc_control_msg msg;
-    msg.type = SC_CONTROL_MSG_TYPE_UHID_CREATE;
-    msg.uhid_create.id = UHID_KEYBOARD_ID;
-    msg.uhid_create.report_desc = SC_HID_KEYBOARD_REPORT_DESC;
-    msg.uhid_create.report_desc_size = SC_HID_KEYBOARD_REPORT_DESC_LEN;
-    if (!sc_controller_push_msg(controller, &msg)) {
-        LOGE("Could not send UHID_CREATE message (keyboard)");
-        return false;
-    }
-
-    return true;
-}

app/src/uhid/keyboard_uhid.h

@@ -1,27 +0,0 @@
-#ifndef SC_KEYBOARD_UHID_H
-#define SC_KEYBOARD_UHID_H
-
-#include "common.h"
-
-#include <stdbool.h>
-
-#include "controller.h"
-#include "hid/hid_keyboard.h"
-#include "uhid/uhid_output.h"
-#include "trait/key_processor.h"
-
-struct sc_keyboard_uhid {
-    struct sc_key_processor key_processor; // key processor trait
-    struct sc_uhid_receiver uhid_receiver;
-
-    struct sc_hid_keyboard hid;
-    struct sc_controller *controller;
-    atomic_uint_least16_t device_mod;
-};
-
-bool
-sc_keyboard_uhid_init(struct sc_keyboard_uhid *kb,
-                      struct sc_controller *controller,
-                      struct sc_uhid_devices *uhid_devices);
-
-#endif

app/src/uhid/mouse_uhid.c

@@ -1,89 +0,0 @@
-#include "mouse_uhid.h"
-
-#include "hid/hid_mouse.h"
-#include "input_events.h"
-#include "util/log.h"
-
-/** Downcast mouse processor to mouse_uhid */
-#define DOWNCAST(MP) container_of(MP, struct sc_mouse_uhid, mouse_processor)
-
-#define UHID_MOUSE_ID 2
-
-static void
-sc_mouse_uhid_send_input(struct sc_mouse_uhid *mouse,
-                         const struct sc_hid_event *event, const char *name) {
-    struct sc_control_msg msg;
-    msg.type = SC_CONTROL_MSG_TYPE_UHID_INPUT;
-    msg.uhid_input.id = UHID_MOUSE_ID;
-
-    assert(event->size <= SC_HID_MAX_SIZE);
-    memcpy(msg.uhid_input.data, event->data, event->size);
-    msg.uhid_input.size = event->size;
-
-    if (!sc_controller_push_msg(mouse->controller, &msg)) {
-        LOGE("Could not send UHID_INPUT message (%s)", name);
-    }
-}
-
-static void
-sc_mouse_processor_process_mouse_motion(struct sc_mouse_processor *mp,
-                                    const struct sc_mouse_motion_event *event) {
-    struct sc_mouse_uhid *mouse = DOWNCAST(mp);
-
-    struct sc_hid_event hid_event;
-    sc_hid_mouse_event_from_motion(&hid_event, event);
-
-    sc_mouse_uhid_send_input(mouse, &hid_event, "mouse motion");
-}
-
-static void
-sc_mouse_processor_process_mouse_click(struct sc_mouse_processor *mp,
-                                   const struct sc_mouse_click_event *event) {
-    struct sc_mouse_uhid *mouse = DOWNCAST(mp);
-
-    struct sc_hid_event hid_event;
-    sc_hid_mouse_event_from_click(&hid_event, event);
-
-    sc_mouse_uhid_send_input(mouse, &hid_event, "mouse click");
-}
-
-static void
-sc_mouse_processor_process_mouse_scroll(struct sc_mouse_processor *mp,
-                                    const struct sc_mouse_scroll_event *event) {
-    struct sc_mouse_uhid *mouse = DOWNCAST(mp);
-
-    struct sc_hid_event hid_event;
-    sc_hid_mouse_event_from_scroll(&hid_event, event);
-
-    sc_mouse_uhid_send_input(mouse, &hid_event, "mouse scroll");
-}
-
-bool
-sc_mouse_uhid_init(struct sc_mouse_uhid *mouse,
-                   struct sc_controller *controller) {
-    mouse->controller = controller;
-
-    static const struct sc_mouse_processor_ops ops = {
-        .process_mouse_motion = sc_mouse_processor_process_mouse_motion,
-        .process_mouse_click = sc_mouse_processor_process_mouse_click,
-        .process_mouse_scroll = sc_mouse_processor_process_mouse_scroll,
-        // Touch events not supported (coordinates are not relative)
-        .process_touch = NULL,
-    };
-
-    mouse->mouse_processor.ops = &ops;
-
-    mouse->mouse_processor.relative_mode = true;
-
-    struct sc_control_msg msg;
-    msg.type = SC_CONTROL_MSG_TYPE_UHID_CREATE;
-    msg.uhid_create.id = UHID_MOUSE_ID;
-    msg.uhid_create.report_desc = SC_HID_MOUSE_REPORT_DESC;
-    msg.uhid_create.report_desc_size = SC_HID_MOUSE_REPORT_DESC_LEN;
-    if (!sc_controller_push_msg(controller, &msg)) {
-        LOGE("Could not send UHID_CREATE message (mouse)");
-        return false;
-    }
-
-    return true;
-}

app/src/uhid/mouse_uhid.h

@@ -1,19 +0,0 @@
-#ifndef SC_MOUSE_UHID_H
-#define SC_MOUSE_UHID_H
-
-#include <stdbool.h>
-
-#include "controller.h"
-#include "trait/mouse_processor.h"
-
-struct sc_mouse_uhid {
-    struct sc_mouse_processor mouse_processor; // mouse processor trait
-
-    struct sc_controller *controller;
-};
-
-bool
-sc_mouse_uhid_init(struct sc_mouse_uhid *mouse,
-                   struct sc_controller *controller);
-
-#endif

app/src/uhid/uhid_output.c

@@ -1,25 +0,0 @@
-#include "uhid_output.h"
-
-#include <assert.h>
-
-void
-sc_uhid_devices_init(struct sc_uhid_devices *devices) {
-    devices->count = 0;
-}
-
-void
-sc_uhid_devices_add_receiver(struct sc_uhid_devices *devices,
-                             struct sc_uhid_receiver *receiver) {
-    assert(devices->count < SC_UHID_MAX_RECEIVERS);
-    devices->receivers[devices->count++] = receiver;
-}
-
-struct sc_uhid_receiver *
-sc_uhid_devices_get_receiver(struct sc_uhid_devices *devices, uint16_t id) {
-    for (size_t i = 0; i < devices->count; ++i) {
-        if (devices->receivers[i]->id == id) {
-            return devices->receivers[i];
-        }
-    }
-    return NULL;
-}

app/src/uhid/uhid_output.h

@@ -1,45 +0,0 @@
-#ifndef SC_UHID_OUTPUT_H
-#define SC_UHID_OUTPUT_H
-
-#include "common.h"
-
-#include <stdbool.h>
-#include <stdint.h>
-
-/**
- * The communication with UHID devices is bidirectional.
- *
- * This component manages the registration of receivers to handle UHID output
- * messages (sent from the device to the computer).
- */
-
-struct sc_uhid_receiver {
-    uint16_t id;
-
-    const struct sc_uhid_receiver_ops *ops;
-};
-
-struct sc_uhid_receiver_ops {
-    void
-    (*process_output)(struct sc_uhid_receiver *receiver,
-                      const uint8_t *data, size_t len);
-};
-
-#define SC_UHID_MAX_RECEIVERS 1
-
-struct sc_uhid_devices {
-    struct sc_uhid_receiver *receivers[SC_UHID_MAX_RECEIVERS];
-    unsigned count;
-};
-
-void
-sc_uhid_devices_init(struct sc_uhid_devices *devices);
-
-void
-sc_uhid_devices_add_receiver(struct sc_uhid_devices *devices,
-                             struct sc_uhid_receiver *receiver);
-
-struct sc_uhid_receiver *
-sc_uhid_devices_get_receiver(struct sc_uhid_devices *devices, uint16_t id);
-
-#endif

app/src/usb/aoa_hid.c

@@ -5,7 +5,6 @@
 
 #include "aoa_hid.h"
 #include "util/log.h"
-#include "util/str.h"
 
 // See <https://source.android.com/devices/accessories/aoa2#hid-support>.
 #define ACCESSORY_REGISTER_HID 54
@@ -15,18 +14,37 @@
 
 #define DEFAULT_TIMEOUT 1000
 
-#define SC_AOA_EVENT_QUEUE_MAX 64
+#define SC_HID_EVENT_QUEUE_MAX 64
 
 static void
-sc_hid_event_log(uint16_t accessory_id, const struct sc_hid_event *event) {
+sc_hid_event_log(const struct sc_hid_event *event) {
     // HID Event: [00] FF FF FF FF...
     assert(event->size);
-    char *hex = sc_str_to_hex_string(event->data, event->size);
-    if (!hex) {
+    unsigned buffer_size = event->size * 3 + 1;
+    char *buffer = malloc(buffer_size);
+    if (!buffer) {
+        LOG_OOM();
         return;
     }
-    LOGV("HID Event: [%d] %s", accessory_id, hex);
-    free(hex);
+    for (unsigned i = 0; i < event->size; ++i) {
+        snprintf(buffer + i * 3, 4, " %02x", event->buffer[i]);
+    }
+    LOGV("HID Event: [%d]%s", event->accessory_id, buffer);
+    free(buffer);
+}
+
+void
+sc_hid_event_init(struct sc_hid_event *hid_event, uint16_t accessory_id,
+                  unsigned char *buffer, uint16_t buffer_size) {
+    hid_event->accessory_id = accessory_id;
+    hid_event->buffer = buffer;
+    hid_event->size = buffer_size;
+    hid_event->ack_to_wait = SC_SEQUENCE_INVALID;
+}
+
+void
+sc_hid_event_destroy(struct sc_hid_event *hid_event) {
+    free(hid_event->buffer);
 }
 
 bool
@@ -34,7 +52,7 @@ sc_aoa_init(struct sc_aoa *aoa, struct sc_usb *usb,
             struct sc_acksync *acksync) {
     sc_vecdeque_init(&aoa->queue);
 
-    if (!sc_vecdeque_reserve(&aoa->queue, SC_AOA_EVENT_QUEUE_MAX)) {
+    if (!sc_vecdeque_reserve(&aoa->queue, SC_HID_EVENT_QUEUE_MAX)) {
         return false;
     }
 
@@ -58,7 +76,12 @@ sc_aoa_init(struct sc_aoa *aoa, struct sc_usb *usb,
 
 void
 sc_aoa_destroy(struct sc_aoa *aoa) {
-    sc_vecdeque_destroy(&aoa->queue);
+    // Destroy remaining events
+    while (!sc_vecdeque_is_empty(&aoa->queue)) {
+        struct sc_hid_event *event = sc_vecdeque_popref(&aoa->queue);
+        assert(event);
+        sc_hid_event_destroy(event);
+    }
 
     sc_cond_destroy(&aoa->event_cond);
     sc_mutex_destroy(&aoa->mutex);
@@ -74,10 +97,10 @@ sc_aoa_register_hid(struct sc_aoa *aoa, uint16_t accessory_id,
     // index (arg1): total length of the HID report descriptor
     uint16_t value = accessory_id;
     uint16_t index = report_desc_size;
-    unsigned char *data = NULL;
+    unsigned char *buffer = NULL;
     uint16_t length = 0;
     int result = libusb_control_transfer(aoa->usb->handle, request_type,
-                                         request, value, index, data, length,
+                                         request, value, index, buffer, length,
                                          DEFAULT_TIMEOUT);
     if (result < 0) {
         LOGE("REGISTER_HID: libusb error: %s", libusb_strerror(result));
@@ -90,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;
@@ -107,14 +130,14 @@ sc_aoa_set_hid_report_desc(struct sc_aoa *aoa, uint16_t accessory_id,
      * See <https://libusb.sourceforge.io/api-1.0/libusb_packetoverflow.html>
      */
     // value (arg0): accessory assigned ID for the HID device
-    // index (arg1): offset of data in descriptor
+    // index (arg1): offset of data (buffer) in descriptor
     uint16_t value = accessory_id;
     uint16_t index = 0;
     // libusb_control_transfer expects a pointer to non-const
-    unsigned char *data = (unsigned char *) report_desc;
+    unsigned char *buffer = (unsigned char *) report_desc;
     uint16_t length = report_desc_size;
     int result = libusb_control_transfer(aoa->usb->handle, request_type,
-                                         request, value, index, data, length,
+                                         request, value, index, buffer, length,
                                          DEFAULT_TIMEOUT);
     if (result < 0) {
         LOGE("SET_HID_REPORT_DESC: libusb error: %s", libusb_strerror(result));
@@ -127,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;
@@ -146,19 +169,18 @@ sc_aoa_setup_hid(struct sc_aoa *aoa, uint16_t accessory_id,
 }
 
 static bool
-sc_aoa_send_hid_event(struct sc_aoa *aoa, uint16_t accessory_id,
-                      const struct sc_hid_event *event) {
+sc_aoa_send_hid_event(struct sc_aoa *aoa, const struct sc_hid_event *event) {
     uint8_t request_type = LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR;
     uint8_t request = ACCESSORY_SEND_HID_EVENT;
     // <https://source.android.com/devices/accessories/aoa2.html#hid-support>
     // value (arg0): accessory assigned ID for the HID device
     // index (arg1): 0 (unused)
-    uint16_t value = accessory_id;
+    uint16_t value = event->accessory_id;
     uint16_t index = 0;
-    unsigned char *data = (uint8_t *) event->data; // discard const
+    unsigned char *buffer = event->buffer;
     uint16_t length = event->size;
     int result = libusb_control_transfer(aoa->usb->handle, request_type,
-                                         request, value, index, data, length,
+                                         request, value, index, buffer, length,
                                          DEFAULT_TIMEOUT);
     if (result < 0) {
         LOGE("SEND_HID_EVENT: libusb error: %s", libusb_strerror(result));
@@ -170,7 +192,7 @@ sc_aoa_send_hid_event(struct sc_aoa *aoa, uint16_t accessory_id,
 }
 
 bool
-sc_aoa_unregister_hid(struct sc_aoa *aoa, uint16_t accessory_id) {
+sc_aoa_unregister_hid(struct sc_aoa *aoa, const uint16_t accessory_id) {
     uint8_t request_type = LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR;
     uint8_t request = ACCESSORY_UNREGISTER_HID;
     // <https://source.android.com/devices/accessories/aoa2.html#hid-support>
@@ -178,10 +200,10 @@ sc_aoa_unregister_hid(struct sc_aoa *aoa, uint16_t accessory_id) {
     // index (arg1): 0
     uint16_t value = accessory_id;
     uint16_t index = 0;
-    unsigned char *data = NULL;
+    unsigned char *buffer = NULL;
     uint16_t length = 0;
     int result = libusb_control_transfer(aoa->usb->handle, request_type,
-                                         request, value, index, data, length,
+                                         request, value, index, buffer, length,
                                          DEFAULT_TIMEOUT);
     if (result < 0) {
         LOGE("UNREGISTER_HID: libusb error: %s", libusb_strerror(result));
@@ -193,25 +215,16 @@ sc_aoa_unregister_hid(struct sc_aoa *aoa, uint16_t accessory_id) {
 }
 
 bool
-sc_aoa_push_hid_event_with_ack_to_wait(struct sc_aoa *aoa,
-                                       uint16_t accessory_id,
-                                       const struct sc_hid_event *event,
-                                       uint64_t ack_to_wait) {
+sc_aoa_push_hid_event(struct sc_aoa *aoa, const struct sc_hid_event *event) {
     if (sc_get_log_level() <= SC_LOG_LEVEL_VERBOSE) {
-        sc_hid_event_log(accessory_id, event);
+        sc_hid_event_log(event);
     }
 
     sc_mutex_lock(&aoa->mutex);
     bool full = sc_vecdeque_is_full(&aoa->queue);
     if (!full) {
         bool was_empty = sc_vecdeque_is_empty(&aoa->queue);
-
-        struct sc_aoa_event *aoa_event =
-            sc_vecdeque_push_hole_noresize(&aoa->queue);
-        aoa_event->hid = *event;
-        aoa_event->accessory_id = accessory_id;
-        aoa_event->ack_to_wait = ack_to_wait;
-
+        sc_vecdeque_push_noresize(&aoa->queue, *event);
         if (was_empty) {
             sc_cond_signal(&aoa->event_cond);
         }
@@ -239,7 +252,7 @@ run_aoa_thread(void *data) {
         }
 
         assert(!sc_vecdeque_is_empty(&aoa->queue));
-        struct sc_aoa_event event = sc_vecdeque_pop(&aoa->queue);
+        struct sc_hid_event event = sc_vecdeque_pop(&aoa->queue);
         uint64_t ack_to_wait = event.ack_to_wait;
         sc_mutex_unlock(&aoa->mutex);
 
@@ -258,14 +271,17 @@ run_aoa_thread(void *data) {
 
             if (result == SC_ACKSYNC_WAIT_TIMEOUT) {
                 LOGW("Ack not received after 500ms, discarding HID event");
+                sc_hid_event_destroy(&event);
                 continue;
             } else if (result == SC_ACKSYNC_WAIT_INTR) {
                 // stopped
+                sc_hid_event_destroy(&event);
                 break;
             }
         }
 
-        bool ok = sc_aoa_send_hid_event(aoa, event.accessory_id, &event.hid);
+        bool ok = sc_aoa_send_hid_event(aoa, &event);
+        sc_hid_event_destroy(&event);
         if (!ok) {
             LOGW("Could not send HID event to USB device");
         }

app/src/usb/aoa_hid.h

@@ -6,22 +6,28 @@
 
 #include <libusb-1.0/libusb.h>
 
-#include "hid/hid_event.h"
 #include "usb.h"
 #include "util/acksync.h"
 #include "util/thread.h"
 #include "util/tick.h"
 #include "util/vecdeque.h"
 
-#define SC_HID_MAX_SIZE 8
-
-struct sc_aoa_event {
-    struct sc_hid_event hid;
+struct sc_hid_event {
     uint16_t accessory_id;
+    unsigned char *buffer;
+    uint16_t size;
     uint64_t ack_to_wait;
 };
 
-struct sc_aoa_event_queue SC_VECDEQUE(struct sc_aoa_event);
+// Takes ownership of buffer
+void
+sc_hid_event_init(struct sc_hid_event *hid_event, uint16_t accessory_id,
+                  unsigned char *buffer, uint16_t buffer_size);
+
+void
+sc_hid_event_destroy(struct sc_hid_event *hid_event);
+
+struct sc_hid_event_queue SC_VECDEQUE(struct sc_hid_event);
 
 struct sc_aoa {
     struct sc_usb *usb;
@@ -29,7 +35,7 @@ struct sc_aoa {
     sc_mutex mutex;
     sc_cond event_cond;
     bool stopped;
-    struct sc_aoa_event_queue queue;
+    struct sc_hid_event_queue queue;
 
     struct sc_acksync *acksync;
 };
@@ -51,22 +57,12 @@ 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);
 
 bool
-sc_aoa_push_hid_event_with_ack_to_wait(struct sc_aoa *aoa,
-                                       uint16_t accessory_id,
-                                       const struct sc_hid_event *event,
-                                       uint64_t ack_to_wait);
-
-static inline bool
-sc_aoa_push_hid_event(struct sc_aoa *aoa, uint16_t accessory_id,
-                      const struct sc_hid_event *event) {
-    return sc_aoa_push_hid_event_with_ack_to_wait(aoa, accessory_id, event,
-                                                  SC_SEQUENCE_INVALID);
-}
+sc_aoa_push_hid_event(struct sc_aoa *aoa, const struct sc_hid_event *event);
 
 #endif

app/src/usb/hid_keyboard.c

@@ -1,34 +1,40 @@
 #include "hid_keyboard.h"
 
-#include <string.h>
+#include <assert.h>
 
+#include "input_events.h"
 #include "util/log.h"
 
-#define SC_HID_MOD_NONE 0x00
-#define SC_HID_MOD_LEFT_CONTROL (1 << 0)
-#define SC_HID_MOD_LEFT_SHIFT (1 << 1)
-#define SC_HID_MOD_LEFT_ALT (1 << 2)
-#define SC_HID_MOD_LEFT_GUI (1 << 3)
-#define SC_HID_MOD_RIGHT_CONTROL (1 << 4)
-#define SC_HID_MOD_RIGHT_SHIFT (1 << 5)
-#define SC_HID_MOD_RIGHT_ALT (1 << 6)
-#define SC_HID_MOD_RIGHT_GUI (1 << 7)
+/** Downcast key processor to hid_keyboard */
+#define DOWNCAST(KP) container_of(KP, struct sc_hid_keyboard, key_processor)
 
-#define SC_HID_KEYBOARD_INDEX_MODS 0
-#define SC_HID_KEYBOARD_INDEX_KEYS 2
+#define HID_KEYBOARD_ACCESSORY_ID 1
+
+#define HID_MODIFIER_NONE 0x00
+#define HID_MODIFIER_LEFT_CONTROL (1 << 0)
+#define HID_MODIFIER_LEFT_SHIFT (1 << 1)
+#define HID_MODIFIER_LEFT_ALT (1 << 2)
+#define HID_MODIFIER_LEFT_GUI (1 << 3)
+#define HID_MODIFIER_RIGHT_CONTROL (1 << 4)
+#define HID_MODIFIER_RIGHT_SHIFT (1 << 5)
+#define HID_MODIFIER_RIGHT_ALT (1 << 6)
+#define HID_MODIFIER_RIGHT_GUI (1 << 7)
+
+#define HID_KEYBOARD_INDEX_MODIFIER 0
+#define HID_KEYBOARD_INDEX_KEYS 2
 
 // USB HID protocol says 6 keys in an event is the requirement for BIOS
 // keyboard support, though OS could support more keys via modifying the report
 // desc. 6 should be enough for scrcpy.
-#define SC_HID_KEYBOARD_MAX_KEYS 6
-#define SC_HID_KEYBOARD_EVENT_SIZE \
-    (SC_HID_KEYBOARD_INDEX_KEYS + SC_HID_KEYBOARD_MAX_KEYS)
+#define HID_KEYBOARD_MAX_KEYS 6
+#define HID_KEYBOARD_EVENT_SIZE \
+    (HID_KEYBOARD_INDEX_KEYS + HID_KEYBOARD_MAX_KEYS)
 
-#define SC_HID_RESERVED 0x00
-#define SC_HID_ERROR_ROLL_OVER 0x01
+#define HID_RESERVED 0x00
+#define HID_ERROR_ROLL_OVER 0x01
 
 /**
- * For HID, only report descriptor is needed.
+ * For HID over AOAv2, only report descriptor is needed.
  *
  * The specification is available here:
  * <https://www.usb.org/sites/default/files/hid1_11.pdf>
@@ -47,7 +53,7 @@
  *
  * (change vid:pid' to your device's vendor ID and product ID).
  */
-const uint8_t SC_HID_KEYBOARD_REPORT_DESC[] = {
+static const unsigned char keyboard_report_desc[]  = {
     // Usage Page (Generic Desktop)
     0x05, 0x01,
     // Usage (Keyboard)
@@ -113,7 +119,7 @@ const uint8_t SC_HID_KEYBOARD_REPORT_DESC[] = {
     // Report Size (8)
     0x75, 0x08,
     // Report Count (6)
-    0x95, SC_HID_KEYBOARD_MAX_KEYS,
+    0x95, HID_KEYBOARD_MAX_KEYS,
     // Input (Data, Array): Keys
     0x81, 0x00,
 
@@ -121,9 +127,6 @@ const uint8_t SC_HID_KEYBOARD_REPORT_DESC[] = {
     0xC0
 };
 
-const size_t SC_HID_KEYBOARD_REPORT_DESC_LEN =
-    sizeof(SC_HID_KEYBOARD_REPORT_DESC);
-
 /**
  * A keyboard HID event is 8 bytes long:
  *
@@ -198,50 +201,51 @@ const size_t SC_HID_KEYBOARD_REPORT_DESC_LEN =
  *                  +---------------+
  */
 
-static void
-sc_hid_keyboard_event_init(struct sc_hid_event *hid_event) {
-    hid_event->size = SC_HID_KEYBOARD_EVENT_SIZE;
-
-    uint8_t *data = hid_event->data;
-
-    data[SC_HID_KEYBOARD_INDEX_MODS] = SC_HID_MOD_NONE;
-    data[1] = SC_HID_RESERVED;
-    memset(&data[SC_HID_KEYBOARD_INDEX_KEYS], 0, SC_HID_KEYBOARD_MAX_KEYS);
-}
-
-static uint16_t
-sc_hid_mod_from_sdl_keymod(uint16_t mod) {
-    uint16_t mods = SC_HID_MOD_NONE;
+static unsigned char
+sdl_keymod_to_hid_modifiers(uint16_t mod) {
+    unsigned char modifiers = HID_MODIFIER_NONE;
     if (mod & SC_MOD_LCTRL) {
-        mods |= SC_HID_MOD_LEFT_CONTROL;
+        modifiers |= HID_MODIFIER_LEFT_CONTROL;
     }
     if (mod & SC_MOD_LSHIFT) {
-        mods |= SC_HID_MOD_LEFT_SHIFT;
+        modifiers |= HID_MODIFIER_LEFT_SHIFT;
     }
     if (mod & SC_MOD_LALT) {
-        mods |= SC_HID_MOD_LEFT_ALT;
+        modifiers |= HID_MODIFIER_LEFT_ALT;
     }
     if (mod & SC_MOD_LGUI) {
-        mods |= SC_HID_MOD_LEFT_GUI;
+        modifiers |= HID_MODIFIER_LEFT_GUI;
     }
     if (mod & SC_MOD_RCTRL) {
-        mods |= SC_HID_MOD_RIGHT_CONTROL;
+        modifiers |= HID_MODIFIER_RIGHT_CONTROL;
     }
     if (mod & SC_MOD_RSHIFT) {
-        mods |= SC_HID_MOD_RIGHT_SHIFT;
+        modifiers |= HID_MODIFIER_RIGHT_SHIFT;
     }
     if (mod & SC_MOD_RALT) {
-        mods |= SC_HID_MOD_RIGHT_ALT;
+        modifiers |= HID_MODIFIER_RIGHT_ALT;
     }
     if (mod & SC_MOD_RGUI) {
-        mods |= SC_HID_MOD_RIGHT_GUI;
+        modifiers |= HID_MODIFIER_RIGHT_GUI;
     }
-    return mods;
+    return modifiers;
 }
 
-void
-sc_hid_keyboard_init(struct sc_hid_keyboard *hid) {
-    memset(hid->keys, false, SC_HID_KEYBOARD_KEYS);
+static bool
+sc_hid_keyboard_event_init(struct sc_hid_event *hid_event) {
+    unsigned char *buffer = malloc(HID_KEYBOARD_EVENT_SIZE);
+    if (!buffer) {
+        LOG_OOM();
+        return false;
+    }
+
+    buffer[HID_KEYBOARD_INDEX_MODIFIER] = HID_MODIFIER_NONE;
+    buffer[1] = HID_RESERVED;
+    memset(&buffer[HID_KEYBOARD_INDEX_KEYS], 0, HID_KEYBOARD_MAX_KEYS);
+
+    sc_hid_event_init(hid_event, HID_KEYBOARD_ACCESSORY_ID, buffer,
+                      HID_KEYBOARD_EVENT_SIZE);
+    return true;
 }
 
 static inline bool
@@ -249,10 +253,10 @@ scancode_is_modifier(enum sc_scancode scancode) {
     return scancode >= SC_SCANCODE_LCTRL && scancode <= SC_SCANCODE_RGUI;
 }
 
-bool
-sc_hid_keyboard_event_from_key(struct sc_hid_keyboard *hid,
-                               struct sc_hid_event *hid_event,
-                               const struct sc_key_event *event) {
+static bool
+convert_hid_keyboard_event(struct sc_hid_keyboard *kb,
+                           struct sc_hid_event *hid_event,
+                           const struct sc_key_event *event) {
     enum sc_scancode scancode = event->scancode;
     assert(scancode >= 0);
 
@@ -264,37 +268,39 @@ sc_hid_keyboard_event_from_key(struct sc_hid_keyboard *hid,
         return false;
     }
 
-    sc_hid_keyboard_event_init(hid_event);
+    if (!sc_hid_keyboard_event_init(hid_event)) {
+        LOGW("Could not initialize HID keyboard event");
+        return false;
+    }
 
-    uint16_t mods = sc_hid_mod_from_sdl_keymod(event->mods_state);
+    unsigned char modifiers = sdl_keymod_to_hid_modifiers(event->mods_state);
 
     if (scancode < SC_HID_KEYBOARD_KEYS) {
         // Pressed is true and released is false
-        hid->keys[scancode] = (event->action == SC_ACTION_DOWN);
+        kb->keys[scancode] = (event->action == SC_ACTION_DOWN);
         LOGV("keys[%02x] = %s", scancode,
-             hid->keys[scancode] ? "true" : "false");
+             kb->keys[scancode] ? "true" : "false");
     }
 
-    hid_event->data[SC_HID_KEYBOARD_INDEX_MODS] = mods;
+    hid_event->buffer[HID_KEYBOARD_INDEX_MODIFIER] = modifiers;
 
-    uint8_t *keys_data = &hid_event->data[SC_HID_KEYBOARD_INDEX_KEYS];
+    unsigned char *keys_buffer = &hid_event->buffer[HID_KEYBOARD_INDEX_KEYS];
     // Re-calculate pressed keys every time
     int keys_pressed_count = 0;
     for (int i = 0; i < SC_HID_KEYBOARD_KEYS; ++i) {
-        if (hid->keys[i]) {
+        if (kb->keys[i]) {
             // USB HID protocol says that if keys exceeds report count, a
             // phantom state should be reported
-            if (keys_pressed_count >= SC_HID_KEYBOARD_MAX_KEYS) {
+            if (keys_pressed_count >= HID_KEYBOARD_MAX_KEYS) {
                 // Phantom state:
                 //  - Modifiers
                 //  - Reserved
                 //  - ErrorRollOver * HID_MAX_KEYS
-                memset(keys_data, SC_HID_ERROR_ROLL_OVER,
-                       SC_HID_KEYBOARD_MAX_KEYS);
+                memset(keys_buffer, HID_ERROR_ROLL_OVER, HID_KEYBOARD_MAX_KEYS);
                 goto end;
             }
 
-            keys_data[keys_pressed_count] = i;
+            keys_buffer[keys_pressed_count] = i;
             ++keys_pressed_count;
         }
     }
@@ -302,32 +308,124 @@ sc_hid_keyboard_event_from_key(struct sc_hid_keyboard *hid,
 end:
     LOGV("hid keyboard: key %-4s scancode=%02x (%u) mod=%02x",
          event->action == SC_ACTION_DOWN ? "down" : "up", event->scancode,
-         event->scancode, mods);
+         event->scancode, modifiers);
 
     return true;
 }
 
-bool
-sc_hid_keyboard_event_from_mods(struct sc_hid_event *event,
-                                uint16_t mods_state) {
+
+static bool
+push_mod_lock_state(struct sc_hid_keyboard *kb, uint16_t mods_state) {
     bool capslock = mods_state & SC_MOD_CAPS;
     bool numlock = mods_state & SC_MOD_NUM;
     if (!capslock && !numlock) {
         // Nothing to do
+        return true;
+    }
+
+    struct sc_hid_event hid_event;
+    if (!sc_hid_keyboard_event_init(&hid_event)) {
+        LOGW("Could not initialize HID keyboard event");
         return false;
     }
 
-    sc_hid_keyboard_event_init(event);
-
     unsigned i = 0;
     if (capslock) {
-        event->data[SC_HID_KEYBOARD_INDEX_KEYS + i] = SC_SCANCODE_CAPSLOCK;
+        hid_event.buffer[HID_KEYBOARD_INDEX_KEYS + i] = SC_SCANCODE_CAPSLOCK;
         ++i;
     }
     if (numlock) {
-        event->data[SC_HID_KEYBOARD_INDEX_KEYS + i] = SC_SCANCODE_NUMLOCK;
+        hid_event.buffer[HID_KEYBOARD_INDEX_KEYS + i] = SC_SCANCODE_NUMLOCK;
         ++i;
     }
 
+    if (!sc_aoa_push_hid_event(kb->aoa, &hid_event)) {
+        sc_hid_event_destroy(&hid_event);
+        LOGW("Could not request HID event (mod lock state)");
+        return false;
+    }
+
+    LOGD("HID keyboard state synchronized");
+
     return true;
 }
+
+static void
+sc_key_processor_process_key(struct sc_key_processor *kp,
+                             const struct sc_key_event *event,
+                             uint64_t ack_to_wait) {
+    if (event->repeat) {
+        // In USB HID protocol, key repeat is handled by the host (Android), so
+        // just ignore key repeat here.
+        return;
+    }
+
+    struct sc_hid_keyboard *kb = DOWNCAST(kp);
+
+    struct sc_hid_event hid_event;
+    // Not all keys are supported, just ignore unsupported keys
+    if (convert_hid_keyboard_event(kb, &hid_event, event)) {
+        if (!kb->mod_lock_synchronized) {
+            // Inject CAPSLOCK and/or NUMLOCK if necessary to synchronize
+            // keyboard state
+            if (push_mod_lock_state(kb, event->mods_state)) {
+                kb->mod_lock_synchronized = true;
+            }
+        }
+
+        if (ack_to_wait) {
+            // Ctrl+v is pressed, so clipboard synchronization has been
+            // requested. Wait until clipboard synchronization is acknowledged
+            // by the server, otherwise it could paste the old clipboard
+            // content.
+            hid_event.ack_to_wait = ack_to_wait;
+        }
+
+        if (!sc_aoa_push_hid_event(kb->aoa, &hid_event)) {
+            sc_hid_event_destroy(&hid_event);
+            LOGW("Could not request HID event (key)");
+        }
+    }
+}
+
+bool
+sc_hid_keyboard_init(struct sc_hid_keyboard *kb, struct sc_aoa *aoa) {
+    kb->aoa = aoa;
+
+    bool ok = sc_aoa_setup_hid(aoa, HID_KEYBOARD_ACCESSORY_ID,
+                               keyboard_report_desc,
+                               ARRAY_LEN(keyboard_report_desc));
+    if (!ok) {
+        LOGW("Register HID keyboard failed");
+        return false;
+    }
+
+    // Reset all states
+    memset(kb->keys, false, SC_HID_KEYBOARD_KEYS);
+
+    kb->mod_lock_synchronized = false;
+
+    static const struct sc_key_processor_ops ops = {
+        .process_key = sc_key_processor_process_key,
+        // Never forward text input via HID (all the keys are injected
+        // separately)
+        .process_text = NULL,
+    };
+
+    // Clipboard synchronization is requested over the control socket, while HID
+    // events are sent over AOA, so it must wait for clipboard synchronization
+    // to be acknowledged by the device before injecting Ctrl+v.
+    kb->key_processor.async_paste = true;
+    kb->key_processor.ops = &ops;
+
+    return true;
+}
+
+void
+sc_hid_keyboard_destroy(struct sc_hid_keyboard *kb) {
+    // Unregister HID keyboard so the soft keyboard shows again on Android
+    bool ok = sc_aoa_unregister_hid(kb->aoa, HID_KEYBOARD_ACCESSORY_ID);
+    if (!ok) {
+        LOGW("Could not unregister HID keyboard");
+    }
+}

app/src/usb/hid_keyboard.h

@@ -5,8 +5,8 @@
 
 #include <stdbool.h>
 
-#include "hid/hid_event.h"
-#include "input_events.h"
+#include "aoa_hid.h"
+#include "trait/key_processor.h"
 
 // See "SDL2/SDL_scancode.h".
 // Maybe SDL_Keycode is used by most people, but SDL_Scancode is taken from USB
@@ -14,9 +14,6 @@
 // 0x65 is Application, typically AT-101 Keyboard ends here.
 #define SC_HID_KEYBOARD_KEYS 0x66
 
-extern const uint8_t SC_HID_KEYBOARD_REPORT_DESC[];
-extern const size_t SC_HID_KEYBOARD_REPORT_DESC_LEN;
-
 /**
  * HID keyboard events are sequence-based, every time keyboard state changes
  * it sends an array of currently pressed keys, the host is responsible for
@@ -30,19 +27,18 @@ extern const size_t SC_HID_KEYBOARD_REPORT_DESC_LEN;
  * phantom state.
  */
 struct sc_hid_keyboard {
+    struct sc_key_processor key_processor; // key processor trait
+
+    struct sc_aoa *aoa;
     bool keys[SC_HID_KEYBOARD_KEYS];
+
+    bool mod_lock_synchronized;
 };
 
+bool
+sc_hid_keyboard_init(struct sc_hid_keyboard *kb, struct sc_aoa *aoa);
+
 void
-sc_hid_keyboard_init(struct sc_hid_keyboard *hid);
-
-bool
-sc_hid_keyboard_event_from_key(struct sc_hid_keyboard *hid,
-                               struct sc_hid_event *hid_event,
-                               const struct sc_key_event *event);
-
-bool
-sc_hid_keyboard_event_from_mods(struct sc_hid_event *event,
-                                uint16_t mods_state);
+sc_hid_keyboard_destroy(struct sc_hid_keyboard *kb);
 
 #endif

app/src/usb/hid_mouse.c

@@ -0,0 +1,267 @@
+#include "hid_mouse.h"
+
+#include <assert.h>
+
+#include "input_events.h"
+#include "util/log.h"
+
+/** Downcast mouse processor to hid_mouse */
+#define DOWNCAST(MP) container_of(MP, struct sc_hid_mouse, mouse_processor)
+
+#define HID_MOUSE_ACCESSORY_ID 2
+
+// 1 byte for buttons + padding, 1 byte for X position, 1 byte for Y position
+#define HID_MOUSE_EVENT_SIZE 4
+
+/**
+ * Mouse descriptor from the specification:
+ * <https://www.usb.org/sites/default/files/hid1_11.pdf>
+ *
+ * Appendix E (p71): §E.10 Report Descriptor (Mouse)
+ *
+ * The usage tags (like Wheel) are listed in "HID Usage Tables":
+ * <https://www.usb.org/sites/default/files/documents/hut1_12v2.pdf>
+ * §4 Generic Desktop Page (0x01) (p26)
+ */
+static const unsigned char mouse_report_desc[]  = {
+    // Usage Page (Generic Desktop)
+    0x05, 0x01,
+    // Usage (Mouse)
+    0x09, 0x02,
+
+    // Collection (Application)
+    0xA1, 0x01,
+
+    // Usage (Pointer)
+    0x09, 0x01,
+
+    // Collection (Physical)
+    0xA1, 0x00,
+
+    // Usage Page (Buttons)
+    0x05, 0x09,
+
+    // Usage Minimum (1)
+    0x19, 0x01,
+     // Usage Maximum (5)
+    0x29, 0x05,
+    // Logical Minimum (0)
+    0x15, 0x00,
+    // Logical Maximum (1)
+    0x25, 0x01,
+    // Report Count (5)
+    0x95, 0x05,
+    // Report Size (1)
+    0x75, 0x01,
+    // Input (Data, Variable, Absolute): 5 buttons bits
+    0x81, 0x02,
+
+    // Report Count (1)
+    0x95, 0x01,
+    // Report Size (3)
+    0x75, 0x03,
+    // Input (Constant): 3 bits padding
+    0x81, 0x01,
+
+    // Usage Page (Generic Desktop)
+    0x05, 0x01,
+    // Usage (X)
+    0x09, 0x30,
+    // Usage (Y)
+    0x09, 0x31,
+    // Usage (Wheel)
+    0x09, 0x38,
+    // Local Minimum (-127)
+    0x15, 0x81,
+    // Local Maximum (127)
+    0x25, 0x7F,
+    // Report Size (8)
+    0x75, 0x08,
+    // Report Count (3)
+    0x95, 0x03,
+    // Input (Data, Variable, Relative): 3 position bytes (X, Y, Wheel)
+    0x81, 0x06,
+
+    // End Collection
+    0xC0,
+
+    // End Collection
+    0xC0,
+};
+
+/**
+ * A mouse HID event is 3 bytes long:
+ *
+ *  - byte 0: buttons state
+ *  - byte 1: relative x motion (signed byte from -127 to 127)
+ *  - byte 2: relative y motion (signed byte from -127 to 127)
+ *
+ *                   7 6 5 4 3 2 1 0
+ *                  +---------------+
+ *         byte 0:  |0 0 0 . . . . .| buttons state
+ *                  +---------------+
+ *                         ^ ^ ^ ^ ^
+ *                         | | | | `- left button
+ *                         | | | `--- right button
+ *                         | | `----- middle button
+ *                         | `------- button 4
+ *                         `--------- button 5
+ *
+ *                  +---------------+
+ *         byte 1:  |. . . . . . . .| relative x motion
+ *                  +---------------+
+ *         byte 2:  |. . . . . . . .| relative y motion
+ *                  +---------------+
+ *         byte 3:  |. . . . . . . .| wheel motion (-1, 0 or 1)
+ *                  +---------------+
+ *
+ * As an example, here is the report for a motion of (x=5, y=-4) with left
+ * button pressed:
+ *
+ *                  +---------------+
+ *                  |0 0 0 0 0 0 0 1| left button pressed
+ *                  +---------------+
+ *                  |0 0 0 0 0 1 0 1| horizontal motion (x = 5)
+ *                  +---------------+
+ *                  |1 1 1 1 1 1 0 0| relative y motion (y = -4)
+ *                  +---------------+
+ *                  |0 0 0 0 0 0 0 0| wheel motion
+ *                  +---------------+
+ */
+
+static bool
+sc_hid_mouse_event_init(struct sc_hid_event *hid_event) {
+    unsigned char *buffer = calloc(1, HID_MOUSE_EVENT_SIZE);
+    if (!buffer) {
+        LOG_OOM();
+        return false;
+    }
+
+    sc_hid_event_init(hid_event, HID_MOUSE_ACCESSORY_ID, buffer,
+                      HID_MOUSE_EVENT_SIZE);
+    return true;
+}
+
+static unsigned char
+buttons_state_to_hid_buttons(uint8_t buttons_state) {
+    unsigned char c = 0;
+    if (buttons_state & SC_MOUSE_BUTTON_LEFT) {
+        c |= 1 << 0;
+    }
+    if (buttons_state & SC_MOUSE_BUTTON_RIGHT) {
+        c |= 1 << 1;
+    }
+    if (buttons_state & SC_MOUSE_BUTTON_MIDDLE) {
+        c |= 1 << 2;
+    }
+    if (buttons_state & SC_MOUSE_BUTTON_X1) {
+        c |= 1 << 3;
+    }
+    if (buttons_state & SC_MOUSE_BUTTON_X2) {
+        c |= 1 << 4;
+    }
+    return c;
+}
+
+static void
+sc_mouse_processor_process_mouse_motion(struct sc_mouse_processor *mp,
+                                    const struct sc_mouse_motion_event *event) {
+    struct sc_hid_mouse *mouse = DOWNCAST(mp);
+
+    struct sc_hid_event hid_event;
+    if (!sc_hid_mouse_event_init(&hid_event)) {
+        return;
+    }
+
+    unsigned char *buffer = hid_event.buffer;
+    buffer[0] = buttons_state_to_hid_buttons(event->buttons_state);
+    buffer[1] = CLAMP(event->xrel, -127, 127);
+    buffer[2] = CLAMP(event->yrel, -127, 127);
+    buffer[3] = 0; // wheel coordinates only used for scrolling
+
+    if (!sc_aoa_push_hid_event(mouse->aoa, &hid_event)) {
+        sc_hid_event_destroy(&hid_event);
+        LOGW("Could not request HID event (mouse motion)");
+    }
+}
+
+static void
+sc_mouse_processor_process_mouse_click(struct sc_mouse_processor *mp,
+                                   const struct sc_mouse_click_event *event) {
+    struct sc_hid_mouse *mouse = DOWNCAST(mp);
+
+    struct sc_hid_event hid_event;
+    if (!sc_hid_mouse_event_init(&hid_event)) {
+        return;
+    }
+
+    unsigned char *buffer = hid_event.buffer;
+    buffer[0] = buttons_state_to_hid_buttons(event->buttons_state);
+    buffer[1] = 0; // no x motion
+    buffer[2] = 0; // no y motion
+    buffer[3] = 0; // wheel coordinates only used for scrolling
+
+    if (!sc_aoa_push_hid_event(mouse->aoa, &hid_event)) {
+        sc_hid_event_destroy(&hid_event);
+        LOGW("Could not request HID event (mouse click)");
+    }
+}
+
+static void
+sc_mouse_processor_process_mouse_scroll(struct sc_mouse_processor *mp,
+                                    const struct sc_mouse_scroll_event *event) {
+    struct sc_hid_mouse *mouse = DOWNCAST(mp);
+
+    struct sc_hid_event hid_event;
+    if (!sc_hid_mouse_event_init(&hid_event)) {
+        return;
+    }
+
+    unsigned char *buffer = hid_event.buffer;
+    buffer[0] = 0; // buttons state irrelevant (and unknown)
+    buffer[1] = 0; // no x motion
+    buffer[2] = 0; // no y motion
+    // In practice, vscroll is always -1, 0 or 1, but in theory other values
+    // are possible
+    buffer[3] = CLAMP(event->vscroll, -127, 127);
+    // Horizontal scrolling ignored
+
+    if (!sc_aoa_push_hid_event(mouse->aoa, &hid_event)) {
+        sc_hid_event_destroy(&hid_event);
+        LOGW("Could not request HID event (mouse scroll)");
+    }
+}
+
+bool
+sc_hid_mouse_init(struct sc_hid_mouse *mouse, struct sc_aoa *aoa) {
+    mouse->aoa = aoa;
+
+    bool ok = sc_aoa_setup_hid(aoa, HID_MOUSE_ACCESSORY_ID, mouse_report_desc,
+                               ARRAY_LEN(mouse_report_desc));
+    if (!ok) {
+        LOGW("Register HID mouse failed");
+        return false;
+    }
+
+    static const struct sc_mouse_processor_ops ops = {
+        .process_mouse_motion = sc_mouse_processor_process_mouse_motion,
+        .process_mouse_click = sc_mouse_processor_process_mouse_click,
+        .process_mouse_scroll = sc_mouse_processor_process_mouse_scroll,
+        // Touch events not supported (coordinates are not relative)
+        .process_touch = NULL,
+    };
+
+    mouse->mouse_processor.ops = &ops;
+
+    mouse->mouse_processor.relative_mode = true;
+
+    return true;
+}
+
+void
+sc_hid_mouse_destroy(struct sc_hid_mouse *mouse) {
+    bool ok = sc_aoa_unregister_hid(mouse->aoa, HID_MOUSE_ACCESSORY_ID);
+    if (!ok) {
+        LOGW("Could not unregister HID mouse");
+    }
+}

app/src/usb/hid_mouse.h

@@ -1,5 +1,5 @@
-#ifndef SC_MOUSE_AOA_H
-#define SC_MOUSE_AOA_H
+#ifndef SC_HID_MOUSE_H
+#define SC_HID_MOUSE_H
 
 #include "common.h"
 
@@ -8,16 +8,16 @@
 #include "aoa_hid.h"
 #include "trait/mouse_processor.h"
 
-struct sc_mouse_aoa {
+struct sc_hid_mouse {
     struct sc_mouse_processor mouse_processor; // mouse processor trait
 
     struct sc_aoa *aoa;
 };
 
 bool
-sc_mouse_aoa_init(struct sc_mouse_aoa *mouse, struct sc_aoa *aoa);
+sc_hid_mouse_init(struct sc_hid_mouse *mouse, struct sc_aoa *aoa);
 
 void
-sc_mouse_aoa_destroy(struct sc_mouse_aoa *mouse);
+sc_hid_mouse_destroy(struct sc_hid_mouse *mouse);
 
 #endif

app/src/usb/keyboard_aoa.c

@@ -1,110 +0,0 @@
-#include "keyboard_aoa.h"
-
-#include <assert.h>
-
-#include "input_events.h"
-#include "util/log.h"
-
-/** Downcast key processor to keyboard_aoa */
-#define DOWNCAST(KP) container_of(KP, struct sc_keyboard_aoa, key_processor)
-
-#define HID_KEYBOARD_ACCESSORY_ID 1
-
-static bool
-push_mod_lock_state(struct sc_keyboard_aoa *kb, uint16_t mods_state) {
-    struct sc_hid_event hid_event;
-    if (!sc_hid_keyboard_event_from_mods(&hid_event, mods_state)) {
-        // Nothing to do
-        return true;
-    }
-
-    if (!sc_aoa_push_hid_event(kb->aoa, HID_KEYBOARD_ACCESSORY_ID,
-                               &hid_event)) {
-        LOGW("Could not request HID event (mod lock state)");
-        return false;
-    }
-
-    LOGD("HID keyboard state synchronized");
-
-    return true;
-}
-
-static void
-sc_key_processor_process_key(struct sc_key_processor *kp,
-                             const struct sc_key_event *event,
-                             uint64_t ack_to_wait) {
-    if (event->repeat) {
-        // In USB HID protocol, key repeat is handled by the host (Android), so
-        // just ignore key repeat here.
-        return;
-    }
-
-    struct sc_keyboard_aoa *kb = DOWNCAST(kp);
-
-    struct sc_hid_event hid_event;
-
-    // Not all keys are supported, just ignore unsupported keys
-    if (sc_hid_keyboard_event_from_key(&kb->hid, &hid_event, event)) {
-        if (!kb->mod_lock_synchronized) {
-            // Inject CAPSLOCK and/or NUMLOCK if necessary to synchronize
-            // keyboard state
-            if (push_mod_lock_state(kb, event->mods_state)) {
-                kb->mod_lock_synchronized = true;
-            }
-        }
-
-        // If ack_to_wait is != SC_SEQUENCE_INVALID, then Ctrl+v is pressed, so
-        // clipboard synchronization has been requested. Wait until clipboard
-        // synchronization is acknowledged by the server, otherwise it could
-        // paste the old clipboard content.
-
-        if (!sc_aoa_push_hid_event_with_ack_to_wait(kb->aoa,
-                                                    HID_KEYBOARD_ACCESSORY_ID,
-                                                    &hid_event,
-                                                    ack_to_wait)) {
-            LOGW("Could not request HID event (key)");
-        }
-    }
-}
-
-bool
-sc_keyboard_aoa_init(struct sc_keyboard_aoa *kb, struct sc_aoa *aoa) {
-    kb->aoa = aoa;
-
-    bool ok = sc_aoa_setup_hid(aoa, HID_KEYBOARD_ACCESSORY_ID,
-                               SC_HID_KEYBOARD_REPORT_DESC,
-                               SC_HID_KEYBOARD_REPORT_DESC_LEN);
-    if (!ok) {
-        LOGW("Register HID keyboard failed");
-        return false;
-    }
-
-    sc_hid_keyboard_init(&kb->hid);
-
-    kb->mod_lock_synchronized = false;
-
-    static const struct sc_key_processor_ops ops = {
-        .process_key = sc_key_processor_process_key,
-        // Never forward text input via HID (all the keys are injected
-        // separately)
-        .process_text = NULL,
-    };
-
-    // Clipboard synchronization is requested over the control socket, while HID
-    // events are sent over AOA, so it must wait for clipboard synchronization
-    // to be acknowledged by the device before injecting Ctrl+v.
-    kb->key_processor.async_paste = true;
-    kb->key_processor.hid = true;
-    kb->key_processor.ops = &ops;
-
-    return true;
-}
-
-void
-sc_keyboard_aoa_destroy(struct sc_keyboard_aoa *kb) {
-    // Unregister HID keyboard so the soft keyboard shows again on Android
-    bool ok = sc_aoa_unregister_hid(kb->aoa, HID_KEYBOARD_ACCESSORY_ID);
-    if (!ok) {
-        LOGW("Could not unregister HID keyboard");
-    }
-}

app/src/usb/keyboard_aoa.h

@@ -1,27 +0,0 @@
-#ifndef SC_KEYBOARD_AOA_H
-#define SC_KEYBOARD_AOA_H
-
-#include "common.h"
-
-#include <stdbool.h>
-
-#include "aoa_hid.h"
-#include "hid/hid_keyboard.h"
-#include "trait/key_processor.h"
-
-struct sc_keyboard_aoa {
-    struct sc_key_processor key_processor; // key processor trait
-
-    struct sc_hid_keyboard hid;
-    struct sc_aoa *aoa;
-
-    bool mod_lock_synchronized;
-};
-
-bool
-sc_keyboard_aoa_init(struct sc_keyboard_aoa *kb, struct sc_aoa *aoa);
-
-void
-sc_keyboard_aoa_destroy(struct sc_keyboard_aoa *kb);
-
-#endif

app/src/usb/mouse_aoa.c

@@ -1,89 +0,0 @@
-#include "mouse_aoa.h"
-
-#include <assert.h>
-
-#include "hid/hid_mouse.h"
-#include "input_events.h"
-#include "util/log.h"
-
-/** Downcast mouse processor to mouse_aoa */
-#define DOWNCAST(MP) container_of(MP, struct sc_mouse_aoa, mouse_processor)
-
-#define HID_MOUSE_ACCESSORY_ID 2
-
-static void
-sc_mouse_processor_process_mouse_motion(struct sc_mouse_processor *mp,
-                                    const struct sc_mouse_motion_event *event) {
-    struct sc_mouse_aoa *mouse = DOWNCAST(mp);
-
-    struct sc_hid_event hid_event;
-    sc_hid_mouse_event_from_motion(&hid_event, event);
-
-    if (!sc_aoa_push_hid_event(mouse->aoa, HID_MOUSE_ACCESSORY_ID,
-                               &hid_event)) {
-        LOGW("Could not request HID event (mouse motion)");
-    }
-}
-
-static void
-sc_mouse_processor_process_mouse_click(struct sc_mouse_processor *mp,
-                                   const struct sc_mouse_click_event *event) {
-    struct sc_mouse_aoa *mouse = DOWNCAST(mp);
-
-    struct sc_hid_event hid_event;
-    sc_hid_mouse_event_from_click(&hid_event, event);
-
-    if (!sc_aoa_push_hid_event(mouse->aoa, HID_MOUSE_ACCESSORY_ID,
-                               &hid_event)) {
-        LOGW("Could not request HID event (mouse click)");
-    }
-}
-
-static void
-sc_mouse_processor_process_mouse_scroll(struct sc_mouse_processor *mp,
-                                    const struct sc_mouse_scroll_event *event) {
-    struct sc_mouse_aoa *mouse = DOWNCAST(mp);
-
-    struct sc_hid_event hid_event;
-    sc_hid_mouse_event_from_scroll(&hid_event, event);
-
-    if (!sc_aoa_push_hid_event(mouse->aoa, HID_MOUSE_ACCESSORY_ID,
-                               &hid_event)) {
-        LOGW("Could not request HID event (mouse scroll)");
-    }
-}
-
-bool
-sc_mouse_aoa_init(struct sc_mouse_aoa *mouse, struct sc_aoa *aoa) {
-    mouse->aoa = aoa;
-
-    bool ok = sc_aoa_setup_hid(aoa, HID_MOUSE_ACCESSORY_ID,
-                               SC_HID_MOUSE_REPORT_DESC,
-                               SC_HID_MOUSE_REPORT_DESC_LEN);
-    if (!ok) {
-        LOGW("Register HID mouse failed");
-        return false;
-    }
-
-    static const struct sc_mouse_processor_ops ops = {
-        .process_mouse_motion = sc_mouse_processor_process_mouse_motion,
-        .process_mouse_click = sc_mouse_processor_process_mouse_click,
-        .process_mouse_scroll = sc_mouse_processor_process_mouse_scroll,
-        // Touch events not supported (coordinates are not relative)
-        .process_touch = NULL,
-    };
-
-    mouse->mouse_processor.ops = &ops;
-
-    mouse->mouse_processor.relative_mode = true;
-
-    return true;
-}
-
-void
-sc_mouse_aoa_destroy(struct sc_mouse_aoa *mouse) {
-    bool ok = sc_aoa_unregister_hid(mouse->aoa, HID_MOUSE_ACCESSORY_ID);
-    if (!ok) {
-        LOGW("Could not unregister HID mouse");
-    }
-}

app/src/usb/scrcpy_otg.c

@@ -10,8 +10,8 @@
 struct scrcpy_otg {
     struct sc_usb usb;
     struct sc_aoa aoa;
-    struct sc_keyboard_aoa keyboard;
-    struct sc_mouse_aoa mouse;
+    struct sc_hid_keyboard keyboard;
+    struct sc_hid_mouse mouse;
 
     struct sc_screen_otg screen_otg;
 };
@@ -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);
@@ -73,8 +73,8 @@ scrcpy_otg(struct scrcpy_options *options) {
 
     enum scrcpy_exit_code ret = SCRCPY_EXIT_FAILURE;
 
-    struct sc_keyboard_aoa *keyboard = NULL;
-    struct sc_mouse_aoa *mouse = NULL;
+    struct sc_hid_keyboard *keyboard = NULL;
+    struct sc_hid_mouse *mouse = NULL;
     bool usb_device_initialized = false;
     bool usb_connected = false;
     bool aoa_started = false;
@@ -117,15 +117,10 @@ scrcpy_otg(struct scrcpy_options *options) {
     }
     aoa_initialized = true;
 
-    assert(options->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_AOA
-        || options->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_DISABLED);
-    assert(options->mouse_input_mode == SC_MOUSE_INPUT_MODE_AOA
-        || options->mouse_input_mode == SC_MOUSE_INPUT_MODE_DISABLED);
-
     bool enable_keyboard =
-        options->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_AOA;
+        options->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_HID;
     bool enable_mouse =
-        options->mouse_input_mode == SC_MOUSE_INPUT_MODE_AOA;
+        options->mouse_input_mode == SC_MOUSE_INPUT_MODE_HID;
 
     // If neither --hid-keyboard or --hid-mouse is passed, enable both
     if (!enable_keyboard && !enable_mouse) {
@@ -134,7 +129,7 @@ scrcpy_otg(struct scrcpy_options *options) {
     }
 
     if (enable_keyboard) {
-        ok = sc_keyboard_aoa_init(&s->keyboard, &s->aoa);
+        ok = sc_hid_keyboard_init(&s->keyboard, &s->aoa);
         if (!ok) {
             goto end;
         }
@@ -142,7 +137,7 @@ scrcpy_otg(struct scrcpy_options *options) {
     }
 
     if (enable_mouse) {
-        ok = sc_mouse_aoa_init(&s->mouse, &s->aoa);
+        ok = sc_hid_mouse_init(&s->mouse, &s->aoa);
         if (!ok) {
             goto end;
         }
@@ -191,10 +186,10 @@ end:
     sc_usb_stop(&s->usb);
 
     if (mouse) {
-        sc_mouse_aoa_destroy(&s->mouse);
+        sc_hid_mouse_destroy(&s->mouse);
     }
     if (keyboard) {
-        sc_keyboard_aoa_destroy(&s->keyboard);
+        sc_hid_keyboard_destroy(&s->keyboard);
     }
 
     if (aoa_initialized) {

app/src/usb/screen_otg.h

@@ -6,12 +6,12 @@
 #include <stdbool.h>
 #include <SDL2/SDL.h>
 
-#include "keyboard_aoa.h"
-#include "mouse_aoa.h"
+#include "hid_keyboard.h"
+#include "hid_mouse.h"
 
 struct sc_screen_otg {
-    struct sc_keyboard_aoa *keyboard;
-    struct sc_mouse_aoa *mouse;
+    struct sc_hid_keyboard *keyboard;
+    struct sc_hid_mouse *mouse;
 
     SDL_Window *window;
     SDL_Renderer *renderer;
@@ -22,8 +22,8 @@ struct sc_screen_otg {
 };
 
 struct sc_screen_otg_params {
-    struct sc_keyboard_aoa *keyboard;
-    struct sc_mouse_aoa *mouse;
+    struct sc_hid_keyboard *keyboard;
+    struct sc_hid_mouse *mouse;
 
     const char *window_title;
     bool always_on_top;

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;
-}

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

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);
+}

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

app/src/util/str.c

@@ -3,7 +3,6 @@
 #include <assert.h>
 #include <errno.h>
 #include <limits.h>
-#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -334,22 +333,3 @@ sc_str_remove_trailing_cr(char *s, size_t len) {
     }
     return len;
 }
-
-char *
-sc_str_to_hex_string(const uint8_t *data, size_t size) {
-    size_t buffer_size = size * 3 + 1;
-    char *buffer = malloc(buffer_size);
-    if (!buffer) {
-        LOG_OOM();
-        return NULL;
-    }
-
-    for (size_t i = 0; i < size; ++i) {
-        snprintf(buffer + i * 3, 4, "%02X ", data[i]);
-    }
-
-    // Remove the final space
-    buffer[size * 3] = '\0';
-
-    return buffer;
-}

app/src/util/str.h

@@ -138,10 +138,4 @@ sc_str_index_of_column(const char *s, unsigned col, const char *seps);
 size_t
 sc_str_remove_trailing_cr(char *s, size_t len);
 
-/**
- * Convert binary data to hexadecimal string
- */
-char *
-sc_str_to_hex_string(const uint8_t *data, size_t len);
-
 #endif

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;
-}

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;
+}

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,78 +312,16 @@ 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)));
 }
 
-static void test_serialize_uhid_create(void) {
-    const uint8_t report_desc[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
-    struct sc_control_msg msg = {
-        .type = SC_CONTROL_MSG_TYPE_UHID_CREATE,
-        .uhid_create = {
-            .id = 42,
-            .report_desc_size = sizeof(report_desc),
-            .report_desc = report_desc,
-        },
-    };
-
-    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
-    size_t size = sc_control_msg_serialize(&msg, buf);
-    assert(size == 16);
-
-    const uint8_t expected[] = {
-        SC_CONTROL_MSG_TYPE_UHID_CREATE,
-        0, 42, // id
-        0, 11, // size
-        1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
-    };
-    assert(!memcmp(buf, expected, sizeof(expected)));
-}
-
-static void test_serialize_uhid_input(void) {
-    struct sc_control_msg msg = {
-        .type = SC_CONTROL_MSG_TYPE_UHID_INPUT,
-        .uhid_input = {
-            .id = 42,
-            .size = 5,
-            .data = {1, 2, 3, 4, 5},
-        },
-    };
-
-    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
-    size_t size = sc_control_msg_serialize(&msg, buf);
-    assert(size == 10);
-
-    const uint8_t expected[] = {
-        SC_CONTROL_MSG_TYPE_UHID_INPUT,
-        0, 42, // id
-        0, 5, // size
-        1, 2, 3, 4, 5,
-    };
-    assert(!memcmp(buf, expected, sizeof(expected)));
-}
-
-static void test_serialize_open_hard_keyboard(void) {
-    struct sc_control_msg msg = {
-        .type = SC_CONTROL_MSG_TYPE_OPEN_HARD_KEYBOARD_SETTINGS,
-    };
-
-    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
-    size_t size = sc_control_msg_serialize(&msg, buf);
-    assert(size == 1);
-
-    const uint8_t expected[] = {
-        SC_CONTROL_MSG_TYPE_OPEN_HARD_KEYBOARD_SETTINGS,
-    };
-    assert(!memcmp(buf, expected, sizeof(expected)));
-}
-
 int main(int argc, char *argv[]) {
     (void) argc;
     (void) argv;
@@ -403,8 +340,5 @@ int main(int argc, char *argv[]) {
     test_serialize_set_clipboard_long();
     test_serialize_set_screen_power_mode();
     test_serialize_rotate_device();
-    test_serialize_uhid_create();
-    test_serialize_uhid_input();
-    test_serialize_open_hard_keyboard();
     return 0;
 }

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,45 +44,23 @@ 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);
     assert(msg.ack_clipboard.sequence == UINT64_C(0x0102030405060708));
 }
 
-static void test_deserialize_uhid_output(void) {
-    const uint8_t input[] = {
-        DEVICE_MSG_TYPE_UHID_OUTPUT,
-        0, 42, // id
-        0, 5, // size
-        0x01, 0x02, 0x03, 0x04, 0x05, // data
-    };
-
-    struct sc_device_msg msg;
-    ssize_t r = sc_device_msg_deserialize(input, sizeof(input), &msg);
-    assert(r == 10);
-
-    assert(msg.type == DEVICE_MSG_TYPE_UHID_OUTPUT);
-    assert(msg.uhid_output.id == 42);
-    assert(msg.uhid_output.size == 5);
-
-    uint8_t expected[] = {1, 2, 3, 4, 5};
-    assert(!memcmp(msg.uhid_output.data, expected, sizeof(expected)));
-
-    sc_device_msg_destroy(&msg);
-}
-
 int main(int argc, char *argv[]) {
     (void) argc;
     (void) argv;
@@ -90,6 +68,5 @@ int main(int argc, char *argv[]) {
     test_deserialize_clipboard();
     test_deserialize_clipboard_big();
     test_deserialize_ack_set_clipboard();
-    test_deserialize_uhid_output();
     return 0;
 }

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

doc/shortcuts.md

@@ -48,10 +48,8 @@ _<kbd>[Super]</kbd> is typically the <kbd>Windows</kbd> or <kbd>Cmd</kbd> key._
  | Cut to clipboard⁵                           | <kbd>MOD</kbd>+<kbd>x</kbd>
  | Synchronize clipboards and paste⁵           | <kbd>MOD</kbd>+<kbd>v</kbd>
  | Inject computer clipboard text              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
- | Open keyboard settings (HID keyboard only)  | <kbd>MOD</kbd>+<kbd>k</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)
 

meson.build

@@ -16,3 +16,5 @@ endif
 if get_option('compile_server')
     subdir('server')
 endif
+
+run_target('run', command: ['scripts/run-scrcpy.sh'])

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"

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

@@ -79,7 +79,7 @@ public final class AudioCapture {
         intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
         intent.addCategory(Intent.CATEGORY_LAUNCHER);
         intent.setComponent(new ComponentName(FakeContext.PACKAGE_NAME, "com.android.shell.HeapDumpActivity"));
-        ServiceManager.getActivityManager().startActivity(intent);
+        ServiceManager.getActivityManager().startActivityAsUserWithFeature(intent);
     }
 
     private static void stopWorkaroundAndroid11() {
@@ -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) {

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

@@ -53,8 +53,6 @@ public class CameraCapture extends SurfaceCapture {
 
     private final AtomicBoolean disconnected = new AtomicBoolean();
 
-    private CameraCaptureSession currentSession;
-
     public CameraCapture(String explicitCameraId, CameraFacing cameraFacing, Size explicitSize, int maxSize, CameraAspectRatio aspectRatio, int fps,
             boolean highSpeed) {
         this.explicitCameraId = explicitCameraId;
@@ -198,22 +196,7 @@ public class CameraCapture extends SurfaceCapture {
     public void start(Surface surface) throws IOException {
         try {
             CameraCaptureSession session = createCaptureSession(cameraDevice, surface);
-            CaptureRequest request = createCaptureRequest(surface, false);
-            setRepeatingRequest(session, request);
-            setCurrentSession(session);
-        } catch (CameraAccessException | InterruptedException e) {
-            throw new IOException(e);
-        }
-    }
-
-    @TargetApi(Build.VERSION_CODES.M)
-    public void setTorchEnabled(boolean enabled) throws IOException {
-        CameraCaptureSession session = getCurrentSession();
-        if (session == null) {
-            return;
-        }
-        try {
-            CaptureRequest request = createCaptureRequest(session.getInputSurface(), enabled);
+            CaptureRequest request = createCaptureRequest(surface);
             setRepeatingRequest(session, request);
         } catch (CameraAccessException | InterruptedException e) {
             throw new IOException(e);
@@ -327,12 +310,9 @@ public class CameraCapture extends SurfaceCapture {
         }
     }
 
-    private CaptureRequest createCaptureRequest(Surface surface, boolean torch) throws CameraAccessException {
+    private CaptureRequest createCaptureRequest(Surface surface) throws CameraAccessException {
         CaptureRequest.Builder requestBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_RECORD);
         requestBuilder.addTarget(surface);
-        if (torch) {
-            requestBuilder.set(CaptureRequest.FLASH_MODE, CaptureRequest.FLASH_MODE_TORCH);
-        }
 
         if (fps > 0) {
             requestBuilder.set(CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE, new Range<>(fps, fps));
@@ -368,12 +348,4 @@ public class CameraCapture extends SurfaceCapture {
     public boolean isClosed() {
         return disconnected.get();
     }
-
-    private synchronized void setCurrentSession(CameraCaptureSession session) {
-        currentSession = session;
-    }
-
-    private synchronized CameraCaptureSession getCurrentSession() {
-        return currentSession;
-    }
 }

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);
     }
 }

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);
-    }
-}

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

@@ -17,10 +17,6 @@ public final class ControlMessage {
     public static final int TYPE_SET_CLIPBOARD = 9;
     public static final int TYPE_SET_SCREEN_POWER_MODE = 10;
     public static final int TYPE_ROTATE_DEVICE = 11;
-    public static final int TYPE_UHID_CREATE = 12;
-    public static final int TYPE_UHID_INPUT = 13;
-    public static final int TYPE_OPEN_HARD_KEYBOARD_SETTINGS = 14;
-    public static final int TYPE_SET_CAMERA_TORCH = 15;
 
     public static final long SEQUENCE_INVALID = 0;
 
@@ -44,9 +40,6 @@ public final class ControlMessage {
     private boolean paste;
     private int repeat;
     private long sequence;
-    private int id;
-    private byte[] data;
-    private boolean enabled;
 
     private ControlMessage() {
     }
@@ -130,29 +123,6 @@ public final class ControlMessage {
         return msg;
     }
 
-    public static ControlMessage createUhidCreate(int id, byte[] reportDesc) {
-        ControlMessage msg = new ControlMessage();
-        msg.type = TYPE_UHID_CREATE;
-        msg.id = id;
-        msg.data = reportDesc;
-        return msg;
-    }
-
-    public static ControlMessage createUhidInput(int id, byte[] data) {
-        ControlMessage msg = new ControlMessage();
-        msg.type = TYPE_UHID_INPUT;
-        msg.id = id;
-        msg.data = data;
-        return msg;
-    }
-
-    public static ControlMessage createSetCameraTorch(boolean enabled) {
-        ControlMessage msg = new ControlMessage();
-        msg.type = TYPE_SET_CAMERA_TORCH;
-        msg.enabled = enabled;
-        return msg;
-    }
-
     public int getType() {
         return type;
     }
@@ -216,16 +186,4 @@ public final class ControlMessage {
     public long getSequence() {
         return sequence;
     }
-
-    public int getId() {
-        return id;
-    }
-
-    public byte[] getData() {
-        return data;
-    }
-
-    public boolean getEnabled() {
-        return enabled;
-    }
 }

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

@@ -15,9 +15,6 @@ public class ControlMessageReader {
     static final int SET_SCREEN_POWER_MODE_PAYLOAD_LENGTH = 1;
     static final int GET_CLIPBOARD_LENGTH = 1;
     static final int SET_CLIPBOARD_FIXED_PAYLOAD_LENGTH = 9;
-    static final int UHID_CREATE_FIXED_PAYLOAD_LENGTH = 4;
-    static final int UHID_INPUT_FIXED_PAYLOAD_LENGTH = 4;
-    static final int CAMERA_TORCH_PAYLOAD_LENGTH = 1;
 
     private static final int MESSAGE_MAX_SIZE = 1 << 18; // 256k
 
@@ -87,18 +84,8 @@ public class ControlMessageReader {
             case ControlMessage.TYPE_EXPAND_SETTINGS_PANEL:
             case ControlMessage.TYPE_COLLAPSE_PANELS:
             case ControlMessage.TYPE_ROTATE_DEVICE:
-            case ControlMessage.TYPE_OPEN_HARD_KEYBOARD_SETTINGS:
                 msg = ControlMessage.createEmpty(type);
                 break;
-            case ControlMessage.TYPE_UHID_CREATE:
-                msg = parseUhidCreate();
-                break;
-            case ControlMessage.TYPE_UHID_INPUT:
-                msg = parseUhidInput();
-                break;
-            case ControlMessage.TYPE_SET_CAMERA_TORCH:
-                msg = parseCameraTorch();
-                break;
             default:
                 Ln.w("Unknown event type: " + type);
                 msg = null;
@@ -123,21 +110,12 @@ public class ControlMessageReader {
         return ControlMessage.createInjectKeycode(action, keycode, repeat, metaState);
     }
 
-    private int parseBufferLength(int sizeBytes) {
-        assert sizeBytes > 0 && sizeBytes <= 4;
-        if (buffer.remaining() < sizeBytes) {
-            return -1;
-        }
-        int value = 0;
-        for (int i = 0; i < sizeBytes; ++i) {
-            value = (value << 8) | (buffer.get() & 0xFF);
-        }
-        return value;
-    }
-
     private String parseString() {
-        int len = parseBufferLength(4);
-        if (len == -1 || buffer.remaining() < len) {
+        if (buffer.remaining() < 4) {
+            return null;
+        }
+        int len = buffer.getInt();
+        if (buffer.remaining() < len) {
             return null;
         }
         int position = buffer.position();
@@ -146,16 +124,6 @@ public class ControlMessageReader {
         return new String(rawBuffer, position, len, StandardCharsets.UTF_8);
     }
 
-    private byte[] parseByteArray(int sizeBytes) {
-        int len = parseBufferLength(sizeBytes);
-        if (len == -1 || buffer.remaining() < len) {
-            return null;
-        }
-        byte[] data = new byte[len];
-        buffer.get(data);
-        return data;
-    }
-
     private ControlMessage parseInjectText() {
         String text = parseString();
         if (text == null) {
@@ -225,38 +193,6 @@ public class ControlMessageReader {
         return ControlMessage.createSetScreenPowerMode(mode);
     }
 
-    private ControlMessage parseUhidCreate() {
-        if (buffer.remaining() < UHID_CREATE_FIXED_PAYLOAD_LENGTH) {
-            return null;
-        }
-        int id = buffer.getShort();
-        byte[] data = parseByteArray(2);
-        if (data == null) {
-            return null;
-        }
-        return ControlMessage.createUhidCreate(id, data);
-    }
-
-    private ControlMessage parseUhidInput() {
-        if (buffer.remaining() < UHID_INPUT_FIXED_PAYLOAD_LENGTH) {
-            return null;
-        }
-        int id = buffer.getShort();
-        byte[] data = parseByteArray(2);
-        if (data == null) {
-            return null;
-        }
-        return ControlMessage.createUhidInput(id, data);
-    }
-
-    private ControlMessage parseCameraTorch() {
-        if (buffer.remaining() < CAMERA_TORCH_PAYLOAD_LENGTH) {
-            return null;
-        }
-        boolean enabled = buffer.get() != 0;
-        return ControlMessage.createSetCameraTorch(enabled);
-    }
-
     private static Position readPosition(ByteBuffer buffer) {
         int x = buffer.getInt();
         int y = buffer.getInt();

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

@@ -1,9 +1,7 @@
 package com.genymobile.scrcpy;
 
 import com.genymobile.scrcpy.wrappers.InputManager;
-import com.genymobile.scrcpy.wrappers.ServiceManager;
 
-import android.content.Intent;
 import android.os.Build;
 import android.os.SystemClock;
 import android.view.InputDevice;
@@ -28,12 +26,8 @@ public class Controller implements AsyncProcessor {
 
     private Thread thread;
 
-    private UhidManager uhidManager;
-
     private final Device device;
-    private final ControlChannel controlChannel;
-    private final CameraCapture cameraCapture;
-    private final CleanUp cleanUp;
+    private final DesktopConnection connection;
     private final DeviceMessageSender sender;
     private final boolean clipboardAutosync;
     private final boolean powerOn;
@@ -47,23 +41,13 @@ public class Controller implements AsyncProcessor {
 
     private boolean keepPowerModeOff;
 
-    public Controller(Device device, ControlChannel controlChannel, CameraCapture cameraCapture, CleanUp cleanUp, boolean clipboardAutosync,
-            boolean powerOn) {
+    public Controller(Device device, DesktopConnection connection, boolean clipboardAutosync, boolean powerOn) {
         this.device = device;
-        this.controlChannel = controlChannel;
-        this.cameraCapture = cameraCapture;
-        this.cleanUp = cleanUp;
+        this.connection = connection;
         this.clipboardAutosync = clipboardAutosync;
         this.powerOn = powerOn;
         initPointers();
-        sender = new DeviceMessageSender(controlChannel);
-    }
-
-    private UhidManager getUhidManager() {
-        if (uhidManager == null) {
-            uhidManager = new UhidManager(sender);
-        }
-        return uhidManager;
+        sender = new DeviceMessageSender(connection);
     }
 
     private void initPointers() {
@@ -95,9 +79,8 @@ public class Controller implements AsyncProcessor {
             SystemClock.sleep(500);
         }
 
-        boolean alive = true;
-        while (!Thread.currentThread().isInterrupted() && alive) {
-            alive = handleEvent();
+        while (!Thread.currentThread().isInterrupted()) {
+            handleEvent();
         }
     }
 
@@ -107,12 +90,9 @@ public class Controller implements AsyncProcessor {
             try {
                 control();
             } catch (IOException e) {
-                Ln.e("Controller error", e);
+                // this is expected on close
             } finally {
                 Ln.d("Controller stopped");
-                if (uhidManager != null) {
-                    uhidManager.closeAll();
-                }
                 listener.onTerminated(true);
             }
         }, "control-recv");
@@ -140,15 +120,8 @@ public class Controller implements AsyncProcessor {
         return sender;
     }
 
-    private boolean handleEvent() throws IOException {
-        ControlMessage msg;
-        try {
-            msg = controlChannel.recv();
-        } catch (IOException e) {
-            // this is expected on close
-            return false;
-        }
-Ln.i("==== msg = " + msg.getType());
+    private void handleEvent() throws IOException {
+        ControlMessage msg = connection.receiveControlMessage();
         switch (msg.getType()) {
             case ControlMessage.TYPE_INJECT_KEYCODE:
                 if (device.supportsInputEvents()) {
@@ -197,34 +170,15 @@ Ln.i("==== msg = " + msg.getType());
                     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;
             case ControlMessage.TYPE_ROTATE_DEVICE:
-                device.rotateDevice();
-                break;
-            case ControlMessage.TYPE_UHID_CREATE:
-                getUhidManager().open(msg.getId(), msg.getData());
-                break;
-            case ControlMessage.TYPE_UHID_INPUT:
-                getUhidManager().writeInput(msg.getId(), msg.getData());
-                break;
-            case ControlMessage.TYPE_OPEN_HARD_KEYBOARD_SETTINGS:
-                openHardKeyboardSettings();
-                break;
-            case ControlMessage.TYPE_SET_CAMERA_TORCH:
-                Ln.i("===");
-                cameraCapture.setTorchEnabled(msg.getEnabled());
+                Device.rotateDevice();
                 break;
             default:
                 // do nothing
         }
-
-        return true;
     }
 
     private boolean injectKeycode(int action, int keycode, int repeat, int metaState) {
@@ -433,8 +387,7 @@ Ln.i("==== msg = " + msg.getType());
         if (!clipboardAutosync) {
             String clipboardText = Device.getClipboardText();
             if (clipboardText != null) {
-                DeviceMessage msg = DeviceMessage.createClipboard(clipboardText);
-                sender.send(msg);
+                sender.pushClipboardText(clipboardText);
             }
         }
     }
@@ -452,15 +405,9 @@ Ln.i("==== msg = " + msg.getType());
 
         if (sequence != ControlMessage.SEQUENCE_INVALID) {
             // Acknowledgement requested
-            DeviceMessage msg = DeviceMessage.createAckClipboard(sequence);
-            sender.send(msg);
+            sender.pushAckClipboard(sequence);
         }
 
         return ok;
     }
-
-    private void openHardKeyboardSettings() {
-        Intent intent = new Intent("android.settings.HARD_KEYBOARD_SETTINGS");
-        ServiceManager.getActivityManager().startActivity(intent);
-    }
 }

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);
     }
 }

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);
@@ -359,30 +359,21 @@ public final class Device {
     /**
      * Disable auto-rotation (if enabled), set the screen rotation and re-enable auto-rotation (if it was enabled).
      */
-    public void rotateDevice() {
+    public static void rotateDevice() {
         WindowManager wm = ServiceManager.getWindowManager();
 
-        boolean accelerometerRotation = !wm.isRotationFrozen(displayId);
+        boolean accelerometerRotation = !wm.isRotationFrozen();
 
-        int currentRotation = getCurrentRotation(displayId);
+        int currentRotation = wm.getRotation();
         int newRotation = (currentRotation & 1) ^ 1; // 0->1, 1->0, 2->1, 3->0
         String newRotationString = newRotation == 0 ? "portrait" : "landscape";
 
         Ln.i("Device rotation requested: " + newRotationString);
-        wm.freezeRotation(displayId, newRotation);
+        wm.freezeRotation(newRotation);
 
         // restore auto-rotate if necessary
         if (accelerometerRotation) {
-            wm.thawRotation(displayId);
+            wm.thawRotation();
         }
     }
-
-    private static int getCurrentRotation(int displayId) {
-        if (displayId == 0) {
-            return ServiceManager.getWindowManager().getRotation();
-        }
-
-        DisplayInfo displayInfo = ServiceManager.getDisplayManager().getDisplayInfo(displayId);
-        return displayInfo.getRotation();
-    }
 }

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

@@ -4,13 +4,12 @@ public final class DeviceMessage {
 
     public static final int TYPE_CLIPBOARD = 0;
     public static final int TYPE_ACK_CLIPBOARD = 1;
-    public static final int TYPE_UHID_OUTPUT = 2;
+
+    public static final long SEQUENCE_INVALID = ControlMessage.SEQUENCE_INVALID;
 
     private int type;
     private String text;
     private long sequence;
-    private int id;
-    private byte[] data;
 
     private DeviceMessage() {
     }
@@ -29,14 +28,6 @@ public final class DeviceMessage {
         return event;
     }
 
-    public static DeviceMessage createUhidOutput(int id, byte[] data) {
-        DeviceMessage event = new DeviceMessage();
-        event.type = TYPE_UHID_OUTPUT;
-        event.id = id;
-        event.data = data;
-        return event;
-    }
-
     public int getType() {
         return type;
     }
@@ -48,12 +39,4 @@ public final class DeviceMessage {
     public long getSequence() {
         return sequence;
     }
-
-    public int getId() {
-        return id;
-    }
-
-    public byte[] getData() {
-        return data;
-    }
 }

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

@@ -1,30 +1,54 @@
 package com.genymobile.scrcpy;
 
 import java.io.IOException;
-import java.util.concurrent.ArrayBlockingQueue;
-import java.util.concurrent.BlockingQueue;
 
 public final class DeviceMessageSender {
 
-    private final ControlChannel controlChannel;
+    private final DesktopConnection connection;
 
     private Thread thread;
-    private final BlockingQueue<DeviceMessage> queue = new ArrayBlockingQueue<>(16);
 
-    public DeviceMessageSender(ControlChannel controlChannel) {
-        this.controlChannel = controlChannel;
+    private String clipboardText;
+
+    private long ack;
+
+    public DeviceMessageSender(DesktopConnection connection) {
+        this.connection = connection;
     }
 
-    public void send(DeviceMessage msg) {
-        if (!queue.offer(msg)) {
-            Ln.w("Device message dropped: " + msg.getType());
-        }
+    public synchronized void pushClipboardText(String text) {
+        clipboardText = text;
+        notify();
+    }
+
+    public synchronized void pushAckClipboard(long sequence) {
+        ack = sequence;
+        notify();
     }
 
     private void loop() throws IOException, InterruptedException {
         while (!Thread.currentThread().isInterrupted()) {
-            DeviceMessage msg = queue.take();
-            controlChannel.send(msg);
+            String text;
+            long sequence;
+            synchronized (this) {
+                while (ack == DeviceMessage.SEQUENCE_INVALID && clipboardText == null) {
+                    wait();
+                }
+                text = clipboardText;
+                clipboardText = null;
+
+                sequence = ack;
+                ack = DeviceMessage.SEQUENCE_INVALID;
+            }
+
+            if (sequence != DeviceMessage.SEQUENCE_INVALID) {
+                DeviceMessage event = DeviceMessage.createAckClipboard(sequence);
+                connection.sendDeviceMessage(event);
+            }
+            if (text != null) {
+                DeviceMessage event = DeviceMessage.createClipboard(text);
+                connection.sendDeviceMessage(event);
+            }
         }
     }
 

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

@@ -29,13 +29,6 @@ public class DeviceMessageWriter {
                 buffer.putLong(msg.getSequence());
                 output.write(rawBuffer, 0, buffer.position());
                 break;
-            case DeviceMessage.TYPE_UHID_OUTPUT:
-                buffer.putShort((short) msg.getId());
-                byte[] data = msg.getData();
-                buffer.putShort((short) data.length);
-                buffer.put(data);
-                output.write(rawBuffer, 0, buffer.position());
-                break;
             default:
                 Ln.w("Unknown device message: " + msg.getType());
                 break;

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

@@ -2,7 +2,6 @@ package com.genymobile.scrcpy;
 
 import android.os.BatteryManager;
 import android.os.Build;
-import android.os.SystemClock;
 
 import java.io.File;
 import java.io.IOException;
@@ -52,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);
             }
         }
     }
@@ -103,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,6 +123,12 @@ public final class Server {
                 connection.sendDeviceMeta(Device.getDeviceName());
             }
 
+            if (control) {
+                Controller controller = new Controller(device, connection, options.getClipboardAutosync(), options.getPowerOn());
+                device.setClipboardListener(text -> controller.getSender().pushClipboardText(text));
+                asyncProcessors.add(controller);
+            }
+
             if (audio) {
                 AudioCodec audioCodec = options.getAudioCodec();
                 AudioCapture audioCapture = new AudioCapture(options.getAudioSource());
@@ -145,7 +143,6 @@ public final class Server {
                 asyncProcessors.add(audioRecorder);
             }
 
-            CameraCapture cameraCapture = null;
             if (video) {
                 Streamer videoStreamer = new Streamer(connection.getVideoFd(), options.getVideoCodec(), options.getSendCodecMeta(),
                         options.getSendFrameMeta());
@@ -153,26 +150,14 @@ public final class Server {
                 if (options.getVideoSource() == VideoSource.DISPLAY) {
                     surfaceCapture = new ScreenCapture(device);
                 } else {
-                    cameraCapture = new CameraCapture(options.getCameraId(), options.getCameraFacing(), options.getCameraSize(),
+                    surfaceCapture = new CameraCapture(options.getCameraId(), options.getCameraFacing(), options.getCameraSize(),
                             options.getMaxSize(), options.getCameraAspectRatio(), options.getCameraFps(), options.getCameraHighSpeed());
-                    surfaceCapture = cameraCapture;
                 }
                 SurfaceEncoder surfaceEncoder = new SurfaceEncoder(surfaceCapture, videoStreamer, options.getVideoBitRate(), options.getMaxFps(),
                         options.getVideoCodecOptions(), options.getVideoEncoder(), options.getDownsizeOnError());
                 asyncProcessors.add(surfaceEncoder);
             }
 
-            if (control) {
-                ControlChannel controlChannel = connection.getControlChannel();
-                Controller controller = new Controller(
-                        device, controlChannel, cameraCapture, cleanUp, options.getClipboardAutosync(), options.getPowerOn());
-                device.setClipboardListener(text -> {
-                    DeviceMessage msg = DeviceMessage.createClipboard(text);
-                    controller.getSender().send(msg);
-                });
-                asyncProcessors.add(controller);
-            }
-
             Completion completion = new Completion(asyncProcessors.size());
             for (AsyncProcessor asyncProcessor : asyncProcessors) {
                 asyncProcessor.start((fatalError) -> {
@@ -182,9 +167,7 @@ public final class Server {
 
             completion.await();
         } finally {
-            if (initThread != null) {
-                initThread.interrupt();
-            }
+            initThread.interrupt();
             for (AsyncProcessor asyncProcessor : asyncProcessors) {
                 asyncProcessor.stop();
             }
@@ -192,9 +175,7 @@ public final class Server {
             connection.shutdown();
 
             try {
-                if (initThread != null) {
-                    initThread.join();
-                }
+                initThread.join();
                 for (AsyncProcessor asyncProcessor : asyncProcessors) {
                     asyncProcessor.join();
                 }
@@ -206,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;
     }

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

@@ -1,218 +0,0 @@
-package com.genymobile.scrcpy;
-
-import android.os.Build;
-import android.os.HandlerThread;
-import android.os.MessageQueue;
-import android.system.ErrnoException;
-import android.system.Os;
-import android.system.OsConstants;
-import android.util.ArrayMap;
-
-import java.io.FileDescriptor;
-import java.io.IOException;
-import java.io.InterruptedIOException;
-import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
-import java.nio.charset.StandardCharsets;
-
-public final class UhidManager {
-
-    // Linux: include/uapi/linux/uhid.h
-    private static final int UHID_OUTPUT = 6;
-    private static final int UHID_CREATE2 = 11;
-    private static final int UHID_INPUT2 = 12;
-
-    // Linux: include/uapi/linux/input.h
-    private static final short BUS_VIRTUAL = 0x06;
-
-    private static final int SIZE_OF_UHID_EVENT = 4380; // sizeof(struct uhid_event)
-
-    private final ArrayMap<Integer, FileDescriptor> fds = new ArrayMap<>();
-    private final ByteBuffer buffer = ByteBuffer.allocate(SIZE_OF_UHID_EVENT).order(ByteOrder.nativeOrder());
-
-    private final DeviceMessageSender sender;
-    private final HandlerThread thread = new HandlerThread("UHidManager");
-    private final MessageQueue queue;
-
-    public UhidManager(DeviceMessageSender sender) {
-        this.sender = sender;
-        thread.start();
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-            queue = thread.getLooper().getQueue();
-        } else {
-            queue = null;
-        }
-    }
-
-    public void open(int id, byte[] reportDesc) throws IOException {
-        try {
-            FileDescriptor fd = Os.open("/dev/uhid", OsConstants.O_RDWR, 0);
-            try {
-                FileDescriptor old = fds.put(id, fd);
-                if (old != null) {
-                    Ln.w("Duplicate UHID id: " + id);
-                    close(old);
-                }
-
-                byte[] req = buildUhidCreate2Req(reportDesc);
-                Os.write(fd, req, 0, req.length);
-
-                registerUhidListener(id, fd);
-            } catch (Exception e) {
-                close(fd);
-                throw e;
-            }
-        } catch (ErrnoException e) {
-            throw new IOException(e);
-        }
-    }
-
-    private void registerUhidListener(int id, FileDescriptor fd) {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-            queue.addOnFileDescriptorEventListener(fd, MessageQueue.OnFileDescriptorEventListener.EVENT_INPUT, (fd2, events) -> {
-                try {
-                    buffer.clear();
-                    int r = Os.read(fd2, buffer);
-                    buffer.flip();
-                    if (r > 0) {
-                        int type = buffer.getInt();
-                        if (type == UHID_OUTPUT) {
-                            byte[] data = extractHidOutputData(buffer);
-                            if (data != null) {
-                                DeviceMessage msg = DeviceMessage.createUhidOutput(id, data);
-                                sender.send(msg);
-                            }
-                        }
-                    }
-                } catch (ErrnoException | InterruptedIOException e) {
-                    Ln.e("Failed to read UHID output", e);
-                    return 0;
-                }
-                return events;
-            });
-        }
-    }
-
-    private static byte[] extractHidOutputData(ByteBuffer buffer) {
-        /*
-         * #define UHID_DATA_MAX 4096
-         * struct uhid_event {
-         *     uint32_t type;
-         *     union {
-         *         // ...
-         *         struct uhid_output_req {
-         *             __u8 data[UHID_DATA_MAX];
-         *             __u16 size;
-         *             __u8 rtype;
-         *         };
-         *     };
-         * } __attribute__((__packed__));
-         */
-
-        if (buffer.remaining() < 4099) {
-            Ln.w("Incomplete HID output");
-            return null;
-        }
-        int size = buffer.getShort(buffer.position() + 4096) & 0xFFFF;
-        if (size > 4096) {
-            Ln.w("Incorrect HID output size: " + size);
-            return null;
-        }
-        byte[] data = new byte[size];
-        buffer.get(data);
-        return data;
-    }
-
-    public void writeInput(int id, byte[] data) throws IOException {
-        FileDescriptor fd = fds.get(id);
-        if (fd == null) {
-            Ln.w("Unknown UHID id: " + id);
-            return;
-        }
-
-        try {
-            byte[] req = buildUhidInput2Req(data);
-            Os.write(fd, req, 0, req.length);
-        } catch (ErrnoException e) {
-            throw new IOException(e);
-        }
-    }
-
-    private static byte[] buildUhidCreate2Req(byte[] reportDesc) {
-        /*
-         * struct uhid_event {
-         *     uint32_t type;
-         *     union {
-         *         // ...
-         *         struct uhid_create2_req {
-         *             uint8_t name[128];
-         *             uint8_t phys[64];
-         *             uint8_t uniq[64];
-         *             uint16_t rd_size;
-         *             uint16_t bus;
-         *             uint32_t vendor;
-         *             uint32_t product;
-         *             uint32_t version;
-         *             uint32_t country;
-         *             uint8_t rd_data[HID_MAX_DESCRIPTOR_SIZE];
-         *         };
-         *     };
-         * } __attribute__((__packed__));
-         */
-
-        byte[] empty = new byte[256];
-        ByteBuffer buf = ByteBuffer.allocate(280 + reportDesc.length).order(ByteOrder.nativeOrder());
-        buf.putInt(UHID_CREATE2);
-        buf.put("scrcpy".getBytes(StandardCharsets.US_ASCII));
-        buf.put(empty, 0, 256 - "scrcpy".length());
-        buf.putShort((short) reportDesc.length);
-        buf.putShort(BUS_VIRTUAL);
-        buf.putInt(0); // vendor id
-        buf.putInt(0); // product id
-        buf.putInt(0); // version
-        buf.putInt(0); // country;
-        buf.put(reportDesc);
-        return buf.array();
-    }
-
-    private static byte[] buildUhidInput2Req(byte[] data) {
-        /*
-         * struct uhid_event {
-         *     uint32_t type;
-         *     union {
-         *         // ...
-         *         struct uhid_input2_req {
-         *             uint16_t size;
-         *             uint8_t data[UHID_DATA_MAX];
-         *         };
-         *     };
-         * } __attribute__((__packed__));
-         */
-
-        ByteBuffer buf = ByteBuffer.allocate(6 + data.length).order(ByteOrder.nativeOrder());
-        buf.putInt(UHID_INPUT2);
-        buf.putShort((short) data.length);
-        buf.put(data);
-        return buf.array();
-    }
-
-    public void close(int id) {
-        FileDescriptor fd = fds.get(id);
-        assert fd != null;
-        close(fd);
-    }
-
-    public void closeAll() {
-        for (FileDescriptor fd : fds.values()) {
-            close(fd);
-        }
-    }
-
-    private static void close(FileDescriptor fd) {
-        try {
-            Os.close(fd);
-        } catch (ErrnoException e) {
-            Ln.e("Failed to close uhid: " + e.getMessage());
-        }
-    }
-}

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);
                 }
             }
 

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")
@@ -22,23 +23,10 @@ public final class ActivityManager {
     private Method getContentProviderExternalMethod;
     private boolean getContentProviderExternalMethodNewVersion = true;
     private Method removeContentProviderExternalMethod;
-    private Method startActivityAsUserMethod;
+    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);
         }
     }
@@ -107,25 +95,26 @@ public final class ActivityManager {
         return getContentProviderExternal("settings", new Binder());
     }
 
-    private Method getStartActivityAsUserMethod() throws NoSuchMethodException, ClassNotFoundException {
-        if (startActivityAsUserMethod == null) {
+    private Method getStartActivityAsUserWithFeatureMethod() throws NoSuchMethodException, ClassNotFoundException {
+        if (startActivityAsUserWithFeatureMethod == null) {
             Class<?> iApplicationThreadClass = Class.forName("android.app.IApplicationThread");
             Class<?> profilerInfo = Class.forName("android.app.ProfilerInfo");
-            startActivityAsUserMethod = manager.getClass()
-                    .getMethod("startActivityAsUser", iApplicationThreadClass, String.class, Intent.class, String.class, IBinder.class, String.class,
-                            int.class, int.class, profilerInfo, Bundle.class, int.class);
+            startActivityAsUserWithFeatureMethod = manager.getClass()
+                    .getMethod("startActivityAsUserWithFeature", iApplicationThreadClass, String.class, String.class, Intent.class, String.class,
+                            IBinder.class, String.class, int.class, int.class, profilerInfo, Bundle.class, int.class);
         }
-        return startActivityAsUserMethod;
+        return startActivityAsUserWithFeatureMethod;
     }
 
     @SuppressWarnings("ConstantConditions")
-    public int startActivity(Intent intent) {
+    public int startActivityAsUserWithFeature(Intent intent) {
         try {
-            Method method = getStartActivityAsUserMethod();
+            Method method = getStartActivityAsUserWithFeatureMethod();
             return (int) method.invoke(
                     /* this */ manager,
                     /* caller */ null,
                     /* callingPackage */ FakeContext.PACKAGE_NAME,
+                    /* callingFeatureId */ null,
                     /* intent */ intent,
                     /* resolvedType */ null,
                     /* resultTo */ null,

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;
         }

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;
         }

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;
         }

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);
         }
     }

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;
         }

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;
         }

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;
     }
 

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);
         }
     }

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;
         }

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

@@ -7,24 +7,17 @@ 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 {
     private final IInterface manager;
     private Method getRotationMethod;
     private Method freezeRotationMethod;
-    private Method freezeDisplayRotationMethod;
     private Method isRotationFrozenMethod;
-    private Method isDisplayRotationFrozenMethod;
     private Method thawRotationMethod;
-    private Method thawDisplayRotationMethod;
 
-    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;
     }
 
@@ -50,15 +43,6 @@ public final class WindowManager {
         return freezeRotationMethod;
     }
 
-    // New method added by this commit:
-    // <https://android.googlesource.com/platform/frameworks/base/+/90c9005e687aa0f63f1ac391adc1e8878ab31759%5E%21/>
-    private Method getFreezeDisplayRotationMethod() throws NoSuchMethodException {
-        if (freezeDisplayRotationMethod == null) {
-            freezeDisplayRotationMethod = manager.getClass().getMethod("freezeDisplayRotation", int.class, int.class);
-        }
-        return freezeDisplayRotationMethod;
-    }
-
     private Method getIsRotationFrozenMethod() throws NoSuchMethodException {
         if (isRotationFrozenMethod == null) {
             isRotationFrozenMethod = manager.getClass().getMethod("isRotationFrozen");
@@ -66,15 +50,6 @@ public final class WindowManager {
         return isRotationFrozenMethod;
     }
 
-    // New method added by this commit:
-    // <https://android.googlesource.com/platform/frameworks/base/+/90c9005e687aa0f63f1ac391adc1e8878ab31759%5E%21/>
-    private Method getIsDisplayRotationFrozenMethod() throws NoSuchMethodException {
-        if (isDisplayRotationFrozenMethod == null) {
-            isDisplayRotationFrozenMethod = manager.getClass().getMethod("isDisplayRotationFrozen", int.class);
-        }
-        return isDisplayRotationFrozenMethod;
-    }
-
     private Method getThawRotationMethod() throws NoSuchMethodException {
         if (thawRotationMethod == null) {
             thawRotationMethod = manager.getClass().getMethod("thawRotation");
@@ -82,77 +57,40 @@ public final class WindowManager {
         return thawRotationMethod;
     }
 
-    // New method added by this commit:
-    // <https://android.googlesource.com/platform/frameworks/base/+/90c9005e687aa0f63f1ac391adc1e8878ab31759%5E%21/>
-    private Method getThawDisplayRotationMethod() throws NoSuchMethodException {
-        if (thawDisplayRotationMethod == null) {
-            thawDisplayRotationMethod = manager.getClass().getMethod("thawDisplayRotation", int.class);
-        }
-        return thawDisplayRotationMethod;
-    }
-
     public int getRotation() {
         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;
         }
     }
 
-    public void freezeRotation(int displayId, int rotation) {
+    public void freezeRotation(int rotation) {
         try {
-            try {
-                Method method = getFreezeDisplayRotationMethod();
-                method.invoke(manager, displayId, rotation);
-            } catch (ReflectiveOperationException e) {
-                if (displayId == 0) {
-                    Method method = getFreezeRotationMethod();
-                    method.invoke(manager, rotation);
-                } else {
-                    Ln.e("Could not invoke method", e);
-                }
-            }
-        } catch (ReflectiveOperationException e) {
+            Method method = getFreezeRotationMethod();
+            method.invoke(manager, rotation);
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
             Ln.e("Could not invoke method", e);
         }
     }
 
-    public boolean isRotationFrozen(int displayId) {
+    public boolean isRotationFrozen() {
         try {
-            try {
-                Method method = getIsDisplayRotationFrozenMethod();
-                return (boolean) method.invoke(manager, displayId);
-            } catch (ReflectiveOperationException e) {
-                if (displayId == 0) {
-                    Method method = getIsRotationFrozenMethod();
-                    return (boolean) method.invoke(manager);
-                } else {
-                    Ln.e("Could not invoke method", e);
-                    return false;
-                }
-            }
-        } catch (ReflectiveOperationException e) {
+            Method method = getIsRotationFrozenMethod();
+            return (boolean) method.invoke(manager);
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
             Ln.e("Could not invoke method", e);
             return false;
         }
     }
 
-    public void thawRotation(int displayId) {
+    public void thawRotation() {
         try {
-            try {
-                Method method = getThawDisplayRotationMethod();
-                method.invoke(manager, displayId);
-            } catch (ReflectiveOperationException e) {
-                if (displayId == 0) {
-                    Method method = getThawRotationMethod();
-                    method.invoke(manager);
-                } else {
-                    Ln.e("Could not invoke method", e);
-                }
-            }
-        } catch (ReflectiveOperationException e) {
+            Method method = getThawRotationMethod();
+            method.invoke(manager);
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
             Ln.e("Could not invoke method", e);
         }
     }

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

@@ -322,66 +322,6 @@ public class ControlMessageReaderTest {
         Assert.assertEquals(ControlMessage.TYPE_ROTATE_DEVICE, event.getType());
     }
 
-    @Test
-    public void testParseUhidCreate() throws IOException {
-        ControlMessageReader reader = new ControlMessageReader();
-
-        ByteArrayOutputStream bos = new ByteArrayOutputStream();
-        DataOutputStream dos = new DataOutputStream(bos);
-        dos.writeByte(ControlMessage.TYPE_UHID_CREATE);
-        dos.writeShort(42); // id
-        byte[] data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
-        dos.writeShort(data.length); // size
-        dos.write(data);
-
-        byte[] packet = bos.toByteArray();
-
-        reader.readFrom(new ByteArrayInputStream(packet));
-        ControlMessage event = reader.next();
-
-        Assert.assertEquals(ControlMessage.TYPE_UHID_CREATE, event.getType());
-        Assert.assertEquals(42, event.getId());
-        Assert.assertArrayEquals(data, event.getData());
-    }
-
-    @Test
-    public void testParseUhidInput() throws IOException {
-        ControlMessageReader reader = new ControlMessageReader();
-
-        ByteArrayOutputStream bos = new ByteArrayOutputStream();
-        DataOutputStream dos = new DataOutputStream(bos);
-        dos.writeByte(ControlMessage.TYPE_UHID_INPUT);
-        dos.writeShort(42); // id
-        byte[] data = {1, 2, 3, 4, 5};
-        dos.writeShort(data.length); // size
-        dos.write(data);
-
-        byte[] packet = bos.toByteArray();
-
-        reader.readFrom(new ByteArrayInputStream(packet));
-        ControlMessage event = reader.next();
-
-        Assert.assertEquals(ControlMessage.TYPE_UHID_INPUT, event.getType());
-        Assert.assertEquals(42, event.getId());
-        Assert.assertArrayEquals(data, event.getData());
-    }
-
-    @Test
-    public void testParseOpenHardKeyboardSettings() throws IOException {
-        ControlMessageReader reader = new ControlMessageReader();
-
-        ByteArrayOutputStream bos = new ByteArrayOutputStream();
-        DataOutputStream dos = new DataOutputStream(bos);
-        dos.writeByte(ControlMessage.TYPE_OPEN_HARD_KEYBOARD_SETTINGS);
-
-        byte[] packet = bos.toByteArray();
-
-        reader.readFrom(new ByteArrayInputStream(packet));
-        ControlMessage event = reader.next();
-
-        Assert.assertEquals(ControlMessage.TYPE_OPEN_HARD_KEYBOARD_SETTINGS, event.getType());
-    }
-
     @Test
     public void testMultiEvents() throws IOException {
         ControlMessageReader reader = new ControlMessageReader();

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

@@ -52,27 +52,4 @@ public class DeviceMessageWriterTest {
 
         Assert.assertArrayEquals(expected, actual);
     }
-
-    @Test
-    public void testSerializeUhidOutput() throws IOException {
-        DeviceMessageWriter writer = new DeviceMessageWriter();
-
-        ByteArrayOutputStream bos = new ByteArrayOutputStream();
-        DataOutputStream dos = new DataOutputStream(bos);
-        dos.writeByte(DeviceMessage.TYPE_UHID_OUTPUT);
-        dos.writeShort(42); // id
-        byte[] data = {1, 2, 3, 4, 5};
-        dos.writeShort(data.length);
-        dos.write(data);
-
-        byte[] expected = bos.toByteArray();
-
-        DeviceMessage msg = DeviceMessage.createUhidOutput(42, data);
-        bos = new ByteArrayOutputStream();
-        writer.writeTo(msg, bos);
-
-        byte[] actual = bos.toByteArray();
-
-        Assert.assertArrayEquals(expected, actual);
-    }
 }