Simulating Input Events with ADB

Android Debug Bridge (ADB) is a versatile command-line tool that allows you to communicate with an Android device or emulator. A crucial part of its functionality is the ability to simulate input events – essentially mimicking user interactions like key presses, touch screen input, and more. This tutorial will focus on the two primary ADB commands for achieving this: adb shell input keyevent and adb shell sendevent.

Understanding the Basics

Both commands serve the purpose of injecting input into the Android system, but they operate at different levels of abstraction and are suited for different tasks.

• adb shell input keyevent: This command is designed for simulating discrete key presses, such as volume up, home button, or specific character keys. It operates at a higher level, sending pre-defined key codes to the system. It’s ideal for automated testing scenarios where you need to trigger specific actions or simulate user input without complex interactions.

• adb shell sendevent: This command is a more low-level tool. It allows you to send raw input events directly to the kernel. This can include touch events (x, y coordinates, pressure), keyboard events, and other sensor data. It provides greater control but requires a deeper understanding of the Android input system.

Using adb shell input keyevent

The input keyevent command is straightforward to use. The basic syntax is:

adb shell input keyevent <event_code>

<event_code> is an integer representing the desired key or action. Android defines a set of predefined key codes. Here are some commonly used examples:

• 1: Menu key
• 3: Home key
• 4: Back key
• 5: Call key
• 6: End call key
• 7-16: Number keys (0-9)
• 29-54: Letter keys (A-Z)
• 24: Volume Up
• 25: Volume Down
• 66: Enter/Return key

For example, to simulate pressing the home button, you would use:

adb shell input keyevent 3

To simulate pressing the number ‘5’, you’d use:

adb shell input keyevent 11

Using adb shell sendevent

The sendevent command is more complex. It requires you to specify the type of event, the code, and the value. The general syntax is:

adb shell sendevent <device_path> <event_type> <event_code> <event_value>

• <device_path>: The path to the input device. Common values include /dev/input/event0, /dev/input/event1, etc. Identifying the correct device path may require experimentation.
• <event_type>: The type of event (e.g., 0 for EV_KEY, 1 for EV_ABS).
• <event_code>: The code for the specific event (e.g., 116 for KEY_VOLUMEUP, 0 for ABS_X).
• <event_value>: The value associated with the event (e.g., 1 for key press, 0 for key release, coordinates for touch events).

Here’s a simple example to simulate a key press (using EV_KEY, KEY_VOLUMEUP):

adb shell sendevent /dev/input/event0 0 116 1
adb shell sendevent /dev/input/event0 0 116 0

This sequence first sends the key press event (1) and then the key release event (0).

Choosing the Right Command

• For simple key presses and discrete actions, adb shell input keyevent is the preferred choice. It’s easier to use and understand.
• For more complex interactions, such as simulating touch screen gestures, custom keyboard input, or sensor data, adb shell sendevent is necessary. However, it requires more technical knowledge and experimentation. You’ll need to understand the Android input system and the specific event codes and values for the device you’re targeting.

Resources

• Android Input Events Documentation: Provides an overview of input events and how to inject them.
• Archived article on low level shell clicks: https://web.archive.org/web/20221206055221/https://www.rightpoint.com/rplabs/automating-input-events-abd-keyevent