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

[Jerry Hildenbrand]

Right up front – there are a lot of ways to do this, and this is not the most efficient or the best way to get it done. It is the easiest way for someone not familiar with the process though.

1. Get Ubuntu 9.04

The tools needed to build the Linux kernel as used for Android are pretty specific version. Thankfully, they also happen to be the current version available if you're using Ubuntu 9.04. To make things easy, we will have to install Ubuntu. When all said and done, we will end up with a windows/Ubuntu 9.04/Ubuntu 9.10 triple boot computer.
Like I said, not the best way but it works well and is easy to set up and use.

Get your existing Windows installation ready. Use the tools included with Windows to defragment your hard drive(s). Open your web browser and go to Ubuntu 9.04 (Jaunty Jackalope) to download the Ubuntu installation CD. Unless you're sure you need the 64 bit version, just download the 32 bit version. Burn it to a CD using whatever program you're comfortable using to burn .iso images.

Install Ubuntu 9.04 on your computer. There's a bajillion tutorials on the web to walk you through this, but honestly there is little need for one. Installing Ubuntu is easier than installing Windows. Just be sure when you reach the point to set up your hard disks, you give Ubuntu 9.04 about 12 gigs of space. It's a very easy to understand slider, adjust it so the Ubuntu 9.04 uses 12 gigs and the rest is allocated without any changes. When you have it installed, reboot into Ubuntu and wait about 5 minutes. You'll get a notification that there are updates available, follow the wizard and install the updates. Be sure to reboot when finished. In the future ignore these update notifications. When Android requires any packages to get updated, you can install those packages then. Remember, this install is only to build the kernel.

Q. - Why use an old version of Ubuntu, and why not keep it up to date?
A. - As I said earlier, Android requires the kernel be built with a very specific version of the tools used. These aren't necessarily the latest or best version of those tools, but they are the right ones for Android's kernel. Hopefully later versions of the kernel source will be updated to work with a better toolchain, but for now – it is what it is. It's actually pretty common to have to use a specific version of software to build from source

2. Installing the extra software needed to build your kernel.

Ubuntu uses a package manager to install and remove sofware. This makes it pretty easy to install everything needed. Follow along here and you'll have all the required libraries and tools required to build the kernel.

Open the terminal (Ubuntu Main Menu → Accessories → Terminal) and type or paste this into it:

sudo apt-get install sun-java5-jdk

When asked for a password, enter the password you used to set up your login for Ubuntu. Ubuntu automagically places new users into a group that has permission to run programs as root, and to do so requires you to enter YOUR password

A quick breakdown of the above command -

sudo
The first portion of the command is short for “switch user do-it”. It's an old BSD command that allows an approved user (you are an approved user – see above) to run a command as root.

apt-get install
“apt-get” is the terminal command to start the package manager. It requires an option so it knows what to do when it starts. To see all these options, enter apt-get –help in your terminal. “install” is the option to tell apt-get to download and install the named package(s).

sun-java5-jdk
This is the name of the package you want to install through apt.

This will fetch the required packages and install the closed source Java Dev. Kit ver 5 from Sun Micro. At a certain point during the installation, you'll have to accept the license from Sun. Read through it if you like, but the important thing to remember is that what we are using it for is approved and encouraged by Sun so there is no issue. Once you have java installed and set up, continue by entering the following into the same terminal window

sudo apt-get install git-core gnupg flex bison gperf libsdl-dev libesd0-dev libwxgtk2.6-dev build-essential zip curl libncurses5-dev zlib1g-dev valgrind

this fetches all the other tools needed to build the kernel. We installed java separately because it requires user action (accepting the license) to install. Notice it's just like the command used to install java in the above step “sudo apt-get install **package name(s)**” We can do many at once here because it needs no user interaction.

When that is all finished you have the tools needed to build a Linux kernel. You don't have the tools to build a Linux kernel for an ARM processor though. That's the next step.


3. Installing the arm specific toolchain and Android source

This will install tools and source from Google. A lot of tools and source. A whole lot. There are ways around this step, but this is the proper way, and gives you everything you need to build AOSP for your phone for future use. Yes, after we all get building kernels down to an artform, we'll work on building our own OS from the ground up.

In your terminal, type the following (READ THIS SECTION BEFORE ACTUALLY DOING THIS)

cd /home/*your-user-name
mkdir myandroid
mkdir bin
curl http://android.git.kernel.org/repo > ~/bin/repo
chmod a+x ~/bin/repo

What these steps mean -

1. Change to your home directory. In Linux, your home directory is yours and yours alone. You have permission and control over everything in your directory.
2. Create a new directory and name it myandroid. You could name it anything you want, but almost every tutorial and FAQ from Google uses the name “myandroid” so we're going to use it as well.
3. Create another new directory named bin. Having a “bin” (short for binary) directory in your home folder is a common practice. This will hold programs that you use and install yourself, and not system programs.
4. Use the program “curl” to get a copy of the Android repository script (the list of thing to download) direct from Android's GIT repository and place it in your “bin” directory we just made. Curl is a popular program to download text over the internet, and GIT is a standard code hosting program that Android uses to keep track of their versions.
5. Use the Linux command “chmod” (short for change mode) to make the script we download readable by all (a) and executable (x)

Now for the big step – downloading all the tools and source from Google.

cd ~/myandroid
~/bin/repo init -u git://android.git.kernel.org/platform/manifest.git
~/bin/repo sync

What's going on here -

1. Change to your myandroid directory FAILURE TO DO THIS STEP WILL TRASH YOUR WHOLE HOME FOLDER
2. use the repo script we downloaded to find the source tree from Google, and create a list for downloading it all
3. syncronize your local copy of the source code tree with Google's copy.

A couple things – you'll notice commands that start with the tilde “~”. In Linux, this ALWAYS means your home folder. Since we moved into the myandroid directory, we have to use the whole path to the command we are running. ~/bin/repo simply means “home/*your-user-name*/bin/repo”. You can use the tilde to start the path for any command from your home folder, and in Linux terminal work, you will be using it a lot.

This step takes about forever and a day. You're downloading about 1.7 gigabytes of data, and often times the android git repo is hammered for bandwidth. You're pretty lucky to get speeds over 900kb/s or so. You can safely start the download and walk away for a while. As long as nobody comes by and shuts down your terminal you can pick back up when it's finished. I usually run this command and give it at least an hour, sometimes overnight. Just be sure not to interfere with it.

 

[Jerry Hildenbrand]

When it's done and you're back to your command prompt, copy and paste this long command, all at once. This is all one command and it contains Google's PGP key to ensure everything and anything you download from the Android GIT repo is really from Google. Don't skip this step.

echo "-----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-----"> /tmp/android.gpg

This copies Googles public key to a file on your system at /tmp/. Next we need to import the key into your keyring

gpg --import < /tmp/android.gpg
rm -rf /tmp/android.gpg

Whats going on here -

1. PGP (pretty good privacy) is a standard for security across many platforms. It's very common for people who offer up source code to provide a copy of their Key so you can verify that the code really came from them. As long as we know that the Public portion of the key (the long string above) actually came from Google (it does, and you can find it on the web HERE to verify character by character if you like. I won't be offended if you don't trust me in this situation) then the code we downloaded can be verified as being signed by the person who's key is listed above. Yes it's confusing. You need to create a key to sign anything. The key is in two parts – public and private. If you check the signature against the public portion of the key (that long ass text block above) it will tell you if it was signed with the private portion of the key pair. We're taking that key and copying it to a text file so we can have Googles public portion in our keyring.
2. Use that text file, import it into your keyring
3. Delete the temporary text file after we import it and verify

You will see an error if anything went wrong. If that happens, stop and ask for help. This step needs done correctly, and it's much easier to fix the PGP key than it is to start over from scratch again.

This is a good stopping point for reading, and actually doing it. The rest will follow soon.

Post any questions, no matter how "stupid" you think they are. We're all here to learn by doing and sharing.

 

[Jerry Hildenbrand]

4. Download and install kernel sources

The next step is to download the Linux kernel sources. At this point in time, we only have the 2.6.27 sources. HTC has not released a ROM using any newer sources, so they don't have to release the kernel source. The minute they (or anyone else - this means you, me and all other Developers) release a different version they are required to make the source available.

Here is the link to HTC's original kernel source as shipped with the Hero

More interesting to us, Here is a Link to the modified Hero sources, with the following fixes -
Multi-Touch/OpenGL lite
Improved memory management

You can download either of these, or both. The following instructions work for either package.

1. Download the source package of your choice, and save it to your Desktop.
2. open the terminal, and enter the following:

mkdir ~/.Hero_Kernel_sources

3. Open Nautilus. It's Ubuntu's version of Windows Explorer. You will find it under Places -> Home folder in the top bar. Make sure you're in your home folder!
4. While the Home Folder window is focused, hit CTRL+H . You'll be able to see hidden folders then. Find the folder you created above (.Hero_Kernel-sources) and open it by clicking on it.
5. Double click the source package you downloaded above. You'll see one folder. Drag the folder from the source package into your .Hero_Kernel_sources folder. It might take a while because the file is tarr'd and bzipped, but it will copy over. When it's finished, open the folder and look through it if you would like. The README and CHANGELOG are just the standard notes from the Linux Kernel maintainers, HTC didn't add any info.
6. Go back to your terminal, and enter the following -

cd ~
mkdir android
cd android
mkdir sources
cd sources
ln -s /home/*your-user-name*/.Hero_Kernel_sources/*EXACT NAME OF THE FOLDER YOU EXTRACTED FROM THE ZIP kernel

What all this means -

1. make sure we're in our home directory
2. Make a new folder named android
3. switch to that folder we just made (android)
4. Make a new folder named sources
5. switch over to the new directory we just made
6. Create a symbolic link to the kernel source package we downloaded and extracted, and name it kernel. Make sure there is a space between the last letter of the folder name and the word kernel at the end of this line.

Now whenever we need to enter our kernel source directory, we can just go to ~/android/sources/kernel. This makes for much cleaner and easy to type commands, and if we download new sources we can just delete the symlink and create a new one like we did in step 6 above. It's good practice to place all your local (things that aren't sync'd) files and folders that have to do with Android in your personal ~/android directory. Even though it's very unlikely that anyone else will use our machine, it's always best to try to maintain and use good coding and housekeeping practices.

 

[Jerry Hildenbrand]

5. The Cheat Sheet

Each time you want to build your kernel source you'll need to set some variables. Even if you're ONLY using the machine to build android kernels, you don't want these active all the time.

Fire up the text editor (applications->accessories->gedit Text Editor and make yourself a little cheat sheet by copying the following into a blank file:

#To make kernel
export ARCH=arm
export CROSS_COMPILE=arm-eabi-
export PATH=$PATH:~/myandroid/prebuilt/linux-x86/toolchain/arm-eabi-4.4.0/bin

#To make wifi module
export KERNEL_DIR=~/android/sources/kernel
cd ~/myandroid/system/wlan/ti/sta_dk_4_0_4_32/

#Pull kernel config from running phone
adb pull /proc/config.gz ~/android/sources/kernel/
cd ~/android/sources/kernel/
gunzip config.gz

#Pull boot image from running phone
adb shell
cat /dev/mtd/mtd2 > /sdcard/running.img
exit
adb pull /sdcard/running.img /PATH TO PLACE BOOT IMAGE
cd *path-you-placed-the-image
cp running.img boot.img

#Locations
~/android/sources/kernel/arch/arm/boot/zImage <-----compiled kernel
~/myandroid/system/wlan/ti/sta_dk_4_0_4_32/wlan.ko <-----WiFi module

Save this cheat sheet anywhere you like. It's just a reference so you don't have to dig through a pile of post-it's or dig through folders. You will need these commands when we start making the kernel

 

[Jerry Hildenbrand]

6. Building the kernel

The first thing you need is the config for the running kernel. In the above post there's a section in the cheat sheet to get this

#Pull kernel config from running phone
adb pull /proc/config.gz ~/android/sources/kernel/
cd ~/android/sources/kernel/
gunzip config.gz

This will leave a file named config in /home/*your-user-name*/android/sources/kernel/ . We need this to see what HTC thinks we have to have in our kernel.

Lets edit the makefile

• 1. Open your terminal, and head to your kernel source code directory.
• 2. At the prompt, type
  

  make clean

  (you do NOT have to do this if you downloaded one of the packages above. i have already cleaned them. It is however a good practice to get in to.
• 3. Next we need to specify our tool-chain and cross compiler.
  Look at your cheat sheet, we need to enter this (one line at a time)
  

  export ARCH=arm
  export CROSS_COMPILE=arm-eabi-
  export PATH=$PATH:~/myandroid/prebuilt/linux-x86/toolchain/arm-eabi-4.4.0/bin

• 4. When that's finished, enter the command
  

  make menuconfig

• 5. In the window that opens (inside your terminal) scroll to the bottom. Highlight the "Load an Alternative Configuration File" entry and hit enter. In the space that pops up, type the full path to the config file you pulled from your phone- /home/*your-user-name*/android/sources/kernel/config and hit enter.
• 6. Edit your kernel make options by selecting or deselecting them from the menu.

Here's the changes from my latest kernel -
1. General Setup--->
local version - append to kernel release
change this to something so you know which version of your kernel is running at a glance

2. System Type --->
[ ] HTC Performance Lock (uncheck)
MSM Hardware 3D Register Driver (Android 2.0+ (Eclair)) --->
(select whether this kernel will be for cupcake or eclair)

3. CPU Frequency scaling --->
(select the cpu governors you want to include. Less is better, i use msm7k, ondemand, and performance)

4. Kernel hacking --->
[ ] Kernel debugging (unchecked for release builds, checked for test builds)

That's it. That combined with the patched sources will give you a basic kernel with 3d accell, multitouch, scalable cpu frequency, and improved memory management.

Some fun things to think about in your kernel

USB host
Device Drivers --->
[*] USB support --->
< > Support for Host-side USB
< > USB Gadget Support --->
Check these if you want to play with USB interface support. Things like flash drives, keyboards, etc.

File system support
File systems --->
this is where you can add support for other file systems. Don't remove any that are already checked! In a nutshell you can have ext4, resierfs, or JFS support for sd card partitions. Handy if you're going to play with apps2sd

Networking options
[*] Networking support --->
Networking options --->
this is where you can add support for IP tunneling, and other network privacy options.

Once you're done, exit out of the config. you'll be asked if you want to save your configuration. Select yes. It will save it inside the kernel source directory as .config ( a hidden file). At your prompt, type

make

This will build the kernel and any included modules (ip tunneling, USB gadgets, etc).
(Look at the last few lines of output to see the names and locations of any modules. We'll need them. If you haven't built anything as a module, don't worry about it)
It will not build the wifi module. We need to do that next so back to the cheat sheet.

At your prompt, one line at a time-

export KERNEL_DIR=~/android/sources/kernel
cd ~/myandroid/system/wlan/ti/sta_dk_4_0_4_32/
make clean
make

now you have the compiled kernel and wireless module. On our cheat sheet we see these are located:

#Locations
~/android/sources/kernel/arch/arm/boot/zImage <-----compiled kernel
~/myandroid/system/wlan/ti/sta_dk_4_0_4_32/wlan.ko <-----WiFi module

Copy these into a work directory for later. you'll need them when we build the boot.img and kernel package.

 

[Jerry Hildenbrand]

7. Testing the whole thing

Attached to this post is a zip file named imagetools.zip . Download it, and extract the scripts folder inside it to your android folder.

open your terminal and type the following

gedit .bashrc

This file is the "settings" for your terminal. Spend a fun rainy Saturday googleing bashrc to learn all about tweaking it, but for now we're just going to edit the path.

Add these two lines to the bottom of the file

export PATH=${PATH}:/home/gbhil/android/android-sdk-linux_86/tools
export PATH=${PATH}:/home/gbhil/android/scripts

Of course edit it so it has YOUR path to the tools and scripts instead of mine, and save the file. Close the terminal and reopen it.

echo $PATH

to see that the changes stuck

Create a "working" folder. For our purposes, we're going to make this one -

mkdir ~/kernel_test

copy the zImage from above, and the wlan.ko module to this folder. Open the zip file of your favorite ROM, and extract the boot.img file from it inside our new working folder as well. Now enter these commands VERY carefully one line at a time:

cd ~/kernel_test
./extract-kernel.pl boot.img
./extract-ramdisk.pl boot.img
rm boot.img-kernel
cp zImage boot.img-kernel
./mkbootfs boot.img-ramdisk | gzip > ramdisk-boot
./mkbootimg --kernel boot.img-kernel --ramdisk ramdisk-boot --cmdline "no_console_suspend=1 console=null" -o myBoot.img --base 0x19200000

Whats happening you ask?

1. move into our work folder
2. use the python script we placed in our new scripts folder to extract the kernel from the boot image
3. Use the Python script to extract the ramdisk
4. delete the kernel that was inside the boot.img
5. copy/paste our newly compiled kernel with the correct name to re-assemble the boot.img
6. re-assemble the ramdisk and get it ready to place into a new boot image
7. Take the re-assembled ramdisk and our new kernel and create a new boot image named myBoot.img

Now copy the myBoot.img and the wlan.ko file onto the root folder of your SD card. Reboot your phone to recovery. Preform a Nandroid backup, because this next step gets flakey sometimes. Reboot the phone normally, and plug it in to your computer. DO NOT TOUCH IT OR DO ANYTHING ELSE after you plug it in. Once the phone is booted, open your terminal and very carefully type the following:

adb shell
cat /dev/zero > /dev/mtd/mtd2
flash_image boot /sdcard/myBoot.img
reboot

some notes -
You WILL see an out of memory error at the second step. That's fine
Your phone may boot into fastboot. If it does, disconnect from the pc and restart. If it fails to restart, reboot to recovery and restore the backup you just made and try again. We aren't touching the recovery image so it should remain the same as it is now.

Once your phone boots, at the terminal once again -

adb remount
adb shell
cp /sdcard/wlan.ko /system/lib/modules/wlan.ko
reboot

When the phone reboots, check to be sure wifi can start. Even if you don't have an AP to connect to, it will show an error if somethings wrong.

If the wifi loaded correctly (with no errors or did connect), you're running your own kernel. Congratulations.

 

[Darkshneider]

You are the man. Gonna dust off my Kubuntu USB for an installation tonight.

 

[Jerry Hildenbrand]

You are the man. Gonna dust off my Kubuntu USB for an installation tonight.

Make sure it's 9.04 . This is just the tip of the iceburg. Darkshneider Kernel package is is the goal.

 

[beezy]

Thanks for info.

 

[Darkshneider]

Its gonna be named ObmuG? lol.

And its Kubuntu Karmic Koala (holy ****e, KKK!)... damn, I guess Ill be downloading for a bit. Might as well make it Ubuntu.

 

[Jerry Hildenbrand]

Thanks for info.

No need to thank me man. Believe it or not, I'll be just as happy when beezy420 kernel comes out as you are. Everyone tells me i should have been a teacher, instead of a bum lol.

Its gonna be named ObmuG? lol.

And its Kubuntu Karmic Koala (holy ****e, KKK!)... damn, I guess Ill be downloading for a bit. Might as well make it Ubuntu.

Ubuntu is smaller and runs a bit faster. This needs to be a pretty bare install for building software, so Ubuntu/Gnome is actually a better choice. When we get into editing and building images so you can plop your kernel in place of someone else's, that's a good time for Kubuntu if you prefer KDE.

 

[Darkshneider]

I actually like KDE because of eye candy but never really got too much into it, I actually found myself lost a lot of times (Im a Linux noob) using KDE and ended up installing Gnome, switching DE at the log on window.

 

[Jerry Hildenbrand]

I actually like KDE because of eye candy but never really got too much into it, I actually found myself lost a lot of times (Im a Linux noob) using KDE and ended up installing Gnome, switching DE at the log on window.

I've always used Gnome, but I know what you mean. KDE can look pretty damn slick and do things Windows users can only dream of.

Having said that, Gnome with compiz/emerald can be amazing looking as well.

Just trust me and leave this one pretty bare and basic lol. When the day comes that you want to build the whole Android OS from source (and you will) you will be happy you kept a lean and ugly install on your hard drive

 

[Darkshneider]

I used Compiz/Fusion when I first started getting into Ubuntu (and when I had a "real" PC). Pic is attached.

 

[cteneyck]

can't wait for post number 5 gb.

 

[Jerry Hildenbrand]

coming soon (hope for tomorrow). Feet up by the fire and my evening cigar and Wild Turkey on the coffee table for the evening

 

[pseudoremora]

Gbhil - thanks for tutorials, this will really help a lot of us out! By the way, since Linux Mint in built on Ubuntu, I would presume the said instructions (commands) in the first post and such should work, right?

As always, your HOW-TO's are very much appreciated and benefit us all. Thanks again!

 

[Jerry Hildenbrand]

Gbhil - thanks for tutorials, this will really help a lot of us out! By the way, since Linux Mint in built on Ubuntu, I would presume the said instructions (commands) in the first post and such should work, right?

As always, your HOW-TO's are very much appreciated and benefit us all. Thanks again!

Beats me lol. Depending on the version of the toolchain on Mint it might work, or it might not. Make sure you have jre 1.5 and we will assume the rest works.

That's the problem with a step-by-step tutorial, you have to base it on one version of the software. If mint doesn't work out of the box, it can be made to work with some trial and error.

 

[tatonka_Hero]

well this looks like it could be fun to play with, awesome work Gbhil! I appreciate everything you've done for the android community, and have been waiting for some information on tweaking the inner workings myself

 

[Jerry Hildenbrand]

Bump for anyone interested. Some updates