Last week, I was in cycle of several Android developers and partners who have needs to compile and build their own Android for Intel x86 platform from Google source repository, and read through a lot of success/unsuccessful stories. I decided to try my own build. That was a wonderful journey and learning experience. Even though I have pretty of resource and help available around, I still made some wrong turns at different cross-roads, and got to say that back on track wasn't easy. To save your time doing the same, read on:
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 , 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
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.
Edit your bashrc file, located at ~/.bashrc, and add these lines at the end:
Git Proxy Settings
You will need a program called connect 
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:
echo $1 | grep "\.yourcorporatename\.com$" > /dev/null 2>&1
if [ $? -eq 0 ]; then
connect -S proxy-socks.yourcorporate.com:1080 $@
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:
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
$ 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
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 \
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
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
Choose a Target
Choose which target to build with lunch. The exact configuration can be passed as an argument, e.g.
Lunch menu... pick a combo:
Which would you like? [full-eng]: 2.
Then, you will see:
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
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.