Aros/Platforms/Installing on Android

From Wikibooks, open books for an open world
Jump to: navigation, search
Navbar for the Aros wikibook
Aros User Docs
Aros User Docs
Aros User FAQs
Aros User Applications
Aros User DOS Shell
Aros Dev Docs
Aros Developer Docs
Porting Software from AmigaOS/SDL
For Zune Beginners
Zune .MUI Classes
For SDL Beginners
Aros Developer BuildSystem
Specific platforms
Aros x86 Complete System HCL
Aros x86 Audio/Video Support
Aros x86 Network Support
Aros Intel AMD x86 Installing
Aros Storage Support IDE SATA etc
Aros Poseidon USB Support
x86-64 Support
Motorola 68k Amiga Support
Linux and FreeBSD Support
Windows Mingw and MacOSX Support
Android Support
Arm Raspberry Pi Support
PPC Power Architecture
Aros Public License


  • 2011 Sonic Amiga's port of almost working Android-hosted AROS - display is 100% correct (you see background and correct alpha channel), and touchscreen input works. Just very slow. Java part is being optimized. Posted on: 2011/8/18 11:17
  • 2012 development slows
  • 2014 some further work done

Android-hosted port is a new, progressing development. It's not emulating a CPU. AROS is launched as a separate process on top of Linux kernel, leaving JVM aside. Java-side runs a simple X11-alike server, which AROS talks to and uses for the display. So it's ARM AROS. Android OS can be viewed as a subset of Linux, so functionality of this port is the same as of generic UNIX-hosted port.

This is Google Android-hosted port of AROS. Android is a subset of Linux system, so many functionality of this port is the same as of a generic Linux-hosted port. Both ARM and i386 architectures are supported, however only ARM is tested.

A minimum required Android version is 2.2 (API level 8).


[ Git repository], Aros sources and others here

Currently a number of small issues exist but they are in the process of being fixed. An intensive development is needed to remove these limitations.

There is no way to activate a keyboard - i.e. no virtual keyboard, A fully working virtual keyboard, feeding input.device with keypresses. Or even HIDD subsystem (the most lowlevel stuff). This commodity needs some nice way to hide and show itself. And lack keys on keyboardless machines. Menu is already occupied by menu; Home is reserved for host OS, Back currently sends Lamiga+M (only Intuition doesn't support it yet - no time to fix). Well, Search on some machines like Nexus One. Would be nice to be able to add something to screen bar. This way more gadgets could be added like e.g. open menu or virtual keyboard, which would always be accessible. This is especially important considering future iOS port - Apple machines have no usable keys at all. Then, Zune could be extended to inter-operate with virtual keyboard and pop it up automatically when a string gadget is activated.

There is intentionally no support kludges that would make use of Android's own virtual keyboard. AROS is not an emulator, it's an operating system by itself, and it should contain own support for such things, independently on what it's running on. Remember that one day AROS will run natively on these devices.

The same reason prevents AROS from supporting autorotating screen. AROS user interface libraries currently has no concept of screen rotation, and it's unclear how it can be implemented (however it's not impossible).

the right mouse button has been disabled

Note that trackball found on NexusOne phone is of a very poor quality. It is supported by AROS as a mouse, however the cursor speed will be very slow, even if you turn on the acceleration. This is a property of the trackball itself and it can't be fixed by software. Android OS uses it to emulate keypad, not as a mouse. Perhaps AROS should do this too, this is subject to further development.

A lack of arm ported software, should be a matter of re-compilation. Although i have no idea for their dependencies and support for android (if needed at all). Due to lack of developers it is also not a priority. Most of them work constantly on improving AROS itself, not on porting software.


In order to install AROS to your Android device, do the following:

  1. Extract the archive.
  2. Inside the archive you'll see an AROS directory. Copy its whole contents to the SD card (or whatever else removable media your device uses.)
  3. Install the supplied AROSBootstrap.apk in your device.

Please note that minimum required Android version is 2.2.

In order to install AROS on your Android device, you need:

- Copy 'AROS' directory with all its contents to the root of your SD card (or whatever else external storage).
- Instal AROSBootstrap.apk like any other application.

There's nothing particular about this. Run 'AROS' application and enjoy. Note that AROS was initially developed as a desktop OS. Android-hosted port is the first completed port to run on mobile devices. Consequently, AROS lacks many features that could make it a mobile system. First of all, AROS lacks a virtual keyboard. Second, user interface is not optimized to be operated by fingers and/or keypad. If your device has a keyboard, AROS will support it, however this was not tested yet. 'Menu' key found on most of Android devices emulates right mouse button and 'Back' button emulates LAmiga+M sequence (screen switch).

For more comfortable use you can do the following:

- Turn on 'Sticky menus' option in IControl preferences.
- Enable popup system menus.
- Set larger fonts for user interface, to increaze size of controls.


Since Android OS has no command line, you can't watch debug output in real time without any external tools. However, you can redirect it to a file using bootstrap's own functionality. In order to to this you'll need to edit AROS/boot/AROSBootstrap.conf file and add 'logfile <file_pathname> option to it.

In a similar manner you may pass command line options using "arguments <your-options>" option in AROSBootstrap.conf.

It remembers orientation in which it was run. So, if you hold the device in landscape mode, you'll get landscape, until you shut down (reboot, both cold and warm, keeps the orientation). Have ideas on how to implement two orientations as two different screenmodes, so that you'll be able to switch between them using Screenmode prefs, and also specify different programs (which support own screens) to use different orientations. But have no time right now, finishing up with generic software screen drag implementation (will work on Android too). Will get back to Android-hosted display when done. No support device rotation on running AROS at the moment, because AmigaOS previously had no clue about rotating displays. Consequently, software can't rotate on the fly. It's not totally impossible, just some Zune/Intuition extensions need to be developed from scratch. Noone has ever ran Amiga-family OS on a mobile device before.

However, it's actually possible to run AROS in both landscape and portrait orientation. Both orientations are available as different display modes in ScreenMode preferences program.

Please report about your keyboard experience. Some keys can be missing (especially LAmiga/RAmiga) so keycode table is typed blindly, according just to documentation. So all your suggestions about improving keys mapping are welcome.


Android OS currently supports i386 and ARM processors. AROS can be built for both these architectures, however currently only ARM build is in production. i386 version was not tested as there was no test environment available.

The vast majority of modern ARM devices have ARMv6 or better processor with VFP floating-point unit. This configuration is currently the minimum requirement to run AROS. However, some Android devices were available on the market, whose processors are below this requirements typically up to around the year 2011. Known non-working processors are:

  • Qualcomm MSM7225 (ARMv6 but no VFP at all)
  • VIA 8650 (ARMv5)

This is a list of test results on various hardware and Android OS versions:

Device name CPU core Android OS version Linux kernel version AROS Test build Test results
Ainol NOVO7 Aurora 2 1.5 GHz ARM Cortex A9
Dual Core
Amlogic AML8726-M6
4.0.3 (ICS) Black screen, system halts during bootup
Archos 70 1 GHz ARM Cortex A8
(TI OMAP3630)
2.2.1 (Froyo) Working fine. CacheClearU() is known to trigger host system reset (hardware-specific glitch)
Google Nexus One
(HTC Passion)
1 GHz ARM Cortex A8
(Qualcomm Scorpion)
2.3.4 Build GRj22 59463-g52630a3 Working fine
HTC Desire 1 GHz Qualcomm Snapdragon (QSD8250) 2.2 (Froyo) Working fine
HTC Evo Shift 4G 800 MHz Qualcomm Snapdragon S1 (MSM7630) 2.2 (Froyo) gee557fd Working fine
HTC Sensation 2011 1,2 GHz Qualcomm Scorpion S3
Dual Core
2.3.3 (Gingerbread,
HTC Sense 3.0)
Error in C:Mount during DEVS:DOSDrivers processing
HTC Wildfire A3333 525 MHz Qualcomm Snapdragon S1 (MSM7225) 2.2.1 (Froyo) g8f75634 htc-kernel "Illegal instruction" crash. The processor is below AROS minimal requirements.
HTC One XL 1,5 GHz Qualcomm Snapdragon S4 Dual Core (MSM8960) 4.1.1 (Jelly Bean,
Viper XL 3.2.3)
3.4.10 g240d4d5 root@abm033#1 SMP PREEMPT Working fine
LG Optimus Black 1 GHz ARM Cortex A8
(TI OMAP3630)
2.2.2 (Froyo) Working fine
LG Optimus One (P500) 600 MHz Qualcomm ARM1136EJ-S 2.2.2 (Froyo) Working fine
LG Optimus Speed 1 GHz ARM Cortex A9
Dual Core (AP20H)
2.2.2 (Froyo) dirty Black screen, system halts during bootup
RoverPad 3W T71D 1 GHz ARM Cortex A8
(Allwinner Boxchip A10)
4.0.3 (ICS) 3.0.8+ (inet_hxj @InetSoftware) (gcc version 4.5.1 (Sourcery G++ Lite 2010.09-50) ) # 106 PREEMPT Working fine
Samsung Galaxy S 1 GHz ARM Cortex A8
(TI OMAP3630)
2.3.3 (Gingerbread) Working fine
Samsung Galaxy Tab 2 1 GHz ARM Cortex A9
Dual Core (TI OMAP4430)
4.0.3 (ICS) 3.0.8 Working (but apparently not entirely crash free)
Samsung Nexus S 1 GHz ARM Cortex A8
(TI OMAP3630)
2.3.4 Build GRj22 2.6.35-7 ge382d80 Working fine
Sony Tablet S 1 GHz ARM Cortex A9
Dual Core (AP20H)
3.2 (Honeycomb) Working fine
Sony Ericsson XPeria X10 Mini Pro 600 MHz Qualcomm Snapdragon S1 (MSM7227) 2.1 (Eclair) Working fine, keyboard needs specific keymap
VIA 8650 2.2 (Froyo) "Illegal instruction" crash. The processor is below AROS minimal requirements.

Status of bugfixing:

  • LG (and possibly other dual-core devices): The problem has not been confirmed on all dual-core devices. In october, 2011, a bug has been discovered in icon generation tool, used in AROS build process, which caused trashing icon tooltypes. Corrupted icons caused system-wide memory trashing, which could be a reason for this problem. Icon generator was fixed, but there were no test reports.
  • HTC Sensation: installation problem (MacOS X created accompanying dot-underscope files when the system was copied to phone's flash. The issue has been reproduced and addressed since 09.11.2011, but there is no confirmation (yet).

Compiling / Build[edit]

In order to compile Android-hosted AROS you need:

- A usual prerequisites for building AROS (GNU/UNIX-compatible environment). If you are running Windows, MinGW
  (MSYS) is the recommended one. Cygwin is much slower, and it will unlikely work with Android NDK because gcc
  versions supplied with modern Android NDK are MinGW-hosted, not Cygwin. Don't be confused by the fact that
  NDK's own build system is claimed to require Cygwin. AROS doesn't use this build system, it uses only gcc
  compiler, includes and link libraries from the NDK. NDK build system, when used, translates paths from UNIX
  to Windows style for the gcc; AROS build system won't do the same under Cygwin. If running Cygwin, it assumes
  all tools are Cygwin-hosted. It's possible to build Android-targetted gcc for Cygwin, but this was never tested.
  At the moment Cygwin is generally deprecated for building AROS, and Cygwin-related portions in the configure
  script are poorly maintained.

One note: MinGW project does not offer netpbm package on their web site. It can be found in another project, GNUWin32. GNUWin32 ports perfectly cooperate with MinGW ones.

- ARM AROS-targeted crosscompiler. At the moment only MacOS X/x86-64 version can be found on AROS Archives
  as binary distribution. You have to build own AROS toolchain if running another system. The process is
  straightforward and explained in README files for gcc and collect-aros. Please feel free to release your
  built toolchains on AROS Archives in order to assist other developers.

Note that Android-targetted gcc can't be used for building AROS binaries even with wrapper scripts. Android ABI is not 100% compatible to AROS one.

- Android SDK (Java one). The new build was succesfully tested with SDK r10 on MacOS X v10.6.8 (x86-64).
  During early development stages SDK v1.6r1 was used under Windows. In fact any SDK version should work.
- Android NDK (Native Development Kit). Versions statring from r5 are known to be supported. Earlier versions
  are not expected to work, because directory tree structure was changed.
  Android NDK has an option to generate a "standalone" version of Android toolchain. For AROS this is options.
  AROS build system is expected to support such toolchains, but this was not tested.
- Apache Ant or Eclipse. These are optional, however without them you won't be able to build Java application
  containing the bootstrap. For automated builds (e. g. nightly build) Ant is mandatory.

Configure script needs the following additional parameters to set up Android-hosted build:

--target=linux-<cpu>            - Android is a subset of Linux architecture
--enable-target-variant=android - This actually tells to set up Android-hosted build
--with-sdk=<path>             - Specifies location of installed Android SDK. 

This parameter currently can't be omitted at all. There is some default for it, however it is unlikely to fit your machine, since the SDK does not suggest any specific default location by itself.

--with-ndk=<path>             - Specifies location of installed Android NDK. 

If you omit this, AROS build system will expect to use standalone toolchain installed in your $PATH.

--with-gcc-version=<number>     - 

If you are not using a standalone Android toolchain generated from the NDK, you must specify it. Otherwise AROS won't be able to locate a gcc inside it. NDKs r5 and r6 are both supplied with version 4.4.3. If this ever changes, you can easily check which gcc version is contained in your NDK. Just look into "toolchains" subdirectory.

--with-sdk-version=<number>     - The value of this parameter is Android API level number (not OS version).

It specifies platform version to use within the SDK. Current minimum SDK API level is 12. Please don't confuse it with minimum API version required to run AROS, these are different. Java code uses some methods declared only starting from v12 API, however it works correctly if they are missing. High SDK version is required just to compile this code. You can easily look up what platform versions are supported by your SDK by examining its 'platforms' subdirectory.

--with-ndk-version=<number>   - Similar to --with-sdk-version, but specifies API level for the NDK. 

This is different from SDK because: a) SDK doesn't include all levels included in the NDK; and b) AROS display driver needs some includes from API level 9 (despite AROS runs on level 8). This parameters defaults to 9 and will be needed if older API levels are dropped from the NDK at some point.

Android documentation says that APKs must be signed in order for the system to allow installing them. AROS build system is set up to sign the built application with "AROS" key located in $HOME/.android/AROS.keystore. If you are setting up the build for the first time, you need to create this key. In order to do this you need to use "keytool" utility supplied with the JDK:

keytool -genkey -keystore ~/.android/AROS.keystore -alias AROS -validity 366000

Unfortunately, a certificate must have validity period. In this example we set it to more than 1000 years (for simplicity we count every year for 366 days). The longer the time, the better. AROS is not going to die! :)

After this command keytool will ask for your personal data. It's recommented to fill them in correctly, this can help to identify origins of the build. When the keytool asks you for key password, use ''. This password is specified in file of the Java project, this allows ant to operate fully automatically and not to ask you for the password every time. This is especially useful for automated (e. g. nightly) builds.

Remember that AROS is an open project! It doesn't honor any conspiracy. Everyone is allowed to make builds and publish them. This key exists only because Android mandates it. It's neither meant to be used for some private authentication, nor serves for enforcing some limitations on the end user. These are reasons why key password is stored open in the SVN tree. It's possible to adjust the build system to use arbitrary system-specific key and password, but this is not done for simplicity reasons.

Configure parameters for building andoid hosted port (softfp)

./configure --host=i686-pc-linux-gnu --target=linux-arm --enable-target-variant=android --with-apk-version=debug --enable-build-type=personal --with-sdk=~/android-sdk-linux --with-ndk=~/android-ndk-r10d --with-sdk-version=22 --with-ndk-version=9


In future can build pelya's SDL-lib based android-port of AROS with audio, internet and additional control for show/hide android keyboard and customisation for right mouse click

part of code causes an error and must be removed from sources for successful compilation

AROS-20150908-source/arch/all-linux/kernel/cpu_arm.h:41:8: error: redefinition of ‘struct ucontext’

#ifdef HOST_OS_android

* Android NDK doesn't have some necessary includes.
* Linux kernel is Linux kernel, i hope they won't break binary compatibility,
* so it's okay to define this structure here.
#include <asm/sigcontext.h>

struct ucontext
unsigned long uc_flags;
struct ucontext *uc_link;
stack_t uc_stack;
struct sigcontext uc_mcontext;
sigset_t uc_sigmask;
int reserved[32 - (sizeof (sigset_t) / sizeof (int))];
unsigned long uc_regspace[128] __attribute__((__aligned__(8)));


Dopus5 works fine via windows-hosted AROS ABIv0. Problem only with Android-hosted AROS

ABIv1 broken for android. It requested for x11 and glx on build.


Android is a very hostile environment to native code. All Android applications are running inside a Java VM. It uses UNIX signals for own purposes, conflicting with AROS multitasking. This makes it impossible to run AROS directly in application's context. It was proved during early port development. There's no way to shut down Java environment.

In order to work around this limitation, AROS runs in its own process asynchronously. Communication with Android OS is implemented using client-server architecture. Before running AROS via fork(), bootstrap creates two pipes (see Kick() method implementation). These pipes are used as communication channels to and from display server, written in Java. AROS display driver sends action commands to the server, and gets input events from it. This is the only way for AROS to communicate with Android APIs other than Linux kernel and C libraries on top of it. It's unknown whether it's possible to call Android GL API from within AROS under this conditions.

Because of this, please, keep communication with Java at a minimum. In order to prevent from de-synchronization all commands are processed by display server in the same order as in which they arrived. In order to satisty this, Java display server thread forwards all commands to main user interface thread, where they are processed and replied. Such an architecture very negatively impacts on the overall AROS performance, especially when a command needs a reply, and it's a good practice to stay away from it. It's impossible to remove a separate display server thread because Java API lacks asynchronous I/O facilities which could be used together with Android user interface processing.

Fortunately Android's lower layers (kernel and C libraries) do not suffer from any limitations, and at least basic system services (file access, time, signals, etc) can be freely used by AROS. If someone wants to try his hands on, for example, accelerometer support for AROS, the primary way to go would be direct interfacing with the device using /dev directory.

If you work with code using communication pipes, remember the general rule: pipe error on any side should cause immediate process exit. The pipe can be broken if one of processses exit. In this case, if the user interface exits, and AROS fails to notice this, you'll end up in blindly running AROS process without any control on it. It's impossible to even use kill command on non-rooted device, so the only way to get rid of such process (draining the battery and system resources) is to completely reboot the device. Please do everything possible to avoid this!

An alternate way to run hosted AROS on Android device would be total shutdown of Java environment and taking over the device. AROS would need a Linux framebuffer display and raw hardware input drivers. There is very old source code of these drivers which is slowly being reworked. The only drawback of such approach is that cellular phone will stop being serviced. AROS would need to take care of it itself then. Additionally, it would require a rooted device.


Add the following to AROSBootstrap.conf file:

logfile AROS.log arguments sysdebug=all

then run. After a reboot you should get AROS.log file in your AROS directory.

Install ALogcat program to your machines, run it, then run AROS. When it all stops, ALogcat should display some log. Mail me that log. BTW, i need exact error messages, "something like that" simply won't help me.

Improved software faulire requester. First, now it correctly displays buttons on small screens. Second' after you press 'More', there'll be 'Log' button. Press it and the whole crashlog will be dumped to debug output.

For Java part AROS build system creates a complete Eclipse project. It's located in $(TOP)/bin/linux-$(CPU)-android/gen/arch/all-android/bootstrap/app. You can import it into Eclipse workspace and work with it as usually. On UNIX systems the project will contain symlinks to original directories, so files modified in Eclipse will stay in their original place. Unfortunately on Windows this is not possible, and directories will be copied instead (unless MinGW implements support for post-XP symlinks). So, if you modify something there, you'll have to copy your changes back to SVN tree. Theoretically it's possible to work around it by modifying Java build paths inside the project,

Debug output from AROS itself is copied to Android debug buffer. You can read it as usually, using 'logcat' command in Android shell. Also you can use 'logfile' option in AROSBootstrap.conf in order to save the output to a file, the same as in any other hosted port.

Androd NDK documentation describes a way to attach gdb to a process on the device. This was not tested with AROS, however is expected to work.

AROS is expected to run inside Android emulator, since it's full ARM machine emulator, not a hosted environment like for example iOS or Symbian simulators. Not tested because of: a) complicated process of SD card image creation; and b) overall slowness of the emulator even on very fast computers. It was much faster and easier to use the real hardware for the development.

Run Logs[edit]

AROS-20120905-android-arm-system.tar.bz2 on my Galaxy S3 but I get program failed.

Task : 0x5C27F5A0 - Boot Mount
Error : 0xB0000000 - unknown bootstrap error

I tried to use the logfile-argument on the bootstrap.conf aswell and that says:

[AGFX] DisplayPipe 59 InputPipe 60
[AGFX] Init OK
[AGFX] Display size: 1280x720, Titlebar size: 100, Orientation: 2
AGFX::New(): Got object from super
Exit AGFXGfx::New=5c26174
[AGFX] Show(0x5c2ac154)
[AGFX.server] Error condition on input pipe

Is this a bad version or just incompatible with my new phone ? =)

This phone is running Android 4.0.4 if that matters (not rooted)

Android does not need to be rooted. When i last time checked this version, it worked. But now i can't maintain this port because i have no devices capable of running Android.

From the log it looks like there's some problem in communication of AROS display driver with Android part. You may have an older version installed and did not update the bootstrap? Actually bootstrap and display driver (which is in the BSP) versions should match. If they differ, various things can happen.

Not only the bootstrap, but also a display server written in Java. And if i change something significant in the display driver, i need to update the server too.

Please used a OTG-cable and take the files from a USB-stick =)

Copying the archive content causes error messages because there are symlinks in the archive and FAT doesn't support them. Example: AROS/Development/lib/libm.a is a symlink to libarosm.a P.S. About these symlinks: simply ignore them, this is actually SDK, you don't need it just ro run AROS.

Would ZIP be a more appropriate format for this package? Using ZIP might get rid of the symlinks. ZIP will irreversibly clobber UTF8 file names of some locales

Resident modules (addr: pri flags version name):
+ 48f33648: 127 02 3 "kernel.resource"
+ 48f383e4: 125 02 3 "hostlib.resource"
+ 48f340e8: 120 01 45 "exec.library"
+ 48f373a8: 110 82 41 "expansion.library"
+ 48fd9adc: 103 81 41 "utility.library"
+ 48fd4f9c: 102 81 1 "debug.library"
+ 48fd4e9c: 101 81 41 "aros.library"
+ 48fdb920: 100 01 41 "bootloader.resource"
+ 48f384a4: 99 01 2 "processor.resource"
+ 48fd9758: 94 81 42 "oop.library"
+ 48fda6ec: 92 81 1 "hiddclass.hidd"
+ 48f378c0: 91 81 43 "unixio.hidd"
+ 48fdfb2c: 80 01 1 "FileSystem.resource"
+ 48f3827c: 70 81 41 "battclock.resource"
+ 48fdad44: 66 81 1 "graphics.hidd"
+ 48fd6498: 65 81 41 "graphics.library"
+ 48fd92cc: 60 81 50 "layers.library"
+ 48f37704: 50 81 41 "timer.device"
+ 48fdb594: 45 81 1 "keyboard.hidd"
+ 48fdb76c: 45 81 1 "mouse.hidd"
+ 48fda3e4: 44 81 41 "gameport.device"
+ 48fda55c: 44 81 41 "keyboard.device"
+ 48fd8cb0: 40 81 41 "keymap.library"
+ 48fda1f4: 30 81 41 "input.device"
+ 48fd7a54: 15 81 50 "intuition.library"
+ 48f37c50: 9 81 42 "androidgfx.hidd"
+ 48fd9cac: 4 81 41 "console.device"
+ 48f33ae0: -1 01 42 "emul-handler"
+ 48fdba2c: -50 01 41 "dosboot.resource"
+ 48fd536c: -120 00 50 "dos.library"
+ 48fdf7dc: -120 04 41 "DOSBoot cleanup"
+ 48fdfbf8: -123 04 41 "lddemon.resource"
+ 48fd48b8: -124 04 41 "con-handler"
+ 48fd47d4: -125 04 1 "amber-ram-handler"
[Init] Post-kernel init
[Init] Memory page size: 4096
[InitResident] InitResident end 0x48F33648 ("kernel.resource"), result 0x48FF5044
[InitCode] calling InitResident (125 02 "hostlib.resource")
[InitResident] InitResident begin 0x48F383E4 ("hostlib.resource")
[InitResident] Initresident !RTF_AUTOINIT
[CreateLibrary] MakeFunctions(0x48FF52F0, 0x48F383C0, 0x00000000)
[CreateLibrary] Created 36 vectors
[InitResident] InitResident end 0x48F383E4 ("hostlib.resource"), result 0x48FF52F0
[InitCode] calling InitResident (110 82 "expansion.library")
[InitResident] InitResident begin 0x48F373A8 ("expansion.library")
[InitResident] Initresident RTF_AUTOINIT
[CreateLibrary] MakeLibrary: functions table at 0x48F37450, data size is 184
[CreateLibrary] Table contains 27 absolute pointers
[CreateLibrary] Allocated vector table at 0x48FF5340, size is 112
[CreateLibrary] MakeFunctions(0x48FF53B0, 0x48F37450, 0x00000000)
[CreateLibrary] Created 112 vectors
[CreateLibrary] Created library 0x48FF53B0
[InitResident] InitResident end 0x48F373A8 ("expansion.library"), result 0x48FF53B0
[InitCode] leave InitCode(0x02, 0)
[InitCode] enter InitCode(0x01, 0)
[InitCode] kickmemptr=0x00000000 kicktagptr=0x00000000 kickchecksum=0x00000000
[InitCode] calling InitResident (120 01 "exec.library")
[InitResident] InitResident begin 0x48F340E8 ("exec.library")
[InitResident] Initresident !RTF_AUTOINIT
[Init] exec.library init
[AddTask] NewCreateTaskA: name __RemTask_Cleaner__
[AddTask] NewAddTask (0x48FF5B20 ("__RemTask_Cleaner__"), 0x48F26860, 0x48F20AA0)
[AddTask] NewAddTask MemEntry head: 0x48FF5AE0
[AddTask] NewAddTask: SPLower: 0x48FF5B80 SPUpper: 0x48FFFB80 SP: 0x48FFFB80
[AddTask] Added task 0x48FF5B20
[RemTask] __RemTa[RemTask] remtaskcleaner RemTaskPort created

and here the other log from Alogcat

I/INKSPOT ( 1307): ContentResolver.registerContentObserver : android.database.AbstractCursor$SelfContentObserver@46e35628, uri : content://com.lge.provider.appMenuInfos/app_child_infos?notify=true
I/AllAppsWorkspace( 1307): notificationExecute():packageName=org.aros.bootstrap, className=org.aros.bootstrap.OrientationDetector
I/AllAppsWorkspace( 1307): FIND packageName=org.aros.bootstrap
D/Launcher( 1307): onSaveInstanceState
D/Launcher( 1307): ==== Launcher onPause====== 
I/AllAppsWorkspace( 1307): onPause()
D/DragLayer( 1307): endDrag()
D/Launcher( 1307): Ori_Sensor_on_off _SENSOR_OFF
D/dalvikvm(16575): Trying to load lib /data/data/org.aros.bootstrap/lib/ 0x46cac658
D/dalvikvm(16575): Added shared lib /data/data/org.aros.bootstrap/lib/ 0x46cac658
D/dalvikvm(16575): No JNI_OnLoad found in /data/data/org.aros.bootstrap/lib/ 0x46cac658, skipping init
D/AROS (16575): Started
D/AROS.UI (16575): Orientation set to 1
D/AROS.UI (16575): Activity created
V/OMXPlayer( 1031): worker before pause call = 0x711e0
D/AROS.UI (16575): Screen size set: 480x724
D/AROS (16575): Loading AROS, root path: /mnt/sdcard/AROS
D/AROS (16575): [ELF Loader] Calculating kickstart size...
D/AROS (16575): [ELF Loader] Code 895163 bytes, data 3064 bytes, BSS array 24 bytes
D/AROS (16575): [ELF Loader] Loading kickstart...
D/AROS (16575): [ELF Loader] Code 0x46b2c000, Data 0x206600, Module aros-bsp-android...
D/AROS (16575): [ELF Loader] Code 0x46b51d51, Data 0x206e50, Module aros-base...
D/AROS (16575): Starting AROS...
D/AROS (16584): Resident modules (addr: pri flags version name):
D/AROS (16584): + 46b46648: 127 02 3 "kernel.resource"
D/AROS (16584): + 46b4b3e4: 125 02 3 "hostlib.resource"
D/AROS (16584): + 46b470e8: 120 01 45 "exec.library"
D/AROS (16584): + 46b4a3a8: 110 82 41 "expansion.library"
D/AROS (16584): + 46becadc: 103 81 41 "utility.library"
D/AROS (16584): + 46be7f9c: 102 81 1 "debug.library"
D/AROS (16584): + 46be7e9c: 101 81 41 "aros.library"
D/AROS (16584): + 46bee920: 100 01 41 "bootloader.resource"
D/AROS (16584): + 46b4b4a4: 99 01 2 "processor.resource"
D/AROS (16584): + 46bec758: 94 81 42 "oop.library"
D/AROS (16584): + 46bed6ec: 92 81 1 "hiddclass.hidd"
D/AROS (16584): + 46b4a8c0: 91 81 43 "unixio.hidd"
D/AROS.Server(16575): Display server started
D/AROS (16584): + 46bf2b2c: 80 01 1 "FileSystem.resource"
D/AROS (16584): + 46b4b27c: 70 81 41 "battclock.resource"
D/AROS (16584): + 46bedd44: 66 81 1 "graphics.hidd"
D/AROS (16584): + 46be9498: 65 81 41 "graphics.library"
I/#LGIME ( 1300): #### onStartInput restarting : false / inputType : 0
V/MediaPlayerService( 1031): disconnect(155) from pid 1300
V/MediaPlayerService( 1031): Client(156) constructor
V/MediaPlayerService( 1031): Create new client(156) from pid 1300, fd=35, offset=810707, length=4650
V/MediaPlayerService( 1031): setDataSource fd=35, offset=810707, length=4650
V/MediaPlayerService( 1031): st_dev = 45825
V/MediaPlayerService( 1031): st_mode = 33188
V/MediaPlayerService( 1031): st_uid = 0
V/MediaPlayerService( 1031): st_gid = 0
V/MediaPlayerService( 1031): st_size = 2823849
V/MediaPlayerService( 1031): player type = 3
V/MediaPlayerService( 1031): create VorbisPlayer
V/MediaPlayerService( 1031): Client(155) destructor pid = 1300
V/AudioSink( 1031): close
V/MediaPlayerService( 1031): disconnect(155) from pid 1300
V/MediaPlayerService( 1031): [156] setAudioStreamType(3)
V/MediaPlayerService( 1031): [156] prepareAsync
V/MediaPlayerService( 1031): [156] notify (0x176b78, 1, 0, 0)
D/AROS (16584): + 46bec2cc: 60 81 50 "layers.library"
D/AROS (16584): + 46b4a704: 50 81 41 "timer.device"
D/AROS (16584): + 46bee594: 45 81 1 "keyboard.hidd"
D/AROS (16584): + 46bee76c: 45 81 1 "mouse.hidd"
D/AROS (16584): + 46bed3e4: 44 81 41 "gameport.device"
D/AROS (16584): + 46bed55c: 44 81 41 "keyboard.device"
D/AROS (16584): + 46bebcb0: 40 81 41 "keymap.library"
D/AROS (16584): + 46bed1f4: 30 81 41 "input.device"
D/AROS (16584): + 46beaa54: 15 81 50 "intuition.library"
D/AROS (16584): + 46b4ac50: 9 81 42 "androidgfx.hidd"
D/AROS (16584): + 46beccac: 4 81 41 "console.device"
D/AROS (16584): + 46b46ae0: -1 01 42 "emul-handler"
D/AROS (16584): + 46beea2c: -50 01 41 "dosboot.resource"
D/AROS (16584): + 46be836c: -120 00 50 "dos.library"
D/AROS (16584): + 46bf27dc: -120 04 41 "DOSBoot cleanup"
D/AROS (16584): + 46bf2bf8: -123 04 41 "lddemon.resource"
D/AROS (16584): + 46be78b8: -124 04 41 "con-handler"
D/AROS (16584): + 46be77d4: -125 04 1 "amber-ram-handler"
D/AROS (16584): [Init] Post-kernel init
D/AROS (16584): [Init] Memory page size: 4096
D/AROS (16584): [InitResident] InitResident end 0x46B46648 ("kernel.resource"), result 0x4903A044
D/AROS (16584): [InitCode] calling InitResident (125 02 "hostlib.resource")
I/ActivityManager( 1103): Displayed activity org.aros.bootstrap/.PortraitActivity: 182 ms (total 338 ms)
D/AROS (16584): [InitResident] InitResident begin 0x46B4B3E4 ("hostlib.resource")
D/AROS (16584): [InitResident] Initresident !RTF_AUTOINIT
D/AROS (16584): [CreateLibrary] MakeFunctions(0x4903A2F0, 0x46B4B3C0, 0x00000000)
D/AROS (16584): [CreateLibrary] Created 36 vectors
D/AROS (16584): [InitResident] InitResident end 0x46B4B3E4 ("hostlib.resource"), result 0x4903A2F0
D/AROS (16584): [InitCode] calling InitResident (110 82 "expansion.library")
D/AROS (16584): [InitResident] InitResident begin 0x46B4A3A8 ("expansion.library")
D/AROS (16584): [InitResident] Initresident RTF_AUTOINIT
D/AROS (16584): [CreateLibrary] MakeLibrary: functions table at 0x46B4A450, data size is 184
D/AROS (16584): [CreateLibrary] Table contains 27 absolute pointers
D/lifecycle( 1307): onStop:com.lge.launcher.Launcher@46ba4680
I/INKSPOT ( 1307): ContentResolver.unregisterContentObserver : android.database.AbstractCursor$SelfContentObserver@46ba2ee8
I/INKSPOT ( 1307): ContentResolver.unregisterContentObserver : android.database.AbstractCursor$SelfContentObserver@46bd4660
I/INKSPOT ( 1307): ContentResolver.unregisterContentObserver : android.database.AbstractCursor$SelfContentObserver@46e35628
I/INKSPOT ( 1307): ContentResolver.unregisterContentObserver : android.database.AbstractCursor$SelfContentObserver@46c8ff98
D/AROS (16584): [CreateLibrary] Allocated vector table at 0x4903A340, size is 112
D/AROS (16584): [CreateLibrary] MakeFunctions(0x4903A3B0, 0x46B4A450, 0x00000000)
D/AROS (16584): [CreateLibrary] Created 112 vectors
D/AROS (16584): [CreateLibrary] Created library 0x4903A3B0
D/AROS (16584): [InitResident] InitResident end 0x46B4A3A8 ("expansion.library"), result 0x4903A3B0
D/AROS (16584): [InitCode] leave InitCode(0x02, 0)
D/AROS (16584): [InitCode] enter InitCode(0x01, 0)
D/AROS (16584): [InitCode] kickmemptr=0x00000000 kicktagptr=0x00000000 kickchecksum=0x00000000
D/AROS (16584): [InitCode] calling InitResident (120 01 "exec.library")
D/AROS (16584): [InitResident] InitResident begin 0x46B470E8 ("exec.library")
D/AROS (16584): [InitResident] Initresident !RTF_AUTOINIT
D/AROS (16584): [Init] exec.library init
D/AROS (16584): [AddTask] NewCreateTaskA: name __RemTask_Cleaner__
D/AROS (16584): [AddTask] NewAddTask (0x4903AB20 ("__RemTask_Cleaner__"), 0x46B39860, 0x46B33AA0)
D/AROS (16584): [AddTask] NewAddTask MemEntry head: 0x4903AAE0
D/AROS (16584): [AddTask] NewAddTask: SPLower: 0x4903AB80 SPUpper: 0x49044B80 SP: 0x49044B80
D/AROS (16584): [AddTask] Added task 0x4903AB20
D/AROS (16584): [RemTask] __RemTask_Setup cleaner task created
D/AROS (16584): [InitResident] InitResident end 0x46B470E8 ("exec.library"), result 0x49039380
D/AROS (16584): [InitCode] calling InitResident (103 81 "utility.library")
D/AROS (16584): [InitResident] InitResident begin 0x46BECADC ("utility.library")
D/AROS (16584): [InitResident] Initresident RTF_AUTOINIT
D/AROS (16584): [CreateLibrary] MakeLibrary: functions table at 0x46BECB80, data size is 116
D/AROS (16584): [CreateLibrary] Table contains 45 absolute pointers
D/AROS (16584): [CreateLibrary][RemTask] remtaskcleaner RemTaskPort created