Remove obsolete alternative injection method

The previous commit replaced the IInterface instance (the "input"
service) by the InputManager instance (retrieved by
InputManager.getInstance()).

Both define an "injectInputEvent" method, but the alternate version
(probably) does not concern the InputManager.

This reverts commit b7a06278fe.

README.md

@@ -448,6 +448,9 @@ scrcpy --serial 0123456789abcdef
 scrcpy -s 0123456789abcdef  # short version
 ```
 
+The serial may also be provided via the environment variable `ANDROID_SERIAL`
+(also used by `adb`).
+
 If the device is connected over TCP/IP:
 
 ```bash

app/scrcpy.1

@@ -477,6 +477,10 @@ Push file to device (see \fB\-\-push\-target\fR)
 .B ADB
 Path to adb.
 
+.TP
+.B ANDROID_SERIAL
+Device serial to use if no selector (-s, -d, -e or --tcpip=<addr>) is specified.
+
 .TP
 .B SCRCPY_ICON_PATH
 Path to the program icon.

app/src/adb/adb.c

@@ -473,9 +473,12 @@ sc_adb_accept_device(const struct sc_adb_device *device,
             }
             return !strcmp(selector->serial, device->serial);
         case SC_ADB_DEVICE_SELECT_USB:
-            return !sc_adb_is_serial_tcpip(device->serial);
+            return sc_adb_device_get_type(device->serial) ==
+                    SC_ADB_DEVICE_TYPE_USB;
         case SC_ADB_DEVICE_SELECT_TCPIP:
-            return sc_adb_is_serial_tcpip(device->serial);
+            // Both emulators and TCP/IP devices are selected via -e
+            return sc_adb_device_get_type(device->serial) !=
+                    SC_ADB_DEVICE_TYPE_USB;
         default:
             assert(!"Missing SC_ADB_DEVICE_SELECT_* handling");
             break;
@@ -509,8 +512,10 @@ sc_adb_devices_log(enum sc_log_level level, struct sc_adb_device *devices,
     for (size_t i = 0; i < count; ++i) {
         struct sc_adb_device *d = &devices[i];
         const char *selection = d->selected ? "-->" : "   ";
-        const char *type = sc_adb_is_serial_tcpip(d->serial) ? "(tcpip)"
+        bool is_usb =
-                                                             : "  (usb)";
+            sc_adb_device_get_type(d->serial) == SC_ADB_DEVICE_TYPE_USB;
+        const char *type = is_usb ? "  (usb)"
+                                  : "(tcpip)";
         LOG(level, "    %s %s  %-20s  %16s  %s",
              selection, type, d->serial, d->state, d->model ? d->model : "");
     }
@@ -531,6 +536,8 @@ sc_adb_device_check_state(struct sc_adb_device *device,
         LOGE("A popup should open on the device to request authorization.");
         LOGE("Check the FAQ: "
              "<https://github.com/Genymobile/scrcpy/blob/master/FAQ.md>");
+    } else {
+        LOGE("Device could not be connected (state=%s)", state);
     }
 
     return false;
@@ -705,8 +712,3 @@ sc_adb_get_device_ip(struct sc_intr *intr, const char *serial, unsigned flags) {
 
     return sc_adb_parse_device_ip_from_output(buf);
 }
-
-bool
-sc_adb_is_serial_tcpip(const char *serial) {
-    return strchr(serial, ':');
-}

app/src/adb/adb.h

@@ -114,13 +114,4 @@ sc_adb_getprop(struct sc_intr *intr, const char *serial, const char *prop,
 char *
 sc_adb_get_device_ip(struct sc_intr *intr, const char *serial, unsigned flags);
 
-/**
- * Indicate if the serial represents an IP address
- *
- * In practice, it just returns true if and only if it contains a ':', which is
- * sufficient to distinguish an ip:port from a real USB serial.
- */
-bool
-sc_adb_is_serial_tcpip(const char *serial);
-
 #endif

app/src/adb/adb_device.c

@@ -1,6 +1,7 @@
 #include "adb_device.h"
 
 #include <stdlib.h>
+#include <string.h>
 
 void
 sc_adb_device_destroy(struct sc_adb_device *device) {
@@ -25,3 +26,18 @@ sc_adb_devices_destroy(struct sc_vec_adb_devices *devices) {
     sc_vector_destroy(devices);
 }
 
+enum sc_adb_device_type
+sc_adb_device_get_type(const char *serial) {
+    // Starts with "emulator-"
+    if (!strncmp(serial, "emulator-", sizeof("emulator-") - 1)) {
+        return SC_ADB_DEVICE_TYPE_EMULATOR;
+    }
+
+    // If the serial contains a ':', then it is a TCP/IP device (it is
+    // sufficient to distinguish an ip:port from a real USB serial)
+    if (strchr(serial, ':')) {
+        return SC_ADB_DEVICE_TYPE_TCPIP;
+    }
+
+    return SC_ADB_DEVICE_TYPE_USB;
+}

app/src/adb/adb_device.h

@@ -15,6 +15,12 @@ struct sc_adb_device {
     bool selected;
 };
 
+enum sc_adb_device_type {
+    SC_ADB_DEVICE_TYPE_USB,
+    SC_ADB_DEVICE_TYPE_TCPIP,
+    SC_ADB_DEVICE_TYPE_EMULATOR,
+};
+
 struct sc_vec_adb_devices SC_VECTOR(struct sc_adb_device);
 
 void
@@ -35,4 +41,10 @@ sc_adb_device_move(struct sc_adb_device *dst, struct sc_adb_device *src);
 void
 sc_adb_devices_destroy(struct sc_vec_adb_devices *devices);
 
+/**
+ * Deduce the device type from the serial
+ */
+enum sc_adb_device_type
+sc_adb_device_get_type(const char *serial);
+
 #endif

app/src/cli.c

@@ -660,6 +660,11 @@ static const struct sc_envvar envvars[] = {
         .name = "ADB",
         .text = "Path to adb executable",
     },
+    {
+        .name = "ANDROID_SERIAL",
+        .text = "Device serial to use if no selector (-s, -d, -e or "
+                "--tcpip=<addr>) is specified",
+    },
     {
         .name = "SCRCPY_ICON_PATH",
         .text = "Path to the program icon",

app/src/common.h

@@ -1,5 +1,5 @@
-#ifndef COMMON_H
+#ifndef SC_COMMON_H
-#define COMMON_H
+#define SC_COMMON_H
 
 #include "config.h"
 #include "compat.h"

app/src/compat.h

@@ -1,5 +1,5 @@
-#ifndef COMPAT_H
+#ifndef SC_COMPAT_H
-#define COMPAT_H
+#define SC_COMPAT_H
 
 #include "config.h"
 

app/src/control_msg.h

@@ -1,5 +1,5 @@
-#ifndef CONTROLMSG_H
+#ifndef SC_CONTROLMSG_H
-#define CONTROLMSG_H
+#define SC_CONTROLMSG_H
 
 #include "common.h"
 

app/src/controller.h

@@ -1,5 +1,5 @@
-#ifndef CONTROLLER_H
+#ifndef SC_CONTROLLER_H
-#define CONTROLLER_H
+#define SC_CONTROLLER_H
 
 #include "common.h"
 

app/src/decoder.c

@@ -2,7 +2,6 @@
 
 #include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
-#include <libavutil/pixdesc.h>
 
 #include "events.h"
 #include "video_buffer.h"
@@ -12,39 +11,6 @@
 /** Downcast packet_sink to decoder */
 #define DOWNCAST(SINK) container_of(SINK, struct sc_decoder, packet_sink)
 
-static int hw_decoder_init(struct sc_decoder *decoder, const enum AVHWDeviceType type)
-{
-    int err = 0;
-
-    AVBufferRef *hw_device_ctx;
-    if ((err = av_hwdevice_ctx_create(&hw_device_ctx, type,
-                                      NULL, NULL, 0)) < 0) {
-        LOGE("Failed to create specified HW device.");
-        return err;
-    }
-    decoder->codec_ctx->hw_device_ctx = av_buffer_ref(hw_device_ctx);
-
-    return err;
-}
-
-static enum AVPixelFormat get_hw_format(AVCodecContext *ctx,
-                                        const enum AVPixelFormat *pix_fmts)
-{
-    (void) ctx;
-    const enum AVPixelFormat *p;
-
-    LOGD("== get_hw_format ==");
-
-    for (p = pix_fmts; *p != AV_PIX_FMT_NONE; p++) {
-        LOGD("==== %s (%d)", av_get_pix_fmt_name(*p), *p);
-        if (*p == AV_PIX_FMT_VAAPI)
-            return *p;
-    }
-
-    LOGE("Failed to get HW surface format.");
-    return AV_PIX_FMT_NONE;
-}
-
 static void
 sc_decoder_close_first_sinks(struct sc_decoder *decoder, unsigned count) {
     while (count) {
@@ -82,10 +48,6 @@ sc_decoder_open(struct sc_decoder *decoder, const AVCodec *codec) {
 
     decoder->codec_ctx->flags |= AV_CODEC_FLAG_LOW_DELAY;
 
-    int r = hw_decoder_init(decoder, AV_HWDEVICE_TYPE_VAAPI);
-    assert(!r);
-    decoder->codec_ctx->get_format = get_hw_format;
-
     if (avcodec_open2(decoder->codec_ctx, codec, NULL) < 0) {
         LOGE("Could not open codec");
         avcodec_free_context(&decoder->codec_ctx);
@@ -100,9 +62,6 @@ sc_decoder_open(struct sc_decoder *decoder, const AVCodec *codec) {
         return false;
     }
 
-    decoder->hw_frame = av_frame_alloc();
-    assert(decoder->hw_frame);
-
     if (!sc_decoder_open_sinks(decoder)) {
         LOGE("Could not open decoder sinks");
         av_frame_free(&decoder->frame);
@@ -117,7 +76,6 @@ sc_decoder_open(struct sc_decoder *decoder, const AVCodec *codec) {
 static void
 sc_decoder_close(struct sc_decoder *decoder) {
     sc_decoder_close_sinks(decoder);
-    av_frame_free(&decoder->hw_frame);
     av_frame_free(&decoder->frame);
     avcodec_close(decoder->codec_ctx);
     avcodec_free_context(&decoder->codec_ctx);
@@ -149,26 +107,15 @@ sc_decoder_push(struct sc_decoder *decoder, const AVPacket *packet) {
         LOGE("Could not send video packet: %d", ret);
         return false;
     }
-    ret = avcodec_receive_frame(decoder->codec_ctx, decoder->hw_frame);
+    ret = avcodec_receive_frame(decoder->codec_ctx, decoder->frame);
     if (!ret) {
         // a frame was received
-
-        sc_tick t = sc_tick_now();
-        ret = av_hwframe_transfer_data(decoder->frame, decoder->hw_frame, 0);
-        if (ret < 0) {
-            LOGE("HWFRAME transfer fail");
-            return false;
-        }
-
-        LOGD("av_hwframe_transfer_data: %ld", sc_tick_now() - t);
-
         bool ok = push_frame_to_sinks(decoder, decoder->frame);
         // A frame lost should not make the whole pipeline fail. The error, if
         // any, is already logged.
         (void) ok;
 
         av_frame_unref(decoder->frame);
-        av_frame_unref(decoder->hw_frame);
     } else if (ret != AVERROR(EAGAIN)) {
         LOGE("Could not receive video frame: %d", ret);
         return false;

app/src/decoder.h

@@ -19,7 +19,6 @@ struct sc_decoder {
 
     AVCodecContext *codec_ctx;
     AVFrame *frame;
-    AVFrame *hw_frame;
 };
 
 void

app/src/device_msg.h

@@ -1,5 +1,5 @@
-#ifndef DEVICEMSG_H
+#ifndef SC_DEVICEMSG_H
-#define DEVICEMSG_H
+#define SC_DEVICEMSG_H
 
 #include "common.h"
 

app/src/fps_counter.h

@@ -1,5 +1,5 @@
-#ifndef FPSCOUNTER_H
+#ifndef SC_FPSCOUNTER_H
-#define FPSCOUNTER_H
+#define SC_FPSCOUNTER_H
 
 #include "common.h"
 

app/src/icon.h

@@ -1,5 +1,5 @@
-#ifndef ICON_H
+#ifndef SC_ICON_H
-#define ICON_H
+#define SC_ICON_H
 
 #include "common.h"
 

app/src/input_manager.h

@@ -1,5 +1,5 @@
-#ifndef INPUTMANAGER_H
+#ifndef SC_INPUTMANAGER_H
-#define INPUTMANAGER_H
+#define SC_INPUTMANAGER_H
 
 #include "common.h"
 

app/src/opengl.c

@@ -28,7 +28,7 @@ sc_opengl_init(struct sc_opengl *gl) {
                                sizeof(OPENGL_ES_PREFIX) - 1);
     if (gl->is_opengles) {
         /* skip the prefix */
-        version += sizeof(PREFIX) - 1;
+        version += sizeof(OPENGL_ES_PREFIX) - 1;
     }
 
     int r = sscanf(version, "%d.%d", &gl->version_major, &gl->version_minor);

app/src/receiver.h

@@ -1,5 +1,5 @@
-#ifndef RECEIVER_H
+#ifndef SC_RECEIVER_H
-#define RECEIVER_H
+#define SC_RECEIVER_H
 
 #include "common.h"
 

app/src/screen.c

@@ -244,7 +244,7 @@ static inline SDL_Texture *
 create_texture(struct sc_screen *screen) {
     SDL_Renderer *renderer = screen->renderer;
     struct sc_size size = screen->frame_size;
-    SDL_Texture *texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_NV12,
+    SDL_Texture *texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_YV12,
                                              SDL_TEXTUREACCESS_STREAMING,
                                              size.width, size.height);
     if (!texture) {
@@ -711,11 +711,10 @@ prepare_for_frame(struct sc_screen *screen, struct sc_size new_frame_size) {
 // write the frame into the texture
 static void
 update_texture(struct sc_screen *screen, const AVFrame *frame) {
-//    SDL_UpdateYUVTexture(screen->texture, NULL,
+    SDL_UpdateYUVTexture(screen->texture, NULL,
-//            frame->data[0], frame->linesize[0],
+            frame->data[0], frame->linesize[0],
-//            frame->data[1], frame->linesize[1],
+            frame->data[1], frame->linesize[1],
-//            frame->data[2], frame->linesize[2]);
+            frame->data[2], frame->linesize[2]);
-    SDL_UpdateTexture(screen->texture, NULL, frame->data[0], frame->linesize[0]);
 
     if (screen->mipmaps) {
         SDL_GL_BindTexture(screen->texture, NULL, NULL);

app/src/server.c

@@ -649,7 +649,8 @@ sc_server_configure_tcpip_known_address(struct sc_server *server,
 static bool
 sc_server_configure_tcpip_unknown_address(struct sc_server *server,
                                           const char *serial) {
-    bool is_already_tcpip = sc_adb_is_serial_tcpip(serial);
+    bool is_already_tcpip =
+        sc_adb_device_get_type(serial) == SC_ADB_DEVICE_TYPE_TCPIP;
     if (is_already_tcpip) {
         // Nothing to do
         LOGI("Device already connected via TCP/IP: %s", serial);
@@ -707,7 +708,15 @@ run_server(void *data) {
         } else if (params->select_tcpip) {
             selector.type = SC_ADB_DEVICE_SELECT_TCPIP;
         } else {
-            selector.type = SC_ADB_DEVICE_SELECT_ALL;
+            // No explicit selection, check $ANDROID_SERIAL
+            const char *env_serial = getenv("ANDROID_SERIAL");
+            if (env_serial) {
+                LOGI("Using ANDROID_SERIAL: %s", env_serial);
+                selector.type = SC_ADB_DEVICE_SELECT_SERIAL;
+                selector.serial = env_serial;
+            } else {
+                selector.type = SC_ADB_DEVICE_SELECT_ALL;
+            }
         }
         struct sc_adb_device device;
         ok = sc_adb_select_device(&server->intr, &selector, 0, &device);

app/src/util/cbuf.h

@@ -1,6 +1,6 @@
 // generic circular buffer (bounded queue) implementation
-#ifndef CBUF_H
+#ifndef SC_CBUF_H
-#define CBUF_H
+#define SC_CBUF_H
 
 #include "common.h"
 

app/src/util/net.h

@@ -1,5 +1,5 @@
-#ifndef NET_H
+#ifndef SC_NET_H
-#define NET_H
+#define SC_NET_H
 
 #include "common.h"
 

run

@@ -20,6 +20,6 @@ then
     exit 1
 fi
 
-SCRCPY_ICON_PATH="data/icon.png" \
+SCRCPY_ICON_PATH="app/data/icon.png" \
 SCRCPY_SERVER_PATH="$BUILDDIR/server/scrcpy-server" \
 "$BUILDDIR/app/scrcpy" "$@"

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

@@ -14,24 +14,18 @@ public final class InputManager {
     public static final int INJECT_INPUT_EVENT_MODE_WAIT_FOR_RESULT = 1;
     public static final int INJECT_INPUT_EVENT_MODE_WAIT_FOR_FINISH = 2;
 
-    private final IInterface manager;
+    private final android.hardware.input.InputManager manager;
     private Method injectInputEventMethod;
-    private boolean alternativeInjectInputEventMethod;
 
     private static Method setDisplayIdMethod;
 
-    public InputManager(IInterface manager) {
+    public InputManager(android.hardware.input.InputManager manager) {
         this.manager = manager;
     }
 
     private Method getInjectInputEventMethod() throws NoSuchMethodException {
         if (injectInputEventMethod == null) {
-            try {
+            injectInputEventMethod = manager.getClass().getMethod("injectInputEvent", InputEvent.class, int.class);
-                injectInputEventMethod = manager.getClass().getMethod("injectInputEvent", InputEvent.class, int.class);
-            } catch (NoSuchMethodException e) {
-                injectInputEventMethod = manager.getClass().getMethod("injectInputEvent", InputEvent.class, int.class, int.class);
-                alternativeInjectInputEventMethod = true;
-            }
         }
         return injectInputEventMethod;
     }
@@ -39,10 +33,6 @@ public final class InputManager {
     public boolean injectInputEvent(InputEvent inputEvent, int mode) {
         try {
             Method method = getInjectInputEventMethod();
-            if (alternativeInjectInputEventMethod) {
-                // See <https://github.com/Genymobile/scrcpy/issues/2250>
-                return (boolean) method.invoke(manager, inputEvent, mode, 0);
-            }
             return (boolean) method.invoke(manager, inputEvent, mode);
         } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
             Ln.e("Could not invoke method", e);

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

@@ -4,6 +4,7 @@ import android.annotation.SuppressLint;
 import android.os.IBinder;
 import android.os.IInterface;
 
+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 
 @SuppressLint("PrivateApi,DiscouragedPrivateApi")
@@ -56,7 +57,13 @@ public final class ServiceManager {
 
     public InputManager getInputManager() {
         if (inputManager == null) {
-            inputManager = new InputManager(getService("input", "android.hardware.input.IInputManager"));
+            try {
+                Method getInstanceMethod = android.hardware.input.InputManager.class.getDeclaredMethod("getInstance");
+                android.hardware.input.InputManager im = (android.hardware.input.InputManager) getInstanceMethod.invoke(null);
+                inputManager = new InputManager(im);
+            } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
+                throw new AssertionError(e);
+            }
         }
         return inputManager;
     }