The [Android Debug Bridge](https://developer.android.com/studio/command-line/adb.html) (ADB) is a toolkit included in the Android SDK package, it is not only a powerful tool for Android developers and testers, but also a good toy for Android fans.
This repository renews continually, Pull Requests and Issues are welcomed. If you found [this](https://github.com/mzlogin/awesome-adb) is useful, you can star it and conveniently back here to view when necessary.
| `-s <SerialNumber>` | Specifies the device number corresponding serialNumber / simulator command target |
In the case of multiple devices / simulators are connected to the more common `-s <serialNumber>` parameters, serialNumber can be obtained through `adb devices` command. Such as:
```sh
$ adb devices
List of devices attached
cf264b8f device
emulator-5554 device
```
Output in the `cf264b8f` and` emulator-5554` is serialNumber. For example, this time I want to specify `cf264b8f` this equipment to run the adb command to take a screen resolution:
```sh
adb -s cf264b8f shell wm size
```
Encountered multiple devices / simulators use the case of these parameters for the command to specify the target device, hereinafter to simplify the description will not be repeated.
### Start/Stop
Start adb server command:
```sh
adb start-server
```
(Generally no need to manually execute this command, when you run the command adb adb server if found does not start automatically from the transfer.)
The operating principle is adb adb server daemon and the phone side PC side adbd establish a connection, then the PC side adb client via adb server forward command parsing after running adbd receive commands.
So if adbd ordinary rights to perform some require root privileges to execute the command can not be directly used `adb xxx` execution. Then you can then execute the command `adb shell` after` su`, but also allows adbd root privileges to perform this high privilege can execute arbitrary commands.
command:
```sh
adb root
```
Normal output:
```sh
restarting adbd as root
```
Now run `adb shell`, take a look at the command line prompt is not turned into a` `#?
After some phone root can not let adbd by `adb root` execute commands with root privileges, some models such as Samsung, will be prompted to` adbd can not run as root in production builds`, then you can install adbd Insecure, then `adb root` try.
Accordingly, if you want to restore adbd non-root privileges, you can use `adb unroot` command.
### Designated adb server network port
command:
```sh
adb -P <port> start-server
```
The default port is 5037.
## Device connection management
### Inquiries connected device / simulator
command:
```sh
adb devices
```
Example output:
```sh
List of devices attached
cf264b8f device
emulator-5554 device
```
Output format is `[serialNumber] [state]`, serialNumber that is, we often say that the SN, state the following categories:
*`Offline` - indicates that the device is not connected to the success or unresponsive.
*`Device` - device is connected. Note that this state does not identify the Android system has been fully activated and operational in the device during startup device instance can be connected to the adb, but after boot the system before it becomes operational.
*`No device` - no device / emulator connection.
The output shows the current connected the two devices / simulators, `cf264b8f` and` emulator-5554` are they SN. As can be seen from the `emulator-5554` name it is an Android emulator.
Common alarm output:
1. No device / emulator connection is successful.
```sh
List of devices attached
```
2. The device / emulator is not connected to adb or unresponsive.
```sh
List of devices attached
cf264b8f offline
```
### USB connection
USB connection normal use adb by the need to ensure that:
1. Hardware status is normal.
Including Android devices in the normal power state, USB cable and interface intact.
Developer Options 2. Android devices and USB debugging mode is on.
You can go to the "Settings" - "Developer options" - "Android Debug" view.
If you can not find the developer options in the settings, it needs to make it through an egg is displayed: In the "Settings" - "About phone" continuous click "version number" 7 times.
3. The device driver is normal.
It seems to worry about the Linux and Mac OS X, the Windows likely to be encountered in the case of the need to install drivers, this can be confirmed right "Computer" - "Properties", the "Device Manager" in view on related equipment Is there a yellow exclamation point or question mark, if not explain the driving state has been good. Otherwise, you can download a mobile assistant class program to install the driver first.
4. Status after confirmation via USB cable connected computers and devices.
```sh
adb devices
```
If you can see
```sh
xxxxxx device
```
Description Connection successful.
### Wireless connection (need to use the USB cable)
In addition to the USB connection to the computer to use adb, can also be a wireless connection - although the connection process is also step using USB needs, but after a successful connection to your device can get rid of the limit of the USB cable within a certain range it !
Steps:
1. Connect Android device to run adb computer connected to the same local area network, such as connected to the same WiFi.
2. The device connected to the computer via a USB cable.
Make sure the connection is successful (you can run `adb devices` see if you can list the device).
3. Allow the device listens on port 5555 TCP / IP connections:
Generally the 'Settings' in - "About phone" - "state information" - "IP address" is found, you can also use the following in the [View device information - IP address][1] a Lane method adb command.
Here `<device-ip-address>` is the IP address of the device found in the previous step.
7. Confirm the connection status.
```sh
adb devices
```
If you can see
```sh
<device-ip-address>:5555 device
```
Description Connection successful.
If you can not connect, verify that Android devices and the computer is connected to the same WiFi, then execute `adb connect <device-ip-address>` that step again;
If that does not work, by `adb kill-server` restart the adb and then try it all over again.
On a "wireless connection (need to use USB cable)" method is described in official documents, need the help of a USB cable to enable the wireless connection.
Since we want to achieve a wireless connection, it can all step down are wireless it? The answer is energy.
1. Install a terminal emulator on the Android device.
Equipment already installed you can skip this step. Terminal emulator download address I use is: [Terminal Emulator for Android Downloads](https://jackpal.github.io/Android-Terminal-Emulator/)
Generally the 'Settings' in - "About phone" - "state information" - "IP address" is found, you can also use the following in the [View device information - IP address][1] a Lane method adb command.
That is the basis of `adb shell pm list packages` can add some parameters on the filter to view different lists, supports filtering parameters are as follows:
For example, to view a list of package names that contain the string `mazhuang` applications, order:
```sh
adb shell pm list packages mazhuang
```
Of course, you can also use grep to filter:
```sh
adb shell pm list packages | grep mazhuang
```
### Install APK
Format:
```sh
adb install [-lrtsdg] <path_to_apk>
```
parameter:
`Adb install` may be followed by some optional parameters to control the behavior of the installation APK, available parameters and their meanings are as follows:
| INSTALL\_FAILED\_INVALID\_URI | invalid filename APK | APK file names to ensure no Chinese |
| INSTALL\_FAILED\_INSUFFICIENT\_STORAGE | lack of space | cleanup space |
| INSTALL\_FAILED\_DUPLICATE\_PACKAGE | program of the same name already exists | |
| INSTALL\_FAILED\_NO\_SHARED\_USER | shared user requested does not exist | |
| INSTALL\_FAILED\_UPDATE\_INCOMPATIBLE | already installed the app, but signature is not the same; or uninstalled, but data is not removed. | |
| INSTALL\_FAILED\_SHARED\_USER\_INCOMPATIBLE | shared user request exists but the signatures do not match | |
| INSTALL\_FAILED\_MISSING\_SHARED\_LIBRARY | installation package used on the device unusable shared library | |
| INSTALL\_FAILED\_REPLACE\_COULDNT\_DELETE | can not be deleted when replacing | |
| INSTALL\_FAILED\_DEXOPT | dex optimization validation failure or lack of space | |
| INSTALL\_FAILED\_OLDER\_SDK | equipment system version is lower than the application requirements | |
| INSTALL\_FAILED\_CONFLICTING\_PROVIDER | equipment already exists with the same name in application content provider | |
| INSTALL\_FAILED\_NEWER\_SDK | equipment system version higher than the application requirements | |
| INSTALL\_FAILED\_TEST\_ONLY | test-only applications, but when you install `-t` parameter is not specified | |
| INSTALL\_FAILED\_CPU\_ABI\_INCOMPATIBLE | contains incompatible device CPU Application Binary Interface for native code | |
| INSTALL\_FAILED\_MISSING\_FEATURE | application uses device features that are unavailable | |
| INSTALL\_FAILED\_CONTAINER\_ERROR | sdcard access failure | confirm sdcard is available, or to install built-in storage |
| INSTALL\_FAILED\_INVALID\_INSTALL\_LOCATION | can not be installed to the specified location | switch mounting position, add or delete `-s` parameters |
| INSTALL\_FAILED\_MEDIA\_UNAVAILABLE | installation location is unavailable | generally sdcard, confirm sdcard is available or to install built-in storage |
| INSTALL\_FAILED\_VERIFICATION\_FAILURE | verify the installation package fails | |
| INSTALL\_FAILED\_PACKAGE\_CHANGED | calling application program expects inconsistent | |
| INSTALL\_FAILED\_UID\_CHANGED | previously installed the app, and this assignment UID inconsistent | remove residual files previously installed |
| INSTALL\_FAILED\_VERSION\_DOWNGRADE | already installed the application later | use `-d` parameters |
| INSTALL\_FAILED\_PERMISSION\_MODEL\_DOWNGRADE | installed target SDK runtime support for application permissions of the same name, to install the runtime version does not support permission | |
| INSTALL\_PARSE\_FAILED\_NOT\_APK | specified path is not a file or not to `.apk` end | |
| INSTALL\_PARSE\_FAILED\_UNEXPECTED\_EXCEPTION | parser encounters an exception | |
| INSTALL\_PARSE\_FAILED\_NO\_CERTIFICATES | installation package is not signed | |
| INSTALL\_PARSE\_FAILED\_INCONSISTENT\_CERTIFICATES | already installed the app, and signed with the APK files are inconsistent | first uninstall the application on the device, then install |
| INSTALL\_PARSE\_FAILED\_MANIFEST\_EMPTY | in the manifest file can not be found to find operable label (instrumentation or application) | |
| INSTALL\_FAILED\_INTERNAL\_ERROR | installation fails because of system problems | |
| INSTALL\_FAILED\_USER\_RESTRICTED | Users are limited to installing applications | |
| INSTALL\_FAILED\_DUPLICATE\_PERMISSION | application attempts to define an existing permission name | |
| INSTALL\_FAILED\_NO\_MATCHING\_ABIS | applications include device application binary interface does not support the native code | |
| INSTALL\_CANCELED\_BY\_USER | applications installed on the device needs confirmation, but not operate the device or the point of cancellation | agree to install on the device |
| INSTALL\_FAILED\_ACWF\_INCOMPATIBLE | applications are not compatible with the device | |
| Does not contain AndroidManifest.xml | invalid APK file | |
| Is not a valid zip file | invalid APK file | |
| Offline | device is not connected successfully | first device with adb successful connection |
| signatures do not match the previously installed version; ignoring! | already installed this app, but signatures do not match | uninstall previous installed, then install this one |
3. Delete the corresponding apk file / data / local / tmp under.
Therefore, when necessary, according to this step, manually step through the installation process.
### Uninstalling
command:
```sh
adb uninstall [-k] <packagename>
```
`<Packagename>` represents the application package name, `-k` optional parameter indicates uninstall the application but keep the data and cache directories.
Command Example:
```sh
adb uninstall com.qihoo360.mobilesafe
```
Uninstall represents 360 mobile guards.
### Clear app cache data
command:
```sh
adb shell pm clear <packagename>
```
`<Packagename>` represents the name of the application package, the effect of this command is equivalent to the application information in the settings screen, click the "Clear Cache" and "Clear data."
`<packagename>` parameter is optional, command with `<packagename>` will output services related with that packagename, and command without `<packagename>` will output all services.
Complete packagename is unnecessary. For example, `adb shell dumpsys activity services org.mazhuang` will output services related with `org.mazhuang.demo1`, `org.mazhuang.demo2` and `org.mazhuang123`, etc.
There are many infos in output, include Activity Resolver Table, Registered ContentProviders, package name, userId, files/resources/codes path after install, version name and code, permissions info and their granted status, signing version, etc.
`<packagename>` is package name of an application.
The command above means starting MainActivity of the application with the package name `org.mazhuang.boottimemeasure` with an extra string information (key is 'toast' and value is 'hello, world').
As another example of issuing a broadcast intent with `BOOT_COMPLETED` only to `org.mazhuang.boottimemeasure / .BootCompletedReceiver` is as following:
The command of issuing a broadcast intent is very useful in the test, especially when a broatcast intent is hard to generate normally, it would be of great use to send the broadcast intent by the command.
Both system predefined and custom broadcast intent are able to be sent. The following is part of the system predefined broadcast intents and the triggers:
- *Tips*: The file from device may be not readable without root permission, you need to make sure your device is rooted and then use `adb shell` and `su` commands to gain the root permission in the `adb shell` environment, after that you can use `cp /path/on/device /sdcard/filename` to copy the target file from those directories which require root permission to a public directory, and finaly you can use `adb pull /sdcard/filename /path/on/pc` normally as mentioned above after exiting the `adb shell` environment.
- *Tips*: The directory on device may be not writable without root permission, you need to make sure your device is rooted and then use `adb push /path/on/pc /sdcard/filename` firstly, and use `adb shell` and `su` to gain the root permission in the `adb shell` environment, and finaly use `cp /sdcard/filename /path/on/device` to copy the file to the target directory.
Such as using `adb shell input keyevent <keycode>` command, different keycode to achieve different functions, keycode complete list see [KeyEvent](https://developer.android.com/reference/android/view/KeyEvent.html), I think the interesting part of the quote is as follows:
Here are some examples of the use of `input` command.
### Power button
command:
```sh
adb shell input keyevent 26
```
Executive effect equivalent to pressing the power button.
### menu
command:
```sh
adb shell input keyevent 82
```
### HOME key
command:
```sh
adb shell input keyevent 3
```
### return key
command:
```sh
adb shell input keyevent 4
```
### volume control
Increase the volume:
```sh
adb shell input keyevent 24
```
lower the volume:
```sh
adb shell input keyevent 25
```
Mute:
```sh
adb shell input keyevent 164
```
### Media Control
play / Pause:
```sh
adb shell input keyevent 85
```
Stop play:
```sh
adb shell input keyevent 86
```
Play the next song:
```sh
adb shell input keyevent 87
```
Played on one:
```sh
adb shell input keyevent 88
```
Resume playback:
```sh
adb shell input keyevent 126
```
Pause playback:
```sh
adb shell input keyevent 127
```
### On / Off screen
It can be switched on and off by telling off the screen above the analog power button, but if you want to light up or clear off the screen, then you can use the following method.
Light up the screen:
```sh
adb shell input keyevent 224
```
Off screen:
```sh
adb shell input keyevent 223
```
### Slide to unlock
If no password lock screen is unlocked by sliding gestures, so you can `input swipe` to unlock.
Command (parameter models Nexus 5, swipe up to unlock, for example):
`3001000300 parameters represent` 500` starting x coordinate of the start point y coordinate of the end point x coordinate y coordinate of the end point '.
Represents an output tag `ActivityManager` above the level of Info logs, Debug log output above the level of the tag` MyApp`, and other tag Silent level of log (ie, shield other tag logging).
#### Log format
You can use `adb logcat -v <format>` option specifies log output format.
Log supported by the following `<format>`:
* brief
The default format. The format is:
```sh
<priority>/<tag>(<pid>): <message>
```
Example:
```sh
D/HeadsetStateMachine( 1785): Disconnected process message: 10, size: 0
```
* process
The format is:
```sh
<priority>(<pid>) <message>
```
Example:
```sh
D( 1785) Disconnected process message: 10, size: 0 (HeadsetStateMachine)
```
* tag
The format is:
```sh
<priority>/<tag>: <message>
```
Example:
```sh
D/HeadsetStateMachine: Disconnected process message: 10, size: 0
In brackets `[14201.684016]` time represents the core begins to start in seconds.
By kernel log, we can do some things, such as a measure of the kernel boot time, `Freeing init memory` find that time is in front of the line after system startup, the kernel log.
`Scale` means the maximum value of `level`, and `level` means the current battery level. The output above means there is 44% of battery left of the device.
The `mDisplayId` stands for the number of the display screen, `init` shows the initial resolution and density of the screen, the height in `app` is smaller than that in `init`, which means the device has a virtual navigation bar with a height: `1920 - 1794 = 126px (42dp)`.
For Android 5.0 and the aboves, the command used to view IMEI above is not working which always comes out nothing, the alternative is like this(requires root privileges):
Reference: [adb shell dumpsys iphonesubinfo not working since Android 5.0 Lollipop](http://stackoverflow.com/questions/27002663/adb-shell-dumpsys-iphonesubinfo-not-working-since-android-5-0-lollipop)
Are you getting bored for pressing "Setting" - "About phone" - "state information" - "IP address" to get the IP address of the device? You can make it easily via adb command:
The above command may result in an empty result on some devices if they are connected via WIFI, then you can use the following command to view the LAN IP:
The output above is the Mac address of LAN, if you want other infomation of connection, the command `adb shell netcfg` mentioned in the section **IP address** would be helpful.
This is the CPU information of Nexus 5, we can find from the output that the hardware is `Qualcomm MSM 8974`, and the processor number is from 0 to 3, which means the cpu is a quad-core, then from the `Processor` we can find the architecture of the cpu is` ARMv7 Processor rev 0 ( v71) `.
This will output a lot of information, including "model" and "Android system version" and other infomation which are mentioned in previous several sections.
Settings in this section correspond with "Expanded desktop" in Cyanogenmod.
command:
```sh
adb shell settings put global policy_control <key-values>
```
`<key-values>` composite by keys and their values below, format is `<key1>=<value1>:<key2>=<value2>`.
| key | meaning |
|-----------------------|---------------------|
| immersive.full | Hide both |
| immersive.status | Hide status bar |
| immersive.navigation | Hide navigation bar |
| immersive.preconfirms | ? |
Values for these keys are comma-delimited list of tokens, where tokens:
| value | 含义 |
|----------------|------------------|
| `apps` | All applications |
| `*` | Everywhere |
| `packagename` | Include package |
| `-packagename` | Exclude package |
For example:
```sh
adb shell settings put global policy_control immersive.full=*
```
Means set hide both status bar and navigation bar everywhere.
```sh
adb shell settings put global policy_control immersive.status=com.package1,com.package2:immersive.navigation=apps,-com.package3
```
Means set hide status bar in applications whoes package name is `com.package1` or `com.package2`, hide navigation bar in all applications, exclude whoes package name is `com.package3`.
| -d Display-id | screenshots display the specified number (multiple screen display case next) |
Found If you specify a file name can be omitted when the -p parameter to `.png` ending; otherwise you need to use the -p parameter. If you do not specify a file name, file contents screenshot will be directly output to stdout.
This depends on `sed` command, it's avaliable in Linux and Mac OS X by default. In Windows, you may find it in bin directory in Git installation place. Otherwise, you may need to download [sed for Windows](http://gnuwin32.sourceforge.net/packages/sed.htm) and add the directory where sed.exe is to PATH environment variable.
/system partitions are mounted read-only, but some operating systems such as Android to add commands to remove the need to bring their own application / system write operation, it is necessary to remount it read-write.
step:
1. Enter the shell and switch to the root user privileges.
mount -o remount,rw -t yaffs2 /dev/block/platform/msm_sdcc.1/by-name/system /system
```
Here `/ dev / block / platform / msm_sdcc.1 / by-name / system` is we get the file path from the output in the previous step.
If the output is not an error, then the operation is successful, you can file / system under wanted.
### Check connection over WiFi password
**Note: You need root privileges.**
command:
```sh
adb shell
su
cat /data/misc/wifi/*.conf
```
Example output:
```sh
network={
ssid="TP-LINK_9DFC"
scan_ssid=1
psk="123456789"
key_mgmt=WPA-PSK
group=CCMP TKIP
auth_alg=OPEN
sim_num=1
priority=13893
}
network={
ssid="TP-LINK_F11E"
psk="987654321"
key_mgmt=WPA-PSK
sim_num=1
priority=17293
}
```
`Ssid` we shall see in the WLAN settings in the name,` psk` the password, `key_mgmt` security encryption.
### To set the system date and time
** Note: You need root privileges. **
command:
```sh
adb shell
su
date -s 20160823.131500
```
It said it would change the system date and time at 13:15:00 on August 23, 2016.
### restart cellphone
command:
```sh
adb reboot
```
### Detect whether the device is root
command:
```sh
adb shell
su
```
In this case the command line prompt is `` $ indicates no root privileges, is `` the # indicates root.
### Monkey use stress testing
Monkey can generate pseudo-random event to simulate a user click, touch, gesture and other operations, you can program being developed random stress test.
Usage is simple:
```sh
adb shell monkey -p <packagename> -v 500
```
He told `<packagename>` specific application to send 500 pseudo-random events.
Android system is based on Linux kernel, so Linux where many commands in Android also has the same or similar implement, in `adb shell` where you can call. Part earlier in this document have been used in the `adb shell` command.
### See process
command:
```sh
adb shell ps
```
Example output:
```sh
USER PID PPID VSIZE RSS WCHAN PC NAME
root 1 0 8904 788 ffffffff 00000000 S /init
root 2 0 0 0 ffffffff 00000000 S kthreadd
...
u0_a71 7779 5926 1538748 48896 ffffffff 00000000 S com.sohu.inputmethod.sogou:classic
u0_a58 7963 5926 1561916 59568 ffffffff 00000000 S org.mazhuang.boottimemeasure
