Speeding up your Android emulator
Pretty much any Android developer has the same complaint: the emulator is slow to start and slower to run, making app testing very annoying. In last Android Development Tools iterations Google implemented several ways to speed up the emulator to make it usable.
There are three ways to speed up the emulator:
- Using emulator snapshots for fast startup
- Using x86 hardware acceleration on Android images ver. 10 and 15+ (2.3.3 and 4.0.2+)
- Using GPU OpenGL acceleration for interface rendering on images ver 14+ (Android 4.x)
Sadly those methods are usable only on few emulator images (2.3.3 and 4.x+). Those are, however, the most widely used Android versions and are thus most widely used for development. Let’s look at each of those methods in-depth.
One of the most jarring annoyances with the emulator is the slow startup time, especially when using newer OS images. Even a machine with 16GB of RAM and a fast SSD can take several minutes to boot Android in the emulator.
Google has provided the solution for this problem in form of Snapshots - functionality very similar to VirtualBox snapshot functionality or desktop OS hibernation. After first boot the full emulator state is dumped to hard drive and on next startup the state gets read back to the memory without going through time-consuming Android startup procedure. This shortens boot time from several minutes to a couple of seconds.
To use snapshot functionality, you need to enable it in the AVD emulator settings when creating (or editing) a new emulator.
After enabling snapshot support in the emulator, you need to start it via the AVD manager by selecting the emulator, clicking Start and making sure the options Launch from snapshot and Save to snapshot are chosen. The emulator is then started with a click on Launch.
Each launch of the emulator (after first one, which will be slow) will now take only a second or two.
Android usually runs on ARM architecture, which is very different from x86 architecture of desktop PCs and the emulator has to translate all OS instructions from ARM to x86 for Android to run. You can avoid that by using an Intel x86 image of Android with Intel HAXM accelerator.
On Windows and OS X you need to first install Intel HAXM execution manager, which will speed up x86 emulator execution:
- Download HAXM installer with Android SDK manager by selecting Extras -> Intel Hardware Acceleration Execution Manager
- Install HAXM by running IntelHAXM.exe*(Windows)or IntelHAXM.dmg(OS X)from *extras/Intel/Hardware_Accelerated_Execution_Manager folder. You can find
extrasdirectory in your Android SDK directory.
Linux users have to Install KVM on Ubuntu instead.
After installing HAXM you have to download Intel x86 emulator images with Android SDK Manager:
- Android 4.1 (API 16) -> †Intel x86 Atom System Image
- Android 4.0.3 (API 15) -> Intel x86 Atom System Image
- Android 2.3.3 (API 10) -> Intel x86 Atom System Image
When image download is complete you just need to create an emulator using the image. The settings for 2.3.3 slightly differ from settings for 4.x emulator:
For 2.3.3: You need to choose
Intel Atom x86 System Image as a target when creating new emulator.
For 4.x: You need to choose
Android 4.0.3 API Level 15 or
Android 4.1 API Level 16 as a target and then select
Intel Atom (x86) CPU/ABI setting.
Note: You MUST select an Android image, not Google APIs image to get a choice of Intel Atom ABI.
If you’re using Windows or OS X you can now start the accelerated emulator.
Linux users have to make an extra step: because there’s no HAXM module for Linux, Linux users have to add
-qemu -m 512 -enable-kvm
to startup parameters of the emulator. This can be done in Eclipse when running your app (in
Run configuration dialog).
More documentation is available on Android Developer pages.
Android Emulator renders everything in software without help of GPU which is the main cause of terrible performance - especially when emulating tablets. This can be fixed by using OpenGL for all graphics in †the emulator on Android 4.0+.
GPU Acceleration is off by default and has to be enabled when creating an emulator by adding a
GPU Emulation setting set to
NOTE: Snapshots won’t work on emulators with GPU emulation enabled.
Using Intel image with GPU acceleration or Android 4.x+ should make the emulator fast enough to test your app even on 720p+ tablets.