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 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.

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.

What access it needs

No root and no `adb root` — and unusually for this family, no Android permission either. `/dev/input/*` is created `0660 root input` by `ueventd.rc`, so opening an event node is a plain Unix group question, and `adbd` answers it on purpose: when it drops privileges it hands the shell a fixed set of supplementary groups, and the comment beside that array names this very tool — `AID_INPUT to diagnose input issues (getevent)`. That is why raw touch data is readable from an ordinary `adb shell` on a locked production phone when so much else is not, and why nothing in developer options gates it beyond USB debugging itself. Two things follow. The group grants reading only: every node is opened `O_RDONLY`, so this page can watch the digitiser but cannot synthesise a touch — that is `input`'s job, through a different mechanism and a different permission. And error reporting is itself behind a flag. The device-error messages are printed only when the verbosity mask has its `errs` bit set; naming a device on the command line turns that bit on by default, but `-q` clears the whole mask, so `getevent -q /dev/input/event3` on a node it cannot open exits non-zero having printed nothing at all.

Failure messages, decoded

Message	Meaning
could not open /dev/input/event3, Permission denied	`open()` failed and the text after the comma is the C library's `strerror`. `Permission denied` means the process is not in the `input` group — the usual cause is something other than an adbd-spawned shell, since adbd grants that group itself. `No such file or directory` means the node number is simply wrong: enumerate with `getevent -lp` rather than guessing.
could not get driver version for /dev/input/event3, Inappropriate ioctl for device	The node opened but the `EVIOCGVERSION` ioctl was refused, so it is not an evdev device. `getevent` gives up on that node and returns non-zero. Seeing this for a path you chose by hand usually means you named something under `/dev/input` that is not an `eventN`.
scan dir failed for /dev/input	With no device argument `getevent` enumerates the directory, and this is the enumeration itself failing rather than any one device. It returns 1 immediately, so you get no stream at all — check that `/dev/input` exists and is traversable before blaming a panel.
getevent: invalid option -z	An unrecognised switch. The usage block follows and the process exits 1 without opening anything. Worth knowing because the flags here are single letters that bundle: `-lp` is `-l -p`, and one typo inside a bundle takes the whole run down.

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.