I want to create a AVD to test my app which uses google APIs in gingerbread 2.3 and honeycomb 3.2,
SO posts said that basically 2 choices exist
x86 image ->faster
ARM v7->slower but most actual devices run it
and the the two images also come with a Google API version which can help test apps using G-Maps etc
I use a Intel 64 bit process with HMAX installed ,vt-x and working fine
For API 21(Lollipop) I created an AVD with googleAPIx86 and x86-system-image and its fine and fast
(cause it seems for the googleAPI image need the corresponding system image should be there,for API 21 I could get both images for x86)
For API 19(Kitkat) also I icreated AVD with googleAPIx86 and x86-system-image and it works
For API 18(Jelly Bean ) the google-api is available only in the ARM version, so i cannot use the x86 system image even though it is faster , so i created AVD with google-api(ARM version) and corresponding ARM-system-image
For API 15(Icecream sandwich ) Also the same as API 18 ,Used ARM for both
The problem now is
For API 13(Honey Comb) and API10(GingerbBread) the Google-API is available only in the ARM Version but the system image is present only in the x86 version.
So is there anyway to run my app using google APIs in these two emeulators ?
(NOTE:AVD Shows error and doesn't if i use a googleAPI-arm with x86system-image)
See screenshot below:
API 10 and 13 have only x86system image but only google-api-ARM
For API 13(Honey Comb) and API10(GingerbBread) the Google-API is available only in the ARM Version but the system image is present only in the x86 version.
ARM images exist for all Android versions. However, it was only starting with API Level 14 were they called out into a separate installable item in the SDK Manager. In prior API levels, the ARM image comes as part of the "SDK Platform" item.
Related
I've just upgraded the Android Support libraries and thus the minimum version of the OS required for me Xamarin Forms app and now want to test it on some devices. I can run it on my phone just fine but wanted to create an Android 7.1.1 (API 25) or Android 8.0.0 (API 26) emulator to test on.
However when I go to create a new AVD, I get the message
No System Images installed for this target
So I flip over in to the SDK manager, but there are no system images available:
So my question is, where and how do I get these system images? Or am I just not able to create AVD's for these API versions for some reason?
I've tried adding new sources, including this one:
https://dl.google.com/android/repository/sys-img/android/sys-img2-1.xml
But it hasn't made any difference. Do I need different sources for later API versions?
No System Images installed for this target
Check your SDK Update sites, make sure that it contains these entries:
https://dl.google.com/android/repository/sys-img/android/sys-img.xml
https://dl.google.com/android/repository/sys-img/google_apis/sys-img.xml
Then, start SDK Manager as Administrator again, download the API 25 and API 26 system image if they are listed.
After download the system image, you could create an Android 7.1.1 (API 25) or Android 8.0.0 (API 26) emulator.
When I downloaded and select "N" (API = 24) for the AVD, I see the following message on bottom right:
Consider using a System Image with Google APIs to enable testing with Google Play Services.
Is this image not available yet? or am I missing something? I dont see it in the SDK Manager yet.
As of SDK Tools 25.1.7 and Intel x86 Atom_64 System Image Rev. 6, it appears that there is no longer a separate emulator image for the Google APIs - instead, the normal emulator image now includes the Google APIs by default. So, the message shown in the "Recommendation" section when creating an AVD appears to be old/incorrect.
I was able to run this project (using gradlew installObaGoogleDebug), which requires Google Play Services for maps and other items, by selecting Nougat / API Level 24 / x86_64 / Android 7.0.
EDIT Nov. 3rd 2016
It appears this was a temporary issue with the emulator image. As of SDK Tools 25.2.2 and Intel x86 Atom_64 System Image Rev. 7, when I try to run the same app on the same emulator image (API Level 24) I created above, it now says "OneBusAway relies on Google Play Services, which is not supported on your device".
However, it looks like there is now an API Level 25 (Android 7.1.1) emulator w/ ABI x86_64 available for download that does explictly include the Google APIs - see area circled in red below (note that the update message still seems to erronouesly appear):
I had the same issue recently, I think it's probably a bug with the tool.
I was able to solve it by downloading the x86_64 version, and then it allowed me to use both the N x86 and N x86_64 emulator images.
I tried creating many different AVDs with different SDK versions ranging from Jelly Bean to ICS to Lollipop.
Tried both ARM and Intel AVDs
But never once saw Google Play enabled images as an option despite having downloaded those image versions (eg. API-17 armv7 image with Google APIs) except for Lollipop & upwards.
Images below
This is really frustrating.
I saw SO posts like this and this but they're not really relevant (am using Studio & have already tried ARM images)
How can I create for eg. an API-17 with Google APIs AVD in Android Studio ?
I was following this (http://developer.android.com/google/play-services/setup.html#Install). It asked me to install Google APIs for Android API 17 (or higher) but when i opened SDK Manager, this is how it looked like:
So, my question is: What are these two Google APIs? And, what is the difference between these two?
In the beginning the only Android system images available ran on the ARM instruction set. A system image is used to create different Android Virtual Devices (AVDs) and emulate the different Android devices in common use.
As developer workstations are usually Intel x86 based, the ARM instruction set had to be emulated as well. This resulted in poor performance from the AVDs due mainly to the amount of translation the x86 processor was doing to also emulate the ARM instruction set.
At Android 4.0.3 (API 15) Intel provided their own x86 based Android system image. This could then be used to create AVDs that did not need to do ARM translation. Combined with the Intel Hardware Accelerated Execution Manager (HAXM) the x86 AVMs were up to 10 times faster than the equivalent ARM emulators.
Support for Google specific Android APIs like the Android Google maps API, are not provided with the standard Android system images. They need to be installed separately using the Android SDK Manager. To use these APIs with an x86 system image you need to also install the Google APIs (x86 System Image) for the same API level.
I have downloaded the Android SDK(which i think has no version, it is standard). After installing Android SDK, Android SDK Manager comes which by default selects 3 things to be downloaded (1)Android SDK tools(2)Android 4.0.3 (API 15) and the things under it like documentation, samples etc (3)Google USB driver But at present i am having book on Android 3, so should i deselect the second option i.e. Android 4.0.3 (API 15) and select all things under Android 3.0 (API 11) or keeping Android 4.0.3 will be OK for Android 3.I know there are tutorials for Android 4.0.3 on Web so why should i go for Android 3 because i find it easy through books and i got Android 3 here in my place and still no Android 4. So what should i do?
You can install everything. I would recommend to install the API level you want to develop for. But it doesn't hurt (but wastes disk space) to install everything.
Sidenote: Android 3.0 is for tablets, 2.x for older and 4.x for the latest Android Smartphone devices.
You should select the API level that you will target. For example, I am writing an application for API level 7 (Android 2.1.x), so I've got that version installed on my machine. Of course, you can have more than one API level installed, so it is safe to install any combination (for example 3.0.x and 4.0.4 simultaneously - see last paragraph for the reason).
Once you've got a few API levels installed, Eclipse will allow you to change the target API for your project to any of the versions you have installed. The same applies for the command-line project creation.
There is actually one good use-case for installing a version newer than the one you are targeting in addition to the one you use: testing. You can create an emulation environment for a newer version of the API to ensure that your application does not crash and burn when the API levels do not match. If we were to extend my above example, a sensible set of levels to install is 3.0.x, 3.2, and 4.0.4. You can target the initial release of Honeycomb (unless you need anything from the later versions), and test with both the latest Honeycomb and Ice Cream Sandwitch.