getevent

read-only

Streams raw input events straight from the kernel, or lists what each input device can report.

Command: adb shell getevent
Commands: Input and touch
Risk: read-only

Syntax

getevent [-l] [-t] [-p] [/dev/input/eventN]

Flags and arguments

Token	Meaning
-l	Print kernel label names instead of bare hex.
-t	Prefix each event with the kernel's monotonic timestamp.
-p	Print each device's capabilities and exit instead of streaming.
/dev/input/eventN	Watch one device. This also removes the device prefix from every line, because the prefix is only printed when no device was named.

Examples

```
getevent -lp
```
Every input device with its axes and ranges. Terminates on its own.
```
getevent -lt /dev/input/event3
```
Watch one touchscreen with timestamps.

Reading the output

Sample output

/dev/input/event3: EV_ABS       ABS_MT_TRACKING_ID   ffffffff
/dev/input/event3: EV_SYN       SYN_REPORT           00000000

Three fields per line: event type, event code, value. Values are printed as unsigned 32-bit hex, which is the single biggest trap here — a tracking id of `ffffffff` is -1, the "finger lifted" signal, and read as unsigned it looks like a perfectly ordinary new contact at four billion. `SYN_REPORT` is the frame boundary: everything before it is a partial packet, and drawing it shows fingers at half-updated coordinates.

Output fields

Field	Meaning
EV_ABS / EV_KEY / EV_SYN	The event type: an absolute axis, a key, or a synchronisation marker.
ABS_MT_SLOT	Selects which contact the following axes describe.
ABS_MT_TRACKING_ID	A non-negative value starts a contact; `ffffffff` (-1) ends it.
ABS_MT_POSITION_X / _Y	Contact position in the panel's own units, not screen pixels.
SYN_REPORT	Commit: the frame so far is complete.
SYN_DROPPED	The kernel's queue overflowed. Discard accumulated state and resynchronise.
: value v, min a, max b, fuzz f, flat l, resolution r	The capability line, and the only decimal numbers in the whole output. `max` is inclusive, so a 0-1439 axis has 1440 positions.

Version and vendor notes

Axes are sticky: a driver sends only what changed, so a finger moving horizontally keeps its last vertical position. Accumulate rather than replace.
Panel coordinates are not screen coordinates. Mapping them means subtracting the axis minimum and scaling by screen size over `max - min + 1`; the plus one is not a fudge, it is because the maximum is inclusive.
Whether a given panel is mounted rotated or mirrored relative to the display cannot be worked out from the axis ranges. It has to be confirmed by touching a corner on the real device.
With `-l` a value can be a word: key values render as UP, DOWN or REPEAT, and tool types as MT_TOOL_FINGER, MT_TOOL_PEN or MT_TOOL_PALM.

We have a UI for this

Android Sensor Tester runs this command over USB and parses what comes back — a Chromium browser, no SDK, nothing uploaded.

Open Android Sensor Tester

Related commands

Commands that turn up in the same session as getevent.

Command	What it does
dumpsys sensorservice	Every sensor the phone has, with its vendor, type, rates and batching — plus a buffer of recent readings.
input text	Types a string into whatever field currently has focus.
wm size	Reports the display's resolution, or overrides it so the phone pretends to be a different screen.

More Input and touch commands

Command	What it does
input keyevent	Presses a hardware or virtual key — Home, Back, Power, volume, Enter.

Checked against AOSP, toybox and kernel sources while writing the parsers behind our Web ADB tools. Where a behaviour genuinely varies by Android version or manufacturer, this page says so instead of giving a number that would be wrong on half the phones out there.

Frequently asked questions

How do I run an adb shell command?

Switch on developer options and USB debugging on the phone, plug it in, then run `adb shell <command>` from a machine with platform-tools installed — or run `adb shell` on its own to get an interactive prompt and type the command without the prefix. If the command produces binary output, such as a screenshot, use `adb exec-out` instead of `adb shell`: the plain shell service attaches a terminal, which rewrites newline bytes and corrupts the data.

Do adb shell commands need root?

Not the ones on this reference. They run as the `shell` user, which can manage packages for its own Android user, read most `dumpsys` services, write the settings provider, inject input and read shared storage. Root is only needed for things this reference deliberately avoids — reading another app's private data (except through `run-as` on a debuggable build), writing system partitions, or reading `/data/anr` directly.

Why does the output look different on my phone?

Either the Android version or the manufacturer. Some flags and fields arrived in a specific release, and those are noted per command. The rest is OEM patching, which hits `dumpsys` hardest: a dump is debug output whose text is whatever the service author last printed, and manufacturers change it and backport their changes. Read fields by name rather than by position, and treat an unfamiliar shape as a difference rather than as a failure.

Can I run this from a browser instead of a terminal?

For many commands, yes — the Web ADB tools on this site talk to a phone over WebUSB from a Chromium-based desktop browser, with no SDK installed and nothing uploaded. Each page links to the tool that runs its command, when one exists. Two limits are worth knowing: only one program can hold the ADB interface at a time, so a desktop `adb server` has to be stopped first, and `adb forward` and `adb reverse` cannot work in a browser at all.

Would rather click than type? The Web ADB Toolkit runs commands like this from a browser over USB. Or browse every command.