I have got a 2.67 GHz Celeron processor, and 1.21 GB of RAM on a x86 Windows XP Professional machine.
My understanding is that the Android Emulator should start fairly quickly on such a machine, but for me, it doesn't. I have followed all the instructions in setting up the IDE, SDKs, JDKs and such and have had some success in starting the emulator quickly, but that is very rare. How can I, if possible, fix this problem?
Even if it starts and loads the home screen, it is very sluggish. I have tried the Eclipse IDE in version 3.5 (Galileo) and 3.4 (Ganymede).
This question is related to
android
performance
android-emulator
genymotion
qemu
If you have an Intel CPU, install Intel Hardware Accelerated Execution Manager.
Then assign it as the emulator's CPU in Emulator Settings. When I did it on my Core i7 CPU, it was taking about 10 minutes. Now it is opening in 15 seconds.
Well, since somebody suggested Android x86 as an alternative testing emulator, I'll also present my favorite. This might not be an alternative for everyone, but for me it's perfect!
Use the Bluestacks Player. It runs Android 2.3.4 and is very fluid and fast. Sometimes it is even faster than a normal device. The only downside is, that you can just test apps on the API Level 10 and just on one screen size, but it's perfect just for testing if it's working or not. Just connect the Player with the adb
by running
adb connect 127.0.0.1
After compiling, it installs instantly. It is very impressive, considering I have rather an average computer hardware (dual core with 4 GB of RAM).
You can create emulator.bat with following command to start the emulator. It will start faster.
emulator.exe -cpu-delay 0 -no-boot-anim @<avd name>
Or on Unix (Mac or Linux flavors):
emulator -cpu-delay 0 -no-boot-anim @<avd name>
You can download the genymotion emulator from here. This is fast and efficient.
The fastest emulators at the moment of writing this are the built-in x86 emulators which come with the Android SDK. You can find them in AVD manager where you create virtual machines. Simply pick any of them and then you pick the type of CPU (choose x86 for best performance). It will be as fast as your machine.
The latest such machine for Android 4.0 and 4.0.3 can be found in Giving your Android Emulator a Boost: Building Android ICS with Goldfish & x86 KVM support on EC2 - TestObject.
Note: This is only for a development purpose. To test for performance, you still have to either use a real device or test on the emulator with ARM CPU.
Try reducing screen size, and maybe you should consider using Ubuntu. I've had the same issue, and somehow my emulator on the same PC works five times faster when using Linux.
I would insist you to install BlueStacks now as it works the same as the emulator with many other functionalities in that (for example, it gives access to Android Market). Also you can run applications directly from Eclipse to BlueStack Device/Emulator with a great performance speed. It just takes a fraction of second to run your application from Eclipse to the BlueStack emulator.
IMPORTANT NOTE: Please first refer to the Intel list about VT to make sure your CPU supports Intel VT.
HAXM stands for - "Intel Hardware Accelerated Execution Manager"
Currently, it supports only Intel® VT (Intel Virtualization Technology).
The Android emulator is based on QEMU. The interface between QEMU and the HAXM driver on the host system is designed to be vendor-agnostic.
Update Eclipse: Make sure your Eclipse installation and the ADT plug-in are fully up-to-date.
Update your Android Tools: After each Eclipse plug-in update, it is important to update your Android SDK Tools. To do this, launch the Android SDK Manager and update all the Android SDK components. To take advantage of HAXM, you must be on at least release version 17.
Install the HAXM Driver by running "IntelHaxm.exe". It will be located in one of the following locations:
C:\Program
Files\Android\android-sdk\extras\intel\Hardware_Accelerated_Execution_Manager
C:\Users\<user>\adt-bundle-windows-x86_64\sdk\extras\intel\Hardware_Accelerated_Execution_Manager
If the installer fails with the message that Intel VT must be turned on, you need to enable this in the BIOS. See the description for how to do this in Enabling Intel VT (Virtualization Technology) .
First, install the Intel x86 Emulator Accelerator (HAXM). This can be downloaded directly from Intel or using Android SDK Manager. In the SDK Manager, it's located under Extras.
In the version of Android Studio I used (0.8.9), Android SDK Manager downloads HAXM but doesn't actually run the installer (I assume this will be fixed in later releases). To run the installer I had to go to C:\Program Files (x86)\Android\android-studio\sdk\extras\intel\Hardware_Accelerated_Execution_Manager and manually launch intelhaxm.exe.
HAXM works with Intel devices, so created a new Emulator with Intel CPU.
This improved things considerably, but the emulator was still feeling a bit sluggish. The final step was selecting Use Host GPU in Android Virtual Device Manager (AVD).
After these changes, Android Emulator was launching in 5-10 seconds and running without any noticeable lag. Be aware that these features are hardware dependent (CPU/GPU) and may not work on some systems.
Try Genymotion for Android Studio. Blazing fast! Just needs one time installation. No more AVD pain.
I have noticed that an emulator gets slow over a period of time. So, one can delete the emulator which gets very slow and create a new one with the help of the AVD manager. I have tried it a couple of times and it works well.
You may try Genymotion instead of android emulator. It is faster and better than the android emulator.
Try scaling down the emulator, it makes it a bit faster, even if it doesn't it really feels faster.
Firstly, you need to upgrade your RAM to atleast 8GB.
If you cannot upgrade your RAM, then try running the application on your Android Phone by connecting it via Data Cable and USB Debugging set as ON.
Also, you may use some other emulators like GenyMotion or Nox.
However, with the amount of RAM that you seem to be having, even other emulators may tend to be slow.
Android ADT 18 now includes a (beta) GPU enabled option (simply enable the GPU acceleration from your AVD properties). It makes a huge difference and even ICS feels relatively comfortable now.
HAXM is a way to make emulators fast for intel processors HAXM is the kernel driver part, and the user-space emulator part is based on QEMU - which means there is a branch of QEMU which uses HAXM (This QEMU branch is very android-emulator-specific (and also seems to be based on older version of QEMU).
But still when i used with my intel core i3 processor with 4 GigaBytes RAM it doesn't effect more to speed. So this wasn't a solution for me.
As i am using 4GB RAM cpu Emulator becomes RAM eater but for making it more convenient there are some ways I prefer Android*86 support based emulator. And as android studio now introduce Instant-Run So After first launch app installation became faster, but i always faced problem and seems like no-way to get out of this.
I also used Droid4x and it goes preety convenient to me but i can't found a way to install different api versions ,I used it with kitkat and it was faster then android emulator and it is also VT support enabled, So i found another way and a good solution that is Visual Studio Emulator You can read more about it here , The latest i used is LeapDroid its really a powerful See the comparisons here
I prefer to use Real device then emulators on 4GB ram PCs.
UPDATE: The latest version of Android studio (2.x) made major improvements to the bundled emulator. It's responsive and has a whole bunch of features.
For those still interested: Try using Genymotion. You can download a version for Windows/Mac OS X/Linux after registering. A plugin for Eclipse is also available:
The installation of the plugin can be done by launching Eclipse and going to "Help / Install New Software" menu, then just add a new Update Site with the following URL: http://plugins.genymotion.com/eclipse. Follow the steps indicated by Eclipse.
This emulator is fast and responsive.
GenyMotion allows you to control various sensors of your device including the battery level, signal strength, and GPS. The latest version now also contains camera tools.
Good way to speed up Android Emulator and app testing is Install or Upgrade your Android Studio to Android Studio 2.0 version and then go to app open Settings/Preferences, the go to Build, Execution, Deployment ? Instant Run. Click on Enable Instant Run. And After That This will ensure you have the correct gradle plugin for your project to work with Instant Run.
And Instant run will look like this
However Android Studio is right now in Preview you can try it now.
I just started yesterday on Windows 7 and was facing the same problem. The easiest solution, I found and is working for me is to use the low config device in the emulator. I used Nexus One instead of Nexus 7 and select the snapshot for the device in Android Virtual Device.
And, also important is to leave open the emulator. It works both in Eclipse and Android Studio.
In a window, it says snapshot does not generally work when RAM is more than ~700. So, selecting a lower configured one easily help to test Hello World and then for developing your application. Later, we can test on a high-end device.
For me, virtualization support does not work as my hardware does not support it.
I wonder why nobody has mentioned the Visual Studio Emulator
as an alternative. It's way faster than the native Android Studio Emulator.
Here's a link to performance comparison: https://medium.com/android-news/how-visual-studio-emulator-for-android-can-improve-your-android-development-9e17a6213839#.hlh7ba6ut
What's even better is that the apk files and even gapps (or any other flashable zip) can be installed just by drag and drop. However, the downside is that it requires Hyper-V which is only available on Windows (that too, from Windows 8 onwards). Other limitations (along with the description of the above) and other details can be found here: https://blogs.msdn.microsoft.com/visualstudioalm/2014/11/12/introducing-visual-studios-emulator-for-android/
Simple easy solution for beginners. I have tried many ways and stopped with Genymotion in combination with Eclipse. Genymotion simply adds a virtual device to Eclipse.
Step by step:
In my case, this solution is the one and only fast solution. No emulators in Eclipse have never worked so fast, and every setting was very slow. Only this solution works almost in realtime. I can recommend (notebook i3, 2.6 GHz).
Try using the Intel X86 Atom Storage Image for a relatively faster boot up than using ARM based images when emulating the device.
Another thing to be taken into the notice is that according to your system configuration, running an Android emulator with 1.21 GB RAM can be a sluggish experience, because the emulator requires up to some certain percentage of RAM which is used for emulating the device, not forgetting about the RAM used by the ADT.
Try a system image of 2.1 - 2.3.3 for at least a runnable experience. Plus not forgetting about Save to Snapshot for quicker loading. Though the first load may take time. But saving to a snapshot definitely saves up some time.
Short answer: because of the ARM -> x86 instruction translations. The Emulator works in a similar fashion to a virtual machine that is tasked with booting a full fledged OS and running your test application afterwards. The ARM -> x86 translations can be very time consuming, less for your app, but more for when the OS is booting (it's proportional to complexity and number of instructions involved).
Some suggested running the code on x86 emulators. What this means is instead of loading an ARM based OS, you load an x86 variant that will run faster on your x86 machine, as no ARM->x86 translation are necessary. Still, this is not a perfect solution:
Android applications that use NDK and come packed with native libs (*.so) compiled for ARM, will not work on x86 emulators, so such programs will fail to run. But if you get to that point and get to deal with NDK/native JNI code, you probably know enough about emulators already.
Now instead of using emulator we can test Android apps using ARC Welder app on Chrome, App Runtime for Chrome
I tried booting the emulator from Eclipse (Indigo and Android 1.5, no Snapshot) and after 45 minutes I stopped it, because nothing had happened.
Statistics: Phenom Quad @2.6 MHz with 4 GB DDR2 Corsair Dominator @800 MHz. The AVD is on an SSD drive and the emulator on a 7200 RPM HDD.
I started the emulator manually with the -no-boot-anim
option and it loaded in 30 seconds. :)
In CMD, navigate to folder where the emulator.exe
file is and type
emulator.exe @<YourAVDFromEclipse> -no-boot-anim
The emulator.exe
file is located in the Android SDK folder under Tools.
In Windows, you can find the the Android Virtual Device(AVD) under C:\Users\<NAME>\.android\avd
.
The projects run from inside Eclipse, targeting the AVD you booted, show up just nicely :D
Enabling snapshot may not make it faster in the first run; do not go for big SD size. Adjust the SD card size to 100 MB in the first run.
As of Revision 17 of Android SDK Tools, the emulator can use graphic acceleration and CPU-provided extensions for better efficiency. The prerequisites and full configuration and user notes are at:
http://developer.android.com/guide/developing/devices/emulator.html#acceleration
For enabling GPU aceleration, run the emulator from the command line or add "-gpu on" to the additional emulator command line options in the AVD configuration.
emulator -avd <avd_name> -gpu on
For using the CPU machine extensions, you have to install the driver (caution because it can conflict with existing VirtualBox or VMware drivers). Once it's installed it will be used automatically whenever you use an x86-based AVD.
The option -cpu-delay <delay>
described in Emulator Startup Options can help.
I've noticed that the emulator starts much faster if there's no Dalvik Debug Monitor Server (DDMS) connected. So if you start the emulator from Virtual Device Manager "SDK Setup.exe" and Eclipse is not started, the emulator works faster.
If you start the emulator from Eclipse: DDMS is there, so sometimes the emulator is extremely slow, but sometimes it's faster.
Try Android x86. It's much faster than the Google Android emulator. Follow these steps:
netcfg
, remember the IP address, press Alt+F7.adb connect <virtual_machine_IP>
.The startup of the emulator is very slow. The good thing is that you only need to start the emulator once. If the emulator is already running and you run your app again, the emulator reinstalls the app relatively quickly. Of course, if you want to know how fast it will run on a phone, it is best to test it on a real phone.
If you can, switch to using Ubuntu for Android development. I switched to Ubuntu 14.04 LTS for Android development, and I am glad that I took the jump. All of the steps mentioned made little or no difference in the lag on Windows. Linux is the correct answer to all the problems you are facing
You need more memory.
Here's why I say that:
I'm using VirtualBox on Windows to run Ubuntu 10.10 as a guest. I installed Eclipse and the Android SDK on the VM. My physical box has 4 GB of memory, but when I first configured the Ubuntu virtual machine, I only gave it 1 GB. The emulator took about 15 minutes to launch. Then, I changed my configuration to give the VM 2 GB and the emulator was running in less than a minute.
In AVD Manager
select the VD and click edit, set the resolution to little as you are able to read the text on VD.
I use 800x600 pixels, RAM set to 512 MB, and it works like a charm without high use of CPU time.
Emulators are slow. There's really nothing you can do about it, but there are alternatives to the emulator.
To make your emulator faster, you can host a GPU and use a lighter Android version (Android 2.3 (Gingerbread)). Developing on a Mac would be better. Why use an emulator, BTW? Using a real phone makes more sense.
Remove unwanted activation of some of the plugins at start-up by going to windows-->preference-->General-->Startup and shutdown. Also make sure you don't use those plugins in any of your views
Eclipse is not a word processor. Better to disable the spell check. Disabling spell check will reduce the eclipse burden by going to Windows-->Preference-->General-->Editors --> Text Editors-->Spelling
When eclipse builds the project, it will delete all output folders and rebuild classes built by other compilers. We can disable such features, as deleting the output folders and rebuilding will take sometime. Goto Windows-->Preference-->Java-->Compiler-->Building
Disabling label decorations which is of less use for you, will also help you to gain some performance . Goto Windows-->Preference-->General-->Appearance-->Label Decorations
Close unwanted projects and use working set option to move from one group of project to another smoothly.
You could also disable Eclipse automatic building, if it is not needed for you. Goto Project-->Build Automatically (uncheck it)
Do not keep lot of tabs opened in the editor. Better to have around 20 tabs . Regularly close the unused tabs. To open resource we can always use ctrl+shift+R and ctrl+shift+T (java resource) instead of opening lot of tabs
Disable unwanted plugins. Full J2EE eclipse version has an option to disable/uninstall plugins. Goto Help-->Software Updates-->Manage Configuration. Right click on any installed plugin to get disable option. If this option is not available then enable Classic Update by going to Windows-->Preference-->Capabilty and check classic update. Now the manage configuration option should be available in help menu
Android emulator release 9 has a new "snapshot" feature. You can save the state of the emulator (make an image of the emulator) and avoid booting when you start the emulator.
The current (May 2011) version of the emulator is slow particularly with Android 3.0 (Honeycomb) primarily because the emulator does not support hardware GL -- this means that the GL code gets translated into software (ARM software, in fact) which then gets emulated in software in QEMU. This is crazy-slow. They're working on this problem and have it partially solved, but not with any sort of release quality.
Check out the video Google I/O 2011: Android Development Tools to see it in action -- jump to about 44 minutes.
You can try our new Android virtual machine, Leapdroid, which is fully compatible with the original Android emulator. Since it uses virtualization technology, instead of emulation, it provides pretty much native speed. In addition, we use a new OpenGL technology called LeapGL, which performs OpenGL graphics in native speed. Our vm has the best performance compared to others.
Source code: https://github.com/leapdroid
Leapdroid is fully compatible with Eclipse and Android Studio, as it uses the same adb ports.
A new option is the Visual Studio Emulator for Android--it's fast, Hyper-V, x86, and free to download even without VS.
Update your current Android Studio to Android Studio 2.0 And also update system images.
Android Studio 2.0 emulator runs ~3x faster than Android’s previous emulator, and with ADB enhancements you can now push apps and data 10x faster to the emulator than to a physical device. Like a physical device, the official Android emulator also includes Google Play Services built-in, so you can test out more API functionality. Finally, the new emulator has rich new features to manage calls, battery, network, GPS, and more.
A few things that definitely sped things up for me with this were
1. delegating the rendering process to the GPU by checking "Use Host GPU" checkbox in AVD's edit window.
2. downloading the Intel Atom (x86) image or if you are a windows/mac user downloading the Intel x86 Emulator Accelerator HAXM
Unfortunately the thing with Intel x86 images is that you don't get Google Apps, they only come with ARM images.
which is where Genymotion comes in handy
I just took the default Android 3.1, and it was very slow, but since I realised my code was Android 2.3.3 compatible I switched to that. It's about 50% quicker and also the emulator looks more like my phone, and has a keyboard permanently displayed so that it is easier to use.
I had intermittent slow emulator (SDK v8.0) load times, up to three minutes on Intel Core i7 920 2.67 GHz CPU running on Xubuntu 10.04 VirtualBox 3.2.12 guest with Eclipse (3.6.1) loaded. I changed the VirtualBox guest memory from 1024 MB to 2048 MB and from that point on, I never experienced the slowness again (load times consistent at 33 seconds, CPU load consistent at 20%). Both Eclipse and the emulator are memory hogs.
You can review the emulator issues on the Google I/O 2011: Android Development Tools talk, starting a 0:40:20.
The emulator runs slowly because the complete Android environment is running on emulated hardware and the instructions are executed on an emulated ARM processor as well.
The main choking point is rendering since it's not running on any dedicated hardware but it's actually being performed through software rendering. Lowering the screen size will drastically improve emulator performance. Getting more/faster memory isn't going to help.
They've mentioned, at the time, that they're developing an interface that would allow the emulator to pipe certain instructions through the host hardware, so eventually, you'll be able to leverage emulator performances with the raw power of desktop hardware.
Using the ADB utility I've discovered some more information that is important.
The emulator is actually running, but it seems like the graphical interface may be the problem.
When the Android splash screen is up and you are waiting forever it looks like the following:
The emulator is actually running because you can run the following command-line tool and see the listed processes:
adb -s emulator-5554 shell ps
That will provide you with a list of processes which are running on the device, which seems stuck.
I piped the output to a file and here is a list of all the running processes:
USER PID PPID VSIZE RSS WCHAN PC NAME
root 1 0 696 500 c02ae25a 0805a406 S /init
root 2 0 0 0 c02315a2 00000000 S kthreadd
root 3 2 0 0 c021f9dc 00000000 S ksoftirqd/0
root 5 2 0 0 c022e8d7 00000000 S kworker/u:0
root 6 2 0 0 c022e085 00000000 S khelper
root 7 2 0 0 c022e8d7 00000000 S kworker/u:1
root 255 2 0 0 c02886de 00000000 S sync_supers
root 257 2 0 0 c028935e 00000000 S bdi-default
root 259 2 0 0 c022e085 00000000 S kblockd
root 267 2 0 0 c022e085 00000000 S ata_sff
root 278 2 0 0 c04f610f 00000000 S khubd
root 283 2 0 0 c022e085 00000000 S md
root 297 2 0 0 c022e085 00000000 S cfg80211
root 298 2 0 0 c022e8d7 00000000 S kworker/0:1
root 413 2 0 0 c0283057 00000000 S kswapd0
root 481 2 0 0 c02cd713 00000000 S fsnotify_mark
root 501 2 0 0 c022e085 00000000 S crypto
root 590 2 0 0 c022e085 00000000 S iscsi_eh
root 611 2 0 0 c048aa21 00000000 S mtdblock0
root 619 2 0 0 c048aa21 00000000 S mtdblock1
root 627 2 0 0 c048aa21 00000000 S mtdblock2
root 666 2 0 0 c022e8d7 00000000 S kworker/0:2
root 700 2 0 0 c022e085 00000000 S binder
root 724 2 0 0 c022e085 00000000 S deferwq
root 725 1 624 348 c02ae25a 0805a406 S /sbin/ueventd
root 932 2 0 0 c055236e 00000000 S mmcqd/0
root 939 2 0 0 c0340f30 00000000 S yaffs-bg-1
root 941 2 0 0 c0340f30 00000000 S yaffs-bg-1
root 942 2 0 0 c0340f30 00000000 S yaffs-bg-1
system 943 1 1340 400 c056a35d b76a1eb6 S /system/bin/servicemanager
root 944 1 5540 924 ffffffff b7646c11 S /system/bin/vold
root 947 1 1548 504 c05785ce b766c163 S /system/bin/debuggerd
radio 948 1 6420 1016 ffffffff b76d3c11 S /system/bin/rild
system 949 1 20088 2876 ffffffff b7655eb6 S /system/bin/surfaceflinger
drm 951 1 10480 2920 ffffffff b7585eb6 S /system/bin/drmserver
keystore 954 1 5036 1416 c056a35d b765deb6 S /system/bin/keystore
root 955 1 1324 440 c02d0083 b76b28ab S /system/bin/qemud
shell 958 1 1428 668 c03e9ad9 b767fa76 S /system/bin/sh
root 959 1 4680 304 ffffffff 08063530 S /sbin/adbd
graphics 1012 1 17980 4276 ffffffff b7652eb6 S /system/bin/bootanimation
media 4743 1 25288 6232 ffffffff b75beeb6 S /system/bin/mediaserver
root 4744 1 3944 1164 00000000 b7628976 R /system/bin/netd
root 4770 4744 0 0 c021de78 00000000 Z iptables
root 4771 959 1768 540 00000000 b766fa76 R ps
For fun I then ran the following command and killed the "Android" animation:
adb -s emulator-5554 shell kill 1012
The splash screen became blank so something is really happening.
I tried and succeeded at killing some other processes and that made me feel good but the emulator still didn't ever seem to start. Oh well. I'm running a QuadCore i7 with 8Gb of ram. Also running the haxm with the settings described in other posts in this question.
Note: I'm updating this on 09/19/2014 - I learned that this odd behavior where the emulator would attempt to start the instance but never would was all related to the file rights on the emulator files. They were set to read-only because of the way they were copied, so the emulator attempts to install and write to its "virtual disk" but it's "virtual disk" is really a file or set of files which my OS has set to read-only and so it fails. These failures cause the emulator to never start. I set the files to full access and the emulator starts up in record time.
I had the same problem, but I fixed it by deleting the .android
folder from C:\Users\User\
.
Now everytime I start Eclipse or AVD, I delete that folder. After that my AVD boots up in 20 to 30 seconds and the emulator works smoothly with a negligible lag.
OPTIONAL : If the problem still persists, try to clone the NEXUS S AVD.
Try to reduce the screen size of the emulator while creating a new Android virtual device.
I have seen that this will launch the emulator very fast compared to the default options provided in AVD manager.
This is what has worked for me:
For fast testing (<1 second) use buildroid with VirtualBox's first network card set to “host only network” and then run
C:\Program Files (x86)\Android\android-sdk\platform-tools>adb connect *.*.*.*:5555
connected to *.*.*.*:5555
(^) DOS / bash (v)
# adb connect *.*.*.*:5555
connected to *.*.*.*:5555
where *. *. * .* is the buildroid IP address you get by clicking the buildroid app in buildroid main screen.
Android emulator is dead slow. It takes 800MB memory while running. If you are on Windows, You can use Microsoft Android Emulator. It is superb, provides you functionalities more than Android Studio Emulator. And most important it is fast ( consumes 13MB only). It comes with Visual Studio 2015 Technical Preview. I am using it and happy with it. I downloaded and installed entire VS pack, I need to look how we can install VS Emulator only.
Visual Studio Emulator for Android
EDIT: Try https://www.visualstudio.com/vs/msft-android-emulator/
To reduce your emulator start-up time you need to check the "Disable Boot Animation" before starting the emulator. Refer to the Android documentation.
If in case you don't know, you do not need to close the emulator every-time you run/debug your app. If you click run/debug when it's already open, your APK file will get uploaded to the emulator and start pretty much immediately. Emulator takes annoyingly long time only when it started the first time.
Here are some tips to speed up the Android emulator: How to speed up the Android Emulator by up to 400%.
The emulator included in your (old) version of Eclipse is very slow.
Recent emulators are faster than they use to be in 2010. Update your SDK/IDE.
Personally, I use a real phone to do my tests. It is faster and tests are more realistic. But if you want to test your application on a lot of different Android versions and don't want to buy several phones, you will have to use the emulator from time to time.
I've similar issues on a Mac. What I did;
Those had some effect in lowering CPU use (not it is around 40-60%), not ultimate solution. But again, the CPU use is NOT >100% anymore!
For a better experience, I would recommend the shop.genymotion.com licensed genymotion. If you want to test it out, first you can get genymotion here
Android studio 2.02 has been launched, it has faster emulators, if you want to go with third party, use Genymotion emulators, they are pretty fast
Now on ADT 21, it provides more options for a fast emulator... You should use 512 MB RAM, lower CPU Time, Device Selection and VM Heap Size high. For better results, you should use Intel Atom in CPU/ABI... Using Snapshot and CPU Host may not increase your speed of the emulator, but there are useful ones for other purposes.
Add some more RAM and use SSD drive. Android Studio is best run on 8 to 12 GB of RAM using SSD drives based on my experience.
To add further information to this.
I have recently upgraded my Ubuntu installation to Ubuntu 10.04 LTS (Lucid Lynx) which in turn updated my Java version to:
Java version "1.6.0_20"
Java(TM) SE Runtime Environment (build 1.6.0_20-b02)
Java HotSpot(TM) 64-Bit Server VM (build 16.3-b01, mixed mode)
And now the emulator (although takes a while to start) seems to be running faster than previously.
It might be worth people upgrading their JVM.
Update
You can now enable the Quick Boot option for Android Emulator. That will save emulator state, and it will start the emulator quickly on the next boot.
Click on Emulator edit button, then click Show Advanced Setting. Then enable Quick Boot
like below screenshot.
Android Development Tools (ADT) 9.0.0 (or later) has a feature that allows you to save state of the AVD (emulator), and you can start your emulator instantly. You have to enable this feature while creating a new AVD or you can just create it later by editing the AVD.
Also I have increased the Device RAM Size
to 1024
which results in a very fast emulator.
Refer to the given below screenshots for more information.
Creating a new AVD with the save snapshot feature.
Launching the emulator from the snapshot.
And for speeding up your emulator you can refer to Speed up your Android Emulator!:
Using ssd hard drive has too much impact and I recommend to use more suitable ram (8 or higher)
Intel released recommended installation instructions for the ICS emulator on May 15, 2012. This worked for me. The emulator is now fast and the UI is smooth.
The first half of the instructions are detailed enough, so I will assume you were able to install the Intel x86 Atom System Image(s) using the Android SDK manager, as well as Intel HAXM.
Now to ensure that everything else is set up so you can enjoy a highly performing emulator:
And start it:
sudo kextload -b com.intel.kext.intelhaxm (mac)
If HAXM is working properly, you may see this message when launching the emulator:
HAX is working and emulator runs in fast virtual mode
Otherwise, you may see this error:
HAX is not working and the emulator runs in emulation mode emulator:
Failed to open the hax module
Use GPU emulation. You cannot use the Snapshot option when using GPU emulation as of this writing. Ensure that GPU emulation is set to "yes".
Set the device memory to 1024 MB or more, but not more than the Intel HAXM setting. I use 1024 MB per device and 2048 for HAXM.
Always double-check the settings after saving! The emulator is very picky about what it allows you to set, and it will revert configurations without telling you.
With these settings the software keyboard no longer appears, nor do the on-screen back, menu, and recent keys. This appears to be a limitation of the current ICS Intel x86 system image. You will need to use the keyboard shortcuts.
On Mac OS you will need to hold fn + control for the F1 - F12 keys to work. Page up/down/left/right can be performed using control + arrow keys.
The emulator seems to slow itself down when idle. This is made apparent by rapidly mousing over the keys on the side and observing the light-up responses. As a workaround, I pass -icount auto
to QEMU when starting the emulator. You can make a batch file called my_avd.bat
to do it for you:
emulator @my_avd -no-boot-anim -qemu -icount auto
@my_avd
-- launch a virtual device named 'my_avd'-no-boot-anim
-- disable animation for faster boot-qemu args...
-- pass arguments to qemu-icount [N|auto]
-- enable virtual instruction counter with 2^N clock ticks per instructionThis made animations buttery smooth and sped up adb install
tenfold.
I would suggest playing around with the OpenGL settings. I have a dual-core (quad-thread) i3-2350M running on it's internal GPU, and I get terrible performance if I use SwiftShaders, but changing it to "Desktop Native OpenGL" (Extended Controls > Settings > OpenGL ES Renderer
) makes it run smoothly.
If the device doesn't boot, play around with the OpenGL ES API Level
setting and the GPU emulation setting in the device config.
I don't know why, but on my 2011 Intel processor, it makes a world of difference.
The use of Android x86 provides better productivity than the Android emulator.
Whereas working with Android x86 4.2, it provides extremely fast debugging compared to Android emulator. It's many many times faster for configuration
It is working with the latest Android X86 4.2 (Jelly Bean) and VirtualBox.
I have found different ways to connect with the Internet and ADB.
The easiest solution is just use a NAT adapter that will directly connect you to the Internet if the host is connected to the Internet, but you won't get the ADB connection with this setup.
Here you will get a public IP address, so you can't connect to the host computer.
The easiest solution is just use the host-only adapter.
Note: The default host-only adapter may not work due to DHCP server settings. Either create a new HostOnlyAdapter
or run DHCP server
for existing an adapter.
You will have to take care in this case.
If you are using LAN for the Internet connection you shall use the bridge adapter with your Ethernet card. It will give you a local IP address and the virtual machine will connect to the Internet using the host machine.
Alternatively if you are with Wi-Fi, just do the same by selecting the Wi-Fi adapter.
For other types of connection, you shall go with the same way.
To check the IP address, just press Alt+F1 (for a console Window). (To switch back to the graphics view, press Alt+F7.)
You will see the console window. Type netcfg.
It will show the IP address.
Now move on to your host, run the command prompt, and move to the adb
directory.
type adb connect <your IP address>
adb connect 192.168.1.51
adb kill-server
adb start-server
You can check devices connected to ADB:
adb devices
For the original question, click here.
I suggest you to use the Android phone for developing by USB Debugging. It gives better experience in testing the apps and a better output compared to virtual devices. Or you can also use the options mentioned in rest of the answers and can go with Bluestacks App Player, it is also a good option in case of non-availability of Android Device.
Gone were those days, when we used to run projects on slow Android Emulators. Today, Android Emulators are on steroids.. Yeah you heard me. No other emulators are as fast as Android Emulators. You can go to my blog for more details:
http://androidveteran.blogspot.in/2016/01/android-emulator-multi-touch.html
I have explained in details about new Android Emulators. Check it out.
Believe me they are as fast as your real device works.
My solution is Vysor . I get both of the best worlds. I don't put too much charge on my machine, but I can also see my real Android device on the screen so I don't have to reach for it, take my hands off the keyboard etc. Furthermore there are always some feature that don't work best on an emulator.
There is free version with ads and a payed one which compared to other solutions, won't break the bank.
Here's what I noticed nobody mentioned it at all.
Assign all available processors to the emulator
Here's what you can try. It does speed up the emulator for me, especially during loading time. I noticed the emulator is only using a single core of the available CPU. I set it to use all available processors.
I'm using Windows 7.
When the Android emulator is starting, open up the Task Manager, look under the Process tab, look for "emulator-arm.exe" or "emulator-arm.exe *32"... Right click on it, select Processor Affinity and assign as much processor as you like to the emulator.
On a 3.4 GHz quad core 6 GB of RAM, Windows 7, the emulator was unusably slow!
I downloaded Launcher-Pro.apk
through the emulator, installed it and set it as the default launcher. It doubled my emulation speed! The screens load much smoother and faster. It doesn't seem to download in 2.1 or 2.2, only in 2.0.
Android Studio performance is greatly optimized in Linux. Windows system might be running different heavy programs in background. Linux is best suited to use available system resources efficiently. Recently I have install android studio in Kali Linux. The speed of emulator and studio performance is way better than windows.
And the software development tools gets downloaded faster from android SDK. As the packages are bundled in binary files. The size of binary files are low.
Android SDK rev. 17 supports Virtual Machine Acceleration using AMD and Intel virtualization technologies.
This feature can improve the emulator performance a lot!
See the following section in the Android emulator documentation for more details: Configuring Virtual Machine Acceleration
Don't forget to install the appropriate driver for your operating system:
After you have installed the drivers and downloaded an Android X86 system image (as described in the documentation) you should be able to create a new AVD using the x86 image:
For example:
I just noticed something I can't explain, but hey, for me it works!
I was compiling Android from sources anyway and the built-in emulator started in a few seconds (my machine is dual core AMD 2.7 GHz) and in a minute, perhaps two at the first run, the system was up. Using Eclipse ADT bundle, on the other hand, resulted in half an hour of emulator startup. Unacceptable.
The solution that works here (I have no means to test it on other machines, so if you feel inclined, test and verify):
<source base dir>/out/host/linux-x86
Also, I agree with running from snapshot and saving state to snapshot. My advice concerns only emulator startup time. I still have no idea why it is so long by default. Anyway, if that works for you, enjoy :)
Try to disable your antivirus. Maybe it will make emulator a little bit faster.
Yes, you are right since native android emulator is very slow than the other custom emulators like genymotion. I figured out that while I was running functional calabash android test.
On the native android emulator, this issue is produced when "timeout exception" occurs, so I moved to genymotion emulator who resolved the problem.
P.S: genymotion emulator is not free anymore.
The older Android versions run a lot faster. When I'm on my netbook, I use Android 1.5 (API level 3). There are a couple of drawbacks, though--your apps need to support the older platforms (obviously), and ndk-gdb requires running Android 2.2 (API level 8) or higher. But regularly testing apps against older platforms is a good idea anyway.
After developing for a while, my emulator became brutally slow. I chose wipe user data, and it was much much better. I am guessing that it takes time to load up each APK file you've deployed.
Source: Stackoverflow.com