The Android SDK includes an Android device emulator — a virtual device that runs on your computer. The Android Emulator lets you develop and test Android apps without using a physical device.
This page describes command-line features that you can use with the Android Emulator. For information about using the Android Emulator UI, see Run Apps on the Android Emulator.
Starting the emulator
Use the emulator command to start the emulator, as an alternative to
running your project or
starting it through the AVD Manager.
Here's the basic command-line syntax for starting a virtual device from a terminal prompt:
emulator -avd avd_name [ {-option [value]} … ]
Or
emulator @avd_name [ {-option [value]} … ]
For example, if you launch the emulator from within Android Studio running on a Mac, the default command line will be similar to the following:
/Users/janedoe/Library/Android/sdk/emulator/emulator -avd Nexus_5X_API_23 -netdelay none -netspeed full
You can specify startup options when you start the emulator, but not later on.
For a list of AVD names, enter the following command:
emulator -list-avds
When you use this option, it displays a list of AVD names from your Android home
directory. Note that you can override the default home directory by setting the
ANDROID_SDK_HOME
environment variable: the root of the
user-specific directory where all configuration and AVD content is stored. You
could set the environment variable in the terminal window before launching a
virtual device, or you could set it through your user settings in the operating
system; for example, in your .bashrc file on Linux.
To stop the Android Emulator, just close the emulator window.
Installing an app
In addition to installing an app through Android Studio or the emulator UI, you can install your app on a virtual device by using the adb utility.
To install an app by using adb, and then run and test the app, follow these general steps:
- Build and package your app into an APK as described in Build and Run Your App.
- Start the emulator from the command line as described in the previous section, using any startup options necessary.
- Install your app using adb.
- Run and test your app on the emulator.
While the emulator is running, you can also use the Emulator Console to issue commands as needed. - The virtual device preserves the app and its state data across restarts,
in a user-data disk partition (
userdata-qemu.img). To clear this data, start the emulator with the-wipe-dataoption or wipe the data in the AVD Manager, for example. For more information about the user-data partition and other storage, see the following section.
To uninstall an app, do so as you would on an Android device.
Note: The adb utility sees the virtual device as
an actual physical device. For this reason, you might have to use the
-d flag with some common adb commands, such as
install. The -d flag lets you specify which of several
connected devices to use as the target of a command. If you don't specify
-d, the emulator targets the first device in its list.
Understanding the default directories and files
The emulator uses associated files, of which the AVD system and data directories are the most important. It helps to understand the emulator directory structure and files when specifying command-line options. Although, you normally don't need to modify the default directories or files.
The Android Emulator uses the Quick Emulator (QEMU) hypervisor. Initial versions of the Android Emulator used QEMU 1 (goldfish), and later versions use QEMU 2 (ranchu).
AVD system directory
The system directory contains the Android system images that the emulator uses to simulate the operating system. It has platform-specific, read-only files shared by all AVDs of the same type, including API level, CPU architecture, and Android variant. The default locations are the following:
- Mac OS X and Linux -
~/Library/Android/sdk/system-images/android-apiLevel/variant/arch/ - Microsoft Windows XP -
C:\Documents and Settings\user\Library\Android\sdk\system-images\android-apiLevel\variant\arch\ - Windows Vista -
C:\Users\user\Library\Android\sdk\system-images\android-apiLevel\variant\arch\
Where:
apiLevelis a numeric API level, or a letter for preview releases. For example,android-Mindicated the Android Marshmallow preview. On release, it became API level 23, designated byandroid-23.variantis a name corresponding to specific features implemented by the system image; for example,google_apisorandroid-wear.archis the target CPU architecture; for example,x86.
Use the -sysdir option to specify a different system directory for
the AVD.
The emulator reads the following files from the system directory.
| File | Description | Option to Specify a Different File |
|---|---|---|
kernel-qemu or kernel-ranchu
|
The binary kernel image for the AVD. kernel-ranchu is the
QEMU 2 emulator, the latest version.
|
-kernel
|
system.img
|
The read-only initial version of the system image; specifically, the partition containing the system libraries and data corresponding the API level and variant. | -system
|
ramdisk.img
|
The boot partition image. This is a subset of system.img
that's loaded by the kernel initially before the system image is mounted. It
typically contains just a few binaries and initialization scripts.
|
-ramdisk
|
userdata.img
|
The initial version of the data partition, which appears as
data/ in the emulated system and contains all writable data for the
AVD. The emulator uses this file when you create a new AVD or use the
‑wipe-data option. For more information, see the
userdata-qemu.img file description in the following section.
|
-initdata
-init-data
|
AVD data directory
The AVD data directory, also called the content directory, is specific to a single AVD instance and contains all modifiable data for the AVD.
The default location is the following, where name is the
AVD name:
- Mac OS X and Linux -
~/.android/avd/name.avd/ - Microsoft Windows XP -
C:\Documents and Settings\user\.android\name.avd\ - Windows Vista, and higher -
C:\Users\user\.android\name.avd\
Use the -datadir option to specify a different AVD data directory.
The following table lists the most important files contained in this directory.
| File | Description | Option to Specify a Different File |
|---|---|---|
userdata-qemu.img
|
The content of the data partition, which appears as
Each virtual device instance uses a writable user-data image to store user- and
session-specific data. For example, it uses the image to store a unique user's
installed app data, settings, databases, and files. Each user has a
different |
-data
|
cache.img
|
The cache partition image, which appears as cache/ in the
emulated system. It's empty when you first create an AVD or use the
-wipe-data option. It stores temporary download files and is
populated by the download manager and sometimes the system; for example, the
browser uses it to cache downloaded web pages and images while the emulator is
running. When you power off the virtual device, the file is deleted. You can
persist the file by using the -cache option.
|
-cache
|
sdcard.img
|
(Optional) An SD card partition image that lets you simulate an SD card
on a virtual device. You can create an SD card image file in the AVD
Manager or using the
When defining an AVD in the AVD Manager, you have the choice
to use an automatically managed SD card file, or a file that you created with
the You can browse, send files to, and copy and remove files from a simulated SD card by using the emulator UI or the adb utility while the virtual device is running. You can't remove a simulated SD card from a running virtual device.
To copy files to the SD card file before loading it, you can mount the image
file as a loop device and then copy the files. Or use a utility such as the
The emulator treats the file as a pool of bytes so the SD card format doesn't matter.
Note that the |
-sdcard
|
Listing directories and files used by the emulator
You can discover where files are located in two ways:
- When you start the emulator from the command line, use the
-verboseor-debug initoption, and look at the output. - Use the
emulator-help-optioncommand to list a default directory. For example:emulator -help-datadir
Use '-datadir <dir>' to specify a directory where writable image files will be searched. On this system, the default directory is: /Users/me/.android See '-help-disk-images' for more information about disk image files.
Command-line startup options
This section lists options you can supply on the command line when you start the emulator.
Note: The Android Emulator is continually under development to make it more reliable. For status on the issues reported against various command-line options, and to report bugs, see the Android Issue Tracker.
Commonly used options
The following table lists command-line startup options that you might use more often.
| Command-Line Option | Description |
|---|---|
| Quick Boot | |
-no-snapshot-load
|
Performs a cold boot, and saves the emulator state on exit. |
-no-snapshot-save
|
Performs a quick boot if possible, but does not save the emulator state on exit. |
-no-snapshot
|
Disables the Quick Boot feature completely—it does not load or save the emulator state. |
| Device Hardware | |
-camera-back mode-camera-front mode
|
Set the emulation mode for a camera facing back or front. It overrides any camera setting in
the AVD.
For example: emulator @Nexus_5X_API_23 -camera-back webcam0 |
-webcam-list
|
List the web cameras on your development computer that are available for emulation. For
example:
emulator @Nexus_5X_API_23 -webcam-list
List of web cameras connected to the computer:
Camera 'webcam0' is connected to device 'webcam0'
on channel 0 using pixel format 'UYVY'
In the example, the first As of SDK Tools 25.2.4, the AVD name is required, although it might not be in the future. |
| Disk Images and Memory | |
-memory size
|
Specify the physical RAM size from 128 to 4096 MBs. For example: emulator @Nexus_5X_API_23 -memory 2048 This value overrides the AVD setting. |
-sdcard filepath
|
Specify the filename and path to an SD card partition image file. For
example:
emulator @Nexus_5X_API_23 -sdcard C:/sd/sdcard.img If the file isn't found, the emulator still launches, but without an SD card; the command returns a No SD Card Image warning.
If you don't specify this option, the default is |
-wipe-data
|
Delete user data and copy data from the initial data file. This option
clears the data for the virtual device and returns it to the same state as when
it was first defined. All installed apps and settings are removed. For example:
emulator @Nexus_5X_API_23 -wipe-data
By default, the user data file is |
| Debug | |
-debug tags
|
Enable or disable the display of debug messages for one or more tags.
Separate multiple tags by a space, comma, or column. For example:
$ emulator @Nexus_5X_API_23 -debug init,metrics To disable a tag, place a dash (-) in front of it; for example, the following option displays all debug messages, except the ones related to network sockets and metrics:
For a list of tags and descriptions, use the
emulator -help-debug-tags
You can define the default debug tags in the
ANDROID_VERBOSE=socket,gles It's equivalent to using:
|
-debug-tag-debug-no-tag
|
Enable a specific debug message type. Use the no form to
disable a debug message type. For example:
emulator @Nexus_5X_API_23 -debug-all -debug-no-metrics
For a list of tags, use the |
-logcat logtags
|
Enable the display of logcat messages for one or more tags, and write
them to the terminal window. For example, the following command enables error
messages from all components:
emulator @Nexus_5X_API_23 -logcat *:e
The following example displays GSM component messages at the informative log level:
emulator @Nexus_5X_API_23 -logcat '*:s GSM:i'
If you don't supply the |
-show-kernel
|
Display kernel debug messages in the terminal window. For example:
emulator @Nexus_5X_API_23 -show-kernel One use of this option is to check that the boot process works correctly. |
-verbose
|
Print emulator initialization messages to the terminal window. For
example:
emulator @Nexus_5X_API_23 -verbose
It displays which files and settings are actually selected when starting a
virtual device defined in an AVD. This option is the same as specifying
|
| Network | |
-dns-server servers
|
Use the specified DNS servers. servers is a
comma-separated list of up to four DNS server names or IP addresses. For
example:
emulator @Nexus_5X_API_23 -dns-server 192.0.2.0,
By default, the emulator tries to detect the DNS servers you're using and sets
up special aliases in the emulated firewall network to allow the Android system
to connect directly to them. Use the |
-http-proxy proxy
|
Make all TCP connections through a specified HTTP/HTTPS proxy. If your
emulator must access the internet through a proxy server, you can use this
option or the http_proxy environment variable to set up the
appropriate redirection. For example:
emulator @Nexus_5X_API_23 -http-proxy myserver:1981
The
If this option isn't supplied, the emulator looks up the |
-netdelay delay
|
Set network latency emulation to one of the following
For example: emulator @Nexus_5X_API_23 -netdelay gsm
The emulator supports network throttling (limiting the maximum network
bandwidth, also called network shaping) as well as higher connection latencies.
You can define it either through the skin configuration, or with the
|
-netfast
|
Disable network throttling. For example:
emulator @Nexus_5X_API_23 -netfast
This option is the same as specifying |
-netspeed speed
|
Set the network speed emulation. Specify the maximum network upload and
download speeds with one of the following
For example: emulator @Nexus_5X_API_23 -netspeed edge
The emulator supports network throttling (limiting the maximum network
bandwidth, also called network shaping) as well as higher connection latencies.
You can define it either through the skin configuration, or with the
|
-port port
|
Set the TCP port number that's used for the console and adb. For example:
emulator @Nexus_5X_API_23 -port 5556 The default value is 5554 for the first virtual device instance running on the your machine. A virtual device normally occupies a pair of adjacent ports: a console port and an adb port. The console of the first virtual device running on a particular machine uses console port 5554 and adb port 5555. Subsequent instances use port numbers increasing by two — for example, 5556/5557, 5558/5559, and so on. The range is 5554 to 5682, allowing for 64 concurrent virtual devices.
The port assignments are often the same as specifying
Note that if the |
-ports
|
Set the TCP ports used for the console and adb. For example:
emulator @Nexus_5X_API_23 -ports 5556,5559
The valid ports range is 5554 to 5682, allowing for 64 concurrent virtual
devices. The
We recommend using the
For more information about setting console and adb ports, see the
|
-tcpdump filepath
|
Capture network packets and store them in a file. For example:
emulator @Nexus_5X_API_23 -tcpdump /path/dumpfile.cap Use the option to begin capturing all network packets that are sent through the virtual Ethernet LAN of the emulator. After, you can use a tool like Wireshark to analyze the traffic. Note that this option captures all Ethernet packets, and isn't limited to TCP connections. |
| System | |
-accel mode
|
Configure emulator VM acceleration. For example:
emulator @Nexus_5X_API_23 -accel auto Accelerated emulation works for x86 and x86_64 system images only. On Linux, it relies on KVM. On Windows and Mac, it relies on an Intel CPU and Intel HAXM driver. This option is ignored if you're not emulating an x86 or x86_64 device.
Valid values for
For more information, see Configure Hardware Acceleration. |
-accel-check
|
Check whether a required hypervisor for emulator VM acceleration is
installed (HAXM or KVM). For example:
emulator -accel-check For more information, see Determining whether HAXM or KVM is installed. |
-engine engine
|
Specify the emulator engine:
For example:
emulator @Nexus_5X_API_23 -engine auto
Auto-detection should choose the value that provides the best performance when
emulating a particular AVD. You should use the |
-gpu mode
|
Select the GPU emulation mode. For example:
emulator @Nexus_5X_API_23 -gpu swiftshader_indirect For more information, see Configuring graphics acceleration on the command line. |
-no-accel
|
Disable emulator VM acceleration when using an x86 or x86_64 system
image. It's useful for debugging only and is the same as specifying -accel
off. For example:
emulator @Nexus_5X_API_23 -no-accel For more information, see Configure Hardware Acceleration. |
-nojni
-no-jni
|
Disable extended Java Native Interface (JNI) checks in the Android Dalvik
or ART runtime. For example:
emulator @Nexus_5X_API_23 -nojni When you start a virtual device, extended JNI checks are enabled by default. For more information, see JNI Tips. |
-selinux {disabled|permissive}
|
Set the Security-Enhanced Linux (SELinux)
security module to either disabled or permissive mode on a Linux operating
system. For example:
me-linux$ emulator @Nexus_5X_API_23 -selinux permissive
By default, SELinux is in enforcing mode, meaning the security policy is
enforced. |
-timezone timezone
|
Set the timezone for the virtual device to
emulator @Nexus_5X_API_23 -timezone Europe/Paris
By default, the emulator uses the timezone of your development computer. Use
this option to specify a different timezone or if the automatic detection isn't
working correctly. The
The specified timezone must be in the zoneinfo database. |
-version
|
Display the emulator version number. For example:
emulator @Nexus_5X_API_23 -version Or
emulator -version |
| UI | |
-no-boot-anim
|
Disable the boot animation during emulator startup for faster booting.
For example:
emulator @Nexus_5X_API_23 -no-boot-anim On slower computers, this option can significantly speed up the boot sequence. |
-screen mode
|
Set emulated touch screen mode. For example:
emulator @Nexus_5X_API_23 -screen no-touch
|
Advanced options
The following command-line startup options are available, but not commonly used by the average app developer.
In the descriptions, the working directory is the current directory in the terminal where you're entering commands. For information about the AVD system directory and data directory, and the files stored within them, see Understanding the default directories and files.
Some of these options are appropriate for external app developers, and some of them are used primarily by platform developers. App developers create Android apps and run them on specific AVDs. Platform developers work on the Android system and run it inside the emulator with no pre-created AVD; they're internal Android team members, not external app developers.
| Advanced Option | Brief Description |
|---|---|
-bootchart timeout
|
Enable bootcharting, with a timeout in seconds. Some Android system images have a modified init system that integrates a bootcharting facility. You can pass a bootcharting timeout period to the system with this option. If your init system doesn't have bootcharting activated, the option does nothing. This option is primarily useful to platform developers, not external app developers. For example: emulator @Nexus_5X_API_23 -bootchart 120 |
-cache filepath
|
Specify a cache partition image file. Provide a filename, and an absolute
path or a path relative to the data directory, to set up a persistent cache
file. If the file doesn't exist, the emulator creates it as an empty file. If
you don't use this option, the default is a temporary file named
For example: emulator @Nexus_5X_API_23 -cache ~/.android/avd/Nexus_5X_API_23.avd/cache_persistent.img |
-cache-size size
|
Set the cache partition size in MBs. If you don't specify this option, the default is 66 MB. Normally, most app developers don't need this option, unless they need to download very large files that are larger than the default cache. For more information about the cache file, see AVD data directory. For example: emulator @Nexus_5X_API_23 -cache-size 1000 |
-data filepath
|
Set the user data partition image file. Provide a filename, and an
absolute path or a path relative to the working directory, to set up a
persistent user data file. If the file doesn't exist, the emulator creates an
image from the default For example: emulator @Nexus_5X_API_23 -data ~/.android/avd/Nexus_5X_API_23.avd/userdata-test.img |
-datadir dir
|
Specify a data directory using an absolute path. For more information, see AVD data directory. For example: emulator @Nexus_5X_API_23 -datadir ~/.android/avd/Nexus_5X_API_23.avd/mytest |
-force-32bit
|
Use the 32-bit emulator on 64-bit platforms. Occasionally, this option is useful for testing or debugging. For example, there was an issue where the emulator would sometimes not run on 64-bit Windows, but 32-bit did run; this option was helpful for performing comparisons to debug the issue. Here's an example: emulator @Nexus_5X_API_23 -force-32bit |
-help-disk-images
|
Get help about about disk images. It provides information relevant to both app and platform developers. For example: emulator -help-disk-images |
-help-char-devices
|
Get help about character emulator -help-char-devices |
-help-sdk-images
|
Get help about disk images relevant to app developers. It explains where the image files are located for an AVD created with the SDK tools. For example: emulator -help-sdk-images |
-help-build-images
|
Get help about disk images relevant to platform developers. For example: emulator -help-build-images |
-initdata filepath-init-data
filepath
|
Specify the initial version of the data partition. After wiping
user data, the emulator copies the contents of the specified file to user
data (by default, the For example: emulator @Nexus_5X_API_23 -initdata ~/Library/Android/sdk/system-images/android-23/ google_apis/x86/userdata-test.img |
-kernel filepath
|
Use a specific emulated kernel. If you don't specify a path, the emulator
looks in the system directory. If you don't specify this option, the default is
For example: emulator @Nexus_5X_API_23 -kernel ~/Library/Android/sdk/system-images/android-23/ google_apis/x86/kernel-test.img -show-kernel |
-noaudio
-no-audio
|
Disable audio support for this virtual device. Some Linux and Windows
computers have faulty audio drivers that cause different symptoms, such as
preventing the emulator from starting. In this case, you can use this option to
overcome the issue. Alternatively, you can use the For example: emulator @Nexus_5X_API_23 -noaudio |
-nocache
-no-cache
|
Start the emulator without a cache partition. If you don't use this
option, the default is a temporary file named For example: emulator @Nexus_5X_API_23 -nocache |
-no-snapshot
|
Inhibit both the automatic load and save operations, causing the emulator
to execute a full boot sequence and to lose its state when closed. It overrides
the For example: emulator @Nexus_5X_API_23 -no-snapshot |
-no-snapshot-load
|
Prevent the emulator from loading the AVD state from snapshot storage. Perform a full boot. For example: emulator @Nexus_5X_API_23 -no-snapshot-load |
-no-snapshot-save
|
Prevent the emulator from saving the AVD state to snapshot storage on exit, meaning that all changes will be lost. For example: emulator @Nexus_5X_API_23 -no-snapshot-save |
-no-snapshot-update-time
|
Don't try to correct the AVD clock time immediately on snapshot restore. This option can be useful during testing as it avoids a sudden time jump. Time updates are still sent to the AVD about every 15 seconds, however. For example: emulator @Nexus_5X_API_23 -no-snapshot-update-time |
-no-snapstorage
|
Start the emulator without mounting a file to store or load state
snapshots, forcing a full boot and disabling state snapshot functionality. This
option overrides the For example: emulator @Nexus_5X_API_23 -no-snapstorage |
-no-window
|
Disable graphical window display on the emulator. This option is useful when running the emulator on servers that have no display. You'll still be able to access the emulator through adb or the console. For example: emulator @Nexus_5X_API_23 -no-window |
-partition-size size
|
Specify the system data partition size in MBs. For example: emulator @Nexus_5X_API_23 -partition-size 1024 |
-prop name=value
|
Set an Android system property in the emulator when it boots.
emulator @Nexus_5X_API_23 -prop status.battery.level_raw=80 -prop ro.serialno=123456 |
-qemu args
|
Pass arguments to the QEMU emulator software. Note that QEMU 1 and QEMU 2 can use different arguments. When using this option, make sure it's the last option specified, as all options after it are interpreted as QEMU-specific options. This option is quite advanced and should be used only by developers who are very familiar with QEMU and Android emulation. |
-qemu -h
|
Display emulator -qemu -h |
-ramdisk filepath
|
Specify a ramdisk boot image. Specify the filename, and an absolute path
or a path relative to the working directory. If you don't use this option, the
default is the For example: emulator @Nexus_5X_API_23 -ramdisk ~/Library/Android/sdk/system-images/android-23/ google_apis/x86/ramdisk-test.img |
-report-console socket
|
Report the console port to a remote third party before starting
emulation. It can be useful for an automated testing script.
For more information, use the |
-shell
|
Create a root shell console on the current terminal. It differs from the
For example: emulator @Nexus_5X_API_23 -shell |
-snapshot name
|
Specify the name of a snapshot within a snapshot storage file for automatic start and save operations. Rather than executing a full boot sequence, the emulator can resume execution from an earlier state snapshot, which is usually significantly faster. When you supply this option, the emulator loads the snapshot of that name from the snapshot image and saves it back under the same name on exit. If you don’t use this option, the default is a full boot sequence. If the specified snapshot doesn’t exist, the emulator performs a full boot sequence instead, and performs a save operation. See the emulator @Nexus_5X_API_23 -snapshot snapshot2 It’s important to remember that in the process of loading a snapshot, all contents of the system, user data, and SD card images are overwritten with the contents they held when the snapshot was made. Unless you save this information in a different snapshot, any changes since then are lost. You can also create a snapshot from the Emulator Console by using the
|
-snapshot-list
|
Display a list of available snapshots. It prints a table of snapshots
that are stored in the snapshot storage file that the emulator was started
with, then exits. If you specify For example: emulator @Nexus_5X_API_23 -snapshot-list -snapstorage ~/.android/avd/Nexus_5X_API_23.avd/snapshots-test.img You can use the ID and TAG column values in the output
as arguments for the |
-snapstorage filepath
|
Specify a repository file that contains all state snapshots. All
snapshots made during execution will be saved in this file, and only
snapshots in this file can be restored during the emulator run. If you
don’t specify this option, the default is For example: emulator @Nexus_5X_API_23 -snapstorage ~/.android/avd/Nexus_5X_API_23.avd/snapshots-test.img |
-sysdir dir
|
Specify a system directory using an absolute path. For more information, see AVD system directory. For example: emulator @Nexus_5X_API_23 -sysdir ~/Library/Android/sdk/system-images/android-23/ google_apis/x86/test |
-system filepath
|
Specify an initial system file. Provide the filename, and an absolute path
or a path relative to the working directory. If you don't use this option, the
default is the emulator @Nexus_5X_API_23 -system ~/Library/Android/sdk/system-images/android-23/ google_apis/x86/system-test.img |
-use-system-libs
|
On Linux, use the system For example: me-linux$ emulator @Nexus_5X_API_23 -use-system-libs |
-writable-system
|
Use this option to have a writable system image during your emulation session. To do so:
Note that using this flag will create a temporary copy of the system image that can be very large (several hundred MBs), but will be destroyed when the emulator exits. |
Deprecated options
The following command-line options are deprecated:
-audio-in-audio-out-charmap-code-profile-cpu-delay-dpi-device-dynamic_skin-enable-kvm-gps-image-keyset-help-keys-help-keyset-file-nand-limits-noskin-no-skin-onion-onion-alpha-onion-rotation-radio-ranchu-raw-keys-scale-shared-net-id-shell-serial-skin-skindir-trace-useaudio
Getting help about command-line options
This section describes how to get help about the command-line options. The following section provides more in-depth information about the commonly used emulator command-line options that are available when you start the emulator.
Listing all emulator options
To print a list of all emulator options, including a short description, enter this command:
emulator -help
Getting detailed help for a specific option
To print help for a specific startup option, enter this command:
emulator -help-option
For example:
emulator -help-netspeed
This help is more detailed than the description provided by the
-help option.
Getting detailed help for all options
To get detailed help for all emulator options, enter this command:
emulator -help-all
Listing emulator environment variables
To get a list of emulator environment variables, enter this command:
emulator -help-environment
You can set environment variables in the terminal window before launching a
virtual device, or you could set it through your user settings in the operating
system; for example, in your .bashrc file on Linux.
Listing debug tags
To print a list of tags for the -debug options, enter this command:
emulator -help-debug-tags
The -debug options let you enable or disable debug messages from
specific emulator components, as specified by the tags.