I would like to run a small Windows program on an Android slate. It runs just fine under Wine in Ubuntu, but I am unsure how to install & run Wine on the Android slate.
Sorry if it's not strictly a programming question. If you want it to be so, I could rephrase it as "will I have to write my Delphi code again Java in order to run it on an Android slate?"
but I am unsure how to install & run Wine on the Android slate.
I sincerely doubt that is possible or will be within the next decade. While Android runs a Linux kernel, most of what WINE depends upon in Linux will look very different on Android. Not to mention the opcode issue noted by JOTN.
"will I have to write my Delphi code again Java in order to run it on an Android slate?"
Most likely. I don't know what "my Delphi code" entails. If it is pure algorithm stuff, conceivably you could use Free Pascal to get an ARM library you could link to via the Android NDK. If, however, "my Delphi code" involves the UI and the like, you would have to rewrite it (or cook up your own Delphi->Android translator) to get it to use Android's widget library.
I don't believe it will work because you would be trying to run x86 software on a non-x86 processor. To start you would need binaries compiled for an ARM processor.
If your windows program has any GUI, then it will definitely not work. Wine relies on an X-windows system when Android has its own graphical framework...
I've been looking at something similar recently. Wine doesn't run on anything that is not x86, period. When you introduce a GUI (as noted by Matthieu), anything outside of wine will need to utilise another graphics libraries.
It might be worth mentioning wine-lib, you can use this with gcc to cross complile to ARM but you'll end up in a 'world of pain' as soon as you have a GUI. I cannot be 100% but my guess is you're in for a rewrite. http://wiki.winehq.org/ARM
If you do go for a rewrite perhaps look at other languages as Java for android is not nessarliy the same Java you'll run on your desktop. http://www.oreillynet.com/onjava/blog/2007/11/dalvik_googles_tweaked_nonstan.html
I know it's a bit of a 'fad' but you might be best looking at html5/webapp or using c/c++ and gtk/qt if you can find work-arounds.
You can, but it is not easy and possibly too slow. The experimental process is described here: http://forum.xda-developers.com/showthread.php?t=1258506
It is a multi-step process. First you get an Ubuntu system image and chroot into that. Then from there you can invoke wine to display on the local vncserver. Then you install a vncviewer app on android to view the GUI.
Your android device would need to have an x86 CPU. So far, only netbooks will work for this as I don't believe there are any tablets available with x86 and Android compatability. I would only recommend going this route for fun and experimentation -- not productivity.
Related
I have coded a program in Fortran an works perfectly in Windows, my question is if there is any way I can use it in Android.
I don't have the reputation to just make a comment, but I will answer the concern you raise of "not wanting to install compilers" to build fortran programs for android. On pretty much any operating system there are no default compilers for any language, so you have to install compilers (luckily for fortran on windows you even have a lot of options). For Android, right now, you have only one choice. That is to build your own custom version of the NDK gcc cross toolchain and force it to build gfortran and libgfortran. As of right now, gcc has been deprecated in the toolchain. Soon that won't even be an option. I have recently built the previous version of the NDK with gfortran using the following link:
https://github.com/buffer51/android-gfortran
The other problem you're going to run into is that depending on what kind of application you have on windows (command line, gui, webapp, etc.), you're not going to be able to run it on a typical android tablet or phone because there is no command line interface by default (you'll probably have to root the device to get one). The easiest way to develop a usable android app is to write a Java app (using the SDK), and then use JNI to interface with a fortran "library". Unfortunately, there is no straightforward way to compile and use your program on Android, and soon even the complicated ways (building a custom compiler) will get even more complicated.
Perhaps some of you are aware that there is an Android port of GCC 4.7.
I've tested it and it works perfectly, however when 'make' and 'configure' are out of the picture, it is rather useless.
What would it take to port Autotools, including make and configure to Android itself?
If you are wondering who in the world would develop on a phone, you are forgetting that some tablets run Android, though I myself have a phone.
make require nothing, but C library and shell; configure is actually shell script, produced by autoconf, which in turn depends on awk, m4 and diffutils. The hardest part is using autoconf and make with Android built-in shell, which is said to lack lot of functionality. Fortunately Android ports of bash already exist.
The most problematic part with porting GNU programming stack to Android is undocumented file hierarchy (device vendors tend to modify it on every whim) and severely lacking Bionic library. There is number of projects, trying to work around this issues (such as http://sourceforge.net/projects/droidoverlay/, for example), but generally this area is still to be explored.
OK this is a strange one:
Is there a way someone can develop native C applications or libraries for Android without using the Android NDK?
What was happening before the NDK was released?
(It's not there for too long, I think it was released only one or two years ago).
Apparently, you can -- a friend of mine is a real Android guru and he managed to build a GCC-based native toolchain entirely by hand. He also fixed some missing parts in Android's libc. The main idea is the following: GCC has builtin support for the arm-elf-linux target, so with an appropriate build script, you can configure it to build for Android. However, you have to root the phone to run the resulting binaries. One even cooler thing is that because GCC is a self-hosting compiler, with the arm-linux-elf toolchain, you can recompile GCC once again and have the toolchain on the phone itself.
Before the NDK was released, the only officially supported way of developing Android applications was to use the Android SDK and writing your applications in Java.
As others have mentioned, it's possible to cross-compile some applications as completely stand-alone and run them on a rooted phone. The downsides of this should be obvious: very few people will be able to run your application (they also need to be root, plus you won't be able to get your application up on the Play store); and you might even run into compatibility problems yourself across different devices e.g. if you rely on dynamic linking against various libraries (which you might need to do in order to keep the size of the binary down).
TL;DR: it's possible, but severly limited, and not recommended.
You can compile your C code with an Android-compatible toolchain (such as CodeSourcery) and run it on a non-rooted phone, from its command line (for example through an SSH connection like SSHDroid).
I'd like to know the technical difficulty in porting Android to x86 architecture.
Since its source is open, what is the main difficulty in getting to run on x86?
Or is it correct to ask why it cannot be compiled to a Java bytecode to run on a JVM on a PC? Is it because of the Dalvik VM?
I'd appreciate if somebody could explain this.
Thank you.
Actually, it is already ported to x86: http://www.android-x86.org/
Also, Android does not run in a JVM. The Android Kernel is a modified Linux Kernel and written in C. You can't compile it to run in a JVM.
The DVM (used by Android) is a modified JVM based on the OpenSource JVM-implementation Apache Harmony. All Java-Applications on Android run in a DVM.
There isn't a problem. VirtualBox can run an android OS guest machine just fine.
The main difficulty is that x86 and ARM are totally different architectures. They have a totally different mentality about them, different instructions, different registers, different behaviours, different memory architecture, etc. Even the way they interface with other hardware is different.
In terms of technical difficulty, the architectures don't have instructions or mechanisms that are compatible with each other, so the behaviour that is relied upon by a compiler for ARM does not exist on x86, and vice versa.
Knowing enough about one of them to implement anything major usually means you've not spent much time dealing with the other, which just adds to the difficulty.
I just got a EEE pad transformer. Like any hardware I own I'd like to have a C compiler on it. I know I can cross compile, but I'd like to do development ON the device itself. I've searched google and all I can seem to find are pages on how to build an arm toolchain for x86/64 Linux. Thoughts?
The process of building gcc (et al.) to run on your target should be similar to building a cross-compiler, excepting that you will:
need to have an ARM cross compiler that runs on your, for example, x86 machine. So the results of your googleing are still useful.
use the --host option to specify your ARM platform when running configure for all of the parts of your toolchain.
Since you asked about this in June, 2011, (or maybe starting right around that same time) there's something that does EXACTLY what you want called "Terminal-IDE." This is a much better answer than the one you checked off as correct because it doesn't rely upon cross-compilation as the checked answer does.
Terminal-IDE is an Integrated Development Environment that runs ON your Android device (just as you asked about), and has both a C compiler and Java (of course).
There's a Terminal-IDE web site with a more in-depth description and links to other resources.
NOTE: Since I wrote this reply, the author of Terminal-IDE has stopped supporting it.