Setting up Android Development

Environment

This page describes the steps needed to set up a system for android development, both at

application and OS/kernel level. It is based on a Ubuntu installation and a Nexus One device.

This tutorial is being actively built. I will be adding further information about kernel

development, etc. as soon as possible.

Android Development Setup

This tutorial describes the steps taken to provide a complete development environment for

android. These are the steps I took for setting up a development environment for the Nexus

One. A description of the system I used for this setup is shown below. Most google

documentation is based on a 32-bit Ubuntu installation, which is the reason for my setup. Other

systems may require different setups. A 64-bit linux system in particular requires some changes

in order to support the 32-bit android SDK tools. Methods for other Android devices may differ

also, particularly the steps related to the kernel, since these code branches are specific to each

hardware.

Thinkpad T410 with Core i5, 3 GB RAM

Ubuntu 10.04 LTS, Lucid Lynx 32-bit

Nexus One (came with stock Android 2.1 build ERD79)

Pre setup

Before installing the android SDK and source files, a couple of other items should be set up, such

as java and eclipse. Java5 and above may be used for applications, but for source development,

Java6 was not supported at the time of this writing due to incompatibilities with

@Override. Unfortunately, Java5 (or java 1.5) is no longer in the Ubuntu repositories as of

10.04. It could be installed by downloading from the Sun website, but I used a work around

found at this site. Be sure to install the Java JDK, not just the JRE.

Installing Sun Java 1.5 on Ubuntu 10.04

This method is only needed for installing Java SDK through Synaptic (or with APT). It can be

installed by downloading the Sun Java5 SDK deb file

from http://java.sun.com/javase/downloads/index_jdk5.jsp.

Add the following to /etc/apt/sources.list:

deb http://us.archive.ubuntu.com/ubuntu/ jaunty multiverse

deb http://us.archive.ubuntu.com/ubuntu/ jaunty-updates multiverse

This can also be accomplished by going to System->Administration->Software Sources, select

Other Software tab, click Add, enter complete line above beginning with deb and click Add

Source. Do this for both lines. Following this, there should be two new entries in the Other

Software tab: Ubuntu 9.04 'Jaunty Jackalope' and Recommended updates.

[You can probably uncheck the Ubuntu 9.04 'Jaunty Jackalope' entry after completing

installation of Java5, since you shouldn't need this included in your repository results anymore.]

Update the package list:

sudo apt-get update

Or open System->Administration->Synaptic Package Manager and click on Reload.

Install Sun Java 1.5:

sudo apt-get install sun-java5-jdk

Or, in Synaptic, search for java and select sun-java5-sdk and click Apply.

Depending on your setup you might need to set this as the default. Check what version is default:

java -version

And list all Java versions installed:

sudo update-java-alternatives -l

Then if necessary:

sudo update-java-alternatives -s java-1.5.0-sun

Installing Eclipse

The android SDK needs Eclipse 3.4 or above, and recommends Eclipse 3.5 classic. This can be

acquired through eclipse's website, but luckily Eclipse 3.5 is the current version in the Ubuntu

10.04 repository. To install using Synaptic, search for eclipse, select eclipse (this should provide

the classic package and install any other needed eclipse packages, but you may choose to add

more eclipse packages - it shouldn't be needed for android development), and click Apply.

Installing Android SDK

The instructions for installing the SDK can be found at

http://developer.android.com/sdk/installing.html. Java and Eclipse should be installed prior to

these steps.

Downloading SDK starter package

First, download the SDK starter package. The starter package is not a full development

environment — it includes only the core SDK Tools, which you can use to download the rest of

the SDK components. You can get the latest version of the SDK starter package from the SDK

download page. Make sure to download the package that is appropriate for your development

computer.

After downloading, unpack the Android SDK archive to a safe location on your machine. By

default, the SDK files are unpacked into a directory named android-sdk-<machine-platform>.

It's a good idea to add the location of the SDK's primary tools directory to your system PATH.

The primary tools/ directory is located at the root of the SDK folder. Adding tools to your path

lets you run Android Debug Bridge (adb) and the other command line tools without needing to

supply the full path to the tools directory.

o On my system, I added the following line to the end of ~/.profile.

PATH="<your_sdk_dir>/tools:$PATH"

o Alternatively, on Linux, edit your ~/.bash_profile or ~/.bashrc file. Look for a

line that sets the PATH environment variable and add the full path to the tools/

directory to it. If you don't see a line setting the path, you can add one:

export PATH=${PATH}:<your_sdk_dir>/tools

Installing the ADT plugin for eclipse

At the time of this writing, I installed ADT version 0.9.7 for Eclipse. The Update Manager

feature of eclipse can be used to install ADT. I used the following method to install ADT on

Eclipse 3.5. For other versions, consult http://developer.android.com/sdk/eclipse-adt.html to

verify that this method is still current.

1. Start Eclipse, then select Help > Install New Software.

2. In the Available Software dialog, click Add....

3. In the Add Site dialog that appears, enter a name for the remote site (for example,

"Android Plugin") in the "Name" field.

In the "Location" field, enter this URL:

https://dl-ssl.google.com/android/eclipse/

Note: If you have trouble acquiring the plugin, you can try using "http" in the URL,

instead of "https" (https is preferred for security reasons).

Click OK.

4. Back in the Available Software view, you should now see "Developer Tools" added to

the list. Select the checkbox next to Developer Tools, which will automatically select the

nested tools Android DDMS and Android Development Tools. Click Next.

5. In the resulting Install Details dialog, the Android DDMS and Android Development

Tools features are listed. Click Next to read and accept the license agreement and install

any dependencies, then click Finish.

6. Restart Eclipse.

To point ADT to your Android SDK directory:

1. Select Window > Preferences... to open the Preferences panel.

2. Select Android from the left panel.

3. For the SDK Location in the main panel, click Browse... and locate your downloaded

SDK directory (this is the same as the <your_sdk_dir> in the previous installing SDK

tutorial, the folder which you extracted from the SDK starter package).

4. Click Apply, then OK.

Adding Android Platforms

The next step is to add the components for the platforms you want to develop for. You can add

whichever components you want, but if you want your applications to be compatible with older

versions of android, you should install all available platforms to test with. Initially, you may just

want to start with the platform you will have installed on your development phone. At the time

of this writing, my development Nexus One has Android 2.2 build FRF83. To install the desired

components, use the Android SDK and AVD Manager

tool in eclipse. To use the tool

1. Open Eclipse

2. Select Window > Android SDK and AVD Manager.

3. Select Available Packages in the left panel. This will reveal all of the components that

are currently available for download from the SDK repository.

4. Select the component(s) you'd like to install and click Install Selected. If you aren't sure

which packages to select, read Which components do I need?.

5. Verify and accept the components you want and click Install Accepted. The components

will now be installed into your existing Android SDK directories.

My installation included the Android SDK Tools, revision 6. The Android 2.2 platform, the

Android API 8 (wich corresponds to Android 2.2), and the documentation and samples for API

8. New platforms are automatically saved into the <sdk>/platforms/ directory of your SDK;

new add-ons are saved in the <sdk>/add-ons/ directory; samples are saved in the

<sdk>/samples/android-<level>/; and new documentation is saved in the existing

<sdk>/docs/ directory (old docs are replaced).

After installing (or updating) these components, it is a good idea to check for updates to ADT in

eclipse, as sometimes this requires an update for the new components. To do this

1. Start Eclipse, then select Help > Check for Updates.

You now have everything you need to begin developing android applications. To get your hands

really messy and make modifications to the android system or kernel, continue to the following

sections.

Android Source Development

The instructions for downloading and installing the android source code can be found at

http://source.android.com/source/download.html. Google uses Repo, which is built on top of Git

to handle code branch management. For more information about Git and Repo, see

http://source.android.com/source/git-repo.html. The source is over 2 GB in size, and you will

need at least 6 GB of free space in order to build the android source.

Prerequisites

To set up the android development environment, install the following packages using Synaptic or

apt-get. The version and package name of my installations are listed in parenthesis. Some of

these may already be present on your system.

Git 1.5.4 or newer (git-core 1.7.0.4)

GNU Privacy Guard (gnupg 1.4.10)

flex (flex 2.5.35)

bison (bison 2.4.1)

gperf (gperf 3.0.3)

libsdl-dev (libsdl1.2-dev 1.2.14)

libesd0-dev (libesd0-dev 0.2.41)

libwxgtk2.6-dev (optional) (libwxgtk2.6-dev 2.6.3.2.2)

build-essential (build-essential 11.4build1)

zip (zip 3.0)

curl (curl 7.19.7)

libncurses5-dev (libncurses5-dev 5.7)

zlib1g-dev (zlib1g-dev 1.2.3.3)

valgrind (valgrind 3.6.0)

lib32readline5-dev or above (libreadline6-dev 6.1)

Installing Repo

To install, initialize, and configure Repo, follow these steps:

1. Make sure you have a ~/bin directory in your home directory, and check to be sure that

this bin directory is in your path: 2. $ cd ~ 3. $ mkdir bin

$ echo $PATH

You may need to exit bash and restart it after mkdir bin. Your profile controller likely

adds ~/bin to your PATH if it exists, but you will need to restart bash for it to recognize it

is there and add it to PATH.

4. Download the repo script and make sure it is executable: 5. $ curl http://android.git.kernel.org/repo >~/bin/repo

$ chmod a+x ~/bin/repo

Initializing a Repo Client

1. Create an empty directory to hold your working files:

$ mkdir mydroid

$ cd mydroid

2. Be sure you are in your mydroid directory before this step. This is where the repository

will be installed. 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:

$ repo init -u git://android.git.kernel.org/platform/manifest.git

o If you would like to check out a branch other than "master", specify it with -b,

like:

$ repo init -u git://android.git.kernel.org/platform/manifest.git -b cupcake

A list of the available branches can be found by going to ~/mydroid/manifest/ and

entering:

$ git branch -r

The branch name is the title following origin/ for each item in the list. This could

only be run after running the above command to obtain the master branch, since

this installs the manifest folder and downloads manifest.git. Alternatively, this

may be possible by running

$ git clone git://android.git.kernel.org/platform/manifest.git

but I have not tried doing this before running the repo command, and I don't know

if that will cause a conflict with repo.

3. When prompted, configure Repo with your real name and email address. If you plan to

submit code, use an email address that is associated with a Google account.

A successful initialization will end with a message such as

repo initialized in /mydroid

Your client directory should now contain a .repo directory where files such as the manifest will

be kept. These steps simply set up and install the manifest data. The following step will install

the designated source files based on the manifest file.

Getting the files

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

manifest, change to your mydroid directory and run

$ repo sync

[This step will take a long time. You are downloading a couple gigs worth of files, so use the

best internet connection you can for this step, and if possible, do it before going to bed or when

you plan on being away from your computer for a while.]

The Android source files will be located in your working directory under their project names.

Verifying Git Tags

The following step adds Google's PGP key to your system so that you can verify all files you

download from the Android Git repo.

To load the key, run:

$ gpg --import

then copy the full text below (from -----BEGIN to BLOCK-----) and paste it into the bash shell

below the previous command, and press Control-D to end the input and process the key.

-----BEGIN PGP PUBLIC KEY BLOCK-----

Version: GnuPG v1.4.2.2 (GNU/Linux)

mQGiBEnnWD4RBACt9/h4v9xnnGDou13y3dvOx6/t43LPPIxeJ8eX9WB+8LLuROSV

lFhpHawsVAcFlmi7f7jdSRF+OvtZL9ShPKdLfwBJMNkU66/TZmPewS4m782ndtw7

8tR1cXb197Ob8kOfQB3A9yk2XZ4ei4ZC3i6wVdqHLRxABdncwu5hOF9KXwCgkxMD

u4PVgChaAJzTYJ1EG+UYBIUEAJmfearb0qRAN7dEoff0FeXsEaUA6U90sEoVks0Z

wNj96SA8BL+a1OoEUUfpMhiHyLuQSftxisJxTh+2QclzDviDyaTrkANjdYY7p2cq

/HMdOY7LJlHaqtXmZxXjjtw5Uc2QG8UY8aziU3IE9nTjSwCXeJnuyvoizl9/I1S5

jU5SA/9WwIps4SC84ielIXiGWEqq6i6/sk4I9q1YemZF2XVVKnmI1F4iCMtNKsR4

MGSa1gA8s4iQbsKNWPgp7M3a51JCVCu6l/8zTpA+uUGapw4tWCp4o0dpIvDPBEa9

b/aF/ygcR8mh5hgUfpF9IpXdknOsbKCvM9lSSfRciETykZc4wrRCVGhlIEFuZHJv

aWQgT3BlbiBTb3VyY2UgUHJvamVjdCA8aW5pdGlhbC1jb250cmlidXRpb25AYW5k

cm9pZC5jb20+iGAEExECACAFAknnWD4CGwMGCwkIBwMCBBUCCAMEFgIDAQIeAQIX

gAAKCRDorT+BmrEOeNr+AJ42Xy6tEW7r3KzrJxnRX8mij9z8tgCdFfQYiHpYngkI

2t09Ed+9Bm4gmEO5Ag0ESedYRBAIAKVW1JcMBWvV/0Bo9WiByJ9WJ5swMN36/vAl

QN4mWRhfzDOk/Rosdb0csAO/l8Kz0gKQPOfObtyYjvI8JMC3rmi+LIvSUT9806Up

hisyEmmHv6U8gUb/xHLIanXGxwhYzjgeuAXVCsv+EvoPIHbY4L/KvP5x+oCJIDbk

C2b1TvVk9PryzmE4BPIQL/NtgR1oLWm/uWR9zRUFtBnE411aMAN3qnAHBBMZzKMX

LWBGWE0znfRrnczI5p49i2YZJAjyX1P2WzmScK49CV82dzLo71MnrF6fj+Udtb5+

OgTg7Cow+8PRaTkJEW5Y2JIZpnRUq0CYxAmHYX79EMKHDSThf/8AAwUIAJPWsB/M

pK+KMs/s3r6nJrnYLTfdZhtmQXimpoDMJg1zxmL8UfNUKiQZ6esoAWtDgpqt7Y7s

KZ8laHRARonte394hidZzM5nb6hQvpPjt2OlPRsyqVxw4c/KsjADtAuKW9/d8phb

N8bTyOJo856qg4oOEzKG9eeF7oaZTYBy33BTL0408sEBxiMior6b8LrZrAhkqDjA

vUXRwm/fFKgpsOysxC6xi553CxBUCH2omNV6Ka1LNMwzSp9ILz8jEGqmUtkBszwo

G1S8fXgE0Lq3cdDM/GJ4QXP/p6LiwNF99faDMTV3+2SAOGvytOX6KjKVzKOSsfJQ

hN0DlsIw8hqJc0WISQQYEQIACQUCSedYRAIbDAAKCRDorT+BmrEOeCUOAJ9qmR0l

EXzeoxcdoafxqf6gZlJZlACgkWF7wi2YLW3Oa+jv2QSTlrx4KLM=

=Wi5D

-----END PGP PUBLIC KEY BLOCK-----

After importing the keys, you can verify any tag with

$ git tag -v tagname

Building the code

To build the files, run make from within your working directory:

~$ cd ~/mydroid

~/mydroid$ mkdir vendor

~/mydroid$ mkdir vendor/htc

~/mydroid$ mkdir vendor/htc/passion

~/mydroid$ cd device/htc/passion

~/mydroid$ ./extract-files.sh # extract proprietary files from Nexus

~/mydroid$ cd ../../..

~/mydroid$ make clean

~/mydroid$ . ./build/envsetup.sh

~/mydroid$ lunch full_passion-userdebug # configure build for Nexus

(passion)

~/mydroid$ make -j4

~/mydroid$ make modules

If your build fails, complaining about a missing "run-java-tool", try setting the

ANDROID_JAVA_HOME env var to $JAVA_HOME before making.E.g.,

$ export ANDROID_JAVA_HOME=$JAVA_HOME

Android Kernel Development

This section is based on my experiences getting the Android linux kernel for development. As

far as I can tell, there was not a tutorial or documentation specifically for kernel development

from Google, only the above stated Android package source. The following section is based on

an aggregation of information I have found from multiple online sources (all of which I will try

to reference), some of which is based on older systems and devices. I will continue to update

this section to show what has been successful and best practices, but I can not currently verify

that this is the preferred method of acquiring and developing kernel source for the current release

or Nexus One.

HTC has a site with a list of the downloads for kernel source code for each of their android

devices at http://developer.htc.com/. Unfortunately, when I unpack the zip file for Nexus One T-

Mobile source, it is just the image files for the phone, not the kernel source tree. I'm not sure if

this is a mistake, as I have seen tutorials which direct readers to this site for the source tree of

other HTC devices, so perhaps this will be fixed in the future. Instead, I obtained the kernel

source from Google Android's Git repository. Most of the following information was obtained

from these two tutorials:

[HOW-TO] Build your own kernel package from source

Building Android kernel images

Setting up ADB and fastboot

ADB and fastboot are tools that allow you to connect to your device through a terminal on your

development machine, sort of like you may do with ssh. They will be needed for a number of

development steps such as pulling images and files from the devices, pushing images and files to

the device, and attempting trial boots.

First, USB permissions need to be set up for Ubuntu to allow connection to the device when it is

in the bootloader. This information was found in the following thread, [HOW-TO]Set up

Android SDK/ADB/Fastboot on Ubuntu Linux.

Setting up UDEV to recognize HTC Device -

1. Type the following into a terminal (Applications > Accessories > Terminal):

Code:

gksudo gedit /etc/udev/rules.d/51-android.rules

2. Now add the following lines to the blank file:

Code:

SUBSYSTEM=="usb", SYSFS{idVendor}=="0bb4", MODE="0666"

SUBSYSTEM=="usb",ATTR{idVendor}=="0bb4",ATTR{idProduct}=="0c02",SYMLINK

+="android_adb"

SUBSYSTEM=="usb",ATTR{idVendor}=="0bb4",ATTR{idProduct}=="0c01",SYMLINK

+="android_fastboot"

3. Click save and close.

4. To restart udev, open up a terminal and enter:

Code:

sudo restart udev

Preparing Nexus One for Development

The Nexus One should be updated to the Android build that you plan to develop with, so that the

config matches that of the developed kernel. The phone that I began with came stock from

Google with the initial Android 2.1 Build ERD79. At the time of this writing, I was updating to

the current Android 2.2 release, Build FRF83. In order to do this, the device must go through the

proper sequence of build updates. The order is:

ERD79 -> ERE27 -> FRF50 -> FRF83

Each update requires the same process, with a different zip file. The update zip file links are

listed below. For each, perform the following process:

1. First thing you have to do is rename your update file to update.zip.

2. Copy the update.zip file onto your microSD card.

3. With your Nexus One powered off, hold down the trackball and press the power button.

4. You'll be booted into a white screen with three Android robots on skateboards. Select

Bootloader 5. On the next screen, select Recovery

6. Your phone will reboot, giving you a picture of the Android robot and an exclamation

point inside a triangle.

7. Now press the power button and volume up button at the same time. It could take a

couple of tries.

8. Now (using the trackball this time) choose "Apply sdcard:update.zip" and let things run

their course.

This process was found at [GUIDE] Manually flashing an update image to your Google

Nexus One.

To get from ERD79 to ERE27, go to this site, and download the patch zip file under Official

update patch zip.

To get from ERE27 to FRF50, go to this site, and download the zip file under Stock Nexus One

and want Android 2.2 without having to root labeled File One.

To get from FRF50 to FRF83, go to this site, and download the zip file under Stock Nexus One

and want Android 2.2 without having to root labeled File Two.

Rooting and Unlocking the Nexus One

Before images can be extracted and loaded onto the Nexus One, the phone must be unlocked and

rooted. Luckily, developers have made this process very easy and have provided simple scripts

to accomplish this. The following method to unlock the bootloader and root the phone are

provided by:

How to unlock the bootloader on your Nexus One

and

Superboot - rooting the Nexus One

and both are summarized by

[Complete guide with Images] Unlock Bootloader and Root Google Nexus One [Mac,

Windows, Linux]

CAUTION : All your data will be erased.

1. Download the superboot zip file for the Android build you are running from here (since I

had just updated to FRF83, I downloaded the first link, Superboot for FRF83).

2. Extract the zip file to a directory in your development folder.

3. Turn off your Nexus One and connect it to your PC/Mac.

4. Hold the trackball down and hit the power button (while holding the trackball) to enter

bootloader. You should see a white screen with FASTBOOT USB in red and

BOOTLOADER in blue.

5. Open a terminal/command prompt and go to the folder you extracted previously.

6. Type ./fastboot-linux oem unlock and hit Enter (for windows use fastboot-windows

oem unlock or for Mac use ./fastboot-mac oem unlock as appropriate).

7. If performed correctly, your Nexus One should now have a screen titled Unlock

bootloader? with two radio button options for Yes and No. Use the volume buttons on

the side of the Nexus to choose Yes, then push the Power button to make this selection.

8. Great! You have successfully unlocked the bootloader! You will see the unlock image

while your phone boots up.

9. Turn off your Nexus One and if it's not already connected, connect it to your PC/Mac.

10. Hold the trackball down and hit the power button (while holding the trackball) to enter

bootloader. You should see a white screen with FASTBOOT USB in red and

BOOTLOADER in blue. (It now has ***UNLOCKED*** in purple at the top, if the

previous steps were completed correctly)

11. Open a terminal/command prompt and go to the folder you extracted previously.

12. Type chmod +x install-superboot-linux.sh and hit Enter, followed by ./install-

superboot-linux.sh (for Mac use ./install-superboot-mac.sh, for windows just double

click install-superboot-windows.bat)

13. Now use volume keys and power button to select reboot. Once the phone reboots, it

should be rooted.

Downloading kernel source

Kernel sources are also maintained by the Google git repository. To get a list of the available

kernel source branches, get the manifest for the kernel repository. Go to the mydroid directory

you created in the Android Source Development section and do the following:

Checkout the source code from the git repository. From mydroid directory, enter:

~/mydroid$ git clone git://android.git.kernel.org/kernel/msm.git kernel-nexus

This will create a directory called kernel-nexus, with the manifest for the kernel/msm

repository (used for Nexus kernels). You may use a different directory name if you

prefer, this is where the kernel source tree will be downloaded. Change to the kernel-

nexus directory and pull a list of available branches by entering:

~/mydroid$ cd kernel-nexus/

~/mydroid/kernel-nexus$ git branch -a

remotes/origin/HEAD -> origin/android-msm-2.6.27

remotes/origin/android-msm-2.6.25

remotes/origin/android-msm-2.6.27

remotes/origin/android-msm-2.6.29

remotes/origin/android-msm-2.6.29-donut

remotes/origin/android-msm-2.6.29-nexusone

remotes/origin/android-msm-2.6.32

remotes/origin/android-msm-2.6.32-nexusonec

remotes/origin/android-msm-htc-2.6.25

remotes/origin/android-msm8k-2.6.29

remotes/origin/msm-2.6.25

Now checkout the desired branch. I checked out the latest froyo kernel for the nexus,

android-msm-2.6.32-nexusonec. To do this, enter:

~/mydroid/kernel-nexus$ git checkout --track -b android-msm-2.6.32-nexusonec

origin/android-

msm-2.6.32-nexusonec

Branch android-msm-2.6.32-nexusonec set up to track remote branch

refs/remotes/origin/android

-msm-2.6.32-nexusonec.

Switched to a new branch "android-msm-2.6.32-nexusonec"

The kernel tree you have checked out should now be in kernel-nexus. You can verify

which branch using git branch, which will display the checked out kernels and indicate

the active branch with a *.

~/mydroid/kernel-nexus$ git branch

* android-msm-2.6.32-nexusonec

Compiling the Kernel

In order to build kernels for Android devices, we will need to set some environment variables to

cross-compile for the hardware on the devices. For the Nexus One, this is an ARM processor. I

placed all of the environment assignments needed for make in a script called armmake, and

placed it in my ~/bin folder, so that I could use this command instead of make. Here is the

contents of that script:

#!/bin/bash

PATH=$PATH:~/mydroid/prebuilt/linux-x86/toolchain/arm-eabi-4.4.0/bin

make ARCH=arm CROSS_COMPILE=arm-eabi- $1

This kernel tree should be clean already, but before doing anything else, it's a good idea to run:

~/mydroid/kernel-nexus$ armmake distclean

In order to compile the kernel, you will need a .config file to match the target device. This can

be generated automatically by entering:

~/mydroid/kernel-nexus$ armmake mahimahi_defconfig

This will generate a .config file for the Nexus running froyo. Alternatively, you can pull the

config file from the device. I generated the config file automatically, but if you prefer to pull the

config from the device, or if the automatic method isn't working, here's how to get the .config.

Connect the Nexus using the USB cable (don't mount the device), and go to Settings-

>Applications->Development and check USB debugging. Then, in a terminal on your PC, go

to the kernel directory and enter: ~/mydroid/kernel-nexus$ adb pull /proc/config.gz .

84 KB/s (7233 bytes in 0.083s)

~/mydroid/kernel-nexus$ gunzip config.gz

~/mydroid/kernel-nexus$ mv config .config

Finally, to compile the kernel, run:

~/mydroid/kernel-nexus$ armmake

If everything compiles with no errors, you will now have a file named zImage in

~/mydroid/kernel-nexus/arch/arm/boot/. This is the kernel image. Next, we will show how to

load this image on the phone.

You may want to create a copy of the kernel-nexus folder for your development. Now, each time

you want to compile the kernel, you only need to run this short sequence of commands

~/mydroid/kernel-nexus$ armmake distclean

~/mydroid/kernel-nexus$ armmake mahimahi_defconfig

~/mydroid/kernel-nexus$ armmake

Loading kernel image onto Nexus One

Before loading our custom kernel onto the phone, the original boot and recovery images should

be backed up. The partition layout of android is summarized as:

#cat /proc/mtd

dev: size erasesize name

mtd0: 00040000 00020000 "misc"

mtd1: 00500000 00020000 "recovery"

mtd2: 00280000 00020000 "boot"

mtd3: 04380000 00020000 "system"

mtd4: 04380000 00020000 "cache"

mtd5: 04ac0000 00020000 "userdata"

For a good overview of android image layout, as well as how to unpack and re-pack images, see

HOWTO: Unpack, Edit, and Re-Pack Boot Images. NOTE: This tutorial provides a good

overview, but is based on the G1. Most of the information is still accurate for the Nexus,

but keep in mind that some alterations may be needed.

Create a folder where you want to store your images, and go to that directory in the

terminal. Then use adb to pull the boot and recovery images from the phone. Connect the Nexus

using the USB cable (don't mount the device), and go to Settings->Applications->Development

and check USB debugging. Then, in the terminal on your PC, enter: ~/images$ adb shell

# cat /dev/mtd/mtd1 > /sdcard/mtd1.img

# cat /dev/mtd/mtd2 > /sdcard/mtd2.img

# exit

~/images$ adb pull /sdcard/mtd2.img .

1296 KB/s (2621440 bytes in 1.973s)

~/images$ adb pull /sdcard/mtd1.img .

1516 KB/s (5242880 bytes in 3.376s)

This will place mtd1.img and mtd2.img in the images folder you ran this from. The recovery

image is mtd1.img and mtd2.img is the boot image. Next, unpack the boot image to get the

kernel and ramdisk components. Go to this link, and download the two perl scripts under the

first note, (unpack-bootimg.pl, repack-bootimg.pl). Create a folder in your home directory for

android development scripts, and place these scripts in that folder. You will also need to copy

two executables from the compiled android source to this folder. The files are mkbootimg and

mkbootfs, which are located in ~/mydroid/out/host/linux-x86/bin. If you have not already

compiled the android source, you can do so by going to ~/mydroid and running make. Now add

this script folder to your path. I did this by adding the following line to my .profile file:

PATH="~/android/scripts:$PATH"

Now unpack the boot image by running

~/images$ unpack-bootimg.pl mtd2.img

kernel written to mtd2.img-kernel.gz

ramdisk written to mtd2.img-ramdisk.cpio.gz

488 blocks

gzip: ../mtd2.img-ramdisk.cpio.gz: decompression OK, trailing garbage ignored

extracted ramdisk contents to directory mtd2.img-ramdisk/

Now copy the kernel image that you compiled to this folder. The kernel image is named

zImage, and is located in ~/mydroid/kernel-nexus/arch/arm/boot/. Before flashing the custom

kernel to the device, we can use fastboot to test the kernel image. This will boot the device with

the custom kernel, without overwriting the image, so once the phone reboots, it will restore the

original image. To do this, connect the Nexus to your PC in bootloader mode, as described in

the rooting and unlocking section. Power off the Nexus One and connect it to the PC using the

USB cable. Hold the trackball down and hit the power button (while holding the trackball) to

enter bootloader. You should see a white screen with FASTBOOT USB in red and

BOOTLOADER in blue. Then, in the terminal, enter:

~/images$ fastboot-linux boot zImage

The device will reboot, and if all went well, your custom built kernel will be running on the

device. You can check by going to Settings->About phone and checking the Kernel version

field, which should show the user@host where you compiled the kernel. Congratulations, you

have compiled a working kernel for android.

To flash the working kernel to the Nexus One, first build a boot image. Use the following

sequence of commands to create a compressed ramdisk image, and then combine the ramdisk

image with the kernel image to generate a boot image.

~/images$ cp zImage boot.img-kernel

~/images$ mkbootfs boot.img-ramdisk | gzip > ramdisk-boot

~/images$ mkbootimg --kernel boot.img-kernel --ramdisk ramdisk-boot --cmdline

"no_c

onsole_suspend=1 console=null" -o myBoot.img --base 0x20000000

This will generate a boot image named myBoot.img. To flash this image to the device, connect

the device to the PC in bootloader mode again, and in a terminal enter:

~/images$ fastboot-linux flash boot myBoot.img

~/images$ fastboot-linux reboot

When the phone reboots, it should now be running the new boot image with your custom kernel.

Getting Wifi working on custom kernel

The android wifi modules must be compiled against the kernel they are running on. So when

you flashed your new kernel, you probably noticed wifi no longer works. To correct this, we

need to re-compile wlan.ko for our kernel, and copy it and bcm4329.ko to the modules folder in

the android system. The wlan.ko module source is in the main android source tree, under

~/mydroid/system/wlan/ti/sta_dk_4_0_4_32. We will need to go to this directory and compile

the module, while setting the kernel source target to our custom kernel source directory. The

bcm4329.ko module is compiled with the kernel build, and is located in ~/mydroid/kernel-

nexus/drivers/net/wireless/bcm4329. These two modules will need to be pushed to the system

partition of the Nexus. To do this, take the following steps:

~/mydroid$ export PATH=$PATH:~/mydroid/prebuilt/linux-x86/toolchain/arm-eabi-

4.4.0/bin

~/mydroid$ cd system/wlan/ti/sta_dk_4_0_4_32/

~/mydroid/system/wlan/ti/sta_dk_4_0_4_32$ make KERNEL_DIR=~/mydroid/kernel-

nexus clean

~/mydroid/system/wlan/ti/sta_dk_4_0_4_32$ make KERNEL_DIR=~/mydroid/kernel-

nexus

# following this step, there will be a wlan.ko in this folder

~/mydroid/system/wlan/ti/sta_dk_4_0_4_32$ adb shell mount -o remount,rw

/dev/block/mtdb

lock3 /system

# this mounts the system partition as read-write, so that we can write to it.

you

can use 'adb shell cat /proc/mounts' to verify what the mount location

for /system

is on your device.

~/mydroid/system/wlan/ti/sta_dk_4_0_4_32$ adb shell cp

/system/lib/modules/wlan.ko /syste

m/lib/modules/wlan.ko.backup

~/mydroid/system/wlan/ti/sta_dk_4_0_4_32$ adb push wlan.ko

/system/lib/modules/wlan.ko

# wlan.ko is now loaded on Nexus. repeat for bcm4329.ko

~/mydroid/system/wlan/ti/sta_dk_4_0_4_32$ cd ~/mydroid/kernel-

nexus/drivers/net/wireles

s/bcm4329/

~/mydroid/kernel-nexus/drivers/net/wireless/bcm4329$ adb shell cp

/system/lib/modules/bc

m4329.ko /system/lib/modules/bcm4329.ko.backup

~/mydroid/kernel-nexus/drivers/net/wireless/bcm4329$ adb push bcm4329.ko

/system/lib/m

odules/bcm4329.ko

~/mydroid/kernel-nexus/drivers/net/wireless/bcm4329$ adb reboot

The phone should now reboot, and hopefully when it boots back up, Wifi is restored.