Android application development can be supported with multi-threaded programming, which provide convenience for developers to fully utilize the system resource and provide means of designing complicated UI and time consuming operation. It also enhances the user experience of Android users. Multi-threads for Android has no too much difference than for Java. The only change may be that it probably can not directly utilize CANVAS to  modify screen element. Certainly Android provides developers with surfaceview class to change screen using Canvas in Multi-threaded programming and bring convenience for designing UI and Game development. So it is very important that developers need to learn how to use  multi-threaded programming, which plays important role as part of Android programming.

There are many ways of achieving  threading, the most popular way is :

start()；

run()；

sleep()；

stop()；

destroy()；

join();

suspend()；

resume()；

yield()；
wait()；
notify()；

Threading start must use start(); Threading can use run(); Threading sleep can use sleep () etc.. The first three methods are most popular usage. Generally speaking, these three methods can satisfy the need for most threading usage. When run() end, the thread automatically  end life. Although stop() , or destroy()  can be used to stop thread, but are not recommended as stop() can  turn into abnormal, and destroy() can turn into force termination. and will release the lock. The solution is to set a status signal in RUN to wait the thread to terminate automatically.  Here we use volatile boolean bThreadRun. For suspend (), resume() and yield(), they are rarely used due to the possibility of dead lock. So in most situation, developers will use wait() and notify() to replace them.

Here is a multi-thread example. I will use a thread to calculate  a variable and update the new window title. The main source codes are like this: Use Eclipse to create a project, Use Activity to add onStart, onPause, and onStop etc. Activity is the most popular class that we use, and is also a core Class for Android. It is used to  administer and display a screen for an app, and Android developer should be very familiar with it.  Activity operation is following the sequence: onCreate，onStart，onStop，onPause，onResume， onRestart，onDestroy，onRestoreInstanceState，onSaveInstanceState. The popular execution sequence is onCreate，onStart，onResume. When windows is not  at the top level, onPause，onstop are executed, if it is on the top, then onRestart，onResume will be executed.  The loop will continue until onDestroy. If you want to save window, just reload onSaveInstanceState，and reload onRestoreInstanceState when enter。Here are the example that multi-thread is created in onStart using Activity method：

01.MyThread myThread = new MyThread();
02. myThread.start();

Add MyThread code below:

01.public class MyThread extends Thread {
02. // Claim character variable
03. public MyThread() {
04. }
05.
06. @Override
07. public void start() {
08. super.start();
09. }
10.
11. // main working method of thread
12. @Override
13. public void run() {
14. while (true) {
15. try {
16. sleep(5000);
17. if (c > ((1 << 31) - 1)) {
18. c = 0;
19. } else {
20. c++;
21. }
22. Message message = new Message();
23. message.what = 1;
24. mHandler.sendMessage(message);
25. } catch (InterruptedException ex) {
26. }
27. }
28. }
29.
30. }

Method of realize updatetitle：

01.public void updateTitle() {
02. setTitle("test thread " + c);
03. }

Here updatetitle  is not used to directly update new window, instead, handler is used. The reason is that the direct usage of updatetitle  is not safe, and may cause threading restart and other issues. Android introduced Handler as a special class, and use it as a bi-direction bridge between Runnable and Activity. So we can only send Message in method run, but in Handler, we use different Message to execute different tasks, and add handler for program:

01.private Handler mHandler = new Handler() {
02. public void handleMessage(Message msg) {
03. switch (msg.what) {
04. case 1:
05. updateTitle();
06. break;
07. }
08. };
09. };

The final version of completed source codes are as below，threading is used to process data and display data on window:

01.package com.test;
02.
03.import android.app.Activity;
04.import android.os.Bundle;
05.import java.lang.Thread;
06.import android.os.Message;
07.import android.os.Handler;
08.import android.graphics.Color;
09.
10.public class TestThreadActivity extends Activity {
11. int c = Color.BLUE;
12. MyThread myThread;
13. volatile boolean bThreadRun = false;
14.
15. /** Called when the activity is first created. */
16. @Override
17. public void onCreate(Bundle savedInstanceState) {
18. super.onCreate(savedInstanceState);
19. setContentView(R.layout.main);
20. }
21.
22. @Override
23. protected void onRestoreInstanceState(android.os.Bundle savedInstanceState) {
24. super.onRestoreInstanceState(savedInstanceState);
25. }
26.
27. @Override
28. protected void onSaveInstanceState(android.os.Bundle outState) {
29. super.onSaveInstanceState(outState);
30. }
31.
32. @Override
33. protected void onStart() {
34. super.onStart();
35. myThread = new MyThread();
36. myThread.start();
37. bThreadRun = true;
38. }
39.
40. @Override
41. protected void onRestart() {
42. super.onRestart();
43. }
44.
45. @Override
46. protected void onResume() {
47. super.onResume();
48. }
49.
50. @Override
51. protected void onPause() {
52. super.onPause();
53. bThreadRun = false;
54. // myThread.stop();
55. }
56.
57. @Override
58. protected void onStop() {
59. super.onStop();
60. onPause();
61. }
62.
63. @Override
64. protected void onDestroy() {
65. super.onDestroy();
66. // myThread.destroy();
67. }
68.
69. private Handler mHandler = new Handler() {
70. public void handleMessage(Message msg) {
71. switch (msg.what) {
72. case 1:
73. updateTitle();
74. break;
75. }
76. };
77. };
78.
79. public void updateTitle() {
80. setTitle("test thread " + c);
81. setTitleColor(c);
82. }
83.
84. public class MyThread extends Thread {
85. // Claim character variable
86. public MyThread() {
87. }
88.
89. @Override
90. public void start() {
91. super.start();
92. }
93.
94. // The main method of work of threading
95. @Override
96. public void run() {
97. while (bThreadRun) {
98. try {
99. sleep(100);
100. if (c > ((1 << 16) - 1)) {
101. c = 0;
102. } else {
103. c += 100;
104. }
105. Message message = new Message();
106. message.what = 1;
107. mHandler.sendMessage(message);
108. } catch (InterruptedException ex) {
109. }
110. }
111. }
112.
113. }
114.
115.}

Another popular way of threading is to compile Runnable interface. Here we do some modification to the source codes to use threading to realize the redraw of main window. The complete source codes are as below:

01.package com.test;
02.
03.import android.app.Activity;
04.import android.content.Context;
05.import android.os.Bundle;
06.import java.lang.Thread;
07.import android.view.View;
08.import android.graphics.Canvas;
09.import android.graphics.Color;
10.import android.graphics.Paint;
11.import android.graphics.Paint.Style;
12.import android.graphics.Rect;
13.
14.public class TestThreadActivity extends Activity {
15. int c = Color.BLUE;
16. MyThread myThread;
17. volatile boolean bThreadRun = false;
18. MyView mv;
19.
20. /** Called when the activity is first created. */
21. @Override
22. public void onCreate(Bundle savedInstanceState) {
23. super.onCreate(savedInstanceState);
24. // setContentView(R.layout.main);
25. mv = new MyView(this);
26. setContentView(mv);
27. }
28.
29. public class MyView extends View {
30. MyView(Context context) {
31. super(context);
32. }
33.
34. @Override
35. protected void onDraw(Canvas canvas) {
36. // TODO Auto-generated method stub
37. super.onDraw(canvas);
38.
39. // Fist define  a paint
40. Paint paint = new Paint();
41.
42. // draw rectangular area -solid filled rectangular
43. // configure color
44. paint.setColor(c);
45. // Configure style and fill
46. paint.setStyle(Style.FILL);
47. //Draw a rectangular
48. canvas.drawRect(new Rect(0, 0, getWidth(), getHeight()), paint);
49. }
50.
51. }
52.
53. @Override
54. protected void onRestoreInstanceState(android.os.Bundle savedInstanceState) {
55. super.onRestoreInstanceState(savedInstanceState);
56. }
57.
58. @Override
59. protected void onSaveInstanceState(android.os.Bundle outState) {
60. super.onSaveInstanceState(outState);
61. }
62.
63. @Override
64. protected void onStart() {
65. super.onStart();
66. //myThread = new MyThread();
67. //myThread.start();
68. new Thread (new MyThread()).start();
69. bThreadRun = true;
70. }
71.
72. @Override
73. protected void onRestart() {
74. super.onRestart();
75. }
76.
77. @Override
78. protected void onResume() {
79. super.onResume();
80. }
81.
82. @Override
83. protected void onPause() {
84. super.onPause();
85. bThreadRun = false;
86. // myThread.stop();
87. }
88.
89. @Override
90. protected void onStop() {
91. super.onStop();
92. onPause();
93. }
94.
95. @Override
96. protected void onDestroy() {
97. super.onDestroy();
98. // myThread.destroy();
99. }
100.
101. public class MyThread implements Runnable{
102. // the main method of work of threading
103. @Override
104. public void run() {
105. while (bThreadRun) {
106. try {
107. Thread.sleep(500);
108. if (c > ((1 << 31) - 1)) {
109. c = 0;
110. } else {
111. c += 100;
112. }
113. mv.postInvalidate();
114. } catch(InterruptedException e){
115. }
116. }
117. }
118.
119. }
120.
121.}

For beginning  Android game developers, it is very common that they get lost  frequently and do not know where to  start and get their hands wet. Especially when they get problems that they can not resolve by themself, and be jealous about the free game engine  such as Cocos2d-iphone  that iphone developers have. Some start to complain that game development on Android platform is too difficult, and not even a decent game engine is handy to use.  Some even think that  using the Java language to develop games has lower ROI.

In fact,  in the real world, as Android is becoming possibily the only strong competitor against Apple IOS or even pass it,  there are for sure a lot resource that are available to Android developers, including quite a lot of Game Engines. Here I will introcude  the eight common Android game engines for Android game developers (Notes: fee based, low downloads counts, Not Open Sourced and the game engines that  I personally do not know (-_-) are not included here.).

1  Angle

Angle is a specifically designed for the Android platform, agile and suitable for the rapid development of 2D game engine based on OpenGL ES technology development. The engine are written in Java code, and you can replace the inside to achieve according to your needs. The drawback is that there are not enough documentations, and the codes available for download contains limited  sample tutorials.

The minimum operating environment requirements is unknown.

Project Address: http://code.google.com/p/angle/

2  Rokon

Rokon a the Android 2D game engine developed based on  OpenGL ES technology, the physics engine is the Box2D-, and therefore able to achieve some of the more complex physical effects.  The latest version is 2.0.3 (09/07/10). Overall, the biggest advantages of this engine is that  its development documentation is complete and comprehensive. And the author of the project responds to bug report and feedbacks quickly and provid fixs and solution. As a result, this framework is currently the most widely used, and lots of developers call it it called it iPhone version of Cocos2d  (logic, and coding style, did looks very similiar). Several Android Game framework are developed based on this frame (fee based, membership download only) . So we do not stereotype the claims that Fee-based engines are good good, open sourced and free are bad.

The minimum operating environment requirements for the Android 1.5.

Project Address: http://code.google.com/p/rokon/

3  LGame

LGame is a  Java game engine developed by China Android developers. It has two version: Android and PC (J2SE), the highest version is  0.2.6 (31/07/10). The underlying graphics LGrpaphics packaged with   Graphics API provided by J2SE and J2ME (PC version uses the Graphics2D package, the Android version of Canvas emulation for rendering). As a result, developer can directly apply J2SE or J2ME development experience . The Android version has built-in Admob interface,  and there is not need to configure the XML befort you directly hard-code Admob advertising information.

In addition to the basic sound, graphics, physics, Wizard and other common components of the engine, it alos has built-in IoC, xml, http, and other commonly used Java components package. The drawback is that   the jar size is relatively big, the PC version jar size has exceeded 1.2MB, while the Android version is around 500KB. In addition, the engine is also built-in  the J2ME Wizard class and related components that support 1:1 rending, the vast majority of J2ME games can be ported to Android or PC version. The only shortfall is that the author of the project is a very lazy guy, development documentation promised last year still not complete, and only  game example is available  for download.

The minimum operating environment requirements for the Android 1.1.

Project Address: http://code.google.com/p/loon-simple/

4  AndEngine

andengine is also an OpenGL ES technology-based Android game engine, physics engine is the same as the Box2D (standard III). The framwork is average on performance, and lack of development documentation. However, it has a lot of code  examples.

Download (no jar download, source code can be extracted using svn): http://code.google.com/p/andengine/

The minimum operating environment requirements is Android 2.2 or above

Project Address: http://code.google.com/p/rokon/

5 libgdx

Libgdx is a game engine developed using OpenGL ES technology, and support 2d Game development for Android platform, the rendering was done by physical engine using Box2D. From the perspective of performance, it is a very power game engine for Android, the drawback is that the Wizard and other relate componments are  not simple enough and user friendly, and documentations are also underdeveloped.

The minimum operating environment requirements is unknown.

Project Address: http://code.google.com/p/libgdx/

6 jPCT

jPCT is a standard based on OpenGL technology development, 3D graphics engine (PC environment for the OpenGL, Android OpenGL ES), based on the Java language, has a powerful Java 3D solutions. The engine and LGame (This is a 2D game engine) is similar to, with a PC (J2SE) and Android two development versions.

jPCT of one of the biggest advantage is its amazing backwards compatibility. In the PC environment, jPCT can even run in the JVM1.1 environment, because the graphics rendering jPCT internal interfaces fully comply with all the Java 1.1 specification (and even the Microsoft VM has disappeared, even the old Netscape 4 the VM is no exception ).

The minimum operating environment requirements for the Android 1.5.

Project Address: http://www.jpct.net/jpct-ae/

7 Alien3d

Alien3d is a very small volume Android 3D game engine based on OpenGL ES technology development. In order to compress the volume, according to different functions using a multi-jar release (to include alien3d-engine.jar the alien3d-tiled.jar the alien3d-sprites.jar the alien3d-shapes.jar alien3d-particles2d.jar), in fact, it The core file is only about 40KB, the sum of all the relevant jar is less than 150KB.

The minimum operating environment requirements for the Android 1.5.

Project Address: http://code.google.com/p/alien3d/

8 Catcake

Catcake is a cross-platform Java 3D graphics engine, support for the PC (J2SE) and the Android environment running (has been the iPhone version of Planning). All the outstanding performance of the engine in the ease of use and operational performance, support for game development, such as wizard animation, audio processing and video playback.

The minimum operating environment requirements for the Android 1.6.

Project Address: http://code.google.com/p/catcake/

http://www.xolo.in/

Information Week Report

http://www.wired.com/gadgetlab/2012/04/its-official-intel-silicon-to-finally-appear-in-a-shipping-smartphone-in-india/

According the official XOLO website: "Superior Intel technology and Lava’s innovation come together to bring you the new XOLO X900, the first smartphone with Intel Inside®. Experience fast web browsing with the 1.6 GHz Intel processor. Based on Intel patented Hyper Threading technology this processor also enables smooth multi-tasking with optimum battery usage. A 4.03” hi-resolution LCD screen, dedicated HDMI output, full HD 1080p playback and dual speakers ensure an unmatched multimedia experience. Click up to 10 photos in less than a second on the 8MP HD camera which boasts of certain DSLR like features. With XOLO X900’s 400 MHz Graphics Processing Unit, 3D and HD gaming turn immersively realistic. Everything you have always wanted, and more, now comes in a blink into your pocket"

LAVA, one of India’s fastest growing handset brands.  XOLO X900, XOLO’s introductory offering, is the world’s first mobile phone with the power of Intel inside®.The stylish and sleek new XOLO X900 is a result of commitment to quality and innovation, designed to provide a superlative, immersing and engaging experience to address the need for a dynamic smartphone for today’s generation. The brand has invested in a state-of-the-art R&D Centre in Shenzhen (China) and Bangalore (India)

Does Intel Chip use more power? To answer this, one of my colleague quickly looked at the battery life spec, and  you can find them from below. Datas from LAVA and Apple webpage:

XOLO

Talk time (2G) up to 15.5 hours
Talk time (3G) up to 7.8 hours
Music playback (earphones) up to 43.9 hours
Video playback (earphones) up to 6 hours
Total standby time up to 14 days

iPhone 4 Spec:

• Talk time: Up to 8 hours on 3G, up to 14 hours on 2G (GSM)
• Standby time: Up to 200 hours
• Internet use: Up to 6 hours on 3G, up to 9 hours on Wi-Fi
• Video playback: Up to 10 hours
• Audio playback: Up to 40 hours

This  is pretty good considering a phone with 4.03” hi-resolution LCD screen, dedicated HDMI output, full HD 1080p playback!

 " The missing pieces (of emulator) were the completion of Android x86 support, and the GPU support in last week’s release of SDK Tools r17. This works by funneling the OpenGL ES 2.0 instructions from the emulator to the host OS, converted to standard OpenGL 2.0, and running natively on the host GPU", Android team members Xavier Ducrohet and Reto Meier wrote on the blog on the Android Developers Blog.

The blog further acknowledged that because the Android platform allows deep interaction between applications, and with system components,  an emulator with a complete system image is a much-needed tool for Android developers. New Google emulator virtualizes a complete device: hardware, kernel, low-level system libraries, and app framework.

This is indeed a great news for the Android developers who want to develop apps that run on both ARM and Intel Atom based devices

Lenovo K800, the first smart phone  with Intel Medfield platform, drawed  a wide range of media attention in CES2012. According China Tech Portal http://mobile.it168.com/a2012/0327/1330/000001330178.shtml , this week,  Lenovo has cleared all the obstacles and received China Mobile Network Entrance License for K800 from China National Telecommunication Equipment Certification Center,  Ministry of Industry and Information Technologies (TECC MIIT).  This means Lenovo has paved all its way up for the imminent launch of the first Intel Smart Phone Lenovo K800, and make it available to the largest mobile phone market in the world.

Lenovo models K800,  the first Intel Medfield platform phone,  has a 4.5-inch super large screen which is the largest Lenovo mobile touch screen size with the resolution  reaching 720p (1280x720 pixels) specification, plus the pixel density of 326ppi. From the photos released by TECC MIIT, the phone looks simple and stylish from both front and back:

As the main features of the first Intel Smart phone, the Lenovo K800  is equipped with one Intel1.6GHz Atom Medfield processor, which features 32-nanometer process, and the lowest to the highest  main frequency from 600MHz to 1.6GHz .This low power single core processor can reach two-cores by virtual Hyper-Threading technology. The chip comes with 512KB of L2 cache (up to the core level of the ARM Cortex-A15), using dual-channel LPDDR2 program, with PowerVR SGX 540 GPU.  Lenovo K800 is equipped with a 1970 mA battery case, in theory, will receive up to 14 days of standby time eight hours of 3G talk time, and four consecutive 15-hour music playback time. The performance gain is big enough that it  make the most of the smart phones competitors on the market hard to catch up. However, according to the information released from TECC MIIT,  the Lenovo K800 first comes with Android 2.3 Gingerbread system, and  is expected to upgrade to Android ICS 4.0 system shortly, which has much better user experience.

The Lenovo K800 is also equipped with a built-in 8 Million pixels (8MP) camera, auto-focus and high-speed continuous shooting,  as well as 1080p full HD video recording function. In addition, it also supports WCDMA networks and Wi-Fi wireless Internet access, GPS navigation, memory card expansion,  Blue tooth technology, and because the machine uses a Lenovo customization Clover UI and built-in localization of Chinese Service such as Sina, Netease, Sohu, so there are media reports that the first launch of K800 is targeted in China market

Lenovo Launches An Android App Store For The Enterprise

In a separate progress from Computer manufacturer Giant Lenovo, Lenovo  launched  an Android App Store for the Enterprise.  The Lenovo Enterprise App Shop enables IT managers to customize and publish Android corporate apps in an online store, and to purchase volume apps with license management for end users.

Sarah Perez,  a writer for TechCrunch, had wrote an article "Lenovo Launches An Android App Store For The Enterprise"  on http://techcrunch.com and gave an good analysis on Lenovo's  move  which is clearly one designed to target the increasing popularity of the Apple iPad in the enterprise.

Mike wrote " Support for x86 should get better as the facilities settle down from experimental to production. If you do install the x86 emulator then the result runs at close to native speeds - i.e. the sort of response times you would get from running Android on an x86 architecture. This is not surprising as this is exactly what you are doing - only the peripheral hardware is being fully emulated. What this means is that if a consumer version of the emulator can be produced then there is no barrier to running Android apps under Windows, Linux or OSX. Having the emulator prove itself within the SDK seems like a really good way of making sure that it works properly"

Since Google mainly support Android build on Linux platform (with Ubuntu 64-bit OS as top Linux platform, and IOS as 2nd), and a lot of Android Developers are using AVD on Eclipse hosted by a Linux system, it is very critical that Android developers take advantage of Intel hardware-assisted KVM virtualization for Linux just like HAXM for Windows and IOS.

Below are the quick step-by-step's on how to install, enable KVM  on Ubuntu host platform and  start Intel Android x86 Gingerbread emulator with Intel hardware-assisted virtualization (hypervisor). The result is very pleasing and AVD runs significantly faster and smoother than without hypervisor ( see video attached below).

KVM Installation

I referred the instructions from Ubuntu community documentation page. to get KVM installed.To see if your processor supports hardware virtualization, you can review the output from this command:

$ egrep -c '(vmx|svm)' /proc/cpuinfo

I got 64. If 0 it means that your CPU doesn't support hardware virtualization.

Next is to install CPU checker:

$ sudo apt-get install cpu-checker

Now you can check if your cpu supports kvm:

$kvm-ok

If you see:
"INFO: Your CPU supports KVM extensions
INFO: /dev/kvm exists
KVM acceleration can be used"

It means you can  run your virtual machine faster with the KVM extensions.

If you see:
"INFO: KVM is disabled by your BIOS
HINT: Enter your BIOS setup and enable Virtualization Technology (VT),
and then hard poweroff/poweron your system
KVM acceleration can NOT be used"

You need to go to BIOS setup and enable the VT.

Use a 64 bit kernel

Running a 64 bit kernel on the host operating system is recommended but not required.
To serve more than 2GB of RAM for your VMs, you must use a 64-bit kernel (see 32bit_and_64bit). On a 32-bit kernel install, you'll be limited to 2GB RAM at maximum for a given VM.
Also, a 64-bit system can host both 32-bit and 64-bit guests. A 32-bit system can only host 32-bit guests.
To see if your processor is 64-bit, you can run this command:

$ egrep -c ' lm ' /proc/cpuinfo

If 0 is printed, it means that your CPU is not 64-bit.
If 1 or higher, it is. Note: lm stands for Long Mode which equates to a 64-bit CPU.
Now see if your running kernel is 64-bit, just issue the following command:

$ uname -m

x86_64 indicates a running 64-bit kernel. If you use see i386, i486, i586 or i686, you're running a 32-bit kernel.

Install KVM

For Ubuntu Lucid (10.04) or later:

$ sudo apt-get install qemu-kvm libvirt-bin ubuntu-vm-builder bridge-utils

You may ignore the Postfix Configuration below by selecting "No Configuration"

Next is to add your <username> account to the group kvm and libvirtd

$ sudo adduser your_user_name kvm
$ sudo adduser your_user_name libvirtd

After the installation, you need to relogin so that your user account becomes an effective member of kvm and libvirtd user groups. The members of this group can run virtual machines.

Verify Installation
You can test if your install has been successful with the following command:
$ sudo virsh -c qemu:///system list
Your screen will paint the following below if successful:
Id Name                 State
----------------------------------

Start the AVD from Android SDK Directly from Terminal

Now start the Android for x86 Intel Emulator using  the following command:

$ <SDK directory>/tools/emulator-x86 -avd Your_AVD_Name -qemu -m 2047 -enable-kvm

Only a 64-bits Ubuntu can allow you to run allocated Memory of 2G or more. My 64-bit Ubuntu has 6G of Memory, so I used 1/3 of it for Android AVD. My AVD name is Intel_Atom_gingerbread_2.3 . '-qemu' provides the options to qemu, and '-m' specifies the amount of memory for the emulated Android (i.e. guest). If you use too small value for that, it's possible that performance is bad because of frequent swapping activities. Add '-show-kernel' to see the message from the kernel.

The YouTube in Android  x86 Intel Atom Gingerbread AVD is running fast and responsively in two level of virtual mode ( I remote login to a Ubuntu 10.04 and run the AVD from there).

Start the AVD by AVD Manager in Eclipse

Below is procedures recommended by Google. If you are running the emulator from Eclipse, run your Android application with an x86-based AVD and include the KVM options:

• In Eclipse, click your Android project folder and then select Run > Run Configurations...
• In the left panel of the Run Configurations dialog, select your Android project run configuration or create a new configuration.
• Click the Target tab.
• Select the x86-based AVD you created previously.
• In the Additional Emulator Command Line Options field, enter:

  -qemu -m 2047 -enable-kvm

• Run your Android project using this run configuration.

Summary

This blog is a collection of hands-on notes on building Android ICS 4 virtualbox installer for x86  from official Google x86 virtualbox target vbox-x86-eng (included in ICS 4.0 source)  and using a Linux 2.6 kernel provided by Intel to add specific feature for virtualbox and how to use installer.vdi to install Android ICS 4.0 into Virtualbox.

In addition to Google AVD  emulator supported by Intel Hardware Accelerated Execution Manager (HAXM) technology (already available Here),  Android for x86  Virtualbox is completely running x86 codes and provides another fast and high performance tool for developer and partner for quick app development and testing. Booting an Android ICS 4 in virtualbox takes about 20 seconds, same process on an ARM-based ICS 4 AVD emulator in Eclipse takes 65 seconds. Speed, performance, and user experience are all counted for the popularity of virtualbox among Android developers, especially for x86 platform. It takes time for x86 based Android tablet and phone to be easily available on the market.  Develop apps on AVD and virtual platform continue to be a top option for Android for X86 developers.

Why Google provides Virtualbox build Target for ICS 4?

If you have been using Google’s latest ICS source repo, you probably have noticed that Google provided an x86 version of Virtualbox target vbox_x86-eng. When you key in the lunch command before start your build, the first three targets that Google provide for ICS 4.0.1 are:

1. full-eng
2. full_x86-eng
3. vbox_x86-eng

With vbox_x86-eng (#3) target, developer and system builder can compile and make android_disk.vdi and android installer.vdi which can be used to run Android ICS 4 in virtualbox for app development and system integration on Windows, Linux and IOS platform .

Downloading the Source Tree and Installing Repo

Read  Things I Wish I Knew Before I Built My First Android-x86 from Google Source Supported by Intel to set up your app development platform and get ready for your Android build.

To install, initialize, and configure Repo, follow these steps (More detail on Android source site) :
$ mkdir ~/bin
$ PATH=~/bin:$PATH
$ curl https://dl-ssl.google.com/dl/googlesource/git-repo/repo > ~/bin/repo
$ chmod a+x ~/bin/repo
$ mkdir ANDROID_TOP_PATH
$ cd ANDROID_TOP_PATH

To get a list of available branches, (from your android repo checkout root), use this command:

$ git --git-dir .repo/manifests/.git/ branch -a

Google ICS 4.x are listed below:

remotes/origin/android-4.0.1_r1
remotes/origin/android-4.0.1_r1.1
remotes/origin/android-4.0.1_r1.2

Run repo init to bring down the latest version of Repo  with all its most recent bug fixes. I check out android-4.0.1_r1  at this hands-on:

$ repo init -u https://android.googlesource.com/platform/manifest -b android-4.0.1_r1

To use the Gerrit code-review tool, you will need an email address that is connected with a registered Google account. Make sure this is a live address at which you can receive messages. The Kernel version and Build number will be assigned to your build, and information will be displayed in Android/settings/about phone/ page.

A successful initialization will end with a message stating that Repo is initialized in your working directory. Your client directory should now contain a .repo directory where files such as the manifest will be kept.

To pull down files to your working directory from the repositories as specified in the default manifest, run

$ repo sync

By default, access to the Android source code is anonymous. To protect the servers against excessive usage, each IP address is associated with a quota. Now we switch to build a new Kernel before we come back to build ICS4.

What version of gcc and g++ to use?

Ubuntu 11 already start using gcc 4.6. So you can check your C/C++ compiler version by gcc –v to make sure your system is using gcc-4.4.  You also need to make sure that you use g++ version 4.4 for CXX command.

$ gcc -v
$ gcc version 4.4.3 (Ubuntu 4.4.3-4ubuntu5)

I am using Ubuntu 10.04LTS. So it happen on the same GCC version with Google

Using built-in specs.
Target: x86_64-linux-gnu
gcc version 4.4.3 (Ubuntu 4.4.3-4ubuntu 5)

If you are using gcc 4.6, you will always need to do “ make CC=gcc-4.4 CXX=g++-4.4.. “ for following Android build process

Building a Kernel Provided by Intel

Since Android is meant for touchscreen devices, it doesn’t include support for a mouse pointer by default, and possibly no network too as most Android devices are using wireless. To build a Android ICS 4  virtualbox for regular app development platform, we need to rebuild the kernel with mouse support as well as some of features that you probably need for your own apps. Intel Android developer site provided a Linux 2.6. kernel SDK for x86 which included many drivers that Intel developed. Go to Intel Android Developer site to download Android* 2.3.7 (Gingerbread) x86 Emulator Image Add-on.  After Unzip the package Intel_x86_sysimg_2.3.7_Source_Files.zip ( 1.2G), you will find:

• Gingerbread_2.3.7_x86_sdk-20111231.tgz
• kernel_sdk_x86.tar.gz

Run a untar to kernel_sdk_x86.tar.gz to create a new folder with the kernel 2.6.x source ( Intel soon will make new kernel for Ice Cream Sandwich  4 or higher available.However the process is similiar)

We switch to the directory that holds your kernel files. Now that we have the kernel source, we need to modify the configuration according to the hardware that you are using for Virtualbox host system and rebuild it. We can use menuconfig  graphical interface provided by kernel source which will allow us to do this conveniently:

$ cp ANDROID_TOP_PATH/your_kernel_path/arch/x86/configs/vbox_defconfig  .config

$ make  ARCH=x86 menuconfig

It will take a few seconds to compile and load:

Once it does, use Up/Down arrows to navigate, enter to select (i.e. to expand), ‘y’ (or space) to include. e.g. to enable Mice,You will need to go to:  Device Driver->Input Device Support -> Mice. To enable Wireless, you can go to Network Device Support etc.  You can also see that there session dedicated for Tablet, you can  go to related line and select them.

Note: menuconfig is the place that you check to make sure the required features and support for your application or system integration is supported. For App developers, it is equally important that you must test and validate your app on Android that is built with default menuconfig to guarantee the maximum compatibility  of your app to various Android device made by different OEM

$ make ARCH=x86 –j32

After the compiling, if you see the last line that Kernel: arch/x86/boot/bzImage is ready .Then, your make is successful.

Add patched Kernel

 Here the kernel image bzImage need to be renamed to kernel-vbox, and copied to /ANDROID_TOP_PATH/prebuilt/android-x86/kernel/kernel-vbox:

$ cp /ANDROID_TOP_PATH/kernel/arch/x86/boot/bzImage   /ANDROID_TOP_PATH/prebuilt/android-x86/kernel/kernel-vbox

Setup Faster Android Builds using CCACHE

You can greatly reduce the compile time for subsequent compilations by use the compiler cache. To set up a 50GB cache ( I have a big HDD),  you can run:

1. Install CCcache program and Create a directory for your ccache

$ sudo apt-get install ccache
$ sudo mkdir /ANDROID_TOP_PATH/ccache
$ sudo chown $LOGNAME  /ANDROID_TOP_PATH/ccache

2. Set up your environment variables Place these in your ~/.profile,

$ sudo gedit ~/.bashrc

Add:

export CCACHE_DIR=/ANDROID_TOP_PATH/ccache
export USE_CCACHE=1

3. Set the ccache sizes. If  you have a big hard drive, you can set it bigger:

$ ccache -F 100000
$ ccache -M 50G

Build ICS 4 with new Kernel

Setting up Environment:

$ /ANDROID_TOP_PATH/> source build/envsetup.sh

For ICS 4.0.1, you will see:

including device/samsung/maguro/vendorsetup.sh
including device/samsung/tuna/vendorsetup.sh
including device/ti/panda/vendorsetup.sh
including sdk/bash_completion/adb.bash

Time to time, I encounted "No Target to Make" error message when using lunch vbox_x86_eng. So it is easy to just do the following:

$ lunch
You're building on Linux
Lunch menu... pick a combo:
1. full-eng
2. full_x86-eng
3. vbox_x86-eng
4. full_maguro-userdebug
5. full_tuna-userdebug
6. full_panda-eng

Which would you like? [full-eng] 3   (Note: make sure you select 3.vbox_x86-eng)

PLATFORM_VERSION_CODENAME=REL
PLATFORM_VERSION=4.0.1
TARGET_PRODUCT=vbox_x86
TARGET_BUILD_VARIANT=eng
TARGET_BUILD_TYPE=release
TARGET_BUILD_APPS=
TARGET_ARCH=x86
TARGET_ARCH_VARIANT=x86
HOST_ARCH=x86 HOST_OS=linux
HOST_BUILD_TYPE=release
BUILD_ID=ITL41D
Run make,  I have a 16-core server, so I use j=32 (double by HT).

$ make   -j32

Compiling time is dependent on your hardware. Using 2.6 kernel will lead to a image file about 300 mb.

Setup DNS 

There have been issues reported by Android developer that time to time the networking   does not appear to get the default DNS servers. No knowing when  the related patch will be provided to ICS 4 vbox-x86 target repo. One way around this is to use some publicly available DNS servers, such as those provided by Google (8.8.8.8)(See  post here ):

Build the VirtualBox Android Disk (Android_disk.vdi) and VirtualBox Android Installer

Finally, we build the Android_disk.vdi and installer_vdi together :

$ make android_disk_vdi  installer_vdi  -j32

If the build is successful, You will see the output below somewhere:

Done with VirtualBox bootable disk image -[ out/target/product/vbox_x86/android_disk.vdi ]-
Done with VirtualBox bootable installer image -[ out/target/product/vbox_x86/installer.vdi ]-

With android_disk.vdi (334mb), you should be able to New->Create New Virtual Machine and use android_disk.vdi as an existing and run the ICS 4 in virtualbox. Set up the parameters for virtualbox is straigfoward. Unlike the previous Android in virtualbox that you need to click Machine on top menu  -> Disable Mouse Integration to enable your mouse. You just need to click inside the VirtualBox window (Press the right Ctrl key to release your mouse).

Go to setting -About this phone, and you will see your build information:

Install Android Virtualbox using installer.vdi

Even the file size in Virtualbox is expanded to ~550mb. It is still too small to load apps to test. We still need a Android installer disk  to install Android into a much larger partition ( better larger than 4G ).First you start New and follow Create New Virtual Machine Wizard to create a larger disk under IDE controller. In my case, I create a 4G disk in the format of vdi fixed file, and  set it as IDE Primary Master.

Then in  Storage of the Settings of your virtual machine as below:

Add the installer.vdi as the Primary IDE Slave as show below. Now you can get started to install Android  on the larger 4G Disk you just created.

1. Start the emulator
2. Use F12 to get to the BIOS boot menu. Boot to the secondary drive
3. Use grub to select the Install option: 2. Boot from Primary Slave

When you see "Done processing installer config", type "reboot"

Note: The first time you install on your target virtual disk, the install will most likely fail. A message will be printed that tells you to run the installer again. You should do so:

$ installer

After reboot, you can see that your Android is running from the larger disk that you create, and you can safely remove the installer.vdi from Storage under IDE Controller.

Serial Port

The Serial port has been enabled by default . The virtual machine needs a one-time enabling of the COM1 serial port however. The following instructions will cause VirtualBox to create a named pipe called .vbox_pipe in your home directory. From the command line:

$ VBoxManage modifyvm Android --uart1 0x03f8 4

$ VBoxManage modifyvm Android --uartmode1 server /home/user/.vbox_pipe

Or from in the GUI, use the serial ports tab to enable COM1 as a "Host Pipe" and select "Create Pipe" for it to be created as /home/user/.vbox_pipe.

To connect to this named pipe, use:

$ socat unix-client:$HOME/.vbox_pipe stdout

Note: Environment variables (e.g. $HOME) might not be understood by VirtualBox, so you will have to specify a full explicit path, like /home/user/.vbox_pipe.

Ethernet

The ethernet port (eth0) is enabled for DHCP in the image. To connect to it via ADB you will need the DHCP address that has been assigned.

If you are using a bridged ethernet, you may obtain this address from a shell prompt either from the serial port or from "developer tools -> terminal emulator" using the command:

$ netcfg

If you are using a Host-only adapter, 'vboxnet0', you should use the address 192.168.56.101. to create your host-only interface, you may need to use the command:

Final Notes

Now you have a virtualbox completely built from Google official vbox-x86 target for Ice Create Sandwich and the Kernel of your choice, and you control what to add or remove at Kernel built or Android compile level to address your need for Apps development and testing. There are a lot of discussion of Android ICS in virtualbox that you find tips and tricks, In my case,  I was able to twig and  add/install apps made by Java, NDK or Chrome Web application, play around and test them:

I can also user Intel Power Monitor tool to do power related profiling and monitoring about the application:

Start with  64 bits Ubuntu for your development platform build, and forget any 32 bits OS

I had a 32 bits Ubuntu in my lab, and I  love Ubuntu and trust that my apt-get should get everything I need. This is my first wrong turn and here are the results:

• I always had problems with the build failures due to erroneously using some 64-bit or 32-bit libs/headers ( several times I thought I almost fix them).
• Google Source Repository allow a single repository download for a single gmail account and a specific IP address only for an unknown time period. No 2nd try. It is very reasonable as each download transfer 2-4G  of data. I made my mistake on 32bits, and after I built my 64-bits and tried again, No luck!
• Latter, I found notes from Google: " By default, access to the Android source code is anonymous. To protect the servers against excessive usage, each IP address is associated with a quota"

You can download  and install Ubuntu 10.04 (64-bit)  as below

• Download Ubuntu [1], 64-bit edition
• Burn the ISO to CD, or follow the document in the page to create a bootable USB stick
• Boot from CD or USB
• Install

Make sure your check your OS and make sure it is 64-bit. You can "uname -a", and check if you see x86_64.

Set up your Proxy Server (Skip this step if your system connects directly to Internet)

Again, do your repo sync through a proxy is very tricky, and make sure you do this step right

For GNOME (Ubuntu 10.04/10.10/11.04):

Go to System->Settings->Network Proxy. Click on the 'Proxy Configuration' tab and enter in the proxy for your site. After that, click on the 'Ignored Hosts' tab and make sure all the sites you don't want proxy (localhost, 127.0.0.0/8, .local, 192.168.0.0/16, your.corporate.ip are listed there. Once done, click 'Apply System-Wide...' and then close the dialog. You are not done yet.

Bash

Edit your bashrc file, located at ~/.bashrc, and add these lines at the end:
export http_proxy=http://your.corporate.proxy:port#
export https_proxy=https://your.corporate.proxy:port#
export no_proxy=localhost,.yourcorporate.com,127.0.0.0/8,192.168.0.0/16

Git Proxy Settings

You will need a program called connect [2] for Git to utilize proxy (although if you know what you are doing, you can use whatever you like to connect via SOCKS). You can download the source at http://www.meadowy.org/~gotoh/ssh/connect.c and compile. Or if you are using Ubuntu, you can install the package connect-proxy by:

$ sudo apt-get install connect-proxy

After you have the connect program, you will need a script for Git to use. It will choose whether to connect through the proxy depending on the URL of the repository. Create and edit a new file named socks-gw. In it, put the following code:

#!/bin/sh
echo $1 | grep "\.yourcorporatename\.com$" > /dev/null 2>&1
if [ $? -eq 0 ]; then
connect $@
else
connect -S proxy-socks.yourcorporate.com:1080 $@
fi

You should put this somewhere on your path (e.g. ~/bin/). Remember to make the script executable by doing:

$ chmod +x PATH_WHERE_YOU_PLACED_UTILS/socks-gw

Then inside ~/.bashrc, add:
export GIT_PROXY_COMMAND=PATH_WHERE_YOU_PLACED_UTILS/socks-gw

Check Environment Settings

You can restart your terminal and see if the necessary environment variables are exported. After restarting the terminal, execute the following commands to check:

$ echo $http_proxy
$ echo $https_proxy
$ echo $no_proxy
$ echo $GIT_PROXY_COMMAND

Installing the correct version of Java SDK

Android relies on a JDK that is older than the one provided in newer Linux distributions. So do not always choose the latest Java SDK. In order to download it, you need to add the appropriate repository and indicate to the system which JDK should be used. Java 6 should be used for Gingerbread and newer
$ sudo add-apt-repository "deb http://archive.canonical.com/ lucid partner"
$ sudo apt-get update
$ sudo apt-get install sun-java6-jdk

Or get the JDK from oracle. Unpack it into your $HOME/bin/ and edit your .profile or .bashrc to set up the search path to find the javac in your $HOME/bin/jdk1.6.x_xx/bin before anything that may be on your distro install.

Add something like following to the end of ~/.bashrc: be sure to match the path's with whatever java you ended up with, or simply updating your PATH; (i.e. PATH=$HOME/bin/jdk1.6.0_xx/bin:$PATH)

$ export JAVA_1_6=$HOME/bin/jdk1.6.0_xx
# Adjust the next line if necessary, $JAVA_1_6 for Gingerbread
$ export JAVA_HOME=$JAVA_1_6
$ export JAVA_FONTS=/usr/share/fonts/truetype
$ export ANT_HOME=/usr/share/ant
$ PATH=$JAVA_HOME/bin:$ANT_HOME/bin:$PATH
$ export CLASSPATH=.

Note: replace xx with your actual version #

For Ubuntu (Apt-based)

Enable the Canonical Partner repository
Open Synaptic (normally, it's under System -> Administration)
Inside Synaptic, Settings->Repositories->Other Software
Make sure Canonical Partners entry is checked
Close Synaptic

Open a terminal. Do the following (exclude the $ sign):

$ sudo apt-get update
$ sudo apt-get install zip build-essential curl git-core \
python gcc patch flex bison gperf \
g++ squashfs-tools sun-java6-jdk \
ia32-libs g++-multilib zlib1g-dev \
lib32z1-dev lib32ncurses5-dev \
gcc-multilib libwxgtk2.8-dev \
tofrodos texinfo mtools

To make sure you will not miss any packages. Run the Google recommended below again:

$ sudo apt-get install gnupg flex bison gperf build-essential \
zip curl zlib1g-dev libc6-dev lib32ncurses5-dev ia32-libs \
x11proto-core-dev libx11-dev lib32readline5-dev lib32z-dev \
libgl1-mesa-dev g++-multilib mingw32  python-markdown \
libxml2-utils xsltproc

No need to worry about the duplications, just to make sure you will not miss any packages. Then:

$ sudo ln -s /usr/bin/fromdos /usr/local/bin/dos2unix

On Ubuntu 10.10:

$ sudo ln -s /usr/lib32/mesa/libGL.so.1 /usr/lib32/mesa/libGL.so

On Ubuntu 11.10:
$ sudo apt-get install libx11-dev:i386

Installing Repo  and Downloading the Source Tree

Repo is a tool that makes it easier to work with Git in the context of Android. To install, initialize, and configure Repo, follow these steps:
Make sure you have a bin/ directory in your home directory, and that it is included in your path:

$ mkdir ~/bin
$ PATH=~/bin:$PATH

Download the Repo script and ensure it is executable:

$ curl https://dl-ssl.google.com/dl/googlesource/git-repo/repo > ~/bin/repo
$ chmod a+x ~/bin/repo

Initializing a Repo client After installing Repo, set up your client to access the android source repository:

Create an empty directory to hold your working files:

$ mkdir gingerbread
$ cd gingerbread

Run repo init to bring down the latest version of Repo with all its most recent bug fixes. You must specify a URL for the manifest, which specifies where the various repositories included in the Android source will be placed within your working directory.

$ repo init -u https://android.googlesource.com/platform/manifest

The branch label “gingerbread”  has the required build files and modules needed to build the x86 SDK Emulator images. The Ice Cream Sandwich branch will be available shortly. To check out gingerbread branch only other than "master", specify it with -b:

$ repo init -u https://android.googlesource.com/platform/manifest -b gingerbread

When prompted, configure Repo with your real name and email address. To use the Gerrit code-review tool, you will need an email address that is connected with a registered Google account. Make sure this is a live address at which you can receive messages. The name that you provide here will show up in attributions for your code submissions, and also in the Android info page you build.

A successful initialization will end with a message stating that Repo is initialized in your working directory. Your client directory should now contain a .repo directory where files such as the manifest will be kept.

Getting the files

To pull down files to your working directory from the repositories as  specified in the default manifest, run

$ repo sync

The Android source files will be located in your working directory under their project names. Dependent on how fast your system is and your network, the initial sync operation will take about an hour or more to complete.

Building the Android System

Initialize the environment with the envsetup.sh script. Note that replacing "source" with a single dot saves a few characters, and the short form is more commonly used in documentation.

$ source build/envsetup.sh

including device/htc/passion/vendorsetup.sh
including device/samsung/crespo4g/vendorsetup.sh
including device/samsung/crespo/vendorsetup.sh

Choose a Target

Choose which target to build with lunch. The exact configuration can be passed as an argument, e.g.

$ lunch
Lunch menu... pick a combo:
1. full-eng
2. full_x86-eng
3. simulator
4. full_passion-userdebug
5. full_crespo4g-userdebug
6. full_crespo-userdebug
Which would you like? [full-eng]: 2.

Then, you will see:
============================================
PLATFORM_VERSION_CODENAME=REL
PLATFORM_VERSION=2.3.7
TARGET_PRODUCT=full_x86
TARGET_BUILD_VARIANT=eng
TARGET_SIMULATOR=false
TARGET_BUILD_TYPE=release
TARGET_BUILD_APPS=
TARGET_ARCH=x86
TARGET_ARCH_VARIANT=x86-atom
HOST_ARCH=x86
HOST_OS=linux
HOST_BUILD_TYPE=release
BUILD_ID=GINGERBREAD
============================================

Building the Code

$ make -jN

While N is the total core of CPU of your system. The more core you have, the faster it build.
If your build is successful, you will have the following files in

~/WORKING_DIRECTORY/out/target/product/generic_x86/

Next, you are ready to:

• Flash your Android build to your device
• Build an Android installer iso
• Create an Android AVD emulator
• Build a Virtualbox.

Android Ice Cream Sandwich is coming very soon. Same process applied to  ICS. However, any app or system developer will have to keep in mind that over 95% of Android smartphone are using Android Gingerbread or earlier version. To make your app backward capable, you need to make sure your App running well on Gingerbread.

Watch Video here

In many classes during the 4-day conference,  a lot of developers asked about Android for x86. The most commonly agreed answers by those developers are simple and straight forward: " Are there any Android device powered with Intel chip (x86) in the market? Not yet, at least not one sold in large scale except Logitec/Google TV"; then it comes to the 2nd questions " are there any Android for x86 phone or tablet coming to the market in future? A lot  agreed: Yes, probablly a lot!"

So it has been said that ICS has been optimized for Intel x86, then what are those optimization? AnandTech has a  artilce that give some clues: Understanding Intel's Android 4.0 x86 Optimizations. Just read on!!

With Google and Intel announcing collaboration on Android for X86 Intel Architecture last month on Intel IDF, it is official that the door is open for Android to, besides ARM, support Intel CPU family. As the only open source virtual software solution under the terms of the GNU GPL v2, cross-platforms Virtualbox provide a fast and simple solution to open source Android for x86. It allows developers to develop, test or port their existing  apps quickly without hardware. Standardized system images(iso/vdi) from Intel, Google and OEM partners repositories allow developer to test and validate their apps on designated platforms and get accepted earlier for targeted apps store. This is the first of a blog series  aiming at introducing a customer driven solution of developing, testing and validating apps with virtual Android, unconventional installation via VDI conversion, bridged networking and integration with Android Eclipse/DDMS platform.

Oracle full visualizer for Intel X86 architecture

Oracle Virtualbox platform packages are Open Source and Cross-Platforms which support Windows, IOS, Linux and Solaris. The binaries are released under the terms of the GPL version 2 and can be downloaded at:http://www.virtualbox.org/wiki/Downloads.  It support same virtual OS( in a single .vdi file) run on Windows, Linux and IOS, and is a critical key player in open source & cross-platforms ecosystem(Host OS, Virtualbox, Eclipse( Android)).

Download Google Android X86 iso image from Google

Go to Google Code site ( http://code.google.com/p/android-x86/downloads/detail?name=android-x86-2.2-generic.iso&can=2&q=), and download the Android of your preference. However, Android-x86 version 2.2  Generic and 2.3 Ginger Bread  are the versions that have been tested and confirmed the support of both LAN and Wireless connection via bridged network adapter configuration. Same iso image can also been located at www.android-86.org .

Install and setup Android in Virtualbox

Start Oracle VM Virtualbox Manager, and follow the steps below:

• Start New:  1)Name: Android-x86 2.2 Generic, 2). Operating System: Linux, 3). Version: Linux 2.6.
• Memory: 256- 512MB ( Dependent on how much memory your laptop/desktop has).
• Virtual Hard Disk: Create new hard disk
• Hard Disk Storage Type: Fixed-size storage
• Virtual Disk Location and Size: default is 8GB. Select your preferred location for the single vdi. file

Before installation, make sure your parameters are set as below:

Click Settings on the top menu, and select Storage. Click the Green + icon next to IDE Controller and add Android-x86-2.2 Generic iso image you just downloaded from Google.  Then click OK.

Click Start to continue the installation:

Use Up and Down Key to move the highlighted selection to Installation - Install Android-x86 to harddisk, and then press Tab key to enter edit mode, and enter the following (case sensitive. See above):

• DATA=sda1 SDCARD=sda5

This step is very important as we need to set primary partition for Android and a logical partition for SD Card so that you can use simulated SD Card latter to transfer files. You will find this very handy.

On next screens, do the following sequentially:

• Create/Modify Partition
• Highlight the Free Space, and use <- and -> key to select New
• Select Primary
• Set 7000MB for your sda1 partition ( or your prefered size if you have a big disk)
• Select Beginning
• Select Bootable
• Select Write
• Select Yes to confirm Write
• Highlight the remaining Free Space
• Select New
• Select Logical
• Select all remain harddisk size
• Make sure do not make this sda5 bootable (do not select Bootable)
• Write the sda5 partition and confirm with yes.
• Select Quit
• You will see the following table is created:

Click OK to continue to install and complete the steps below:

• Format sda1 as ext3
• Click Yes to install the boot loader grub
• Click Yes to install /system directory as read-write
• Select  Create a fake SD card
• Use all default 2047MB size

Now sit back and relax until the installation is complete. Before reboot, just remeber that you still have an Android 2.2 installation iso image loaded as virtual boot CD-rom. So you have to go back to Setting->Storage to remove the iso image. Now reboot:

Before startting to run virtual Android, you first need to click Machine on top menu and select Disable Mouse Integration. By clicking any area in Android, you mouse icon will change to a darker color, and now you are free to run Virtual Android on your laptop just like a real Android device.  The complete virtual Android is saved as a single .vdi file and you can find it at C:\Users\yourname\VirtualBox VM

Popular keys for virtual Android-X86 on  laptop

At the very first start, you will need to click Machine on the top menu, and select Disable Mouse Integration to enter into virtual Android( rightctrl release the mouse):

• Esc key = Back 1 screen
• Window  key =back to Home Key
• Right Ctrl = Release Mouse key lock
• Right Click Mouse: Back Key
• Home = Home Button
• Alt-F1 = Enter terminal
• Alt-F7  = exit   Terminal
• Menu key: Android Bottom menu
• Alt-F4: Power off

Set up SD card

Virtualbox Android  has pretty much all the functionality of an Android device except for the ability of making calls, location service and proximity sensor etc (same as any emulator including Google AVD). In addition, having the ability to run Android virtually, provides an alternative solution for those who do not want to set aside a computer for this purpose. To get startted, the first step you need to do is to install the SD Card and enable install from outside Android InMarket. To Do this, first go to Setting:

• Go to Setting -> Appstore -> Storage settings ->SD card
• Mount SD card
• Format SD Card.

Connect your Virtual Android to internet as a real device

Dependent on how you connect your host laptop to Internet, you will need different network setting to connect your Android to internet:

• Wireless: If you are connected to internet via wireless adapter, before you start your virtual Android, you need to go to Setting -> Network  to Enable your wireless network Adapter:

•  Network Cable(Cat5): If you are connected to internet via your network port via cat5 cable,  before you start your virtual Android, you need to go to Setting -> Network  to Enable your network Adapter:

Bridged adapter option. All network functionalities are exactly same as real device, and offers:

• Bi-directional access for Guest and Host in single laptop.
• Bi-directional Access on a subnet.
• Bi-directional access between virtual Android’s

After selecting correct network adapter, now start your Android. Unlock your screen and type Alt+F1 to enter into Android terminal window, and enter very typical Linux command: netcfg.  If you see your eth0 obtained an IP address from your DHCP server, your Android is connected to Internet:

Lets get some free apps loaded before shopping Google  Android Market

Start your Brower and confirm that your virtual Android is connected to internet like a real device:

Then, start AndAppStore, and get some free apps for your Android Apps development and testing. Currently there are around 5000 apps listed in Android-x86 2.2 AndAppStore :

One of app that I found of most useful is File Expert (Utilities::File & Disk Management) that you can setup a Web share and FTP share on your virtual Android so that you can freely download and upload files,  which are very convenient when you start to build your development environment:

You can set up your own user name and password for increased security.

Develop and test your Android Apps ( .apk package)

Google apps are all packaged with .apk extension, and put in /system/app folder.  With virtual Android-x86, you can easily upload/download your .apk package:

After you upload your .apk package to /system/app folder,  you can get access to terminal via Alt-F1 and run the following command:

chown 1000:1000 /system/app/yourpackage.apk

Then your app will show up in Android menu.

Test different screen size and resolution

By default, Android in virtualbox is displayed in 800x600. You can easily change the screen size and resolution to your prefered size or the same size of your targeted Android  device. To do this, you need to press"e"  twice at Android start menu to reach grub edit menu and enter vga=ask at the end of entry as below:

Then press "b" to boot your Android, and the screen size and resolution options are displayed as below.  You can select whatever the size/resolution you want to start the Android:

Android-x86 in Virtualbox  vs  Google  Android Virtual Device (AVD)?

There is no doubt, Android-x86 in Virtualbox is way faster than Google AVD. Below are some difference:

Virtual Box:

• Fast: X86 based ( same as iOS or WP7 emulator)
• Only emulate User-mode
• OS image(.vdi) easy to transfer, customizable to meet different needs.
• Allow quick and convenient Snapshot

• Slow- ARM based(ARM-eabi)
• Full system QEMU: emulate whole guest system.
• Additional Dalvik VM, need to run bytecodes for Android Apps

Coming Next

I will continue to blog on my projects:

• Android SDK Integration- Android Debugging Environment and DDMS
• Use Eclipse ADT to Remote test/push apps to Android Virtualbox
• Virtual Android 3.2 Honeycomb in Virtualbox and on real device.

If you are on some of those topics, lets collaborate.

What is Open Source Software

Ridding on the fast blooming of open source development in China, in server, mobile Internet terminal, Internet web sites, high performance computing and embedded categories, the market share for Linux based open source OS has jump to unprecedented level, and open source software has became the major player as more fundamental Internet  backbone software ( operation system, database, middle-ware, and office suites) are developed.

By simple logic, we call any software that can be freely acquired, modified  and source code derived and republished as open source software ( the definition does not involve the commercial purpose of  open source software and other legal implication). Certainly different open source has different degree of freedom and openness. But strictly, by Open Source Initiatives ( OSI), Open source software must meet ten open source codes definition (so called Eric Raymond initiative):

1. Free Redistribution.
2. Source Code: all open source software must include source code and guarantee the openness of source code.
3. Derived Works: Open Source license must allow revise and derive work ( develop and revise based on original software source code)
4. Integrity of the Author's Source Code: To respect the right of original authors, when revised open source software to be published, it must accompany the original source code.
5. No Discrimination Against Persons or Groups: keep openness, encourage maximum participation, collaboration and co-authorization.
6. No Discrimination Against Fields of Endeavor. For example, no discrimination against open source software used in security or commercial purpose.
7. Distribution of License: The license of  open source software apply to all recipients without implementing any limited condition.
8. License Must Not Be Specific to a Product
9. License Must Not Restrict Other Software
10. License Must Be Technology Neutral

We must point out that without  business model and monetization, Open source will have no chance of surviving and becoming a major player, and realizing the production and commercialization; For developing infrastructure software (including those developed using open source infrastructure software), if the software is not self-controllable, the infrastructure software can not be realized or can not guarantee China's national security strategy. Then, the production and promotion to its use will be blocked; To by-pass this potential block, we must explore the innovation of open source software, to meet requirements for developing open source software in  fields such as security and commercial application. Not only should we inherit, promote and realize the value deposition of open and share of open source, but also must we control the potential legal risk of open source software.

What Will be the Future Mobile Operation Systems?

Currently, in global scope, the major mobile phone operation system are Android, Symbian (Open), iOS, Meego, Black Berry OS, Windows Phone(WP), WebOS etc. Among them, 2/3 are open source and 1/3 are proprietorial.

Some mobile computing experts believe that, after fierce competition,  in mobile arena, the mobile OS that can survive maybe not more than 3-4;  From my personal view, I am putting my bid on Android, iOS, and open sourced OS such as Meego that will likely be the top winners.

I have discussed five advantages of Meego in my previous article"Open Source Based Operation System" (Open source, high efficiency in development environment, Open  development environment and architecture, developers from Intel and Nokia QT team,  integrated technologies),  recently there are two additional advantages surfing out:

1. Meego's simple and near primitive  development environment and application architecture, not as complicated as Android, which stepped on the hidden mine of patent infraction, and lead to $5-15 patent fees that Mobile phone maker GTC and Samsung etc has to pay to Microsoft and Apple . In 2011, there are significant numbers of organizations in different segment ( company, institutions, and government) that are developing customized Android OS. One way of another, Patent infractions will most likely be an agenda item on the table.
2. The open source nature of Meego and its innovation model is likely the only solution for an open source operation system to be adopted in commercial and security business and government.

What is the difference between Meego and Android

Meego and Android are all open source operation system based on Linux Kernel. The major difference are:

1. The kernel of Meego is Linux Kernel, so called major distribution kernel released by official Linux Foundation. While Kernel of Android is the branch kernel released by Google, and authorized and approved by Linux Foundation.
2. Meego uses Qt as it development environment and development framework ( Qt abide the single LGPL Open Source license);  while the development environment of Android is diversified and tangled, adopting development tools and software from multiple sources, and abide different open source licenses, may including hidden patents.
3. Meego's application frameworks or function modules ( components)  are mostly LGPL open source licenses (there are also small percentage of framework use other open source, but has not private consultations signed mutual beneficial open source agreement).While Android's application frameworks or function modules are based on Apache-2 Open Source License ( including Java virtual layer), and consists of 185 software framework, and use 19 open source licenses ( including many frameworks not approved by OSI, but signed by private limited mutual beneficial open source agreement: Reciprocal). Among them are some unavoidable hidden patent.
4. Meego and Android independently develop and design its own user interface (UI) based on different mobile terminal device (such as Smart phone, Tablet, IVI and Internet TV etc), develop and integrate various Applications and focusing on User Experience ( UE=UI+Applications). In China, and may be other countries, the majority of development work for UE for both Meego and Android has been subcontracted to mobile terminal devices (MTD) manufacturers. Android platform is focused on  3rd party application development and integration, and managed using Google Android Market App Store (Got polluted by  quite a lot of virus and junk ads due to the loose management at the earlier stage). While Meego is temporarily be supported by Intel's Appup.com and responsible by Meego.com of Linux Foundation.
5. Meego's innovative solution which singles out security strategy and security software from operation system, and allowed separate configuration, and independent development to guarantee the safety independence and controllability of operation system (Meego)
6. Meego's innovative solution which allow modifications, change and independent development of: 1): User Experience ( User Interface and various applications including popular applications provided in OS); 2): Some functional modules ( framework) of middleware. Those changed software part could be either open or proprietary. This guarantee that this OS can be independently owned and controlled by anyone, and a trusted foundation that a commercial model could be safely build on.

In Which Direction the Open Source OS in China Will Go

In the past, most open source OS developed by enterprises in China, are based on Linux Kernel, and transplanted with software from other open source OS. Most companies only organize their own development and own user experience on user interface and some applications (Including integrating some localized software with OS platform, and taking order for customer specified application), and use testing technologies and development tools to Debug, Bug fix and Patch to achieve software  stability, optimization and performance gaining  ( IBM even support the quality certification for Redflag Linux) . As a mater of fact, Some OEM's of Mobile OS in Taiwan have been doing the something long time ago, except that it took about 6 months of development circle and testing/validation are conducted in a more strict way with more regulations.

Recently some well-known companies in China also  jump into the mobile OS development business, and started hardware and whole system design for its mobile device, and adding its own User Experience ( UE=UI+Applications) software on transplanted Android OS. Some even developed its own application frame work software. In general,  independently developed Mobile OS's by China domestic companies are mostly self-allied, isolated and mainly based on transplanted version from open source software outside China. Since only a small portion of the software are self developed, it is very hard for a Mobile OS of this kind to surf out as one of major mobile OS version in the world, and barely have space for improvement and promotion.

Development of the domestic mobile operating system for China market, taking a completely closed "from the ground start" development mode is not desirable; The best choice is development based on open source software OS and it must also meet the two criteria:

1. Meet the requirement for China's national security strategy.
2. Meet the requirements of commercialization for enterprises.

Thus, a complete adoption of  original version of "fully open" OS is off the table. Also some deviated version of open source OS developed domestically does not conform to the needs of self-control; thus developing an innovative model of open source software OS has become a priority.

Why We Need to Develop an Innovative Model of Meego

With regards to developing an open source Operation System in an innovative model, Meego has more advantage than Android in many aspects. Meego's development is  sheep-herded by Linux Foundation.  Mr. Jim Zemlin, Chair and executive director of Linux foundation, fully understand this. He wrote to Professor  Lu in June when 6th Open Source China Open Source World Summit was held Beijing"  I hope you can participate this summit, and we have opportunity to discuss the innovative model for open source, especially from the point of view of Chinese government (in consideration of national security strategy ) and entrepreneur (in consideration of commercialization and monetization) on open source development", " explorer together and find out the new innovation model for Meego open source software". Professor Lu noted that the bigest shortfall of Meego development is that so far there  are missing heavy weight corporation partners in building Meego eco-system. He encourage Linux Foundation and any corporation (big or small) to come to China to find one, and jointly develop Meego operation system, especially the innovative model for Meego open source software development.

Required Software

1. Meego Tablet img image: meego-tablet-ia32-pinetrail-1.2.0.90.0.20110517.1.img （download from here）
2. Kernel patch: kernel-adaptation-pinetrail-2.6.38.2-8.12.i586.rpm（download from here）
3. Patch file：ath3k-1.fw (download from here )
4. USB Bootable burning tool ：win32diskimager-RELEASE-0.2-r23-win32.zip （download from here ）

A project, or a product, once deviated from the commercialization and monetization,  will be hard to survive in the world's second largest blooming economy. Meego's birth wasn't without  the hardship. Looking back to the path of Android's development, one can easily conclude that the open source (Download today and develop! cool!) and co-development concept has, without doubt,  fueled the surprising jump of popularity of Android, so that today, it evolved into the only mobile OS that head-to-head competing  with iOS.

But recently,  the once seems uncontrollable wild fire of Android is calming down, According to [EOE Android Front-line News], from the beginning of this year, the momentum of the rise of the market share of Apple's iPhone is still not dieing down, and the market share of iPhone on Smart phone market has rose to 27%.  While the  market share of Goggles Android is flatten  and even to near zero growth for the first time. So there do have problems on the growth of Android products. Even though its market share is still the #1, and the commercial revenue of  Android platform is second to Apple. Some of the problems of Android are:

1. Too frequent version change:  For each version of Android, usually the smart phone  has three difference version of firmware,  the hardware variations of different brand of smart phone are so wide  that it is causing headache. From the point of mobile phone users,  it mean that the apps on online store have too much bugs and updates, the apps may not run on their phone , or it may barely run with reduced features, or  it may run with bad user experience and inconvenience ( just remember there are more than two dozen of smart phone brands in China, and each brand has over millions' of users). As a result, some people are saying: Android phone means Refresh OS-Power off-Change battery-Go back to first step. On other side, since the first release of the first iPhone in 2007, Apple only made three versions of iPhone, all iPhone users can quickly update the iOS ( or sometime even unware of it), and it leads to a fact that is super sweet to Apple that the percentage  of people using the  same version of OS is much higher than Android. Good or bad? you know it!
2. Immaturity of Apps Store model: the success of Apps store contributes the critical part of Apple's rise.  While the same model of online store seems running not that smooth for Android, some deficiencies of download and payment channel,  simple Apps validation and evaluation process which lead to  penetration of some bad money-sucking app into the online store and reach to phone in people's hand, and most critical one, the volume of Apps. All lead to some negative user experience for Android user compared with Apple. For developer's point of view, even though extremely unhappy with the autocratic style of Apple, they can not overlook the fact that their apps published on App Store brought in higher revenue.
3. Price War: Similar Android on similar smart phone with similar features , but made by different vendors, of course it will lead to a hot price war.  Starting in 2011, low budget Android phones start surfing out in the China market and taking market share quickly with first come first serve strategy, and keep Motorola, Samsung and HTC from holding up their price, and forced to slam their price to compete. Some price tag even dropped 20% in months.  While Android is confronting the civil war, it is also facing the fierce competition from iOS with low budget iPhone 3GS and coming low budget phone.

As the only open source operation system in the Mobile platform market ( Andriod is still qualified as open source? for how long?), Meego  draw a lot of attention at its birth. With the latest release of Tablet and IVI version of Meego 1.2 which attracted increasing # of vendors, and also with the first Meego Smart phone N9  from Nokia,  Meego seems cast a bright light in the horizon. Although people are confused with Nokia's so-called N9 being the last release of Meego Phone, and wonder what is Nokia's intention on this, people are still seeing Meego's potentials on some market segment, and some stand on the sideways waiting a bit to see what will evolve.  For Meego, there are unique advantages that we can see which are open source ( latest Open Source Tablet OS), optimization opportunity for OEM and apps developers,  Support of different hardware architecture ( Intel X86(IA), ARM etc) and extensive platform devices ( not only tablet and IVI, but wide variety of embedded devices), Apps that can be used on different devices without need of re-programming. These will effectively provide opportunity to allow OEM and Apps developers to lower the development cost and reduce the market risks.

Fundamentally, Meego is just a version of Linux, it want to do more, it want integrate more. From the technology viewpoint,  based on current development environment and hardware features and availability, it is still a long way to go for Meego which want to use cross-platform, stability and practical as selling point. On other side, doing better commercialization of an open source OS and attract more and more apps developers to write more apps for Meego is of vital importance ( Need to know that Nokia has only 55k apps which are QT based and can potentially be used in Meego.  Microsoft Windows Phone has  25k. Both  Nokia and Microsoft fall way behind Android (200k) and Apple iOS (424k)). From Meego's current development, we are seeing some new encouraging signs and Intel's ambitions. Hope Meego can continue to improve,  by taking lesson from what Androids just did, and pioneer to  a unique development space and revenue  generation model for developers and OEM, and cutting through its pathway in today's fiercest competition in mobile platform market.