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

@@ -355,6 +355,12 @@ Set the initial window height.
 
 Default is 0 (automatic).
 
+.SH EXIT STATUS
+.B scrcpy
+will exit with code 0 on normal program termination. If an initial
+connection cannot be established, the exit code 1 will be returned. If the
+device disconnects while a session is active, exit code 2 will be returned.
+
 .SH SHORTCUTS
 
 In the following list, MOD is the shortcut modifier. By default, it's (left)
@@ -471,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

@@ -80,6 +80,11 @@ struct sc_envvar {
     const char *text;
 };
 
+struct sc_exit_status {
+    unsigned value;
+    const char *text;
+};
+
 struct sc_getopt_adapter {
     char *optstring;
     struct option *longopts;
@@ -655,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",
@@ -662,7 +672,22 @@ static const struct sc_envvar envvars[] = {
     {
         .name = "SCRCPY_SERVER_PATH",
         .text = "Path to the server binary",
-    }
+    },
+};
+
+static const struct sc_exit_status exit_statuses[] = {
+    {
+        .value = 0,
+        .text = "Normal program termination",
+    },
+    {
+        .value = 1,
+        .text = "Start failure",
+    },
+    {
+        .value = 2,
+        .text = "Device disconnected while running",
+    },
 };
 
 static char *
@@ -901,6 +926,25 @@ print_envvar(const struct sc_envvar *envvar, unsigned cols) {
     free(text);
 }
 
+static void
+print_exit_status(const struct sc_exit_status *status, unsigned cols) {
+    assert(cols > 8); // sc_str_wrap_lines() requires indent < columns
+    assert(status->text);
+
+    // The text starts at 9: 4 ident spaces, 3 chars for numeric value, 2 spaces
+    char *text = sc_str_wrap_lines(status->text, cols, 9);
+    if (!text) {
+        printf("<ERROR>\n");
+        return;
+    }
+
+    assert(strlen(text) >= 9); // Contains at least the initial identation
+
+    // text + 9 to remove the initial indentation
+    printf("    %3d  %s\n", status->value, text + 9);
+    free(text);
+}
+
 void
 scrcpy_print_usage(const char *arg0) {
 #define SC_TERM_COLS_DEFAULT 80
@@ -939,6 +983,11 @@ scrcpy_print_usage(const char *arg0) {
     for (size_t i = 0; i < ARRAY_LEN(envvars); ++i) {
         print_envvar(&envvars[i], cols);
     }
+
+    printf("\nExit status:\n\n");
+    for (size_t i = 0; i < ARRAY_LEN(exit_statuses); ++i) {
+        print_exit_status(&exit_statuses[i], cols);
+    }
 }
 
 static bool

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/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/main.c

@@ -40,19 +40,19 @@ main(int argc, char *argv[]) {
 #endif
 
     if (!scrcpy_parse_args(&args, argc, argv)) {
-        return 1;
+        return SCRCPY_EXIT_FAILURE;
     }
 
     sc_set_log_level(args.opts.log_level);
 
     if (args.help) {
         scrcpy_print_usage(argv[0]);
-        return 0;
+        return SCRCPY_EXIT_SUCCESS;
     }
 
     if (args.version) {
         scrcpy_print_version();
-        return 0;
+        return SCRCPY_EXIT_SUCCESS;
     }
 
 #ifdef SCRCPY_LAVF_REQUIRES_REGISTER_ALL
@@ -66,17 +66,17 @@ main(int argc, char *argv[]) {
 #endif
 
     if (avformat_network_init()) {
-        return 1;
+        return SCRCPY_EXIT_FAILURE;
     }
 
 #ifdef HAVE_USB
-    bool ok = args.opts.otg ? scrcpy_otg(&args.opts)
+    enum scrcpy_exit_code ret = args.opts.otg ? scrcpy_otg(&args.opts)
                                               : scrcpy(&args.opts);
 #else
-    bool ok = scrcpy(&args.opts);
+    enum scrcpy_exit_code ret = scrcpy(&args.opts);
 #endif
 
     avformat_network_deinit(); // ignore failure
 
-    return ok ? 0 : 1;
+    return ret;
 }

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/scrcpy.c

@@ -149,38 +149,41 @@ sdl_configure(bool display, bool disable_screensaver) {
     }
 }
 
-static bool
+static enum scrcpy_exit_code
 event_loop(struct scrcpy *s) {
     SDL_Event event;
     while (SDL_WaitEvent(&event)) {
         switch (event.type) {
             case EVENT_STREAM_STOPPED:
                 LOGW("Device disconnected");
-                return false;
+                return SCRCPY_EXIT_DISCONNECTED;
             case SDL_QUIT:
                 LOGD("User requested to quit");
-                return true;
+                return SCRCPY_EXIT_SUCCESS;
             default:
                 sc_screen_handle_event(&s->screen, &event);
                 break;
         }
     }
-    return false;
+    return SCRCPY_EXIT_FAILURE;
 }
 
+// Return true on success, false on error
 static bool
-await_for_server(void) {
+await_for_server(bool *connected) {
     SDL_Event event;
     while (SDL_WaitEvent(&event)) {
         switch (event.type) {
             case SDL_QUIT:
                 LOGD("User requested to quit");
-                return false;
+                *connected = false;
+                return true;
             case EVENT_SERVER_CONNECTION_FAILED:
                 LOGE("Server connection failed");
                 return false;
             case EVENT_SERVER_CONNECTED:
                 LOGD("Server connected");
+                *connected = true;
                 return true;
             default:
                 break;
@@ -262,7 +265,7 @@ sc_server_on_disconnected(struct sc_server *server, void *userdata) {
     // event
 }
 
-bool
+enum scrcpy_exit_code
 scrcpy(struct scrcpy_options *options) {
     static struct scrcpy scrcpy;
     struct scrcpy *s = &scrcpy;
@@ -270,12 +273,12 @@ scrcpy(struct scrcpy_options *options) {
     // Minimal SDL initialization
     if (SDL_Init(SDL_INIT_EVENTS)) {
         LOGE("Could not initialize SDL: %s", SDL_GetError());
-        return false;
+        return SCRCPY_EXIT_FAILURE;
     }
 
     atexit(SDL_Quit);
 
-    bool ret = false;
+    enum scrcpy_exit_code ret = SCRCPY_EXIT_FAILURE;
 
     bool server_started = false;
     bool file_pusher_initialized = false;
@@ -329,7 +332,7 @@ scrcpy(struct scrcpy_options *options) {
         .on_disconnected = sc_server_on_disconnected,
     };
     if (!sc_server_init(&s->server, &params, &cbs, NULL)) {
-        return false;
+        return SCRCPY_EXIT_FAILURE;
     }
 
     if (!sc_server_start(&s->server)) {
@@ -351,7 +354,14 @@ scrcpy(struct scrcpy_options *options) {
     sdl_configure(options->display, options->disable_screensaver);
 
     // Await for server without blocking Ctrl+C handling
-    if (!await_for_server()) {
+    bool connected;
+    if (!await_for_server(&connected)) {
+        goto end;
+    }
+
+    if (!connected) {
+        // This is not an error, user requested to quit
+        ret = SCRCPY_EXIT_SUCCESS;
         goto end;
     }
 

app/src/scrcpy.h

@@ -6,7 +6,18 @@
 #include <stdbool.h>
 #include "options.h"
 
-bool
+enum scrcpy_exit_code {
+    // Normal program termination
+    SCRCPY_EXIT_SUCCESS,
+
+    // No connection could be established
+    SCRCPY_EXIT_FAILURE,
+
+    // Device was disconnected while running
+    SCRCPY_EXIT_DISCONNECTED,
+};
+
+enum scrcpy_exit_code
 scrcpy(struct scrcpy_options *options);
 
 #endif

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);
@@ -706,9 +707,17 @@ run_server(void *data) {
             selector.type = SC_ADB_DEVICE_SELECT_USB;
         } else if (params->select_tcpip) {
             selector.type = SC_ADB_DEVICE_SELECT_TCPIP;
+        } else {
+            // 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);
         if (!ok) {

app/src/usb/hid_keyboard.c

@@ -340,7 +340,7 @@ push_mod_lock_state(struct sc_hid_keyboard *kb, uint16_t mods_state) {
 
     if (!sc_aoa_push_hid_event(kb->aoa, &hid_event)) {
         sc_hid_event_destroy(&hid_event);
-        LOGW("Could request HID event");
+        LOGW("Could not request HID event (mod lock state)");
         return false;
     }
 
@@ -382,7 +382,7 @@ sc_key_processor_process_key(struct sc_key_processor *kp,
 
         if (!sc_aoa_push_hid_event(kb->aoa, &hid_event)) {
             sc_hid_event_destroy(&hid_event);
-            LOGW("Could request HID event");
+            LOGW("Could not request HID event (key)");
         }
     }
 }

app/src/usb/hid_mouse.c

@@ -181,7 +181,7 @@ sc_mouse_processor_process_mouse_motion(struct sc_mouse_processor *mp,
 
     if (!sc_aoa_push_hid_event(mouse->aoa, &hid_event)) {
         sc_hid_event_destroy(&hid_event);
-        LOGW("Could request HID event");
+        LOGW("Could not request HID event (mouse motion)");
     }
 }
 
@@ -203,7 +203,7 @@ sc_mouse_processor_process_mouse_click(struct sc_mouse_processor *mp,
 
     if (!sc_aoa_push_hid_event(mouse->aoa, &hid_event)) {
         sc_hid_event_destroy(&hid_event);
-        LOGW("Could request HID event");
+        LOGW("Could not request HID event (mouse click)");
     }
 }
 
@@ -228,7 +228,7 @@ sc_mouse_processor_process_mouse_scroll(struct sc_mouse_processor *mp,
 
     if (!sc_aoa_push_hid_event(mouse->aoa, &hid_event)) {
         sc_hid_event_destroy(&hid_event);
-        LOGW("Could request HID event");
+        LOGW("Could not request HID event (mouse scroll)");
     }
 }
 

app/src/usb/scrcpy_otg.c

@@ -29,26 +29,26 @@ sc_usb_on_disconnected(struct sc_usb *usb, void *userdata) {
     }
 }
 
-static bool
+static enum scrcpy_exit_code
 event_loop(struct scrcpy_otg *s) {
     SDL_Event event;
     while (SDL_WaitEvent(&event)) {
         switch (event.type) {
             case EVENT_USB_DEVICE_DISCONNECTED:
                 LOGW("Device disconnected");
-                return false;
+                return SCRCPY_EXIT_DISCONNECTED;
             case SDL_QUIT:
                 LOGD("User requested to quit");
-                return true;
+                return SCRCPY_EXIT_SUCCESS;
             default:
                 sc_screen_otg_handle_event(&s->screen_otg, &event);
                 break;
         }
     }
-    return false;
+    return SCRCPY_EXIT_FAILURE;
 }
 
-bool
+enum scrcpy_exit_code
 scrcpy_otg(struct scrcpy_options *options) {
     static struct scrcpy_otg scrcpy_otg;
     struct scrcpy_otg *s = &scrcpy_otg;
@@ -67,7 +67,7 @@ scrcpy_otg(struct scrcpy_options *options) {
         LOGW("Could not enable mouse focus clickthrough");
     }
 
-    bool ret = false;
+    enum scrcpy_exit_code ret = SCRCPY_EXIT_FAILURE;
 
     struct sc_hid_keyboard *keyboard = NULL;
     struct sc_hid_mouse *mouse = NULL;
@@ -90,7 +90,7 @@ scrcpy_otg(struct scrcpy_options *options) {
     };
     bool ok = sc_usb_init(&s->usb);
     if (!ok) {
-        return false;
+        return SCRCPY_EXIT_FAILURE;
     }
 
     struct sc_usb_device usb_device;

app/src/usb/scrcpy_otg.h

@@ -3,10 +3,10 @@
 
 #include "common.h"
 
-#include <stdbool.h>
 #include "options.h"
+#include "scrcpy.h"
 
-bool
+enum scrcpy_exit_code
 scrcpy_otg(struct scrcpy_options *options);
 
 #endif

app/src/usb/usb.c

@@ -15,6 +15,7 @@ read_string(libusb_device_handle *handle, uint8_t desc_index) {
                                            (unsigned char *) buffer,
                                            sizeof(buffer));
     if (result < 0) {
+        LOGD("Read string: libusb error: %s", libusb_strerror(result));
         return NULL;
     }
 

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