There're several emulator binary variations residing in the Android SDK's /tools folder but I don't find any documentation on their differences (e.g. when to which one).
Android SDK version is 24.4.1, on CentOS.
Normally, you don't need to care about this, a default emulator will be chosen for you (first binary). Each binary represents one of the supported architectures. The last five are the 32-bit emulators.
Android emulator is based on QEMU
When the Android SDK was first made available to the world, Google
used QEMU as the basis for their Android emulator. They copied the
source code to a custom repository in the Android Open Source Project
(AOSP) and made a number of invasive modifications to QEMU.
Specifically, they added emulation of a specific board called goldfish
for the purposes of emulating an Android phone.
Every build of Android targets a specific hardware platform, and the
emulated goldfish platform is no different. A number of specific
emulator features are enabled in both the Android kernel and Android
userspace environment when run in an emulated environment. These
features allow a smooth and complete user experience resembling using
a real Android device, on laptop and desktop workstations.
The Android emulator provides Android application developers with a
convenient development environment and allows developers to develop
and test applications on devices which they do not have physical
access to. With the introduction of the ARMv8-A architecture and
Android support for 64-bit ARM platforms, this need is more important
than ever because it allows developers to begin adapting their
applications to an ARM 64-bit based mobile ecosystem prior to hardware
being available.
You can use the default emulator like here (or add QEMU options, but I never needed it, read this).
You also can force a 32-bit emulator:
Related
Cannot get Sublime Text 3 installed on a android tablet.
Cannot find adequate instructions.
Need good Sublime install on my android tablet.
Sublime can only be installed on Windows, MacOS or Linux, and further requires that the processor on the machine be x86 x86_64 or compatible (for example AMD chips would also work). Most notably that means that anything like a Raspberry PI, Arduino, or an Android device which runs on a different architecture (for example ARM, which is quite common in such scenarios) is not compatible.
In addition to that even if such a device was x86 compatible it still requires the ability to install native Linux Desktop applications and have the appropriate libraries (e.g. GTK3) for Sublime to work; basically it has to support the notion of a full fledged desktop application.
An example of that would be on a ChromeBook running ChromeOS; on such devices if the architecture is Intel compatible and the ChromeBOok has a Linux container installed, Sublime will work there.
I need to do a lot of android testing where the device I use has to be ARM based. While it is possible to create these devices in the default android emulator they are of course very slow on my x86 development machine.
A lot of this testing runs headless and automatically so I thought about setting up an ARM server and emulate the devices there in the hope that the performance would be better. While looking around I realized that there is nearly no information about this. Is it possible to run an android emulator (ether the one provided with the SDK or any other) on a ARM machine to get higher performance for the virtual devices?
This is actually a very good question.
Some cloud services like Amazon are providing the arm based machines. With those machines, we can run android emulators in cheap price.
Google doesn't provide the android emulator binary for arm.
But you can build those emulator binaries from AOSP. You have to do some work such as editing of cross-compile build files, adding target directories and building related third party libraries in arm architecture.
If you need any further information, I would attach detailed technical tips or step-by-step manuals.
I am experimenting with Android Binders at middleware level using C++ so I need an emulator to test it as I cannot afford a board everywhere. My ultimate target is to port a linux middleware application on android and I also want to test that app.
Is the android emulator that comes with SDK suitable for it (which I don't think). If no, is there any emulator for android middleware development or how can I test on my PC instead of running binaries on an ARM board?
As long as you do not rely on/do not want to change the HALs of specific hardware you should be perfectly able to use the emulator.
Depending on what kind of middleware you want to test you could either use the emulator coming with the sdk, create an avd and install your app/library there or you could modify the android source code (when your middleware should be part of thd system) and start the aosp provided emulator directly with thd built ROM.
Don't know if this answers the question as I didn't fully understand what you want to say with 'middleware'
This question has many parts.
Some info about my system:
64-bit Ubuntu Linux
I am wondering what the stock emulator is that comes with Android Studio (A.Studio) (if indeed it has a name).
A helpful answer would include comparing this emulator with other emulators. A list of pros and cons of using each different emulator would also be helpful.
Perhaps there is a more fundamental ~thing~ about using different emulators; information on that is welcome if anything comes to mind.
Finally, i have never used an emulator besides the one that has come with Eclipse or A.Studio. What do I need to know in order to plug any emulator into any IDE? I have had issues with IDEs being "fragile" and breaking frequently, FYI.
You can use genymotion, for fast speed the quality, both for the eclipse and Android studio, get it here.
Also you can set up the Google play service for using Google Maps and downloading apps from Google play store.
Get the package and how it use it , please refer to here.
The emulator used by Android Studio is the exact same one used with Eclipse. It is in fact included with the Android SDK (which is in turn included in Android Studio) and used by various development environments.
The way it works depends on what kind of system image you use it with. For most recent Android versions, there are 2-4 different system images - arm, arm 64-bit, x86, and x86 64-bit (the 64-bit ones are Lollipop only, and fairly experimental at this stage of the game [early 2015]).
There are also Google API versions of these images (they include various Google apps such as Google Play Services) which can be used if these components are needed by your app.
For development purposes, the x86 system images are your best bet as performance is vastly improved by the emulator not having to emulate the ARM architecture - you need to use HAXM (by intel, also available in the Android SDK) to get any real speed benefits with x86 images though. The emulator also provides GPU acceleration (it must be manually enabled for each emulator device) which allows it to use your physical GPU for rendering instead of emulating these operations in software.
The way the development environment (Android Studio) connects to the emulator is via ADB (Android Debug Bridge). This means that it can work with virtually any emulator (such as Genymotion, which runs via VirtualBox). However, there is native support for using the Android Emulator from within Android Studio (this is configured by selecting emulator in the Run/Debug configuration)...when using another emulator (such as Genymotion) you should select USB device (in Run/Debug configuration) and make sure that the ADB instance is connected to your emulator via TCP (Genymotion does this for you automatically at startup).
This should give you enough information and I will not re-post all the various instructions on how to do any of the above as they have been posted as answers to various questions here on SO.
I've seen in the Android Developers page that the SDK requires an x86 computer. Is there someway to use an ARM Based linux machine running Ubuntu to develop for Android?
This depends to some degree on what you mean by "to develop for android".
There are a number of scripting tools and frameworks which can be used to create applications on android, without actually compiling any java code. Some of these are intended even for development on the android device itself.
In terms of traditional SDK apps, most of the android toolchain is open source and potentially build-able for any posix-ish platform. The problem is the java jdk - you would need to obtain something to fill that role in the toolchain which would run on your ARM system. Something which compiles another language to dalvik opcodes and thus bypasses the need for the jdk could also be a possibility.
Presumably porting the NDK gcc & binutils along with the android packager is possible, which could make available either the official "native activity" option of more recent android releases, or some custom solution in which the java portion is a pre-generated wrapper and only native code is written for the interesting parts that would have to change during routine app development.
Finally, we aren't far from the point where it would theoretically be possible to emulate an "older" x86 system on a cutting-edge ARM one; potentially the x86 jdk could be run in such a virtual environment, albeit inefficiently.
Since this answer was written, solutions for doing Android Java->Dalvik development on the device itself have become available. As these work at least on ARM-based Android devices, that would qualify as developing for Android on an "ARM based computer". Presumably the same ideas could be applied to an ARM-based netbook or "chromebook" type of system.