Split workarounds to fix audio on some devices

There were several workarounds applied in a single method. Some of them
are specific to Meizu phones, but cause issues on other devices.

Split the method to be able to only fill the app context for audio
capture without applying the Meizu workarounds.

Fixes #3801 <https://github.com/Genymobile/scrcpy/issues/3801>

app/data/bash-completion/scrcpy

@@ -3,11 +3,9 @@ _scrcpy() {
     local opts="
         --always-on-top
         --audio-bit-rate=
-        --audio-buffer=
         --audio-codec=
         --audio-codec-options=
         --audio-encoder=
-        --audio-output-buffer=
         -b --video-bit-rate=
         --crop=
         -d --select-usb
@@ -117,26 +115,20 @@ _scrcpy() {
             COMPREPLY=($(compgen -W "$("${ADB:-adb}" devices | awk '$2 == "device" {print $1}')" -- ${cur}))
             return
             ;;
-        --audio-bit-rate \
+        -b|--video-bit-rate \
-        |--audio-buffer \
+        |--codec-options \
-        |-b|--video-bit-rate \
-        |--audio-codec-options \
-        |--audio-encoder \
-        |--audio-output-buffer \
         |--crop \
         |--display \
         |--display-buffer \
+        |--encoder \
         |--max-fps \
         |-m|--max-size \
         |-p|--port \
         |--push-target \
-        |--rotation \
         |--tunnel-host \
         |--tunnel-port \
         |--v4l2-buffer \
         |--v4l2-sink \
-        |--video-codec-options \
-        |--video-encoder \
         |--tcpip \
         |--window-*)
             # Option accepting an argument, but nothing to auto-complete

app/data/scrcpy-console.desktop

@@ -5,7 +5,7 @@ Comment=Display and control your Android device
 # For some users, the PATH or ADB environment variables are set from the shell
 # startup file, like .bashrc or .zshrc… Run an interactive shell to get
 # environment correctly initialized.
-Exec=/bin/bash --norc --noprofile -i -c "\"\\$SHELL\" -i -c scrcpy || read -p 'Press Enter to quit...'"
+Exec=/bin/bash --norc --noprofile -i -c '"$SHELL" -i -c scrcpy || read -p "Press any key to quit..."'
 Icon=scrcpy
 Terminal=true
 Type=Application

app/data/scrcpy.desktop

@@ -5,7 +5,7 @@ Comment=Display and control your Android device
 # For some users, the PATH or ADB environment variables are set from the shell
 # startup file, like .bashrc or .zshrc… Run an interactive shell to get
 # environment correctly initialized.
-Exec=/bin/sh -c "\"\\$SHELL\" -i -c scrcpy"
+Exec=/bin/sh -c '"$SHELL" -i -c scrcpy'
 Icon=scrcpy
 Terminal=false
 Type=Application

app/data/zsh-completion/_scrcpy

@@ -10,11 +10,9 @@ local arguments
 arguments=(
     '--always-on-top[Make scrcpy window always on top \(above other windows\)]'
     '--audio-bit-rate=[Encode the audio at the given bit-rate]'
-    '--audio-buffer=[Configure the audio buffering delay (in milliseconds)]'
     '--audio-codec=[Select the audio codec]:codec:(opus aac raw)'
     '--audio-codec-options=[Set a list of comma-separated key\:type=value options for the device audio encoder]'
     '--audio-encoder=[Use a specific MediaCodec audio encoder]'
-    '--audio-output-buffer=[Configure the size of the SDL audio output buffer (in milliseconds)]'
     {-b,--video-bit-rate=}'[Encode the video at the given bit-rate]'
     '--crop=[\[width\:height\:x\:y\] Crop the device screen on the server]'
     {-d,--select-usb}'[Use USB device]'

app/meson.build

@@ -277,6 +277,10 @@ if get_option('buildtype') == 'debug'
             'src/util/strbuf.c',
             'src/util/term.c',
         ]],
+        ['test_clock', [
+            'tests/test_clock.c',
+            'src/clock.c',
+        ]],
         ['test_control_msg_serialize', [
             'tests/test_control_msg_serialize.c',
             'src/control_msg.c',
@@ -306,8 +310,7 @@ if get_option('buildtype') == 'debug'
     ]
 
     foreach t : tests
-        sources = t[1] + ['src/compat.c']
+        exe = executable(t[0], t[1],
-        exe = executable(t[0], sources,
                          include_directories: src_dir,
                          dependencies: dependencies,
                          c_args: ['-DSDL_MAIN_HANDLED', '-DSC_TEST'])

app/scrcpy.1

@@ -33,14 +33,6 @@ Lower values decrease the latency, but increase the likelyhood of buffer underru
 
 Default is 50.
 
-.TP
-.BI "\-\-audio\-output\-buffer ms
-Configure the size of the SDL audio output buffer (in milliseconds).
-
-If you get "robotic" audio playback, you should test with a higher value (10). Do not change this setting otherwise.
-
-Default is 5.
-
 .TP
 .BI "\-\-audio\-codec " name
 Select an audio codec (opus, aac or raw).

app/src/audio_player.c

@@ -59,6 +59,8 @@
 #define SC_AV_SAMPLE_FMT AV_SAMPLE_FMT_FLT
 #define SC_SDL_SAMPLE_FMT AUDIO_F32
 
+#define SC_AUDIO_OUTPUT_BUFFER_MS 5
+
 #define TO_BYTES(SAMPLES) sc_audiobuf_to_bytes(&ap->buf, (SAMPLES))
 #define TO_SAMPLES(BYTES) sc_audiobuf_to_samples(&ap->buf, (BYTES))
 
@@ -228,8 +230,8 @@ sc_audio_player_frame_sink_push(struct sc_frame_sink *sink,
 
     if (played) {
         uint32_t max_buffered_samples = ap->target_buffering
-                                      + 12 * ap->output_buffer
+                + 12 * SC_AUDIO_OUTPUT_BUFFER_MS * ap->sample_rate / 1000
-                                      + ap->target_buffering / 10;
+                + 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);
@@ -244,7 +246,7 @@ sc_audio_player_frame_sink_push(struct sc_frame_sink *sink,
         // max_initial_buffering samples, this would cause unnecessary delay
         // (and glitches to compensate) on start.
         uint32_t max_initial_buffering = ap->target_buffering
-                                       + 2 * ap->output_buffer;
+                + 2 * SC_AUDIO_OUTPUT_BUFFER_MS * ap->sample_rate / 1000;
         if (buffered_samples > max_initial_buffering) {
             uint32_t skip_samples = buffered_samples - max_initial_buffering;
             sc_audiobuf_skip(&ap->buf, skip_samples);
@@ -331,28 +333,11 @@ sc_audio_player_frame_sink_open(struct sc_frame_sink *sink,
     unsigned nb_channels = tmp;
 #endif
 
-    assert(ctx->sample_rate > 0);
-    assert(!av_sample_fmt_is_planar(SC_AV_SAMPLE_FMT));
-    int out_bytes_per_sample = av_get_bytes_per_sample(SC_AV_SAMPLE_FMT);
-    assert(out_bytes_per_sample > 0);
-
-    ap->sample_rate = ctx->sample_rate;
-    ap->nb_channels = nb_channels;
-    ap->out_bytes_per_sample = out_bytes_per_sample;
-
-    ap->target_buffering = ap->target_buffering_delay * ap->sample_rate
-                                                      / SC_TICK_FREQ;
-
-    uint64_t aout_samples = ap->output_buffer_duration * ap->sample_rate
-                                                       / SC_TICK_FREQ;
-    assert(aout_samples <= 0xFFFF);
-    ap->output_buffer = (uint16_t) aout_samples;
-
     SDL_AudioSpec desired = {
         .freq = ctx->sample_rate,
         .format = SC_SDL_SAMPLE_FMT,
         .channels = nb_channels,
-        .samples = aout_samples,
+        .samples = SC_AUDIO_OUTPUT_BUFFER_MS * ctx->sample_rate / 1000,
         .callback = sc_audio_player_sdl_callback,
         .userdata = ap,
     };
@@ -371,6 +356,11 @@ sc_audio_player_frame_sink_open(struct sc_frame_sink *sink,
     }
     ap->swr_ctx = swr_ctx;
 
+    assert(ctx->sample_rate > 0);
+    assert(!av_sample_fmt_is_planar(SC_AV_SAMPLE_FMT));
+    int out_bytes_per_sample = av_get_bytes_per_sample(SC_AV_SAMPLE_FMT);
+    assert(out_bytes_per_sample > 0);
+
 #ifdef SCRCPY_LAVU_HAS_CHLAYOUT
     av_opt_set_chlayout(swr_ctx, "in_chlayout", &ctx->ch_layout, 0);
     av_opt_set_chlayout(swr_ctx, "out_chlayout", &ctx->ch_layout, 0);
@@ -393,6 +383,13 @@ sc_audio_player_frame_sink_open(struct sc_frame_sink *sink,
         goto error_free_swr_ctx;
     }
 
+    ap->sample_rate = ctx->sample_rate;
+    ap->nb_channels = nb_channels;
+    ap->out_bytes_per_sample = out_bytes_per_sample;
+
+    ap->target_buffering = ap->target_buffering_delay * ap->sample_rate
+                                                      / SC_TICK_FREQ;
+
     // Use a ring-buffer of the target buffering size plus 1 second between the
     // 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
@@ -461,10 +458,8 @@ sc_audio_player_frame_sink_close(struct sc_frame_sink *sink) {
 }
 
 void
-sc_audio_player_init(struct sc_audio_player *ap, sc_tick target_buffering,
+sc_audio_player_init(struct sc_audio_player *ap, sc_tick target_buffering) {
-                     sc_tick output_buffer_duration) {
     ap->target_buffering_delay = target_buffering;
-    ap->output_buffer_duration = output_buffer_duration;
 
     static const struct sc_frame_sink_ops ops = {
         .open = sc_audio_player_frame_sink_open,

app/src/audio_player.h

@@ -27,10 +27,6 @@ struct sc_audio_player {
     sc_tick target_buffering_delay;
     uint32_t target_buffering; // in samples
 
-    // SDL audio output buffer size.
-    sc_tick output_buffer_duration;
-    uint16_t output_buffer;
-
     // Audio buffer to communicate between the receiver and the SDL audio
     // callback (protected by SDL_AudioDeviceLock())
     struct sc_audiobuf buf;
@@ -84,7 +80,6 @@ struct sc_audio_player_callbacks {
 };
 
 void
-sc_audio_player_init(struct sc_audio_player *ap, sc_tick target_buffering,
+sc_audio_player_init(struct sc_audio_player *ap, sc_tick target_buffering);
-                     sc_tick audio_output_buffer);
 
 #endif

app/src/cli.c

@@ -71,7 +71,6 @@ enum {
     OPT_LIST_DISPLAYS,
     OPT_REQUIRE_AUDIO,
     OPT_AUDIO_BUFFER,
-    OPT_AUDIO_OUTPUT_BUFFER,
 };
 
 struct sc_option {
@@ -130,16 +129,6 @@ static const struct sc_option options[] = {
                 "likelyhood of buffer underrun (causing audio glitches).\n"
                 "Default is 50.",
     },
-    {
-        .longopt_id = OPT_AUDIO_OUTPUT_BUFFER,
-        .longopt = "audio-output-buffer",
-        .argdesc = "ms",
-        .text = "Configure the size of the SDL audio output buffer (in "
-                "milliseconds).\n"
-                "If you get \"robotic\" audio playback, you should test with "
-                "a higher value (10). Do not change this setting otherwise.\n"
-                "Default is 5.",
-    },
     {
         .longopt_id = OPT_AUDIO_CODEC,
         .longopt = "audio-codec",
@@ -1215,19 +1204,6 @@ parse_buffering_time(const char *s, sc_tick *tick) {
     return true;
 }
 
-static bool
-parse_audio_output_buffer(const char *s, sc_tick *tick) {
-    long value;
-    bool ok = parse_integer_arg(s, &value, false, 0, 1000,
-                                "audio output buffer");
-    if (!ok) {
-        return false;
-    }
-
-    *tick = SC_TICK_FROM_MS(value);
-    return true;
-}
-
 static bool
 parse_lock_video_orientation(const char *s,
                              enum sc_lock_video_orientation *lock_mode) {
@@ -1855,12 +1831,6 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
                     return false;
                 }
                 break;
-            case OPT_AUDIO_OUTPUT_BUFFER:
-                if (!parse_audio_output_buffer(optarg,
-                                               &opts->audio_output_buffer)) {
-                    return false;
-                }
-                break;
             default:
                 // getopt prints the error message on stderr
                 return false;

app/src/clock.c

@@ -1,36 +1,116 @@
 #include "clock.h"
 
-#include <assert.h>
-
 #include "util/log.h"
 
 #define SC_CLOCK_NDEBUG // comment to debug
 
-#define SC_CLOCK_RANGE 32
-
 void
 sc_clock_init(struct sc_clock *clock) {
-    clock->range = 0;
+    clock->count = 0;
-    clock->offset = 0;
+    clock->head = 0;
+    clock->left_sum.system = 0;
+    clock->left_sum.stream = 0;
+    clock->right_sum.system = 0;
+    clock->right_sum.stream = 0;
+}
+
+// Estimate the affine function f(stream) = slope * stream + offset
+static void
+sc_clock_estimate(struct sc_clock *clock,
+                  double *out_slope, sc_tick *out_offset) {
+    assert(clock->count);
+
+    if (clock->count == 1) {
+        // If there is only 1 point, we can't compute a slope. Assume it is 1.
+        struct sc_clock_point *single_point = &clock->right_sum;
+        *out_slope = 1;
+        *out_offset = single_point->system - single_point->stream;
+        return;
+    }
+
+    struct sc_clock_point left_avg = {
+        .system = clock->left_sum.system / (clock->count / 2),
+        .stream = clock->left_sum.stream / (clock->count / 2),
+    };
+    struct sc_clock_point right_avg = {
+        .system = clock->right_sum.system / ((clock->count + 1) / 2),
+        .stream = clock->right_sum.stream / ((clock->count + 1) / 2),
+    };
+
+    double slope = (double) (right_avg.system - left_avg.system)
+                 / (right_avg.stream - left_avg.stream);
+
+    if (clock->count < SC_CLOCK_RANGE) {
+        /* The first frames are typically received and decoded with more delay
+         * than the others, causing a wrong slope estimation on start. To
+         * compensate, assume an initial slope of 1, then progressively use the
+         * estimated slope. */
+        slope = (clock->count * slope + (SC_CLOCK_RANGE - clock->count))
+              / SC_CLOCK_RANGE;
+    }
+
+    struct sc_clock_point global_avg = {
+        .system = (clock->left_sum.system + clock->right_sum.system)
+                 / clock->count,
+        .stream = (clock->left_sum.stream + clock->right_sum.stream)
+                 / clock->count,
+    };
+
+    sc_tick offset = global_avg.system - (sc_tick) (global_avg.stream * slope);
+
+    *out_slope = slope;
+    *out_offset = offset;
 }
 
 void
 sc_clock_update(struct sc_clock *clock, sc_tick system, sc_tick stream) {
-    if (clock->range < SC_CLOCK_RANGE) {
+    struct sc_clock_point *point = &clock->points[clock->head];
-        ++clock->range;
+
+    if (clock->count == SC_CLOCK_RANGE || clock->count & 1) {
+        // One point passes from the right sum to the left sum
+
+        unsigned mid;
+        if (clock->count == SC_CLOCK_RANGE) {
+            mid = (clock->head + SC_CLOCK_RANGE / 2) % SC_CLOCK_RANGE;
+        } else {
+            // Only for the first frames
+            mid = clock->count / 2;
+        }
+
+        struct sc_clock_point *mid_point = &clock->points[mid];
+        clock->left_sum.system += mid_point->system;
+        clock->left_sum.stream += mid_point->stream;
+        clock->right_sum.system -= mid_point->system;
+        clock->right_sum.stream -= mid_point->stream;
     }
 
-    sc_tick offset = system - stream;
+    if (clock->count == SC_CLOCK_RANGE) {
-    clock->offset = ((clock->range - 1) * clock->offset + offset)
+        // The current point overwrites the previous value in the circular
-                  / clock->range;
+        // array, update the left sum accordingly
+        clock->left_sum.system -= point->system;
+        clock->left_sum.stream -= point->stream;
+    } else {
+        ++clock->count;
+    }
+
+    point->system = system;
+    point->stream = stream;
+
+    clock->right_sum.system += system;
+    clock->right_sum.stream += stream;
+
+    clock->head = (clock->head + 1) % SC_CLOCK_RANGE;
+
+    // Update estimation
+    sc_clock_estimate(clock, &clock->slope, &clock->offset);
 
 #ifndef SC_CLOCK_NDEBUG
-    LOGD("Clock estimation: pts + %" PRItick, clock->offset);
+    LOGD("Clock estimation: %f * pts + %" PRItick, clock->slope, clock->offset);
 #endif
 }
 
 sc_tick
 sc_clock_to_system_time(struct sc_clock *clock, sc_tick stream) {
-    assert(clock->range); // sc_clock_update() must have been called
+    assert(clock->count); // sc_clock_update() must have been called
-    return stream + clock->offset;
+    return (sc_tick) (stream * clock->slope) + clock->offset;
 }

app/src/clock.h

@@ -3,8 +3,13 @@
 
 #include "common.h"
 
+#include <assert.h>
+
 #include "util/tick.h"
 
+#define SC_CLOCK_RANGE 32
+static_assert(!(SC_CLOCK_RANGE & 1), "SC_CLOCK_RANGE must be even");
+
 struct sc_clock_point {
     sc_tick system;
     sc_tick stream;
@@ -16,18 +21,40 @@ struct sc_clock_point {
  *
  *     f(stream) = slope * stream + offset
  *
- * Theoretically, the slope encodes the drift between the device clock and the
+ * To that end, it stores the SC_CLOCK_RANGE last clock points (the timestamps
- * computer clock. It is expected to be very close to 1.
+ * of a frame expressed both in stream time and system time) in a circular
+ * array.
  *
- * Since the clock is used to estimate very close points in the future (which
+ * To estimate the slope, it splits the last SC_CLOCK_RANGE points into two
- * are reestimated on every clock update, see delay_buffer), the error caused
+ * sets of SC_CLOCK_RANGE/2 points, and computes their centroid ("average
- * by clock drift is totally negligible, so it is better to assume that the
+ * point"). The slope of the estimated affine function is that of the line
- * slope is 1 than to estimate it (the estimation error would be larger).
+ * passing through these two points.
  *
- * Therefore, only the offset is estimated.
+ * To estimate the offset, it computes the centroid of all the SC_CLOCK_RANGE
+ * points. The resulting affine function passes by this centroid.
+ *
+ * With a circular array, the rolling sums (and average) are quick to compute.
+ * In practice, the estimation is stable and the evolution is smooth.
  */
 struct sc_clock {
-    unsigned range;
+    // Circular array
+    struct sc_clock_point points[SC_CLOCK_RANGE];
+
+    // Number of points in the array (count <= SC_CLOCK_RANGE)
+    unsigned count;
+
+    // Index of the next point to write
+    unsigned head;
+
+    // Sum of the first count/2 points
+    struct sc_clock_point left_sum;
+
+    // Sum of the last (count+1)/2 points
+    struct sc_clock_point right_sum;
+
+    // Estimated slope and offset
+    // (computed on sc_clock_update(), used by sc_clock_to_system_time())
+    double slope;
     sc_tick offset;
 };
 

app/src/delay_buffer.c

@@ -194,7 +194,7 @@ sc_delay_buffer_frame_sink_push(struct sc_frame_sink *sink,
     sc_clock_update(&db->clock, sc_tick_now(), pts);
     sc_cond_signal(&db->wait_cond);
 
-    if (db->first_frame_asap && db->clock.range == 1) {
+    if (db->first_frame_asap && db->clock.count == 1) {
         sc_mutex_unlock(&db->mutex);
         return sc_frame_source_sinks_push(&db->frame_source, frame);
     }

app/src/options.c

@@ -44,7 +44,6 @@ const struct scrcpy_options scrcpy_options_default = {
     .display_buffer = 0,
     .v4l2_buffer = 0,
     .audio_buffer = SC_TICK_FROM_MS(50),
-    .audio_output_buffer = SC_TICK_FROM_MS(5),
 #ifdef HAVE_USB
     .otg = false,
 #endif

app/src/options.h

@@ -127,7 +127,6 @@ struct scrcpy_options {
     sc_tick display_buffer;
     sc_tick v4l2_buffer;
     sc_tick audio_buffer;
-    sc_tick audio_output_buffer;
 #ifdef HAVE_USB
     bool otg;
 #endif

app/src/scrcpy.c

@@ -688,8 +688,7 @@ aoa_hid_end:
         sc_frame_source_add_sink(src, &s->screen.frame_sink);
 
         if (options->audio) {
-            sc_audio_player_init(&s->audio_player, options->audio_buffer,
+            sc_audio_player_init(&s->audio_player, options->audio_buffer);
-                                 options->audio_output_buffer);
             sc_frame_source_add_sink(&s->audio_decoder.frame_source,
                                      &s->audio_player.frame_sink);
         }

app/tests/test_clock.c

@@ -0,0 +1,79 @@
+#include "common.h"
+
+#include <assert.h>
+
+#include "clock.h"
+
+void test_small_rolling_sum(void) {
+    struct sc_clock clock;
+    sc_clock_init(&clock);
+
+    assert(clock.count == 0);
+    assert(clock.left_sum.system == 0);
+    assert(clock.left_sum.stream == 0);
+    assert(clock.right_sum.system == 0);
+    assert(clock.right_sum.stream == 0);
+
+    sc_clock_update(&clock, 2, 3);
+    assert(clock.count == 1);
+    assert(clock.left_sum.system == 0);
+    assert(clock.left_sum.stream == 0);
+    assert(clock.right_sum.system == 2);
+    assert(clock.right_sum.stream == 3);
+
+    sc_clock_update(&clock, 10, 20);
+    assert(clock.count == 2);
+    assert(clock.left_sum.system == 2);
+    assert(clock.left_sum.stream == 3);
+    assert(clock.right_sum.system == 10);
+    assert(clock.right_sum.stream == 20);
+
+    sc_clock_update(&clock, 40, 80);
+    assert(clock.count == 3);
+    assert(clock.left_sum.system == 2);
+    assert(clock.left_sum.stream == 3);
+    assert(clock.right_sum.system == 50);
+    assert(clock.right_sum.stream == 100);
+
+    sc_clock_update(&clock, 400, 800);
+    assert(clock.count == 4);
+    assert(clock.left_sum.system == 12);
+    assert(clock.left_sum.stream == 23);
+    assert(clock.right_sum.system == 440);
+    assert(clock.right_sum.stream == 880);
+}
+
+void test_large_rolling_sum(void) {
+    const unsigned half_range = SC_CLOCK_RANGE / 2;
+
+    struct sc_clock clock1;
+    sc_clock_init(&clock1);
+    for (unsigned i = 0; i < 5 * half_range; ++i) {
+        sc_clock_update(&clock1, i, 2 * i + 1);
+    }
+
+    struct sc_clock clock2;
+    sc_clock_init(&clock2);
+    for (unsigned i = 3 * half_range; i < 5 * half_range; ++i) {
+        sc_clock_update(&clock2, i, 2 * i + 1);
+    }
+
+    assert(clock1.count == SC_CLOCK_RANGE);
+    assert(clock2.count == SC_CLOCK_RANGE);
+
+    // The values before the last SC_CLOCK_RANGE points in clock1 should have
+    // no impact
+    assert(clock1.left_sum.system == clock2.left_sum.system);
+    assert(clock1.left_sum.stream == clock2.left_sum.stream);
+    assert(clock1.right_sum.system == clock2.right_sum.system);
+    assert(clock1.right_sum.stream == clock2.right_sum.stream);
+}
+
+int main(int argc, char *argv[]) {
+    (void) argc;
+    (void) argv;
+
+    test_small_rolling_sum();
+    test_large_rolling_sum();
+    return 0;
+};

doc/audio.md

@@ -88,14 +88,3 @@ avoid glitches and smooth the playback:
 ```
 scrcpy --display-buffer=200 --audio-buffer=200
 ```
-
-It is also possible to configure another audio buffer (the audio output buffer),
-by default set to 5ms. Don't change it, unless you get some [robotic and glitchy
-sound][#3793]:
-
-```bash
-# Only if absolutely necessary
-scrcpy --audio-output-buffer=10
-```
-
-[#3793]: https://github.com/Genymobile/scrcpy/issues/3793

server/build_without_gradle.sh

@@ -14,8 +14,8 @@ set -e
 SCRCPY_DEBUG=false
 SCRCPY_VERSION_NAME=2.0
 
-PLATFORM=${ANDROID_PLATFORM:-23}
+PLATFORM=${ANDROID_PLATFORM:-33}
-BUILD_TOOLS=${ANDROID_BUILD_TOOLS:-23.0.3}
+BUILD_TOOLS=${ANDROID_BUILD_TOOLS:-33.0.0}
 BUILD_TOOLS_DIR="$ANDROID_HOME/build-tools/$BUILD_TOOLS"
 
 BUILD_DIR="$(realpath ${BUILD_DIR:-build_manual})"
@@ -43,17 +43,6 @@ public final class BuildConfig {
 }
 EOF
 
-STUBS_DIR="$BUILD_DIR/stubs"
-rm -rf "$STUBS_DIR"
-mkdir -p "$STUBS_DIR"
-echo "Generating SDK stubs..."
-cd "$SERVER_DIR/src/main/stubs"
-javac -bootclasspath "$ANDROID_JAR" \
-    -d "$STUBS_DIR" \
-    -source 1.8 -target 1.8 \
-    android/content/*
-cd -
-
 echo "Generating java from aidl..."
 cd "$SERVER_DIR/src/main/aidl"
 "$BUILD_TOOLS_DIR/aidl" -o"$GEN_DIR" android/view/IRotationWatcher.aidl
@@ -63,7 +52,7 @@ cd "$SERVER_DIR/src/main/aidl"
 echo "Compiling java sources..."
 cd ../java
 javac -bootclasspath "$ANDROID_JAR" \
-    -cp "$LAMBDA_JAR:$GEN_DIR:$STUBS_DIR" \
+    -cp "$LAMBDA_JAR:$GEN_DIR" \
     -d "$CLASSES_DIR" \
     -source 1.8 -target 1.8 \
     com/genymobile/scrcpy/*.java \

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

@@ -5,7 +5,6 @@ import com.genymobile.scrcpy.wrappers.ServiceManager;
 import android.annotation.SuppressLint;
 import android.annotation.TargetApi;
 import android.content.ComponentName;
-import android.content.Context;
 import android.content.Intent;
 import android.media.AudioFormat;
 import android.media.AudioRecord;
@@ -15,7 +14,6 @@ import android.media.MediaRecorder;
 import android.os.Build;
 import android.os.SystemClock;
 
-import java.lang.reflect.Method;
 import java.nio.ByteBuffer;
 
 public final class AudioCapture {
@@ -44,28 +42,13 @@ public final class AudioCapture {
         return builder.build();
     }
 
-    private static Method setBuilderContext;
-
-    @TargetApi(23)
-    private static void setBuilderContext(AudioRecord.Builder builder, Context context) {
-        try {
-            if (setBuilderContext == null) {
-                setBuilderContext = AudioRecord.Builder.class.getMethod("setContext", Context.class);
-            }
-            setBuilderContext.invoke(builder, context);
-        } catch (Exception e) {
-            Ln.e("Could not call AudioRecord.Builder.setContext() method");
-            //throw new RuntimeException(e);
-        }
-    }
-
     @TargetApi(Build.VERSION_CODES.M)
     @SuppressLint({"WrongConstant", "MissingPermission"})
     private static AudioRecord createAudioRecord() {
         AudioRecord.Builder builder = new AudioRecord.Builder();
-        if (Build.VERSION.SDK_INT >= 31) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
             // On older APIs, Workarounds.fillAppInfo() must be called beforehand
-            setBuilderContext(builder, FakeContext.get());
+            builder.setContext(FakeContext.get());
         }
         builder.setAudioSource(MediaRecorder.AudioSource.REMOTE_SUBMIX);
         builder.setAudioFormat(createAudioFormat());
@@ -76,58 +59,45 @@ public final class AudioCapture {
     }
 
     private static void startWorkaroundAndroid11() {
-        // Android 11 requires Apps to be at foreground to record audio.
+        if (Build.VERSION.SDK_INT == Build.VERSION_CODES.R) {
-        // Normally, each App has its own user ID, so Android checks whether the requesting App has the user ID that's at the foreground.
+            // Android 11 requires Apps to be at foreground to record audio.
-        // But scrcpy server is NOT an App, it's a Java application started from Android shell, so it has the same user ID (2000) with Android
+            // Normally, each App has its own user ID, so Android checks whether the requesting App has the user ID that's at the foreground.
-        // shell ("com.android.shell").
+            // But scrcpy server is NOT an App, it's a Java application started from Android shell, so it has the same user ID (2000) with Android
-        // If there is an Activity from Android shell running at foreground, then the permission system will believe scrcpy is also in the
+            // shell ("com.android.shell").
-        // foreground.
+            // If there is an Activity from Android shell running at foreground, then the permission system will believe scrcpy is also in the
-        Intent intent = new Intent(Intent.ACTION_MAIN);
+            // foreground.
-        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+            if (Build.VERSION.SDK_INT == Build.VERSION_CODES.R) {
-        intent.addCategory(Intent.CATEGORY_LAUNCHER);
+                Intent intent = new Intent(Intent.ACTION_MAIN);
-        intent.setComponent(new ComponentName(FakeContext.PACKAGE_NAME, "com.android.shell.HeapDumpActivity"));
+                intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
-        ServiceManager.getActivityManager().startActivityAsUserWithFeature(intent);
+                intent.addCategory(Intent.CATEGORY_LAUNCHER);
-    }
+                intent.setComponent(new ComponentName(FakeContext.PACKAGE_NAME, "com.android.shell.HeapDumpActivity"));
-
+                ServiceManager.getActivityManager().startActivityAsUserWithFeature(intent);
-    private static void stopWorkaroundAndroid11() {
+                // Wait for activity to start
-        ServiceManager.getActivityManager().forceStopPackage(FakeContext.PACKAGE_NAME);
+                SystemClock.sleep(150);
-    }
-
-    private void tryStartRecording(int attempts, int delayMs) throws AudioCaptureForegroundException {
-        while (attempts-- > 0) {
-            // Wait for activity to start
-            SystemClock.sleep(delayMs);
-            try {
-                startRecording();
-                return; // it worked
-            } catch (UnsupportedOperationException e) {
-                if (attempts == 0) {
-                    Ln.e("Failed to start audio capture");
-                    Ln.e("On Android 11, audio capture must be started in the foreground, make sure that the device is unlocked when starting " +
-                            "scrcpy.");
-                    throw new AudioCaptureForegroundException();
-                } else {
-                    Ln.d("Failed to start audio capture, retrying...");
-                }
             }
         }
     }
 
-    private void startRecording() {
+    private static void stopWorkaroundAndroid11() {
-        recorder = createAudioRecord();
+        if (Build.VERSION.SDK_INT == Build.VERSION_CODES.R) {
-        recorder.startRecording();
+            ServiceManager.getActivityManager().forceStopPackage(FakeContext.PACKAGE_NAME);
+        }
     }
 
     public void start() throws AudioCaptureForegroundException {
-        if (Build.VERSION.SDK_INT == 30) {
+        startWorkaroundAndroid11();
-            startWorkaroundAndroid11();
+        try {
-            try {
+            recorder = createAudioRecord();
-                tryStartRecording(3, 100);
+            recorder.startRecording();
-            } finally {
+        } catch (UnsupportedOperationException e) {
-                stopWorkaroundAndroid11();
+            if (Build.VERSION.SDK_INT == Build.VERSION_CODES.R) {
+                Ln.e("Failed to start audio capture");
+                Ln.e("On Android 11, it is only possible to capture in foreground, make sure that the device is unlocked when starting scrcpy.");
+                throw new AudioCaptureForegroundException();
             }
-        } else {
+            throw e;
-            startRecording();
+        } finally {
+            stopWorkaroundAndroid11();
         }
     }
 
@@ -138,21 +108,7 @@ public final class AudioCapture {
         }
     }
 
-    private static Method getTimestampMethod;
+    @TargetApi(Build.VERSION_CODES.N)
-
-    private static int getRecorderTimestamp(AudioRecord recorder, AudioTimestamp timestamp) {
-        try {
-            if (getTimestampMethod == null) {
-                getTimestampMethod = AudioRecord.class.getMethod("getTimestamp", AudioTimestamp.class, int.class);
-            }
-            return (int) getTimestampMethod.invoke(recorder, timestamp, 0);
-        } catch (Exception e) {
-            Ln.e("Could not call AudioRecord.getTimestamp() method");
-            return AudioRecord.ERROR;
-        }
-    }
-
-    @TargetApi(24)
     public int read(ByteBuffer directBuffer, int size, MediaCodec.BufferInfo outBufferInfo) {
         int r = recorder.read(directBuffer, size);
         if (r <= 0) {
@@ -161,7 +117,7 @@ public final class AudioCapture {
 
         long pts;
 
-        int ret = getRecorderTimestamp(recorder, timestamp);
+        int ret = recorder.getTimestamp(timestamp, AudioTimestamp.TIMEBASE_MONOTONIC);
         if (ret == AudioRecord.SUCCESS) {
             pts = timestamp.nanoTime / 1000;
         } else {

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

@@ -84,7 +84,7 @@ public final class AudioEncoder implements AsyncProcessor {
         return format;
     }
 
-    @TargetApi(24)
+    @TargetApi(Build.VERSION_CODES.N)
     private void inputThread(MediaCodec mediaCodec, AudioCapture capture) throws IOException, InterruptedException {
         final MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
 
@@ -159,7 +159,7 @@ public final class AudioEncoder implements AsyncProcessor {
 
     @TargetApi(Build.VERSION_CODES.M)
     public void encode() throws IOException, ConfigurationException, AudioCaptureForegroundException {
-        if (Build.VERSION.SDK_INT < 30) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
             Ln.w("Audio disabled: it is not supported before Android 11");
             streamer.writeDisableStream(false);
             return;
@@ -271,26 +271,17 @@ public final class AudioEncoder implements AsyncProcessor {
             try {
                 return MediaCodec.createByCodecName(encoderName);
             } catch (IllegalArgumentException e) {
-                Ln.e("Audio encoder '" + encoderName + "' for " + codec.getName() + " not found\n" + LogUtils.buildAudioEncoderListMessage());
+                Ln.e("Encoder '" + encoderName + "' for " + codec.getName() + " not found\n" + LogUtils.buildAudioEncoderListMessage());
                 throw new ConfigurationException("Unknown encoder: " + encoderName);
-            } catch (IOException e) {
-                Ln.e("Could not create audio encoder '" + encoderName + "' for " + codec.getName() + "\n" + LogUtils.buildAudioEncoderListMessage());
-                throw e;
             }
         }
-
+        MediaCodec mediaCodec = MediaCodec.createEncoderByType(codec.getMimeType());
-        try {
+        Ln.d("Using audio encoder: '" + mediaCodec.getName() + "'");
-            MediaCodec mediaCodec = MediaCodec.createEncoderByType(codec.getMimeType());
+        return mediaCodec;
-            Ln.d("Using audio encoder: '" + mediaCodec.getName() + "'");
-            return mediaCodec;
-        } catch (IOException | IllegalArgumentException e) {
-            Ln.e("Could not create default audio encoder for " + codec.getName() + "\n" + LogUtils.buildAudioEncoderListMessage());
-            throw e;
-        }
     }
 
     private class EncoderCallback extends MediaCodec.Callback {
-        @TargetApi(24)
+        @TargetApi(Build.VERSION_CODES.N)
         @Override
         public void onInputBufferAvailable(MediaCodec codec, int index) {
             try {

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

@@ -373,8 +373,8 @@ public class Controller implements AsyncProcessor {
 
     private void getClipboard(int copyKey) {
         // On Android >= 7, press the COPY or CUT key if requested
-        if (copyKey != ControlMessage.COPY_KEY_NONE && Build.VERSION.SDK_INT >= 24 && device.supportsInputEvents()) {
+        if (copyKey != ControlMessage.COPY_KEY_NONE && Build.VERSION.SDK_INT >= Build.VERSION_CODES.N && device.supportsInputEvents()) {
-            int key = copyKey == ControlMessage.COPY_KEY_COPY ? 278 : 277;
+            int key = copyKey == ControlMessage.COPY_KEY_COPY ? KeyEvent.KEYCODE_COPY : KeyEvent.KEYCODE_CUT;
             // Wait until the event is finished, to ensure that the clipboard text we read just after is the correct one
             device.pressReleaseKeycode(key, Device.INJECT_MODE_WAIT_FOR_FINISH);
         }
@@ -397,8 +397,8 @@ public class Controller implements AsyncProcessor {
         }
 
         // On Android >= 7, also press the PASTE key if requested
-        if (paste && Build.VERSION.SDK_INT >= 24 && device.supportsInputEvents()) {
+        if (paste && Build.VERSION.SDK_INT >= Build.VERSION_CODES.N && device.supportsInputEvents()) {
-            device.pressReleaseKeycode(279, Device.INJECT_MODE_ASYNC);
+            device.pressReleaseKeycode(KeyEvent.KEYCODE_PASTE, Device.INJECT_MODE_ASYNC);
         }
 
         if (sequence != ControlMessage.SEQUENCE_INVALID) {

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

@@ -68,8 +68,7 @@ public final class DesktopConnection implements Closeable {
         LocalSocket controlSocket = null;
         try {
             if (tunnelForward) {
-                LocalServerSocket localServerSocket = new LocalServerSocket(socketName);
+                try (LocalServerSocket localServerSocket = new LocalServerSocket(socketName)) {
-                try {
                     videoSocket = localServerSocket.accept();
                     if (sendDummyByte) {
                         // send one byte so the client may read() to detect a connection error
@@ -81,8 +80,6 @@ public final class DesktopConnection implements Closeable {
                     if (control) {
                         controlSocket = localServerSocket.accept();
                     }
-                } finally {
-                    localServerSocket.close();
                 }
             } else {
                 videoSocket = connect(socketName);

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

@@ -124,7 +124,7 @@ public final class Device {
         }
 
         // main display or any display on Android >= Q
-        supportsInputEvents = displayId == 0 || Build.VERSION.SDK_INT >= 29;
+        supportsInputEvents = displayId == 0 || Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q;
         if (!supportsInputEvents) {
             Ln.w("Input events are not supported for secondary displays before Android 10");
         }
@@ -173,7 +173,7 @@ public final class Device {
     }
 
     public static boolean supportsInputEvents(int displayId) {
-        return displayId == 0 || Build.VERSION.SDK_INT >= 29;
+        return displayId == 0 || Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q;
     }
 
     public boolean supportsInputEvents() {
@@ -277,7 +277,7 @@ public final class Device {
      * @param mode one of the {@code POWER_MODE_*} constants
      */
     public static boolean setScreenPowerMode(int mode) {
-        if (Build.VERSION.SDK_INT >= 29) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
             // Change the power mode for all physical displays
             long[] physicalDisplayIds = SurfaceControl.getPhysicalDisplayIds();
             if (physicalDisplayIds == null) {
@@ -288,7 +288,10 @@ public final class Device {
             boolean allOk = true;
             for (long physicalDisplayId : physicalDisplayIds) {
                 IBinder binder = SurfaceControl.getPhysicalDisplayToken(physicalDisplayId);
-                allOk &= SurfaceControl.setDisplayPowerMode(binder, mode);
+                boolean ok = SurfaceControl.setDisplayPowerMode(binder, mode);
+                if (!ok) {
+                    allOk = false;
+                }
             }
             return allOk;
         }

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

@@ -26,20 +26,16 @@ public final class FakeContext extends ContextWrapper {
         return PACKAGE_NAME;
     }
 
+    @Override
     public String getOpPackageName() {
         return PACKAGE_NAME;
     }
 
-    @TargetApi(31)
+    @TargetApi(Build.VERSION_CODES.S)
+    @Override
     public AttributionSource getAttributionSource() {
-        AttributionSource.Builder builder = new AttributionSource.Builder(0);
+        AttributionSource.Builder builder = new AttributionSource.Builder(Process.SHELL_UID);
         builder.setPackageName(PACKAGE_NAME);
         return builder.build();
     }
-
-    // @Override to be added on SDK upgrade for Android 14
-    @SuppressWarnings("unused")
-    public int getDeviceId() {
-        return 0;
-    }
 }

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

@@ -202,22 +202,13 @@ public class ScreenEncoder implements Device.RotationListener {
             try {
                 return MediaCodec.createByCodecName(encoderName);
             } catch (IllegalArgumentException e) {
-                Ln.e("Video encoder '" + encoderName + "' for " + codec.getName() + " not found\n" + LogUtils.buildVideoEncoderListMessage());
+                Ln.e("Encoder '" + encoderName + "' for " + codec.getName() + " not found\n" + LogUtils.buildVideoEncoderListMessage());
                 throw new ConfigurationException("Unknown encoder: " + encoderName);
-            } catch (IOException e) {
-                Ln.e("Could not create video encoder '" + encoderName + "' for " + codec.getName() + "\n" + LogUtils.buildVideoEncoderListMessage());
-                throw e;
             }
         }
-
+        MediaCodec mediaCodec = MediaCodec.createEncoderByType(codec.getMimeType());
-        try {
+        Ln.d("Using encoder: '" + mediaCodec.getName() + "'");
-            MediaCodec mediaCodec = MediaCodec.createEncoderByType(codec.getMimeType());
+        return mediaCodec;
-            Ln.d("Using video encoder: '" + mediaCodec.getName() + "'");
-            return mediaCodec;
-        } catch (IOException | IllegalArgumentException e) {
-            Ln.e("Could not create default video encoder for " + codec.getName() + "\n" + LogUtils.buildVideoEncoderListMessage());
-            throw e;
-        }
     }
 
     private static MediaFormat createFormat(String videoMimeType, int bitRate, int maxFps, List<CodecOption> codecOptions) {
@@ -252,7 +243,7 @@ public class ScreenEncoder implements Device.RotationListener {
     private static IBinder createDisplay() {
         // Since Android 12 (preview), secure displays could not be created with shell permissions anymore.
         // On Android 12 preview, SDK_INT is still R (not S), but CODENAME is "S".
-        boolean secure = Build.VERSION.SDK_INT < 30 || (Build.VERSION.SDK_INT == 30 && !"S"
+        boolean secure = Build.VERSION.SDK_INT < Build.VERSION_CODES.R || (Build.VERSION.SDK_INT == Build.VERSION_CODES.R && !"S"
                 .equals(Build.VERSION.CODENAME));
         return SurfaceControl.createDisplay("scrcpy", secure);
     }

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

@@ -88,7 +88,7 @@ public final class Server {
         // Before Android 11, audio is not supported.
         // Since Android 12, we can properly set a context on the AudioRecord.
         // Only on Android 11 we must fill the application context for the AudioRecord to work.
-        if (audio && Build.VERSION.SDK_INT == 30) {
+        if (audio && Build.VERSION.SDK_INT == Build.VERSION_CODES.R) {
             Workarounds.fillAppContext();
         }
 

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

@@ -34,7 +34,7 @@ public final class Settings {
     }
 
     public static String getValue(String table, String key) throws SettingsException {
-        if (Build.VERSION.SDK_INT <= 30) {
+        if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.R) {
             // on Android >= 12, it always fails: <https://github.com/Genymobile/scrcpy/issues/2788>
             try (ContentProvider provider = ServiceManager.getActivityManager().createSettingsProvider()) {
                 return provider.getValue(table, key);
@@ -47,7 +47,7 @@ public final class Settings {
     }
 
     public static void putValue(String table, String key, String value) throws SettingsException {
-        if (Build.VERSION.SDK_INT <= 30) {
+        if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.R) {
             // on Android >= 12, it always fails: <https://github.com/Genymobile/scrcpy/issues/2788>
             try (ContentProvider provider = ServiceManager.getActivityManager().createSettingsProvider()) {
                 provider.putValue(table, key, value);
@@ -60,7 +60,7 @@ public final class Settings {
     }
 
     public static String getAndPutValue(String table, String key, String value) throws SettingsException {
-        if (Build.VERSION.SDK_INT <= 30) {
+        if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.R) {
             // on Android >= 12, it always fails: <https://github.com/Genymobile/scrcpy/issues/2788>
             try (ContentProvider provider = ServiceManager.getActivityManager().createSettingsProvider()) {
                 String oldValue = provider.getValue(table, key);

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

@@ -7,7 +7,7 @@ public enum VideoCodec implements Codec {
     H264(0x68_32_36_34, "h264", MediaFormat.MIMETYPE_VIDEO_AVC),
     H265(0x68_32_36_35, "h265", MediaFormat.MIMETYPE_VIDEO_HEVC),
     @SuppressLint("InlinedApi") // introduced in API 21
-    AV1(0x00_61_76_31, "av1", "video/av01");
+    AV1(0x00_61_76_31, "av1", MediaFormat.MIMETYPE_VIDEO_AV1);
 
     private final int id; // 4-byte ASCII representation of the name
     private final String name;

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

@@ -51,7 +51,7 @@ public class ActivityManager {
         return removeContentProviderExternalMethod;
     }
 
-    @TargetApi(29)
+    @TargetApi(Build.VERSION_CODES.Q)
     private ContentProvider getContentProviderExternal(String name, IBinder token) {
         try {
             Method method = getGetContentProviderExternalMethod();

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

@@ -16,9 +16,9 @@ public class ClipboardManager {
     private Method getPrimaryClipMethod;
     private Method setPrimaryClipMethod;
     private Method addPrimaryClipChangedListener;
-    private int getMethodVersion;
+    private boolean alternativeGetMethod;
-    private int setMethodVersion;
+    private boolean alternativeSetMethod;
-    private int addListenerMethodVersion;
+    private boolean alternativeAddListenerMethod;
 
     public ClipboardManager(IInterface manager) {
         this.manager = manager;
@@ -26,20 +26,14 @@ public class ClipboardManager {
 
     private Method getGetPrimaryClipMethod() throws NoSuchMethodException {
         if (getPrimaryClipMethod == null) {
-            if (Build.VERSION.SDK_INT < 29) {
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
                 getPrimaryClipMethod = manager.getClass().getMethod("getPrimaryClip", String.class);
             } else {
                 try {
                     getPrimaryClipMethod = manager.getClass().getMethod("getPrimaryClip", String.class, int.class);
-                    getMethodVersion = 0;
+                } catch (NoSuchMethodException e) {
-                } catch (NoSuchMethodException e1) {
+                    getPrimaryClipMethod = manager.getClass().getMethod("getPrimaryClip", String.class, String.class, int.class);
-                    try {
+                    alternativeGetMethod = true;
-                        getPrimaryClipMethod = manager.getClass().getMethod("getPrimaryClip", String.class, String.class, int.class);
-                        getMethodVersion = 1;
-                    } catch (NoSuchMethodException e2) {
-                        getPrimaryClipMethod = manager.getClass().getMethod("getPrimaryClip", String.class, String.class, int.class, int.class);
-                        getMethodVersion = 2;
-                    }
                 }
             }
         }
@@ -48,67 +42,46 @@ public class ClipboardManager {
 
     private Method getSetPrimaryClipMethod() throws NoSuchMethodException {
         if (setPrimaryClipMethod == null) {
-            if (Build.VERSION.SDK_INT < 29) {
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
                 setPrimaryClipMethod = manager.getClass().getMethod("setPrimaryClip", ClipData.class, String.class);
             } else {
                 try {
                     setPrimaryClipMethod = manager.getClass().getMethod("setPrimaryClip", ClipData.class, String.class, int.class);
-                    setMethodVersion = 0;
+                } catch (NoSuchMethodException e) {
-                } catch (NoSuchMethodException e1) {
+                    setPrimaryClipMethod = manager.getClass().getMethod("setPrimaryClip", ClipData.class, String.class, String.class, int.class);
-                    try {
+                    alternativeSetMethod = true;
-                        setPrimaryClipMethod = manager.getClass().getMethod("setPrimaryClip", ClipData.class, String.class, String.class, int.class);
-                        setMethodVersion = 1;
-                    } catch (NoSuchMethodException e2) {
-                        setPrimaryClipMethod = manager.getClass()
-                                .getMethod("setPrimaryClip", ClipData.class, String.class, String.class, int.class, int.class);
-                        setMethodVersion = 2;
-                    }
                 }
             }
         }
         return setPrimaryClipMethod;
     }
 
-    private static ClipData getPrimaryClip(Method method, int methodVersion, IInterface manager)
+    private static ClipData getPrimaryClip(Method method, boolean alternativeMethod, IInterface manager)
             throws InvocationTargetException, IllegalAccessException {
-        if (Build.VERSION.SDK_INT < 29) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
             return (ClipData) method.invoke(manager, FakeContext.PACKAGE_NAME);
         }
-
+        if (alternativeMethod) {
-        switch (methodVersion) {
+            return (ClipData) method.invoke(manager, FakeContext.PACKAGE_NAME, null, FakeContext.ROOT_UID);
-            case 0:
-                return (ClipData) method.invoke(manager, FakeContext.PACKAGE_NAME, FakeContext.ROOT_UID);
-            case 1:
-                return (ClipData) method.invoke(manager, FakeContext.PACKAGE_NAME, null, FakeContext.ROOT_UID);
-            default:
-                return (ClipData) method.invoke(manager, FakeContext.PACKAGE_NAME, null, FakeContext.ROOT_UID, 0);
         }
+        return (ClipData) method.invoke(manager, FakeContext.PACKAGE_NAME, FakeContext.ROOT_UID);
     }
 
-    private static void setPrimaryClip(Method method, int methodVersion, IInterface manager, ClipData clipData)
+    private static void setPrimaryClip(Method method, boolean alternativeMethod, IInterface manager, ClipData clipData)
             throws InvocationTargetException, IllegalAccessException {
-        if (Build.VERSION.SDK_INT < 29) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
             method.invoke(manager, clipData, FakeContext.PACKAGE_NAME);
-            return;
+        } else if (alternativeMethod) {
-        }
+            method.invoke(manager, clipData, FakeContext.PACKAGE_NAME, null, FakeContext.ROOT_UID);
-
+        } else {
-        switch (methodVersion) {
+            method.invoke(manager, clipData, FakeContext.PACKAGE_NAME, FakeContext.ROOT_UID);
-            case 0:
-                method.invoke(manager, clipData, FakeContext.PACKAGE_NAME, FakeContext.ROOT_UID);
-                break;
-            case 1:
-                method.invoke(manager, clipData, FakeContext.PACKAGE_NAME, null, FakeContext.ROOT_UID);
-                break;
-            default:
-                method.invoke(manager, clipData, FakeContext.PACKAGE_NAME, null, FakeContext.ROOT_UID, 0);
-                break;
         }
     }
 
     public CharSequence getText() {
         try {
             Method method = getGetPrimaryClipMethod();
-            ClipData clipData = getPrimaryClip(method, getMethodVersion, manager);
+            ClipData clipData = getPrimaryClip(method, alternativeGetMethod, manager);
             if (clipData == null || clipData.getItemCount() == 0) {
                 return null;
             }
@@ -123,7 +96,7 @@ public class ClipboardManager {
         try {
             Method method = getSetPrimaryClipMethod();
             ClipData clipData = ClipData.newPlainText(null, text);
-            setPrimaryClip(method, setMethodVersion, manager, clipData);
+            setPrimaryClip(method, alternativeSetMethod, manager, clipData);
             return true;
         } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
             Ln.e("Could not invoke method", e);
@@ -131,48 +104,30 @@ public class ClipboardManager {
         }
     }
 
-    private static void addPrimaryClipChangedListener(Method method, int methodVersion, IInterface manager,
+    private static void addPrimaryClipChangedListener(Method method, boolean alternativeMethod, IInterface manager,
             IOnPrimaryClipChangedListener listener) throws InvocationTargetException, IllegalAccessException {
-        if (Build.VERSION.SDK_INT < 29) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
             method.invoke(manager, listener, FakeContext.PACKAGE_NAME);
-            return;
+        } else if (alternativeMethod) {
-        }
+            method.invoke(manager, listener, FakeContext.PACKAGE_NAME, null, FakeContext.ROOT_UID);
-
+        } else {
-        switch (methodVersion) {
+            method.invoke(manager, listener, FakeContext.PACKAGE_NAME, FakeContext.ROOT_UID);
-            case 0:
-                method.invoke(manager, listener, FakeContext.PACKAGE_NAME, FakeContext.ROOT_UID);
-                break;
-            case 1:
-                method.invoke(manager, listener, FakeContext.PACKAGE_NAME, null, FakeContext.ROOT_UID);
-                break;
-            default:
-                method.invoke(manager, listener, FakeContext.PACKAGE_NAME, null, FakeContext.ROOT_UID, 0);
-                break;
         }
     }
 
     private Method getAddPrimaryClipChangedListener() throws NoSuchMethodException {
         if (addPrimaryClipChangedListener == null) {
-            if (Build.VERSION.SDK_INT < 29) {
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
                 addPrimaryClipChangedListener = manager.getClass()
                         .getMethod("addPrimaryClipChangedListener", IOnPrimaryClipChangedListener.class, String.class);
             } else {
                 try {
                     addPrimaryClipChangedListener = manager.getClass()
                             .getMethod("addPrimaryClipChangedListener", IOnPrimaryClipChangedListener.class, String.class, int.class);
-                    addListenerMethodVersion = 0;
+                } catch (NoSuchMethodException e) {
-                } catch (NoSuchMethodException e1) {
+                    addPrimaryClipChangedListener = manager.getClass()
-                    try {
+                            .getMethod("addPrimaryClipChangedListener", IOnPrimaryClipChangedListener.class, String.class, String.class, int.class);
-                        addPrimaryClipChangedListener = manager.getClass()
+                    alternativeAddListenerMethod = true;
-                                .getMethod("addPrimaryClipChangedListener", IOnPrimaryClipChangedListener.class, String.class, String.class,
-                                        int.class);
-                        addListenerMethodVersion = 1;
-                    } catch (NoSuchMethodException e2) {
-                        addPrimaryClipChangedListener = manager.getClass()
-                                .getMethod("addPrimaryClipChangedListener", IOnPrimaryClipChangedListener.class, String.class, String.class,
-                                        int.class, int.class);
-                        addListenerMethodVersion = 2;
-                    }
                 }
             }
         }
@@ -182,7 +137,7 @@ public class ClipboardManager {
     public boolean addPrimaryClipChangedListener(IOnPrimaryClipChangedListener listener) {
         try {
             Method method = getAddPrimaryClipChangedListener();
-            addPrimaryClipChangedListener(method, addListenerMethodVersion, manager, listener);
+            addPrimaryClipChangedListener(method, alternativeAddListenerMethod, manager, listener);
             return true;
         } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
             Ln.e("Could not invoke method", e);

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

@@ -54,7 +54,7 @@ public class ContentProvider implements Closeable {
     @SuppressLint("PrivateApi")
     private Method getCallMethod() throws NoSuchMethodException {
         if (callMethod == null) {
-            if (Build.VERSION.SDK_INT >= 31) {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
                 callMethod = provider.getClass().getMethod("call", AttributionSource.class, String.class, String.class, String.class, Bundle.class);
                 callMethodVersion = 0;
             } else {
@@ -83,7 +83,7 @@ public class ContentProvider implements Closeable {
             Method method = getCallMethod();
             Object[] args;
 
-            if (Build.VERSION.SDK_INT >= 31 && callMethodVersion == 0) {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S && callMethodVersion == 0) {
                 args = new Object[]{FakeContext.get().getAttributionSource(), "settings", callMethod, arg, extras};
             } else {
                 switch (callMethodVersion) {

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

@@ -90,7 +90,7 @@ public final class SurfaceControl {
         if (getBuiltInDisplayMethod == null) {
             // the method signature has changed in Android Q
             // <https://github.com/Genymobile/scrcpy/issues/586>
-            if (Build.VERSION.SDK_INT < 29) {
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
                 getBuiltInDisplayMethod = CLASS.getMethod("getBuiltInDisplay", int.class);
             } else {
                 getBuiltInDisplayMethod = CLASS.getMethod("getInternalDisplayToken");
@@ -102,7 +102,7 @@ public final class SurfaceControl {
     public static IBinder getBuiltInDisplay() {
         try {
             Method method = getGetBuiltInDisplayMethod();
-            if (Build.VERSION.SDK_INT < 29) {
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
                 // call getBuiltInDisplay(0)
                 return (IBinder) method.invoke(null, 0);
             }

server/src/main/stubs/android/content/AttributionSource.java

@@ -1,15 +0,0 @@
-package android.content;
-
-public class AttributionSource {
-    public static class Builder {
-        public Builder(int uid) {
-            throw new UnsupportedOperationException();
-        }
-        public Builder setPackageName(String value) {
-            throw new UnsupportedOperationException();
-        }
-        public AttributionSource build() {
-            throw new UnsupportedOperationException();
-        }
-    }
-}