Gumstix User Wiki - User contributions [en]

Android Source

2011-12-03T15:02:20Z

Kevin Harrington:

This page explains how to build Android from source [[Android_Source#Setup | from fresh]] or to update an [[Android_Source#Updating | existing source build]]. If you just want to [[Android_Usage | test drive Android]], you may prefer to use [[Android_Prebuilt | prebuilt images]].

All the source code is freely available for download, customization, and improvement. This section explains how to set up a development machine to build all the required components from source. These instructions have been tested on Ubuntu Maverick (10.10) 32 and 64 bit machines; as a rough estimate, this process requires 10GB of hard drive space and takes 4 hours (30 minutes of setup, 1.5 hours to download code, and 2 hours to build) on a moderate development machine. Users with existing Android source can [[Android_Source#Updating | rapidly update]].

== Setup ==
Android requires Sun(tm) Java and some additional software packages. These instructions assume an Ubuntu system however for other systems, see [http://source.android.com/source/download.html these pointers]. Begin by adding the official java repository for your system ('lucid' is fine, even if you are using a different Ubuntu version) and installing a new version of Java (you'll need to agree to the license agreement).
<code>
$ sudo add-apt-repository "deb http://archive.canonical.com/ lucid partner"
$ sudo apt-get update
$ sudo apt-get install sun-java6-jdk
$ sudo update-java-alternatives -s java-6-sun
</code>
Note, it is normal to get some ''error: no alternatives for...'' messages.

Now, install other required software. If you are building on a 64-bit machine (i.e. <code>uname -a|grep x86_64</code>), these packages are required:
<code>
$ sudo apt-get install git-core gnupg flex bison gperf build-essential zip curl zlib1g-dev gcc-multilib g++-multilib libc6-dev-i386 lib32ncurses5-dev ia32-libs x11proto-core-dev libx11-dev lib32readline5-dev lib32z-dev expect uboot-mkimage
</code>
For 32-bit machines, use these packages instead:
<code>
$ sudo apt-get install git-core gnupg flex bison gperf build-essential zip curl zlib1g-dev gcc-multilib g++-multilib x11proto-core-dev libx11-dev expect uboot-mkimage
</code>

Finally, install the '''repo''' tool. Repo is a tool to manage multiple Git repositories. You can install it wherever you like but if you have administrator rights, you might find this convenient:
<code>
$ curl https://dl-ssl.google.com/dl/googlesource/git-repo/repo > repo
$ chmod a+x repo
$ sudo mv repo /usr/bin/repo
</code>

== Fetch Source Code ==
With Repo installed, it is possible to use a single manifest file that describes all the git repositories to be fetched. More information about repo can be found [http://source.android.com/source/git-repo.html here]. These instructions place everything in a ''~/android'' directory but there is no restriction where this code is located.
<code>
$ mkdir ~/android
$ cd ~/android
$ repo init -u git://github.com/gumdroid/android-manifest.git
</code>
Respond to the prompted questions to finish the initialization. This next step fetches all the code and may take an hour or so. If a particular repository checkout fails, re-issue this command until everything has been successfully fetched (and most regrettably, it can takes a few tries).
<code>
$ repo sync
</code>
'''Tip:''' Use <code>repo sync -j2</code> to do multi-threaded fetches (but be alert for repositories that fail to download).

== Updating ==
Users trying to get a fresh build system running can skip this section; this may be useful for those who have previously set up an Android repository or who wish to host their own manifest.

To update from a previous android installation, simply issue these commands in your top-level directory.
<code>
$ repo init -u git://github.com/gumdroid/android-manifest.git
$ repo sync
</code>

=== Repository Management ===
A manifest file is a XML file that describes a set of git repositories that, collectively, make up a project. In this case, most of the repositories are cloned directly from [http://android.git.kernel.org/ Google], OMAP3-specific tweaks come from the [http://gitorious.org/rowboat rowboat-android repositories], and items like the kernel and the bootloaders are pulled from [https://github.com/search?q=android&type=Everything&repo=&langOverride=&start_value=1 Gumstix repositories]. To update the manifest and source code, simple issue the 'repo sync' command.
Manifests are themselves stored in a git repository so it is possible to use a manifest from a different git branch or commit.
To specify a new repository source, specify a new argument for the '-u' switch.
<code>
$ repo init -u <git repository source URI>
</code>
To specify a different branch or revision, specify a new argument for the '-b' switch.
<code>
$ repo init -b <branch name>
</code>
By default, the repo expects to use a file named ''default.xml'' as the manifest but it is possible to specify the specific manifest file to use.
<code>
$ repo init -m <manifest.xml>
</code>

By forking the repository on github, it should be very easy to set up your own repository. For a look under the hood, navigate to the ''.repo'' directory.

== Build ==
All required binaries and a root file system can be built for the Overo COM using the pre-built armel cross-compilers downloaded by repo.

=== Root File System ===
In the simple case, just calling 'make PRODUCT-overo-eng' will build an [http://source.android.com/porting/build_system.html#androidBuildVariants engineering build] of the Overo target defined in ''device/gumstix/overo/AndroidBoard.mk''. As usual, the '-j<#>' switch allows for a multi-threaded build. However, the following commands actually pull in some convenient macros, select a predefined combination (see the ''device/gumstix/overo/vendorsetup.mk''; use ''choosecombo'' to select your own) and use the 'm' alias for make to build the root filesystem.
<code>
$ source build/envsetup.sh
$ lunch overo-eng
</code>
The current build will not compile with out these hacks, whoever maintains the sources should look into fixing this.
<code>
$ make update-api
$ find . -type f -name '*.mk' -exec sed -i "s/-flto//g" '{}' \; 
$ find . -type f -name '*.mk' -exec sed -i "s/Werror=strict-aliasing/Wall/g" '{}' \;

</code>
Then compile!
<code>
$ m -j1
</code>
'''Note:''' Those building with a 32-bit system will get angry warnings on the first build. These can be ignored.

'''Note:''' To build a specific directory, navigate there and use the 'mm' macro or use the 'mmm' macro with the directory path as an argument. As explained, 'make clean' and 'make clobber' will clean up any messes.

After an hour or two, the build should complete with populated ''root'' and ''system'' directories in the ''out/target/product/overo'' directory.

=== Bootloaders, Kernel, and SGX support ===
The x-load and u-boot bootloaders, the linux kernel, and the SGX graphics code each have their own build system. These have been crudely integrated with Android: repo fetches the necessary files and a simple script can be called to perform a clean build of each of these component:
<code>
$ source utils/gumcompile
</code>
'''Note:''' This also generates a ''boot.scr'' u-boot bootloader script to set the necessary environment variables on boot. To change this script, modify ''utils/androidboot.cmd''.
For more fine-grained control, use the corresponding build systems directly (though looking at this script prove helpful).

== Create a Tarball ==
The final step is wrapping all the generated files into a tarball with appropriate permissions.
<code>
$ source utils/genrootfs
</code>

In the ''out/target/product/overo'' directory, you should find the following files needed to make a [[Android_Prebuilt | bootable microSD card]].
* MLO
* u-boot.bin
* boot.scr
* uImage
* rootfs.tar.bz2

''Note'': At the moment, the MLO built by the gumcompile will intermittently fail to boot a COM. As such, the MLO found in the output directory is copied from a known good pre-built binary in the ''utils/'' directory.

== Help and Help Out ==
These steps have refined from the [[http://code.google.com/p/rowboat/wiki/Main rowboat-android]] wiki and from [http://source.android.com google] documentation. Other useful links include:
* http://omapzoom.org/wiki/OMAP_Android_Main
* http://groups.google.com/group/android-porting?pli=1

Patches, suggestions and improvements are most welcome---please send to ash (at) gumstix.com. Pull requests on the github repositories are likewise appreciated.

User talk:Ashcharles

2011-12-02T18:02:01Z

Kevin Harrington:

Hey, my name if Kevin Harrington and i am trying to use your android build for my Gumstix using the Palo34 screen. Can you tell me which snapshot is supposed to work, as all of them starting with the current freezes with some sort of core-dump. Also, the instructions to building the image from source do not work at all. The "repo sync" hangs forever. I hacked around and tried the linero branch, and that synced, but would not compile.

My email is kharrington@neuronrobotics.com.

Thanks!

User talk:Ashcharles

2011-12-02T17:57:41Z

Kevin Harrington: Created page with "Hey, my name if Kevin Harrington and i am trying to use your android build for my Gumstix using the Palo34 screen. Can you tell me which snapshot is supposed to work, as all of t..."

Android Prebuilt

2011-12-02T17:17:27Z

Kevin Harrington:

The fastest way to test Android on a Gumstix Overo is using prebuilt images loaded on a bootable microSD card. This page explains where to find prebuilt images and how to make a bootable microSD card. Otherwise, check out how to [[Android_Source | build Android]] from source.

== Android in Four Commands ==
First, some useful tools should be downloaded. Those building from source will have already downloaded this git repository to the ''utils'' directory.
<code>
$ git clone git://github.com/gumdroid/android-utils.git utils
</code>

Images are built daily and can be found [http://cumulus.gumstix.org/images/android here]. Download the [http://cumulus.gumstix.org/images/android/current latest files].
<code>
$ source utils/gumget 
</code>

Next, insert a microSD card (at least 1GB by default) and confirm the path of the microSD card. For example,
<code>
$ df
</code>
might yield a path of <code>/dev/mmcblk0</code>.

Now, make a bootable microSD card (optionally, see [http://gumstix.org/create-a-bootable-microsd-card.html this procedure]):
<code>
$ sudo utils/mkandroidsd /dev/mmcblk0 .
</code>
(note the trailing '.'; this is the path to the directory where the downloaded files are stored)

'''Note:''' If present, the contents of a directory named ''Media'' located alongside the downloaded files will be copied on to the third partition. This is useful to load sample media onto your system.

Finally, remove the microSD from your computer, insert it into your Gumstix COM, and let it boot. Note that many packages are configured during the first boot so it may seem like your system hangs for approximately five minutes on the animated android text log screen. Subsquent boots should complete under a minute.

For information on using this port of Android, see [[Android_Usage | here]].

-----
'''Note:''' If your board fails to load the kernel, you may need to reset your u-boot environment variables as the boot script is not being run. To do this, issue this command at the u-boot prompt on startup.
<code>
$ nand erase 240000 20000
</code>

Android Prebuilt

2011-12-02T16:50:14Z

Kevin Harrington:

The fastest way to test Android on a Gumstix Overo is using prebuilt images loaded on a bootable microSD card. This page explains where to find prebuilt images and how to make a bootable microSD card. Otherwise, check out how to [[Android_Source | build Android]] from source.

== Android in Four Commands ==
First, some useful tools should be downloaded. Those building from source will have already downloaded this git repository to the ''utils'' directory.
<code>
$ git clone git://github.com/gumdroid/android-utils.git utils
</code>

Images are built daily and can be found [http://cumulus.gumstix.org/images/android here]. Download the [http://cumulus.gumstix.org/images/android/current latest files].
<code>
$ source utils/gumget 2011-05-03-yrwv17
</code>

Next, insert a microSD card (at least 1GB by default) and confirm the path of the microSD card. For example,
<code>
$ df
</code>
might yield a path of <code>/dev/mmcblk0</code>.

Now, make a bootable microSD card (optionally, see [http://gumstix.org/create-a-bootable-microsd-card.html this procedure]):
<code>
$ sudo utils/mkandroidsd /dev/mmcblk0 .
</code>
(note the trailing '.'; this is the path to the directory where the downloaded files are stored)

'''Note:''' If present, the contents of a directory named ''Media'' located alongside the downloaded files will be copied on to the third partition. This is useful to load sample media onto your system.

Finally, remove the microSD from your computer, insert it into your Gumstix COM, and let it boot. Note that many packages are configured during the first boot so it may seem like your system hangs for approximately five minutes on the animated android text log screen. Subsquent boots should complete under a minute.

For information on using this port of Android, see [[Android_Usage | here]].

-----
'''Note:''' If your board fails to load the kernel, you may need to reset your u-boot environment variables as the boot script is not being run. To do this, issue this command at the u-boot prompt on startup.
<code>
$ nand erase 240000 20000
</code>

Android Source

2011-12-01T21:34:49Z

Kevin Harrington: /* Root File System */

This page explains how to build Android from source [[Android_Source#Setup | from fresh]] or to update an [[Android_Source#Updating | existing source build]]. If you just want to [[Android_Usage | test drive Android]], you may prefer to use [[Android_Prebuilt | prebuilt images]].

All the source code is freely available for download, customization, and improvement. This section explains how to set up a development machine to build all the required components from source. These instructions have been tested on Ubuntu Maverick (10.10) 32 and 64 bit machines; as a rough estimate, this process requires 10GB of hard drive space and takes 4 hours (30 minutes of setup, 1.5 hours to download code, and 2 hours to build) on a moderate development machine. Users with existing Android source can [[Android_Source#Updating | rapidly update]].

== Setup ==
Android requires Sun(tm) Java and some additional software packages. These instructions assume an Ubuntu system however for other systems, see [http://source.android.com/source/download.html these pointers]. Begin by adding the official java repository for your system ('lucid' is fine, even if you are using a different Ubuntu version) and installing a new version of Java (you'll need to agree to the license agreement).
<code>
$ sudo add-apt-repository "deb http://archive.canonical.com/ lucid partner"
$ sudo apt-get update
$ sudo apt-get install sun-java6-jdk
$ sudo update-java-alternatives -s java-6-sun
</code>
Note, it is normal to get some ''error: no alternatives for...'' messages.

Now, install other required software. If you are building on a 64-bit machine (i.e. <code>uname -a|grep x86_64</code>), these packages are required:
<code>
$ sudo apt-get install git-core gnupg flex bison gperf build-essential zip curl zlib1g-dev gcc-multilib g++-multilib libc6-dev-i386 lib32ncurses5-dev ia32-libs x11proto-core-dev libx11-dev lib32readline5-dev lib32z-dev expect uboot-mkimage
</code>
For 32-bit machines, use these packages instead:
<code>
$ sudo apt-get install git-core gnupg flex bison gperf build-essential zip curl zlib1g-dev gcc-multilib g++-multilib x11proto-core-dev libx11-dev expect uboot-mkimage
</code>

Finally, install the '''repo''' tool. Repo is a tool to manage multiple Git repositories. You can install it wherever you like but if you have administrator rights, you might find this convenient:
<code>
$ curl https://dl-ssl.google.com/dl/googlesource/git-repo/repo > repo
$ chmod a+x repo
$ sudo mv repo /usr/bin/repo
</code>

== Fetch Source Code ==
With Repo installed, it is possible to use a single manifest file that describes all the git repositories to be fetched. More information about repo can be found [http://source.android.com/source/git-repo.html here]. These instructions place everything in a ''~/android'' directory but there is no restriction where this code is located.
<code>
$ mkdir ~/android
$ cd ~/android
$ repo init -u git://github.com/gumdroid/android-manifest.git -b linaro
</code>
Respond to the prompted questions to finish the initialization. This next step fetches all the code and may take an hour or so. If a particular repository checkout fails, re-issue this command until everything has been successfully fetched (and most regrettably, it can takes a few tries).
<code>
$ repo sync
</code>
'''Tip:''' Use <code>repo sync -j2</code> to do multi-threaded fetches (but be alert for repositories that fail to download).

== Updating ==
Users trying to get a fresh build system running can skip this section; this may be useful for those who have previously set up an Android repository or who wish to host their own manifest.

To update from a previous android installation, simply issue these commands in your top-level directory.
<code>
$ repo init -u git://github.com/gumdroid/android-manifest.git -b linaro
$ repo sync
</code>

=== Repository Management ===
A manifest file is a XML file that describes a set of git repositories that, collectively, make up a project. In this case, most of the repositories are cloned directly from [http://android.git.kernel.org/ Google], OMAP3-specific tweaks come from the [http://gitorious.org/rowboat rowboat-android repositories], and items like the kernel and the bootloaders are pulled from [https://github.com/search?q=android&type=Everything&repo=&langOverride=&start_value=1 Gumstix repositories]. To update the manifest and source code, simple issue the 'repo sync' command.
Manifests are themselves stored in a git repository so it is possible to use a manifest from a different git branch or commit.
To specify a new repository source, specify a new argument for the '-u' switch.
<code>
$ repo init -u <git repository source URI>
</code>
To specify a different branch or revision, specify a new argument for the '-b' switch.
<code>
$ repo init -b <branch name>
</code>
By default, the repo expects to use a file named ''default.xml'' as the manifest but it is possible to specify the specific manifest file to use.
<code>
$ repo init -m <manifest.xml>
</code>

By forking the repository on github, it should be very easy to set up your own repository. For a look under the hood, navigate to the ''.repo'' directory.

== Build ==
All required binaries and a root file system can be built for the Overo COM using the pre-built armel cross-compilers downloaded by repo.

=== Root File System ===
In the simple case, just calling 'make PRODUCT-overo-eng' will build an [http://source.android.com/porting/build_system.html#androidBuildVariants engineering build] of the Overo target defined in ''device/gumstix/overo/AndroidBoard.mk''. As usual, the '-j<#>' switch allows for a multi-threaded build. However, the following commands actually pull in some convenient macros, select a predefined combination (see the ''device/gumstix/overo/vendorsetup.mk''; use ''choosecombo'' to select your own) and use the 'm' alias for make to build the root filesystem.
<code>
$ source build/envsetup.sh
$ lunch overo-eng
</code>
The current build will not compile with out these hacks, whoever maintains the sources should look into fixing this.
<code>
$ make update-api
$ find . -type f -name '*.mk' -exec sed -i "s/-flto//g" '{}' \; 
$ find . -type f -name '*.mk' -exec sed -i "s/Werror=strict-aliasing/Wall/g" '{}' \;

</code>
Then compile!
<code>
$ m -j1
</code>
'''Note:''' Those building with a 32-bit system will get angry warnings on the first build. These can be ignored.

'''Note:''' To build a specific directory, navigate there and use the 'mm' macro or use the 'mmm' macro with the directory path as an argument. As explained, 'make clean' and 'make clobber' will clean up any messes.

After an hour or two, the build should complete with populated ''root'' and ''system'' directories in the ''out/target/product/overo'' directory.

=== Bootloaders, Kernel, and SGX support ===
The x-load and u-boot bootloaders, the linux kernel, and the SGX graphics code each have their own build system. These have been crudely integrated with Android: repo fetches the necessary files and a simple script can be called to perform a clean build of each of these component:
<code>
$ source utils/gumcompile
</code>
'''Note:''' This also generates a ''boot.scr'' u-boot bootloader script to set the necessary environment variables on boot. To change this script, modify ''utils/androidboot.cmd''.
For more fine-grained control, use the corresponding build systems directly (though looking at this script prove helpful).

== Create a Tarball ==
The final step is wrapping all the generated files into a tarball with appropriate permissions.
<code>
$ source utils/genrootfs
</code>

In the ''out/target/product/overo'' directory, you should find the following files needed to make a [[Android_Prebuilt | bootable microSD card]].
* MLO
* u-boot.bin
* boot.scr
* uImage
* rootfs.tar.bz2

''Note'': At the moment, the MLO built by the gumcompile will intermittently fail to boot a COM. As such, the MLO found in the output directory is copied from a known good pre-built binary in the ''utils/'' directory.

== Help and Help Out ==
These steps have refined from the [[http://code.google.com/p/rowboat/wiki/Main rowboat-android]] wiki and from [http://source.android.com google] documentation. Other useful links include:
* http://omapzoom.org/wiki/OMAP_Android_Main
* http://groups.google.com/group/android-porting?pli=1

Patches, suggestions and improvements are most welcome---please send to ash (at) gumstix.com. Pull requests on the github repositories are likewise appreciated.

Android Source

2011-12-01T17:36:39Z

Kevin Harrington: /* Root File System */

This page explains how to build Android from source [[Android_Source#Setup | from fresh]] or to update an [[Android_Source#Updating | existing source build]]. If you just want to [[Android_Usage | test drive Android]], you may prefer to use [[Android_Prebuilt | prebuilt images]].

All the source code is freely available for download, customization, and improvement. This section explains how to set up a development machine to build all the required components from source. These instructions have been tested on Ubuntu Maverick (10.10) 32 and 64 bit machines; as a rough estimate, this process requires 10GB of hard drive space and takes 4 hours (30 minutes of setup, 1.5 hours to download code, and 2 hours to build) on a moderate development machine. Users with existing Android source can [[Android_Source#Updating | rapidly update]].

== Setup ==
Android requires Sun(tm) Java and some additional software packages. These instructions assume an Ubuntu system however for other systems, see [http://source.android.com/source/download.html these pointers]. Begin by adding the official java repository for your system ('lucid' is fine, even if you are using a different Ubuntu version) and installing a new version of Java (you'll need to agree to the license agreement).
<code>
$ sudo add-apt-repository "deb http://archive.canonical.com/ lucid partner"
$ sudo apt-get update
$ sudo apt-get install sun-java6-jdk
$ sudo update-java-alternatives -s java-6-sun
</code>
Note, it is normal to get some ''error: no alternatives for...'' messages.

Now, install other required software. If you are building on a 64-bit machine (i.e. <code>uname -a|grep x86_64</code>), these packages are required:
<code>
$ sudo apt-get install git-core gnupg flex bison gperf build-essential zip curl zlib1g-dev gcc-multilib g++-multilib libc6-dev-i386 lib32ncurses5-dev ia32-libs x11proto-core-dev libx11-dev lib32readline5-dev lib32z-dev expect uboot-mkimage
</code>
For 32-bit machines, use these packages instead:
<code>
$ sudo apt-get install git-core gnupg flex bison gperf build-essential zip curl zlib1g-dev gcc-multilib g++-multilib x11proto-core-dev libx11-dev expect uboot-mkimage
</code>

Finally, install the '''repo''' tool. Repo is a tool to manage multiple Git repositories. You can install it wherever you like but if you have administrator rights, you might find this convenient:
<code>
$ curl https://dl-ssl.google.com/dl/googlesource/git-repo/repo > repo
$ chmod a+x repo
$ sudo mv repo /usr/bin/repo
</code>

== Fetch Source Code ==
With Repo installed, it is possible to use a single manifest file that describes all the git repositories to be fetched. More information about repo can be found [http://source.android.com/source/git-repo.html here]. These instructions place everything in a ''~/android'' directory but there is no restriction where this code is located.
<code>
$ mkdir ~/android
$ cd ~/android
$ repo init -u git://github.com/gumdroid/android-manifest.git -b linaro
</code>
Respond to the prompted questions to finish the initialization. This next step fetches all the code and may take an hour or so. If a particular repository checkout fails, re-issue this command until everything has been successfully fetched (and most regrettably, it can takes a few tries).
<code>
$ repo sync
</code>
'''Tip:''' Use <code>repo sync -j2</code> to do multi-threaded fetches (but be alert for repositories that fail to download).

== Updating ==
Users trying to get a fresh build system running can skip this section; this may be useful for those who have previously set up an Android repository or who wish to host their own manifest.

To update from a previous android installation, simply issue these commands in your top-level directory.
<code>
$ repo init -u git://github.com/gumdroid/android-manifest.git -b linaro
$ repo sync
</code>

=== Repository Management ===
A manifest file is a XML file that describes a set of git repositories that, collectively, make up a project. In this case, most of the repositories are cloned directly from [http://android.git.kernel.org/ Google], OMAP3-specific tweaks come from the [http://gitorious.org/rowboat rowboat-android repositories], and items like the kernel and the bootloaders are pulled from [https://github.com/search?q=android&type=Everything&repo=&langOverride=&start_value=1 Gumstix repositories]. To update the manifest and source code, simple issue the 'repo sync' command.
Manifests are themselves stored in a git repository so it is possible to use a manifest from a different git branch or commit.
To specify a new repository source, specify a new argument for the '-u' switch.
<code>
$ repo init -u <git repository source URI>
</code>
To specify a different branch or revision, specify a new argument for the '-b' switch.
<code>
$ repo init -b <branch name>
</code>
By default, the repo expects to use a file named ''default.xml'' as the manifest but it is possible to specify the specific manifest file to use.
<code>
$ repo init -m <manifest.xml>
</code>

By forking the repository on github, it should be very easy to set up your own repository. For a look under the hood, navigate to the ''.repo'' directory.

== Build ==
All required binaries and a root file system can be built for the Overo COM using the pre-built armel cross-compilers downloaded by repo.

=== Root File System ===
In the simple case, just calling 'make PRODUCT-overo-eng' will build an [http://source.android.com/porting/build_system.html#androidBuildVariants engineering build] of the Overo target defined in ''device/gumstix/overo/AndroidBoard.mk''. As usual, the '-j<#>' switch allows for a multi-threaded build. However, the following commands actually pull in some convenient macros, select a predefined combination (see the ''device/gumstix/overo/vendorsetup.mk''; use ''choosecombo'' to select your own) and use the 'm' alias for make to build the root filesystem.
<code>
$ source build/envsetup.sh
$ lunch overo-eng
</code>
The current build will not compile with out this hack, whoever maintains the sources should look into fixing this.
<code>
$ make update-api
$ find . -type f -name '*.mk' -exec sed -i "s/Werror=strict-aliasing/Wall/g" '{}' \;

</code>
Then compile!
<code>
$ m -j1
</code>
'''Note:''' Those building with a 32-bit system will get angry warnings on the first build. These can be ignored.

'''Note:''' To build a specific directory, navigate there and use the 'mm' macro or use the 'mmm' macro with the directory path as an argument. As explained, 'make clean' and 'make clobber' will clean up any messes.

After an hour or two, the build should complete with populated ''root'' and ''system'' directories in the ''out/target/product/overo'' directory.

=== Bootloaders, Kernel, and SGX support ===
The x-load and u-boot bootloaders, the linux kernel, and the SGX graphics code each have their own build system. These have been crudely integrated with Android: repo fetches the necessary files and a simple script can be called to perform a clean build of each of these component:
<code>
$ source utils/gumcompile
</code>
'''Note:''' This also generates a ''boot.scr'' u-boot bootloader script to set the necessary environment variables on boot. To change this script, modify ''utils/androidboot.cmd''.
For more fine-grained control, use the corresponding build systems directly (though looking at this script prove helpful).

== Create a Tarball ==
The final step is wrapping all the generated files into a tarball with appropriate permissions.
<code>
$ source utils/genrootfs
</code>

In the ''out/target/product/overo'' directory, you should find the following files needed to make a [[Android_Prebuilt | bootable microSD card]].
* MLO
* u-boot.bin
* boot.scr
* uImage
* rootfs.tar.bz2

''Note'': At the moment, the MLO built by the gumcompile will intermittently fail to boot a COM. As such, the MLO found in the output directory is copied from a known good pre-built binary in the ''utils/'' directory.

== Help and Help Out ==
These steps have refined from the [[http://code.google.com/p/rowboat/wiki/Main rowboat-android]] wiki and from [http://source.android.com google] documentation. Other useful links include:
* http://omapzoom.org/wiki/OMAP_Android_Main
* http://groups.google.com/group/android-porting?pli=1

Patches, suggestions and improvements are most welcome---please send to ash (at) gumstix.com. Pull requests on the github repositories are likewise appreciated.

Android Source

2011-12-01T17:34:52Z

Kevin Harrington: /* Root File System */

This page explains how to build Android from source [[Android_Source#Setup | from fresh]] or to update an [[Android_Source#Updating | existing source build]]. If you just want to [[Android_Usage | test drive Android]], you may prefer to use [[Android_Prebuilt | prebuilt images]].

All the source code is freely available for download, customization, and improvement. This section explains how to set up a development machine to build all the required components from source. These instructions have been tested on Ubuntu Maverick (10.10) 32 and 64 bit machines; as a rough estimate, this process requires 10GB of hard drive space and takes 4 hours (30 minutes of setup, 1.5 hours to download code, and 2 hours to build) on a moderate development machine. Users with existing Android source can [[Android_Source#Updating | rapidly update]].

== Setup ==
Android requires Sun(tm) Java and some additional software packages. These instructions assume an Ubuntu system however for other systems, see [http://source.android.com/source/download.html these pointers]. Begin by adding the official java repository for your system ('lucid' is fine, even if you are using a different Ubuntu version) and installing a new version of Java (you'll need to agree to the license agreement).
<code>
$ sudo add-apt-repository "deb http://archive.canonical.com/ lucid partner"
$ sudo apt-get update
$ sudo apt-get install sun-java6-jdk
$ sudo update-java-alternatives -s java-6-sun
</code>
Note, it is normal to get some ''error: no alternatives for...'' messages.

Now, install other required software. If you are building on a 64-bit machine (i.e. <code>uname -a|grep x86_64</code>), these packages are required:
<code>
$ sudo apt-get install git-core gnupg flex bison gperf build-essential zip curl zlib1g-dev gcc-multilib g++-multilib libc6-dev-i386 lib32ncurses5-dev ia32-libs x11proto-core-dev libx11-dev lib32readline5-dev lib32z-dev expect uboot-mkimage
</code>
For 32-bit machines, use these packages instead:
<code>
$ sudo apt-get install git-core gnupg flex bison gperf build-essential zip curl zlib1g-dev gcc-multilib g++-multilib x11proto-core-dev libx11-dev expect uboot-mkimage
</code>

Finally, install the '''repo''' tool. Repo is a tool to manage multiple Git repositories. You can install it wherever you like but if you have administrator rights, you might find this convenient:
<code>
$ curl https://dl-ssl.google.com/dl/googlesource/git-repo/repo > repo
$ chmod a+x repo
$ sudo mv repo /usr/bin/repo
</code>

== Fetch Source Code ==
With Repo installed, it is possible to use a single manifest file that describes all the git repositories to be fetched. More information about repo can be found [http://source.android.com/source/git-repo.html here]. These instructions place everything in a ''~/android'' directory but there is no restriction where this code is located.
<code>
$ mkdir ~/android
$ cd ~/android
$ repo init -u git://github.com/gumdroid/android-manifest.git -b linaro
</code>
Respond to the prompted questions to finish the initialization. This next step fetches all the code and may take an hour or so. If a particular repository checkout fails, re-issue this command until everything has been successfully fetched (and most regrettably, it can takes a few tries).
<code>
$ repo sync
</code>
'''Tip:''' Use <code>repo sync -j2</code> to do multi-threaded fetches (but be alert for repositories that fail to download).

== Updating ==
Users trying to get a fresh build system running can skip this section; this may be useful for those who have previously set up an Android repository or who wish to host their own manifest.

To update from a previous android installation, simply issue these commands in your top-level directory.
<code>
$ repo init -u git://github.com/gumdroid/android-manifest.git -b linaro
$ repo sync
</code>

=== Repository Management ===
A manifest file is a XML file that describes a set of git repositories that, collectively, make up a project. In this case, most of the repositories are cloned directly from [http://android.git.kernel.org/ Google], OMAP3-specific tweaks come from the [http://gitorious.org/rowboat rowboat-android repositories], and items like the kernel and the bootloaders are pulled from [https://github.com/search?q=android&type=Everything&repo=&langOverride=&start_value=1 Gumstix repositories]. To update the manifest and source code, simple issue the 'repo sync' command.
Manifests are themselves stored in a git repository so it is possible to use a manifest from a different git branch or commit.
To specify a new repository source, specify a new argument for the '-u' switch.
<code>
$ repo init -u <git repository source URI>
</code>
To specify a different branch or revision, specify a new argument for the '-b' switch.
<code>
$ repo init -b <branch name>
</code>
By default, the repo expects to use a file named ''default.xml'' as the manifest but it is possible to specify the specific manifest file to use.
<code>
$ repo init -m <manifest.xml>
</code>

By forking the repository on github, it should be very easy to set up your own repository. For a look under the hood, navigate to the ''.repo'' directory.

== Build ==
All required binaries and a root file system can be built for the Overo COM using the pre-built armel cross-compilers downloaded by repo.

=== Root File System ===
In the simple case, just calling 'make PRODUCT-overo-eng' will build an [http://source.android.com/porting/build_system.html#androidBuildVariants engineering build] of the Overo target defined in ''device/gumstix/overo/AndroidBoard.mk''. As usual, the '-j<#>' switch allows for a multi-threaded build. However, the following commands actually pull in some convenient macros, select a predefined combination (see the ''device/gumstix/overo/vendorsetup.mk''; use ''choosecombo'' to select your own) and use the 'm' alias for make to build the root filesystem.
<code>
$ source build/envsetup.sh
$ lunch overo-eng
</code>
The current build will not compile with out this hack, whoever maintains the sources should look into fixing this.
<code>
$ find . -type f -name '*.mk' -exec sed -i "s/Werror=strict-aliasing/Wall/g" '{}' \;
$ make update-api
</code>
Then compile!
<code>
$ m -j1
</code>
'''Note:''' Those building with a 32-bit system will get angry warnings on the first build. These can be ignored.

'''Note:''' To build a specific directory, navigate there and use the 'mm' macro or use the 'mmm' macro with the directory path as an argument. As explained, 'make clean' and 'make clobber' will clean up any messes.

After an hour or two, the build should complete with populated ''root'' and ''system'' directories in the ''out/target/product/overo'' directory.

=== Bootloaders, Kernel, and SGX support ===
The x-load and u-boot bootloaders, the linux kernel, and the SGX graphics code each have their own build system. These have been crudely integrated with Android: repo fetches the necessary files and a simple script can be called to perform a clean build of each of these component:
<code>
$ source utils/gumcompile
</code>
'''Note:''' This also generates a ''boot.scr'' u-boot bootloader script to set the necessary environment variables on boot. To change this script, modify ''utils/androidboot.cmd''.
For more fine-grained control, use the corresponding build systems directly (though looking at this script prove helpful).

== Create a Tarball ==
The final step is wrapping all the generated files into a tarball with appropriate permissions.
<code>
$ source utils/genrootfs
</code>

In the ''out/target/product/overo'' directory, you should find the following files needed to make a [[Android_Prebuilt | bootable microSD card]].
* MLO
* u-boot.bin
* boot.scr
* uImage
* rootfs.tar.bz2

''Note'': At the moment, the MLO built by the gumcompile will intermittently fail to boot a COM. As such, the MLO found in the output directory is copied from a known good pre-built binary in the ''utils/'' directory.

== Help and Help Out ==
These steps have refined from the [[http://code.google.com/p/rowboat/wiki/Main rowboat-android]] wiki and from [http://source.android.com google] documentation. Other useful links include:
* http://omapzoom.org/wiki/OMAP_Android_Main
* http://groups.google.com/group/android-porting?pli=1

Patches, suggestions and improvements are most welcome---please send to ash (at) gumstix.com. Pull requests on the github repositories are likewise appreciated.

Android Source

2011-12-01T17:00:12Z

Kevin Harrington: /* Updating */

This page explains how to build Android from source [[Android_Source#Setup | from fresh]] or to update an [[Android_Source#Updating | existing source build]]. If you just want to [[Android_Usage | test drive Android]], you may prefer to use [[Android_Prebuilt | prebuilt images]].

All the source code is freely available for download, customization, and improvement. This section explains how to set up a development machine to build all the required components from source. These instructions have been tested on Ubuntu Maverick (10.10) 32 and 64 bit machines; as a rough estimate, this process requires 10GB of hard drive space and takes 4 hours (30 minutes of setup, 1.5 hours to download code, and 2 hours to build) on a moderate development machine. Users with existing Android source can [[Android_Source#Updating | rapidly update]].

== Setup ==
Android requires Sun(tm) Java and some additional software packages. These instructions assume an Ubuntu system however for other systems, see [http://source.android.com/source/download.html these pointers]. Begin by adding the official java repository for your system ('lucid' is fine, even if you are using a different Ubuntu version) and installing a new version of Java (you'll need to agree to the license agreement).
<code>
$ sudo add-apt-repository "deb http://archive.canonical.com/ lucid partner"
$ sudo apt-get update
$ sudo apt-get install sun-java6-jdk
$ sudo update-java-alternatives -s java-6-sun
</code>
Note, it is normal to get some ''error: no alternatives for...'' messages.

Now, install other required software. If you are building on a 64-bit machine (i.e. <code>uname -a|grep x86_64</code>), these packages are required:
<code>
$ sudo apt-get install git-core gnupg flex bison gperf build-essential zip curl zlib1g-dev gcc-multilib g++-multilib libc6-dev-i386 lib32ncurses5-dev ia32-libs x11proto-core-dev libx11-dev lib32readline5-dev lib32z-dev expect uboot-mkimage
</code>
For 32-bit machines, use these packages instead:
<code>
$ sudo apt-get install git-core gnupg flex bison gperf build-essential zip curl zlib1g-dev gcc-multilib g++-multilib x11proto-core-dev libx11-dev expect uboot-mkimage
</code>

Finally, install the '''repo''' tool. Repo is a tool to manage multiple Git repositories. You can install it wherever you like but if you have administrator rights, you might find this convenient:
<code>
$ curl https://dl-ssl.google.com/dl/googlesource/git-repo/repo > repo
$ chmod a+x repo
$ sudo mv repo /usr/bin/repo
</code>

== Fetch Source Code ==
With Repo installed, it is possible to use a single manifest file that describes all the git repositories to be fetched. More information about repo can be found [http://source.android.com/source/git-repo.html here]. These instructions place everything in a ''~/android'' directory but there is no restriction where this code is located.
<code>
$ mkdir ~/android
$ cd ~/android
$ repo init -u git://github.com/gumdroid/android-manifest.git -b linaro
</code>
Respond to the prompted questions to finish the initialization. This next step fetches all the code and may take an hour or so. If a particular repository checkout fails, re-issue this command until everything has been successfully fetched (and most regrettably, it can takes a few tries).
<code>
$ repo sync
</code>
'''Tip:''' Use <code>repo sync -j2</code> to do multi-threaded fetches (but be alert for repositories that fail to download).

== Updating ==
Users trying to get a fresh build system running can skip this section; this may be useful for those who have previously set up an Android repository or who wish to host their own manifest.

To update from a previous android installation, simply issue these commands in your top-level directory.
<code>
$ repo init -u git://github.com/gumdroid/android-manifest.git -b linaro
$ repo sync
</code>

=== Repository Management ===
A manifest file is a XML file that describes a set of git repositories that, collectively, make up a project. In this case, most of the repositories are cloned directly from [http://android.git.kernel.org/ Google], OMAP3-specific tweaks come from the [http://gitorious.org/rowboat rowboat-android repositories], and items like the kernel and the bootloaders are pulled from [https://github.com/search?q=android&type=Everything&repo=&langOverride=&start_value=1 Gumstix repositories]. To update the manifest and source code, simple issue the 'repo sync' command.
Manifests are themselves stored in a git repository so it is possible to use a manifest from a different git branch or commit.
To specify a new repository source, specify a new argument for the '-u' switch.
<code>
$ repo init -u <git repository source URI>
</code>
To specify a different branch or revision, specify a new argument for the '-b' switch.
<code>
$ repo init -b <branch name>
</code>
By default, the repo expects to use a file named ''default.xml'' as the manifest but it is possible to specify the specific manifest file to use.
<code>
$ repo init -m <manifest.xml>
</code>

By forking the repository on github, it should be very easy to set up your own repository. For a look under the hood, navigate to the ''.repo'' directory.

== Build ==
All required binaries and a root file system can be built for the Overo COM using the pre-built armel cross-compilers downloaded by repo.

=== Root File System ===
In the simple case, just calling 'make PRODUCT-overo-eng' will build an [http://source.android.com/porting/build_system.html#androidBuildVariants engineering build] of the Overo target defined in ''device/gumstix/overo/AndroidBoard.mk''. As usual, the '-j<#>' switch allows for a multi-threaded build. However, the following commands actually pull in some convenient macros, select a predefined combination (see the ''device/gumstix/overo/vendorsetup.mk''; use ''choosecombo'' to select your own) and use the 'm' alias for make to build the root filesystem.
<code>
$ source build/envsetup.sh
$ lunch overo-eng
</code>
The current build will not compile with out this hack, whoever maintains the sources should look into fixing this.
<code>
$ find . -type f -name '*.mk' -exec sed -i "s/Werror=strict-aliasing/Wall/g" '{}' \;
</code>
Then compile!
<code>
$ m -j1
</code>
'''Note:''' Those building with a 32-bit system will get angry warnings on the first build. These can be ignored.

'''Note:''' To build a specific directory, navigate there and use the 'mm' macro or use the 'mmm' macro with the directory path as an argument. As explained, 'make clean' and 'make clobber' will clean up any messes.

After an hour or two, the build should complete with populated ''root'' and ''system'' directories in the ''out/target/product/overo'' directory.

=== Bootloaders, Kernel, and SGX support ===
The x-load and u-boot bootloaders, the linux kernel, and the SGX graphics code each have their own build system. These have been crudely integrated with Android: repo fetches the necessary files and a simple script can be called to perform a clean build of each of these component:
<code>
$ source utils/gumcompile
</code>
'''Note:''' This also generates a ''boot.scr'' u-boot bootloader script to set the necessary environment variables on boot. To change this script, modify ''utils/androidboot.cmd''.
For more fine-grained control, use the corresponding build systems directly (though looking at this script prove helpful).

== Create a Tarball ==
The final step is wrapping all the generated files into a tarball with appropriate permissions.
<code>
$ source utils/genrootfs
</code>

In the ''out/target/product/overo'' directory, you should find the following files needed to make a [[Android_Prebuilt | bootable microSD card]].
* MLO
* u-boot.bin
* boot.scr
* uImage
* rootfs.tar.bz2

''Note'': At the moment, the MLO built by the gumcompile will intermittently fail to boot a COM. As such, the MLO found in the output directory is copied from a known good pre-built binary in the ''utils/'' directory.

== Help and Help Out ==
These steps have refined from the [[http://code.google.com/p/rowboat/wiki/Main rowboat-android]] wiki and from [http://source.android.com google] documentation. Other useful links include:
* http://omapzoom.org/wiki/OMAP_Android_Main
* http://groups.google.com/group/android-porting?pli=1

Patches, suggestions and improvements are most welcome---please send to ash (at) gumstix.com. Pull requests on the github repositories are likewise appreciated.

Android Source

2011-12-01T16:57:08Z

Kevin Harrington: /* Root File System */

This page explains how to build Android from source [[Android_Source#Setup | from fresh]] or to update an [[Android_Source#Updating | existing source build]]. If you just want to [[Android_Usage | test drive Android]], you may prefer to use [[Android_Prebuilt | prebuilt images]].

All the source code is freely available for download, customization, and improvement. This section explains how to set up a development machine to build all the required components from source. These instructions have been tested on Ubuntu Maverick (10.10) 32 and 64 bit machines; as a rough estimate, this process requires 10GB of hard drive space and takes 4 hours (30 minutes of setup, 1.5 hours to download code, and 2 hours to build) on a moderate development machine. Users with existing Android source can [[Android_Source#Updating | rapidly update]].

== Setup ==
Android requires Sun(tm) Java and some additional software packages. These instructions assume an Ubuntu system however for other systems, see [http://source.android.com/source/download.html these pointers]. Begin by adding the official java repository for your system ('lucid' is fine, even if you are using a different Ubuntu version) and installing a new version of Java (you'll need to agree to the license agreement).
<code>
$ sudo add-apt-repository "deb http://archive.canonical.com/ lucid partner"
$ sudo apt-get update
$ sudo apt-get install sun-java6-jdk
$ sudo update-java-alternatives -s java-6-sun
</code>
Note, it is normal to get some ''error: no alternatives for...'' messages.

Now, install other required software. If you are building on a 64-bit machine (i.e. <code>uname -a|grep x86_64</code>), these packages are required:
<code>
$ sudo apt-get install git-core gnupg flex bison gperf build-essential zip curl zlib1g-dev gcc-multilib g++-multilib libc6-dev-i386 lib32ncurses5-dev ia32-libs x11proto-core-dev libx11-dev lib32readline5-dev lib32z-dev expect uboot-mkimage
</code>
For 32-bit machines, use these packages instead:
<code>
$ sudo apt-get install git-core gnupg flex bison gperf build-essential zip curl zlib1g-dev gcc-multilib g++-multilib x11proto-core-dev libx11-dev expect uboot-mkimage
</code>

Finally, install the '''repo''' tool. Repo is a tool to manage multiple Git repositories. You can install it wherever you like but if you have administrator rights, you might find this convenient:
<code>
$ curl https://dl-ssl.google.com/dl/googlesource/git-repo/repo > repo
$ chmod a+x repo
$ sudo mv repo /usr/bin/repo
</code>

== Fetch Source Code ==
With Repo installed, it is possible to use a single manifest file that describes all the git repositories to be fetched. More information about repo can be found [http://source.android.com/source/git-repo.html here]. These instructions place everything in a ''~/android'' directory but there is no restriction where this code is located.
<code>
$ mkdir ~/android
$ cd ~/android
$ repo init -u git://github.com/gumdroid/android-manifest.git -b linaro
</code>
Respond to the prompted questions to finish the initialization. This next step fetches all the code and may take an hour or so. If a particular repository checkout fails, re-issue this command until everything has been successfully fetched (and most regrettably, it can takes a few tries).
<code>
$ repo sync
</code>
'''Tip:''' Use <code>repo sync -j2</code> to do multi-threaded fetches (but be alert for repositories that fail to download).

== Updating ==
Users trying to get a fresh build system running can skip this section; this may be useful for those who have previously set up an Android repository or who wish to host their own manifest.

To update from a previous android installation, simply issue these commands in your top-level directory.
<code>
$ repo init -u git://github.com/gumdroid/android-manifest.git
$ repo sync
</code>

=== Repository Management ===
A manifest file is a XML file that describes a set of git repositories that, collectively, make up a project. In this case, most of the repositories are cloned directly from [http://android.git.kernel.org/ Google], OMAP3-specific tweaks come from the [http://gitorious.org/rowboat rowboat-android repositories], and items like the kernel and the bootloaders are pulled from [https://github.com/search?q=android&type=Everything&repo=&langOverride=&start_value=1 Gumstix repositories]. To update the manifest and source code, simple issue the 'repo sync' command.
Manifests are themselves stored in a git repository so it is possible to use a manifest from a different git branch or commit.
To specify a new repository source, specify a new argument for the '-u' switch.
<code>
$ repo init -u <git repository source URI>
</code>
To specify a different branch or revision, specify a new argument for the '-b' switch.
<code>
$ repo init -b <branch name>
</code>
By default, the repo expects to use a file named ''default.xml'' as the manifest but it is possible to specify the specific manifest file to use.
<code>
$ repo init -m <manifest.xml>
</code>

By forking the repository on github, it should be very easy to set up your own repository. For a look under the hood, navigate to the ''.repo'' directory.

== Build ==
All required binaries and a root file system can be built for the Overo COM using the pre-built armel cross-compilers downloaded by repo.

=== Root File System ===
In the simple case, just calling 'make PRODUCT-overo-eng' will build an [http://source.android.com/porting/build_system.html#androidBuildVariants engineering build] of the Overo target defined in ''device/gumstix/overo/AndroidBoard.mk''. As usual, the '-j<#>' switch allows for a multi-threaded build. However, the following commands actually pull in some convenient macros, select a predefined combination (see the ''device/gumstix/overo/vendorsetup.mk''; use ''choosecombo'' to select your own) and use the 'm' alias for make to build the root filesystem.
<code>
$ source build/envsetup.sh
$ lunch overo-eng
</code>
The current build will not compile with out this hack, whoever maintains the sources should look into fixing this.
<code>
$ find . -type f -name '*.mk' -exec sed -i "s/Werror=strict-aliasing/Wall/g" '{}' \;
</code>
Then compile!
<code>
$ m -j1
</code>
'''Note:''' Those building with a 32-bit system will get angry warnings on the first build. These can be ignored.

'''Note:''' To build a specific directory, navigate there and use the 'mm' macro or use the 'mmm' macro with the directory path as an argument. As explained, 'make clean' and 'make clobber' will clean up any messes.

After an hour or two, the build should complete with populated ''root'' and ''system'' directories in the ''out/target/product/overo'' directory.

=== Bootloaders, Kernel, and SGX support ===
The x-load and u-boot bootloaders, the linux kernel, and the SGX graphics code each have their own build system. These have been crudely integrated with Android: repo fetches the necessary files and a simple script can be called to perform a clean build of each of these component:
<code>
$ source utils/gumcompile
</code>
'''Note:''' This also generates a ''boot.scr'' u-boot bootloader script to set the necessary environment variables on boot. To change this script, modify ''utils/androidboot.cmd''.
For more fine-grained control, use the corresponding build systems directly (though looking at this script prove helpful).

== Create a Tarball ==
The final step is wrapping all the generated files into a tarball with appropriate permissions.
<code>
$ source utils/genrootfs
</code>

In the ''out/target/product/overo'' directory, you should find the following files needed to make a [[Android_Prebuilt | bootable microSD card]].
* MLO
* u-boot.bin
* boot.scr
* uImage
* rootfs.tar.bz2

''Note'': At the moment, the MLO built by the gumcompile will intermittently fail to boot a COM. As such, the MLO found in the output directory is copied from a known good pre-built binary in the ''utils/'' directory.

== Help and Help Out ==
These steps have refined from the [[http://code.google.com/p/rowboat/wiki/Main rowboat-android]] wiki and from [http://source.android.com google] documentation. Other useful links include:
* http://omapzoom.org/wiki/OMAP_Android_Main
* http://groups.google.com/group/android-porting?pli=1

Patches, suggestions and improvements are most welcome---please send to ash (at) gumstix.com. Pull requests on the github repositories are likewise appreciated.

Android Source

2011-12-01T16:52:59Z

Kevin Harrington: /* Root File System */

This page explains how to build Android from source [[Android_Source#Setup | from fresh]] or to update an [[Android_Source#Updating | existing source build]]. If you just want to [[Android_Usage | test drive Android]], you may prefer to use [[Android_Prebuilt | prebuilt images]].

All the source code is freely available for download, customization, and improvement. This section explains how to set up a development machine to build all the required components from source. These instructions have been tested on Ubuntu Maverick (10.10) 32 and 64 bit machines; as a rough estimate, this process requires 10GB of hard drive space and takes 4 hours (30 minutes of setup, 1.5 hours to download code, and 2 hours to build) on a moderate development machine. Users with existing Android source can [[Android_Source#Updating | rapidly update]].

== Setup ==
Android requires Sun(tm) Java and some additional software packages. These instructions assume an Ubuntu system however for other systems, see [http://source.android.com/source/download.html these pointers]. Begin by adding the official java repository for your system ('lucid' is fine, even if you are using a different Ubuntu version) and installing a new version of Java (you'll need to agree to the license agreement).
<code>
$ sudo add-apt-repository "deb http://archive.canonical.com/ lucid partner"
$ sudo apt-get update
$ sudo apt-get install sun-java6-jdk
$ sudo update-java-alternatives -s java-6-sun
</code>
Note, it is normal to get some ''error: no alternatives for...'' messages.

Now, install other required software. If you are building on a 64-bit machine (i.e. <code>uname -a|grep x86_64</code>), these packages are required:
<code>
$ sudo apt-get install git-core gnupg flex bison gperf build-essential zip curl zlib1g-dev gcc-multilib g++-multilib libc6-dev-i386 lib32ncurses5-dev ia32-libs x11proto-core-dev libx11-dev lib32readline5-dev lib32z-dev expect uboot-mkimage
</code>
For 32-bit machines, use these packages instead:
<code>
$ sudo apt-get install git-core gnupg flex bison gperf build-essential zip curl zlib1g-dev gcc-multilib g++-multilib x11proto-core-dev libx11-dev expect uboot-mkimage
</code>

Finally, install the '''repo''' tool. Repo is a tool to manage multiple Git repositories. You can install it wherever you like but if you have administrator rights, you might find this convenient:
<code>
$ curl https://dl-ssl.google.com/dl/googlesource/git-repo/repo > repo
$ chmod a+x repo
$ sudo mv repo /usr/bin/repo
</code>

== Fetch Source Code ==
With Repo installed, it is possible to use a single manifest file that describes all the git repositories to be fetched. More information about repo can be found [http://source.android.com/source/git-repo.html here]. These instructions place everything in a ''~/android'' directory but there is no restriction where this code is located.
<code>
$ mkdir ~/android
$ cd ~/android
$ repo init -u git://github.com/gumdroid/android-manifest.git -b linaro
</code>
Respond to the prompted questions to finish the initialization. This next step fetches all the code and may take an hour or so. If a particular repository checkout fails, re-issue this command until everything has been successfully fetched (and most regrettably, it can takes a few tries).
<code>
$ repo sync
</code>
'''Tip:''' Use <code>repo sync -j2</code> to do multi-threaded fetches (but be alert for repositories that fail to download).

== Updating ==
Users trying to get a fresh build system running can skip this section; this may be useful for those who have previously set up an Android repository or who wish to host their own manifest.

To update from a previous android installation, simply issue these commands in your top-level directory.
<code>
$ repo init -u git://github.com/gumdroid/android-manifest.git
$ repo sync
</code>

=== Repository Management ===
A manifest file is a XML file that describes a set of git repositories that, collectively, make up a project. In this case, most of the repositories are cloned directly from [http://android.git.kernel.org/ Google], OMAP3-specific tweaks come from the [http://gitorious.org/rowboat rowboat-android repositories], and items like the kernel and the bootloaders are pulled from [https://github.com/search?q=android&type=Everything&repo=&langOverride=&start_value=1 Gumstix repositories]. To update the manifest and source code, simple issue the 'repo sync' command.
Manifests are themselves stored in a git repository so it is possible to use a manifest from a different git branch or commit.
To specify a new repository source, specify a new argument for the '-u' switch.
<code>
$ repo init -u <git repository source URI>
</code>
To specify a different branch or revision, specify a new argument for the '-b' switch.
<code>
$ repo init -b <branch name>
</code>
By default, the repo expects to use a file named ''default.xml'' as the manifest but it is possible to specify the specific manifest file to use.
<code>
$ repo init -m <manifest.xml>
</code>

By forking the repository on github, it should be very easy to set up your own repository. For a look under the hood, navigate to the ''.repo'' directory.

== Build ==
All required binaries and a root file system can be built for the Overo COM using the pre-built armel cross-compilers downloaded by repo.

=== Root File System ===
In the simple case, just calling 'make PRODUCT-overo-eng' will build an [http://source.android.com/porting/build_system.html#androidBuildVariants engineering build] of the Overo target defined in ''device/gumstix/overo/AndroidBoard.mk''. As usual, the '-j<#>' switch allows for a multi-threaded build. However, the following commands actually pull in some convenient macros, select a predefined combination (see the ''device/gumstix/overo/vendorsetup.mk''; use ''choosecombo'' to select your own) and use the 'm' alias for make to build the root filesystem.
<code>
$ source build/envsetup.sh
$ lunch overo-eng
</code>
The current build will not compile with out this hack, whoever maintains the sources should look into fixing this.
<code>
$ find . -type f -name '*.mk' -exec sed -i "s/Werror=strict-aliasing/Wall/g" '{}' \;
</code>
Then compile!
<code>
$ m -j8
</code>
'''Note:''' Those building with a 32-bit system will get angry warnings on the first build. These can be ignored.

'''Note:''' To build a specific directory, navigate there and use the 'mm' macro or use the 'mmm' macro with the directory path as an argument. As explained, 'make clean' and 'make clobber' will clean up any messes.

After an hour or two, the build should complete with populated ''root'' and ''system'' directories in the ''out/target/product/overo'' directory.

=== Bootloaders, Kernel, and SGX support ===
The x-load and u-boot bootloaders, the linux kernel, and the SGX graphics code each have their own build system. These have been crudely integrated with Android: repo fetches the necessary files and a simple script can be called to perform a clean build of each of these component:
<code>
$ source utils/gumcompile
</code>
'''Note:''' This also generates a ''boot.scr'' u-boot bootloader script to set the necessary environment variables on boot. To change this script, modify ''utils/androidboot.cmd''.
For more fine-grained control, use the corresponding build systems directly (though looking at this script prove helpful).

== Create a Tarball ==
The final step is wrapping all the generated files into a tarball with appropriate permissions.
<code>
$ source utils/genrootfs
</code>

In the ''out/target/product/overo'' directory, you should find the following files needed to make a [[Android_Prebuilt | bootable microSD card]].
* MLO
* u-boot.bin
* boot.scr
* uImage
* rootfs.tar.bz2

''Note'': At the moment, the MLO built by the gumcompile will intermittently fail to boot a COM. As such, the MLO found in the output directory is copied from a known good pre-built binary in the ''utils/'' directory.

== Help and Help Out ==
These steps have refined from the [[http://code.google.com/p/rowboat/wiki/Main rowboat-android]] wiki and from [http://source.android.com google] documentation. Other useful links include:
* http://omapzoom.org/wiki/OMAP_Android_Main
* http://groups.google.com/group/android-porting?pli=1

Patches, suggestions and improvements are most welcome---please send to ash (at) gumstix.com. Pull requests on the github repositories are likewise appreciated.

Android Source

2011-12-01T16:45:31Z

Kevin Harrington:

This page explains how to build Android from source [[Android_Source#Setup | from fresh]] or to update an [[Android_Source#Updating | existing source build]]. If you just want to [[Android_Usage | test drive Android]], you may prefer to use [[Android_Prebuilt | prebuilt images]].

All the source code is freely available for download, customization, and improvement. This section explains how to set up a development machine to build all the required components from source. These instructions have been tested on Ubuntu Maverick (10.10) 32 and 64 bit machines; as a rough estimate, this process requires 10GB of hard drive space and takes 4 hours (30 minutes of setup, 1.5 hours to download code, and 2 hours to build) on a moderate development machine. Users with existing Android source can [[Android_Source#Updating | rapidly update]].

== Setup ==
Android requires Sun(tm) Java and some additional software packages. These instructions assume an Ubuntu system however for other systems, see [http://source.android.com/source/download.html these pointers]. Begin by adding the official java repository for your system ('lucid' is fine, even if you are using a different Ubuntu version) and installing a new version of Java (you'll need to agree to the license agreement).
<code>
$ sudo add-apt-repository "deb http://archive.canonical.com/ lucid partner"
$ sudo apt-get update
$ sudo apt-get install sun-java6-jdk
$ sudo update-java-alternatives -s java-6-sun
</code>
Note, it is normal to get some ''error: no alternatives for...'' messages.

Now, install other required software. If you are building on a 64-bit machine (i.e. <code>uname -a|grep x86_64</code>), these packages are required:
<code>
$ sudo apt-get install git-core gnupg flex bison gperf build-essential zip curl zlib1g-dev gcc-multilib g++-multilib libc6-dev-i386 lib32ncurses5-dev ia32-libs x11proto-core-dev libx11-dev lib32readline5-dev lib32z-dev expect uboot-mkimage
</code>
For 32-bit machines, use these packages instead:
<code>
$ sudo apt-get install git-core gnupg flex bison gperf build-essential zip curl zlib1g-dev gcc-multilib g++-multilib x11proto-core-dev libx11-dev expect uboot-mkimage
</code>

Finally, install the '''repo''' tool. Repo is a tool to manage multiple Git repositories. You can install it wherever you like but if you have administrator rights, you might find this convenient:
<code>
$ curl https://dl-ssl.google.com/dl/googlesource/git-repo/repo > repo
$ chmod a+x repo
$ sudo mv repo /usr/bin/repo
</code>

== Fetch Source Code ==
With Repo installed, it is possible to use a single manifest file that describes all the git repositories to be fetched. More information about repo can be found [http://source.android.com/source/git-repo.html here]. These instructions place everything in a ''~/android'' directory but there is no restriction where this code is located.
<code>
$ mkdir ~/android
$ cd ~/android
$ repo init -u git://github.com/gumdroid/android-manifest.git -b linaro
</code>
Respond to the prompted questions to finish the initialization. This next step fetches all the code and may take an hour or so. If a particular repository checkout fails, re-issue this command until everything has been successfully fetched (and most regrettably, it can takes a few tries).
<code>
$ repo sync
</code>
'''Tip:''' Use <code>repo sync -j2</code> to do multi-threaded fetches (but be alert for repositories that fail to download).

== Updating ==
Users trying to get a fresh build system running can skip this section; this may be useful for those who have previously set up an Android repository or who wish to host their own manifest.

To update from a previous android installation, simply issue these commands in your top-level directory.
<code>
$ repo init -u git://github.com/gumdroid/android-manifest.git
$ repo sync
</code>

=== Repository Management ===
A manifest file is a XML file that describes a set of git repositories that, collectively, make up a project. In this case, most of the repositories are cloned directly from [http://android.git.kernel.org/ Google], OMAP3-specific tweaks come from the [http://gitorious.org/rowboat rowboat-android repositories], and items like the kernel and the bootloaders are pulled from [https://github.com/search?q=android&type=Everything&repo=&langOverride=&start_value=1 Gumstix repositories]. To update the manifest and source code, simple issue the 'repo sync' command.
Manifests are themselves stored in a git repository so it is possible to use a manifest from a different git branch or commit.
To specify a new repository source, specify a new argument for the '-u' switch.
<code>
$ repo init -u <git repository source URI>
</code>
To specify a different branch or revision, specify a new argument for the '-b' switch.
<code>
$ repo init -b <branch name>
</code>
By default, the repo expects to use a file named ''default.xml'' as the manifest but it is possible to specify the specific manifest file to use.
<code>
$ repo init -m <manifest.xml>
</code>

By forking the repository on github, it should be very easy to set up your own repository. For a look under the hood, navigate to the ''.repo'' directory.

== Build ==
All required binaries and a root file system can be built for the Overo COM using the pre-built armel cross-compilers downloaded by repo.

=== Root File System ===
In the simple case, just calling 'make PRODUCT-overo-eng' will build an [http://source.android.com/porting/build_system.html#androidBuildVariants engineering build] of the Overo target defined in ''device/gumstix/overo/AndroidBoard.mk''. As usual, the '-j<#>' switch allows for a multi-threaded build. However, the following commands actually pull in some convenient macros, select a predefined combination (see the ''device/gumstix/overo/vendorsetup.mk''; use ''choosecombo'' to select your own) and use the 'm' alias for make to build the root filesystem.
<code>
$ source build/envsetup.sh
$ lunch overo-eng
$ m -j8
</code>
'''Note:''' Those building with a 32-bit system will get angry warnings on the first build. These can be ignored.

'''Note:''' To build a specific directory, navigate there and use the 'mm' macro or use the 'mmm' macro with the directory path as an argument. As explained, 'make clean' and 'make clobber' will clean up any messes.

After an hour or two, the build should complete with populated ''root'' and ''system'' directories in the ''out/target/product/overo'' directory.

=== Bootloaders, Kernel, and SGX support ===
The x-load and u-boot bootloaders, the linux kernel, and the SGX graphics code each have their own build system. These have been crudely integrated with Android: repo fetches the necessary files and a simple script can be called to perform a clean build of each of these component:
<code>
$ source utils/gumcompile
</code>
'''Note:''' This also generates a ''boot.scr'' u-boot bootloader script to set the necessary environment variables on boot. To change this script, modify ''utils/androidboot.cmd''.
For more fine-grained control, use the corresponding build systems directly (though looking at this script prove helpful).

== Create a Tarball ==
The final step is wrapping all the generated files into a tarball with appropriate permissions.
<code>
$ source utils/genrootfs
</code>

In the ''out/target/product/overo'' directory, you should find the following files needed to make a [[Android_Prebuilt | bootable microSD card]].
* MLO
* u-boot.bin
* boot.scr
* uImage
* rootfs.tar.bz2

''Note'': At the moment, the MLO built by the gumcompile will intermittently fail to boot a COM. As such, the MLO found in the output directory is copied from a known good pre-built binary in the ''utils/'' directory.

== Help and Help Out ==
These steps have refined from the [[http://code.google.com/p/rowboat/wiki/Main rowboat-android]] wiki and from [http://source.android.com google] documentation. Other useful links include:
* http://omapzoom.org/wiki/OMAP_Android_Main
* http://groups.google.com/group/android-porting?pli=1

Patches, suggestions and improvements are most welcome---please send to ash (at) gumstix.com. Pull requests on the github repositories are likewise appreciated.