I have a Surface RT with Windows 10 on ARM and an unlocked secure boot but I would be curious to see if I could compile android x86 but for ARM. There are no kernel trees and device trees available for this device because it's a Windows device.
I am choosing the Android x86 project because it compiles the android build to an iso to easily install it and it's more like a linux distribution such as Ubuntu.
I searched for some documentation but it says something about a depreciated ARM emulator but nothing else: https://www.android-x86.org/documentation/customize_kernel.html
I know that android x86 is meant for x86 but before I waste my time to download the source, what can I do to actually compile it for ARM, or is it possible? Can someone get me in the right direction?
Thanks for any help!
Related
I am trying to implement my tools on an APK, which can be only installed on arm-v8a or armeabi devices, so when I download the Android-23 image with arm-v8a on my ubuntu and run it, it acts really slow with the warning "Running on x86 based Android Virtual Device (AVD) is 10x faster. We strongly recommend creating a new AVD", and the speed of emulator is really slow, takes 20 mins to start the emulator and 10 - 30s delay when actions send to the device.
So is there any solution to speed up the ARM architecture emulator on x86 devices?
Or is there any way to modify the apk to be able to run on x86 emulator? Since the apk implemented with only arn64-v8a and armeabi libraries, so I don't think this could be a possible solution. However, please let me know if this solution works and how to do it.
I want to test Android Vulkan samples under Android Studio in MS WIndows 10
using this manual https://developer.android.com/ndk/guides/graphics/getting-started
I cannot do it because of the error
Device supports x86, but APK only supports armeabi-v7a
I have tried all options suggested here What is the reason for the error "Device supports x86, but APK only supports armeabi-v7a" but it does not work.
I have following Virtual Devices
Even if I use armeabi-v7a I cannot start app. And it is EXTREMLY slow.
Please help me to use clear steps to get working Vulkan samples under x86 images of Android. Thanks!
There are a couple different problems here:
First, the "device supports x86_64, x86, but APK only supports armeabi-v7a" means exactly what it sounds like: you've got an emulator that only supports 32-bit and 64-bit x86 instruction sets, but the native code in your APK is only compiled for 32-bit ARM. Emulating x86 devices is much faster since they can run in a virtual machine (the host CPU is actually executing emulator instructions directly, instead of having to translate them one by one in software). Configure your project to build native code for x86 in addition to armeabi-v7a.
Second, when using an ARM emulator, or if you fix the first problem and run on an x86 emulator, I don't think the Android emulator emulates a Vulkan-capable GPU yet. So you should be able to create a Vulkan instance, but vkEnumeratePhysicalDevices should return a count of zero available physical devices.
You don't give any details about "cannot start app": do you see anything in the log? Are you able to create an instance? Or is there some other completely unrelated problem before you even get to that point? Nobody can help you with that without more details.
Okey, BlueStacks is a bit slow on my pc, so I read somewhere in the internet that Genymotion is a bit faster then BlueStacks. Then I downloaded Genymotion and installed it. And after a lot of complex steps I finally understood that I need ARM translation and Google app for playing Android games. Now, I can understand that Google app is needed for getting the play store. But I am still in the dark about the 'ARM translation'. Why is it needed? what does it do? what happens if I don't use the ARM translation? And lastly, what does ARM stands for?
-Thanks in advance.
ARM is a processor architecture, you can read more about it here.
Android apps are sometimes designed with X86 architecture and sometimes with ARM.
You have to install the ARM translation in order to install on your emulator apps that use ARM architecture.
It's not a must have, but a lot of apps won't work without it.
Android games generally make use of OpenGL ES which is built from the ground up to work specifically with an ARM SoC. The Android NDK itself allows game developers to optimize their software by using C/C++ and even ARM assembly code.
The GenyMotion emulators are designed to work around an Intel x86 / x64 architecture, which is why they are faster than the Android emulators. But because of that, and because they have now decided to forgo ARM translation, they cannot run games.
A standard Android emulator actually compiles Java source to dex, and dex to ARM assembly, and these ARM instructions are run on an ARM emulation called QEMU. This makes the Android emulator incredibly slow, as it is in effect running an emulation of an ARM processor on top of an Intel-Windows machine. But it is able to run games.
The Android emulators emulate, while GenyMotion is more effectively a simulation.
I've seen that there are emulator images available for Android which can run on x86 virtual machines. I'd like to build my own x86 Android image from source, but I can't seem to find instructions online. Is it currently possible to build a custom x86 "ROM"? (not sure "ROM" is appropriate term for x86 systems, whatever)
Yes it's possible, but you still need a Linux machine to compile it (without going into a lot of troubles).
There are a lot of information on porting android to X86 platform in the net. I suggest you to start with this one: Android-x86 - Porting Android to x86 .
You can also have look at XDA forun. They do a lot of work on porting ROM's.
Regards.
I've upgraded to android sdk tools 12.
As a release note google says:
The AVD manager and emulator can now use system images compiled for ARM v7 and x86 CPUs.
Has anyone tried to run a x86 image? Are there any 3.0+ images?
Thanks,
In the GUI of the SDK for emulator configuration, the CPU type drop down box is disabled. Probably this is something they are preparing for the release 13 of the Android SDK tools. (it is also possible that non of my installed platform revision have x86 images)
I tried to run one of my emulator images as x86 explicitly, and get this:
C:\Program Files\Android-SDK\tools>emulator-x86.exe -avd HTC_Magic
qemu: linux kernel too old to load a ram disk C:\Program Files\Android-SDK/platf
orms\android-4\images\/kernel-qemu, C:\Program Files\Android-SDK/add-ons\addon_g
oogle_apis_google_inc_4\images\/ramdisk.img, qemu=1 console=ttyS0 android.qemud=
ttyS1 androidboot.hardware=goldfish clocksource=pit android.checkjni=1 ndns=2
I think the emulator image needs to be created explicitly for x86... Would be nice to have an x86 image so the performance of underlining qemu goes up, as it will not need to emulate ARM CPU instruction set...
You can already run http://www.android-x86.org/ and connect to it with adb over tcpip right now. You do not need the SDK support for it. And it is very fast.
Otherwise if you install the Google TV add on on linux you can create a Google TV avd and that will use x86. It really works nicely only on Linux though since that is where it is tunneled to the hypervisor properly.
There are various blog post around on how to set that up properly e.g. http://commonsware.com/blog/2011/09/01/google-tv-emulator-seemingly-pointless.html
You should install Intel® Atom™ Android x86 Emulator Image.
You could find detailed instructions at this link
You can build your own android x86 emulator from the AOSP. Here are the instructions from the Intel website:
http://software.intel.com/en-us/articles/android-ia-emulator-gingerbread/
http://software.intel.com/en-us/articles/android-virtual-device-emulation-for-ia/
updated article provides info about using 3.2 images, perhaps my sdk does not offer such choice (tested 2.3.3, 3.2 and 4.0.3)
more likely the article refers to an intel based sdk build, that is not the one provided by android developer site.
They may add intel images (yet it's true the emulator needs x86 based images) later and support also intel abi
After a few months passed, the source code for the android 4.0 was released and I find that the x86 virtual machines are faster than any solution I tried which used the Android Emulator.
You can find instructions on using android x86 images here: http://www.android-x86.org/
I followed the instructions here and was able to build a working x86 image. It runs great, much faster than ARM emulation, provided kvm is enabled, which you can by doing "sudo apt-get install kvm" on Ubuntu machines. To check if kvm is already on your machine, do an lsmod | grep kvm.
To answer the other question, Google hasn't released any images with it's SDK yet and this is the thread where someone from Google responded to my question about it.
They plan to release Gingerbread images pretty soon. Which is why there is no drop down option saying "Intel" or x86 in the CPU box of the Android tool (yet).