Debug KeyStore

$ keytool -list -v -keystore ~/.android/debug.keystore -alias androiddebugkey -storepass android -keypass android

or

$ keytool -list -v -keystore {path_to_keystore}/debug.keystore -alias androiddebugkey -storepass android -keypass android

Release KeyStore

$ keytool -list -v -keystore {path_to_keystore}/my-release.keystore -alias {alias_name} -storepass {store_pass} -keypass {keypass}

ADB

Select a device when multiple devices are connected

You can use adb devices -l to check information related to them, in order to select the one you want. Then:

adb -s <device-serial> <instructions>

where <device-serial> is the number listed when you use adb devices and <instructions> are the instructions you want to execute over the device.

Server actions

The following command kills the adb server:

adb kill-server

This starts the adb server:

adb start-server

Show launcher activity cold start time

Database

Watching StrictMode

If you’re using penaltyLog(), the default, just run

$ adb logcat

and watch the terminal output. Any violations will be logged to your console, slightly rate-limited for duplicate elimination.

If you want to get fancier, turn on penaltyDropbox() and they’ll be written to the DropBoxManager, where you can extract them later with

$ adb shell dumpsys dropbox data_app_strictmode --print

View connected device

$ adb devices

If multiple devices are attached, use adb -s DEVICE_ID to target a specific device

List of running services

$ adb shell dumpsys activity services

Install an application

$ adb install -r file.apk // (or com.package.name)
# optional -r argument reinstalls and keeps any data if the application is already installed on the device.
# optional -s argument installs the app on the SD card instead of the internal storage.

Uninstall an application

$ adb uninstall com.package.name

To uninstall the application using uninstall dialog:

$ adb shell am start -a android.intent.action.DELETE -d package:com.package.name

To keep the data in the cache directory, add -k

$ adb uninstall -k com.package.name

Start an Activity

$ adb shell am start -n com.package.name/.ActivityName
$ adb shell am start -n com.package.name/com.package.name.ActivityName

Open a deep linking intent

$ adb shell am start -n android.intent.action.VIEW -d "scheme://app/deep/linking"

or

$ adb shell am start -n android.intent.action.VIEW -d "https://name.app/user-settings/324" com.packaging.app

Take an screenshot

$ adb shell screencap -p | perl -pe 's/\x0D\x0A/\x0A/g' > screen_name.png

Power button

This command sends the power button event to turn the device ON/OFF.

$ adb shell input keyevent 26
$ adb shell inout text "KEYCODE_POWER"

Unlock screen

This command sends the event that unlocks the lockscreen on the device. It can be combined with the power button command above to turn on and unlock the device

$ adb shell input keyevent 82
$ adb shell inout text "KEYCODE_MENU"

$ adb shell input keyevent 26 82
$ adb shell inout text "KEYCODE_POWER" "KEYCODE_MENU"

Print all installed packages

$ adb shell pm list packages -f

Get the path of an installed application

$ adb shell pm path app.package.application-name

Simulate application being killed

# exit your app using home button
# After that.
$ adb shell ps // Find the process id
$ adb shell ps | grep your.app.package // Then find the line with app name package
$ adb shell kill -9 21997 // Kill the app by PID
# Now return to the app using the task switcher.

Screen recording using Android 4.4

$ adb shell screenrecord --verbose /sdcard/nexus5.mp4 // Basic recording from shell
# Press Ctrl-C to stop.
$ screenrecord --verbose --time-limit 30 /sdcard/nexus5.mp4 // Recording for 30 seconds
$ screenrecord --verbose --bit-rate 8000000 --time-limit 30 /sdcard/nexus5.mp4 // Recording for 30 seconds with 8Mbps bitrate
$ screenrecord --verbose --rotate /sdcard/nexus5.mp4 // Record in portrait view / horizontal

Check battery stats

$ adb shell dumpsys batterystats
# Global and per-UID statistics.
# Options: --help.

Auto Backup Data (only in Android M)

$ adb shell bmgr

$ adb shell bmgr run
# Do some work in the app.
$ adb shell bmgr fullbackup com.domain.android.app_name
# Uninstall and reinstall the app.
$ adb shell bmgr restore com.domain.android.app_name

Simulate fingerprint inputs (only in Android M)

$ adb -e emu finger touch 1

Filter by tagname in Logcat

$ adb logcat -s TAG_NAME
$ adb logcat -s TAG_NAME_1 TAG_NAME_2

Filter by priority in Logcat

$ adb logcat "*:<priority>"
# Where <priority> can be V (Verbose), D (Debug), I (Info), W (Warning), E (Error), F (Fatal), S (Silent).

It can be combined with tagname command, to filter by tagname and priority

$ adb logcat -s TEST: W

Filter using grep in Logcat

$ adb logcat | grep "term"
$ adb logcat | grep "term1\|term2"
`

See the executed SQL statements in plain text in Logcat

$ adb shell setprop log.tag.SQLiteLog V
$ adb shell setprop log.tag.SQLiteStatements V
$ adb shell stop
$ adb shell start

That's it. Whenever any of the installed apps now accesses the database you should see the executed statement in the log output.

Testing - Execute Monkey to test user interaction

The Monkey is a program that runs on your emulator or device and generates pseudo-random streams of user events such as clicks, touches, or gestures, as well as a number of system-level events. You can use the Monkey to stress-test applications that you are developing, in a random yet repeatable manner.

$ adb shell monkey [options] <event-count>
# Basic, make 500 random actions.
$ adb shell monkey -p your.package.name -v 500

Complete information at http://developer.android.com/tools/help/monkey.html

Find out processor version on Android Device (check if it's an ARM, for example)

$ adb shell cat /proc/cpuinfo

Test Alarms

Find out Application Binary Interface (ABI) in different devices

ABI (Application Binary Interface) is gonna tell us if an Android device support 64-bit. So using the next command the developer know if the device is 32-bit or 64-bit based.

$ adb shell getprop ro.product.cpu.abi\

Retrieve application's private data and databases for non debug application without root access

# Get a backup of your application data.
$ adb backup --apk com.package.name
# Change the .ab in .tar.
$ dd if=backup.ab bs=24 skip=1 | openssl zlib -d > backup.tar
# Untar  backup.tar.
tar xfv backup.tar
# Go in you app private dir.
$ cd apps/com.package.name

You'll need :

• adb activated
• physical access to unlocked device
• works on Nexus 5 at least, might not work with other devices. allowBackup=false will break thos method

Indentify Frame Rate Issues (Dumpsys)

$ cd platform-tools/
# Before executing next command, go to Settings --> Developer Options --> Enable Profile GPU rendering option.
# And make sure to kill your application first or at least to kill the window that you want to profile, and then you run the command:
$ adb shell dumpsys gfxinfo

Purpose of Dumpsys is identifying frame rate issues and fix them.

What matter is the three columns shown. Copy paste results in a spreadsheet. And you will get a result like this one:

This is the data you can grab. You can create a stack graph, so every bar contains the sum of the three columns on the left in the data we output. Is the time it takes to update the display list on every frame.

• The middle column is called process display list. It's the time we take to draw the actual display list
• The last column is the time we take to swap the buffers, so to give the buffer back to surface flinger. Scrolling or doing any kind of actions should be below 16 millisecond limit. So this app is running at 60FPS, we're vsync'd, everything is going great. You can see that most of the time, you should spend most of the time in process display list, so drawing, executing the display list should be where you spend the bulk of the time.
• The blue part is your code. When you write your Java code, your onDraw() method, and this is where you can do most of the optimizations

There is a distinction between the GPU composition with frame buffers and overlays. So you can use a tool called dumpsys surface flinger to see the state of overlays and frame buffers in the system.

$ adb shell dumpsys SurfaceFlinger

You're going to get a list with all the windows currently visible on the screen.

Use ADB over Wi-Fi without extra application or software

Prerequisites Android device and computer should be connected in same network.

• Connect Android device with USB cable to computer

• Use following command in terminal to make sure adb is running in USB mode.

  $ adb usb
  # Restarting in USB mode.
  # Connect to the device over USB.
  

• Execute following command in terminal to make sure adb identify/list gets connected with the device.

  $ adb devices
  

• Change adb mode from USB to tcpip using following command.

  $ adb tcpip 5555
  # Restarting in TCP mode port: 5555. 

• Now, adb is running over TCP/IP mode, Let’s find IP address of Android device. Go to Settings in Android device -> About -> Status -> IP address. note down the IP address of connected Android Device.

• Use following command to connect ADB with IP address

  $ adb connect #.#.#.#
  # Connected to #.#.#.#:5555. 

• Now adb is working over Wi-fi, You can remove USB cable from Android device.

• To confirm adb is working over Wi-fi and your device is still connect. you can use following command

  $ adb devices
  *.*.*.*:5555 device
  

You’re now ready to go!, Enjoy ADB over Wi-fi. Use following command to change ADB mode to USB

$ adb usb

Test new Marshmallow permissions

In order to test permissions targeting API 23+, we could use following commands to programatically grant and revoke permissions on the device:

$adb pm grant <package_name> <permission_name>

or

$adb pm revoke <package_name> <permission_name>

Testing your app with App Standby

Testing your app with Doze

Enabling Night Mode on Android Nougat

Copy files from/to a device/emulator

AAPT

Check Permissions in order to avoid Play Store app filtering