This article will explain how to install the official Android emulator as a standalone application in Linux. The official Android emulator comes with the “Android Studio” application development suite. However, if you are not interested in developing Android apps and just want a working emulator without installing Android Studio, this article should help you. All the steps mentioned in the article are tested on Ubuntu 20.04 LTS version.
Install Command Line Tools
Download the latest version of “Android Command Line Tools” from here (scroll down to the command line section).
Extract the downloaded archive and make a new folder named “tools” inside “cmdline-tools” directory. Copy and paste all files from “cmdline-tools” folder to “tools” folder. Your final directory layout should look like this:
Install Required Packages
Go to the “tools/bin” folder, launch a new terminal window and run the following command to update repository details:
Next, run the following command to list available and installed packages:
Install some packages required for the Android emulator to work:
Find Correct System Image to Use
Next you need to make a note of the system image you want to load in the Android emulator. To get a list of downloadable system images, run the command below:
You should get some output similar to this:
You will see some numbers like “27”, “28” etc. in the name of system images. These numbers denote Android API levels. Find the Android version corresponding to the API levels from here and make a note of the appropriate system image you want to use in the emulator and the API level number.
Download System Image and Corresponding Packages
Next, download the following packages using the same API level number you finalized in the step above:
For instance, if you decided to use “system-images;android-29;default;x86_64” as the system image, the command would change to:
You can always use the “list” switch to find correct command and version numbers:
Create a New AVD
AVD or “Android Virtual Device” is a set of configuration parameters that defines values for a virtual device that will emulate a real Android hardware device.
To create a new AVD, you need to use the system image you downloaded in the step above. Run the following command to create a new AVD:
Replace “my_avd_30” with any name of your choice. You may be prompted to alter some configuration parameters. Follow on-screen instructions and change the values as per your requirements.
Confirm that the AVD has been successfully created using the command below:
You should get some output similar to this:
Note the path of AVD in the output above. At the same path, you can find a “config.ini” file that can be used to change configuration parameters of the AVD.
Run Emulator
Go to “emulator” folder (up a few directories) and use the following command to launch the emulator:
Replace “my_avd_30” with the name of your own AVD you created in the step above. Your Android emulator should be now up and running:
You can create as many as AVDs as you want and each AVD / System Image will be treated separately.
Conclusion
Android emulator provides an excellent way to emulate real life Android devices on your desktop PC. You can use the emulator to test some apps that are yet in development or you can use the emulator to regularly run Android compatible apps and games on a Linux PC. The performance of the emulator will depend on your system’s horsepower, virtualization technologies available on your PC and your system’s compatibility with the KVM kernel module.
— Update: 19-03-2023 — us.suanoncolosence.com found an additional article How to install official Android Emulator (SDK) in Linux from the website www.2daygeek.com for the keyword how to install android emulator on linux.
Everyone knows that Android OS (Opensource) is the market leader. It was developed especially for touchscreen mobile devices like smartphones & tablet computer.
Android was developed by Android Inc. Later Google acquired it and are doing further developments on it.
If you want to run any mobile apps such as WhatsApp in your system, you must install an android emulator. The Android Emulator simulates Android devices on your system, which allows you to test any mobile applications on a variety of devices and Android API levels without requiring those physical device at hand.
It provides almost all of the capabilities of a real Android device and you can simulate incoming phone calls and text messages, specify the location of the device and much more.
Android SDK is the official android emulator which was developed by Google to emulate the Android App in Linux System.
In this article, we will explain how to install android emulator using the android SDK in Linux.
If you are looking for alternative tools, please go through the two articles below:
- How To Install GenyMotion (Android Emulator) On Linux
- Anbox – Easy way to run Android Apps on Linux
Prerequisites
Android SDK depends on 32-bit Libraries during run time, so 64-bit users should install 32-bit libraries on their system for it to work properly, otherwise you will get an error when you launch the device:
[Install 32-bit libraries ia32-libs Package] $ sudo apt-get install ia32-libs [If you don't have ia32-libs package, then install Alternative Package] $ sudo apt-get install libgl1-mesa-dev
1) How to install Java in Linux?
Android SDK purely depends on JAVA. So, you have to install either OpenJDK or Oracle JAVA before proceeding with Android SDK installation. Please go through the below articles to understand the Java installation process:
- How To Install Oracle Java 9 & 8 (JDK) on CentOS, RHEL, Fedora, Arch Linux & openSUSE
- How To Install Oracle Java 7, 8 & 9 (JDK & JRE) on Debian Via Repository
- How to install Oracle Java Series (JAVA 9, JAVA 8, JAVA 7, JAVA 6) via PPA in Ubuntu & Mint
- How To Install JAVA ( OpenJDK ) 6 / 7 / 8 on Linux
2) Checking installed JAVA version in Linux
Use the below command to check the java version that’s installed on your system:
$ java -version java version "1.8.0_20" Java(TM) SE Runtime Environment (build 1.8.0_20-b26) Java HotSpot(TM) 64-Bit Server VM (build 25.20-b23, mixed mode)
3) How to download the SDK package?
$ cd /opt $ wget http://dl.google.com/android/android-sdk_r24.4.1-linux.tgz $ sudo tar -zxvf android-sdk_r24.4.1-linux.tgz $ cd /android-sdk-linux/tools $ ./android
You will see the below pop-up window when you run the android shell file:
4) Choose the required Android SDK version
Here you can choose which version of Android SDK you are going to install. I’m going to choose Android version 2.3.3, and hit the Install Packages button to install the required packages from source.
Choose ‘Accept License‘ option and hit the Install button to proceed further.
Installation is on-going. Repeat the steps until all the relevant packages are installed.
Installation got over.
5) How to add Android Virtual Device (AVD)
In the Android Virtual Device manager, go to the Android Virtual Devices tab as shown in the screenshot above. Click the Create button to add a new AVD on your android emulator. Click tools button to launch AVD creation window. If it is not showing, maximize the current window to see the ‘tools button‘.
Choose the required configuration as shown in the screenshot below, and hit the OK button:
This is your configuration output based on your selections in the above steps 1-5. Hit OK button.
6) How to launch a new Android Virtual Device (AVD)?
Choose your Android Virtual Device (AVD) then hit the Start button. It will popup the Launch Options, Just hit the Launch button to kickstart the Android Emulator, if you don’t want to specify any launch option.
It will take a bit of time to load as shown below:
Finally, accept the Google Privacy Policy, and hit the Proceed button to launch the device successfully. Emulator will kickstart your AVD and initiate it. It will take few seconds to load.
7) How to launch a new Android Device?
Please refer the below screenshot. You will see that the new android device is launched on my PC:
Click the Browser icon to access the Internet.
Conclusion:
In this article, we showed you how to install an Android Emulator in Linux along with it’s prerequisites like Java SDK. We installed the official android SDK.
We are preparing all our articles in-depth so that they can be easily understood by Linux administrators at all levels . If the article was useful to you, then please spend less than a minute to share your valuable comments below.
Please stay tuned with us for more articles…Happy learning!.
— Update: 19-03-2023 — us.suanoncolosence.com found an additional article Start the emulator from the command line from the website developer.android.com for the keyword how to install android emulator on linux.
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.
Start 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 after it has started.
For a list of AVD names, enter the following command:
emulator -list-avds
Use this option to display a list of AVD names from your Android home directory. You can override the default home directory by setting the ANDROID_SDK_HOME environment variable that specifies the root of the user-specific directory where all configuration and AVD content is stored.
You can set the environment variable in the terminal window before launching a virtual device or through your user settings in the operating system. For example, in your .bashrc file on Linux.
To stop the Android Emulator, close the emulator window.
- Using ClamAV to detect viruses on Linux
- How to Check the Status of the Apache Tomcat Server (Linux)
- How to Install .NET Framework on Debian 11
- How to Uninstall Steam (Step-by-Step Guide)
- 5 steps to reset root password in RHEL/CentOS 6.x and 7.x -with Images
Read also:
Install 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 use adb to install, run, and test your 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 use the Emulator console to issue commands as needed.
To uninstall an app, do so as you would on an Android device.
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-data option or wipe the data in the AVD Manager. For more information about the user data partition and other storage, see the following section.
Note: The adb utility views 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.
Understand the default directories and files
The emulator uses associated files, of which the AVD system and data directories are the most important. It’s helpful to understand the emulator directory structure and files when specifying command-line options, although you typically 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. This directory 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:
- macOS and Linux –
~/Library/Android/sdk/system-images/android-apiLevel/variant/arch/ - Microsoft Windows XP –
C:Documents and SettingsuserLibraryAndroidsdksystem-imagesandroid-apiLevelvariantarch - Windows Vista –
C:UsersuserLibraryAndroidsdksystem-imagesandroid-apiLevelvariantarch
Where:
apiLevelis a numeric API level or a letter for preview releases. For example,android-Mindicates 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:
Table 1. System directory files read by the Android Emulator
| 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 |
ramdisk.img |
The boot partition image. This is a subset of system.img loaded by the kernel initially before the system image is mounted. It typically contains just a few binaries and initialization scripts. |
-ramdisk |
system.img |
The read-only, initial version of the system image. Specifically, the partition containing the system libraries and data corresponding to the API level and variant. | -system |
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.
Use the -datadir option to specify a different AVD data directory.
The following table lists the most important files contained in this directory:
Table 2. Important files in the AVD data 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 |
When defining an AVD in the AVD Manager, you can choose 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, 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. The |
-sdcard |
List directories and files used by the emulator
You can discover where files are located in two ways:
- Use the
-verboseor-debug initoption when you start the emulator from the command line. Look at the output. - Use the
emulator-help-optioncommand to list a default directory. For example:emulator -help-datadir
Use '-datadir ' 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:
Table 3. Commonly used command-line options
| 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 and doesn’t load or save the emulator state. |
| Device Hardware | |
-camera-back mode-camera-front mode |
Sets the emulation mode for a camera facing back or front. This overrides any camera setting in the AVD.
For example: emulator @Nexus_5X_API_23 -camera-back webcam0 |
-webcam-list |
Lists the webcams 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. |
| Disk images and memory | |
-memory size |
Specifies 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 |
Specifies 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 |
Deletes user data and copies 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 |
Enables or disables 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 environment variable. Define the tags you want to use in a comma-delimited list. Here’s an example that shows how to specify the ANDROID_VERBOSE=socket,gles It’s equivalent to using: or
|
-debug-tag-debug-no-tag |
Enables 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 |
Enables the display of Logcat messages for one or more tags and writes 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' For more information about Logcat and |
-show-kernel |
Displays 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 |
Prints 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 |
Uses 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 the servers. Use the |
-http-proxy proxy |
Makes 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 |
-netdelay delay |
For example: emulator @Nexus_5X_API_23 -netdelay gsm The emulator supports network throttling as well as higher connection latencies. You can define it either through the skin configuration or with the |
-netfast |
Disables network throttling. For example:
emulator @Nexus_5X_API_23 -netfast This option is the same as specifying |
-netspeed speed |
For example: emulator @Nexus_5X_API_23 -netspeed edge The emulator supports network throttling as well as higher connection latencies. You can define it either through the skin configuration or with the |
-port port |
Sets 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 |
-ports |
Sets 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 |
-tcpdump filepath |
Captures network packets and stores them in a file. For example:
emulator @Nexus_5X_API_23 -tcpdump /path/dumpfile.cap Use this option to begin capturing all network packets that are sent through the virtual Ethernet LAN of the emulator. Afterward, 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 |
Configures 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. For more information, see Configure hardware acceleration for the Android Emulator. |
-accel-check |
Checks whether a required hypervisor for emulator VM acceleration is installed (HAXM or KVM). For example:
emulator -accel-check For more information, see Check if a hypervisor is installed. |
-engine engine |
Specifies 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. Use the |
-gpu mode |
Selects the GPU emulation mode. For example:
emulator @Nexus_5X_API_23 -gpu swiftshader_indirect For more information, see Configure graphics acceleration. |
-no-accel |
Disables 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 for the Android Emulator. |
-nojni -no-jni |
Disables 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} |
Sets 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 |
-timezone timezone |
emulator @Nexus_5X_API_23 -timezone Europe/Paris The specified time zone must be in the zoneinfo database. |
-version |
Displays the emulator version number. For example:
emulator @Nexus_5X_API_23 -version Or emulator -version |
| UI | |
-no-boot-anim |
Disables 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 |
Sets emulated touch screen mode. For example:
emulator @Nexus_5X_API_23 -screen no-touch |
Advanced options
The command-line startup options in the following table 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 the section about 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.
Table 4. Advanced command-line options
| Advanced option | Brief description |
|---|---|
-bootchart timeout |
Enables 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 |
Specifies a cache partition image file. Provides 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. For example: emulator @Nexus_5X_API_23 -cache ~/.android/avd/Nexus_5X_API_23.avd/cache_persistent.img If you don’t use this option, the default is a temporary file named |
-cache-size size |
Sets the cache partition size in MBs. For example: emulator @Nexus_5X_API_23 -cache-size 1000 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. |
-data filepath |
Sets the user data partition image file. Provides 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 If you don’t use this option, the default is a file named |
-datadir dir |
Specifies 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 |
Uses 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 |
Gets help about about disk images. This option provides information relevant to both app and platform developers. For example: emulator -help-disk-images |
-help-char-devices |
emulator -help-char-devices |
-help-sdk-images |
Gets help about disk images relevant to app developers. This option gets information about where the image files are located for an AVD created with the SDK tools. For example: emulator -help-sdk-images |
-help-build-images |
Gets help about disk images relevant to platform developers. For example: emulator -help-build-images |
-initdata filepath-init-data filepath |
Specifies 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:
Read more: emulator @Nexus_5X_API_23 -initdata ~/Library/Android/sdk/system-images/android-23/ google_apis/x86/userdata-test.img If you don’t specify a path, it places the file in the system directory. For more information, see AVD system directory. |
-kernel filepath |
Uses a specific emulated kernel. If you don’t specify a path, the emulator looks in the system directory. Use the For example: emulator @Nexus_5X_API_23 -kernel ~/Library/Android/sdk/system-images/android-23/ google_apis/x86/kernel-test.img -show-kernel If you don’t specify this option, the default is |
-noaudio -no-audio |
Disables 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, use this option to overcome the issue. Alternatively, you can use the For example: emulator @Nexus_5X_API_23 -noaudio |
-nocache -no-cache |
Starts 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 |
Inhibits 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 |
Prevents the emulator from loading the AVD state from snapshot storage. Performs a full boot. For example: emulator @Nexus_5X_API_23 -no-snapshot-load |
-no-snapshot-save |
Prevents 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 |
Doesn’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. For example: emulator @Nexus_5X_API_23 -no-snapshot-update-time |
-no-snapstorage |
Starts 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 |
Disables graphical window display on the emulator. This option is useful when running the emulator on servers that have no display. You can access the emulator through emulator @Nexus_5X_API_23 -no-window |
-partition-size size |
Specifies the system data partition size in MBs. For example: emulator @Nexus_5X_API_23 -partition-size 1024 |
-prop name=value |
emulator @Nexus_5X_API_23 -prop qemu.name=value -prop qemu.abc=xyz |
-qemu args |
Passes 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 |
Displays emulator -qemu -h |
-ramdisk filepath |
Specifies a ramdisk boot image. Specifies the filename and an absolute path or a path relative to the working directory. For example: emulator @Nexus_5X_API_23 -ramdisk ~/Library/Android/sdk/system-images/android-23/ google_apis/x86/ramdisk-test.img If you don’t use this option, the default is the |
-report-console socket |
For more information, use the |
-shell |
For example: emulator @Nexus_5X_API_23 -shell |
-snapshot name |
Specifies 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 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. |
-snapshot-list |
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 |
Specifies a repository file that contains all state snapshots. All snapshots made during execution are saved in this file. Only snapshots in this file can be restored during the emulator run. For example: emulator @Nexus_5X_API_23 -snapstorage ~/.android/avd/Nexus_5X_API_23.avd/snapshots-test.img If you don’t specify this option, the default is |
-sysdir dir |
Specifies 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 |
Specifies an initial system file. Provides the filename and an absolute path or a path relative to the working directory. For example: emulator @Nexus_5X_API_23 -system ~/Library/Android/sdk/system-images/android-23/ google_apis/x86/system-test.img If you don’t use this option, the default is the |
-use-system-libs |
On Linux, uses 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:
Using this flag creates a temporary copy of the system image that can be very large, up to 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
Get help about command-line options
This section describes how to get help about the command-line options. It provides more in-depth information about the commonly used emulator command-line options that are available when you start the emulator.
List all emulator options
To print a list of all emulator options, including a short description, enter the following command:
emulator -help
Get detailed help for a specific option
To print help for a specific startup option, enter the following command:
emulator -help-option
For example:
emulator -help-netspeed
This help is more detailed than the description provided by the -help option.
Get detailed help for all options
To get detailed help for all emulator options, enter the following command:
emulator -help-all
List emulator environment variables
To get a list of emulator environment variables, enter the following command:
emulator -help-environment
You can set environment variables in the terminal window before launching a virtual device, or you can set it through your user settings in the operating system. For example, set it in your .bashrc file on Linux.
List debug tags
To print a list of tags for the -debug options, enter the following command:
emulator -help-debug-tags
The -debug options let you enable or disable debug messages from specific emulator components, as specified by the tags.
Source: https://linuxhint.com/setup-android-emulator-without-installing-android-studio-in-linux/