Bucket Guild | FUBU BH Forums

Windows 7 is a nice OS.

base64 -di <(Tm8gdXNlIGZvciBpdCBhbmQgSSByZXF1aXJlIHVuaXggZm9yIHNwZWNpZmljIHByb2dyYW1zLiBXaG8gd2FudHMgdGhlIGZyZWUgd2luNyBrZXkgdW5kZXIgbXkgbGFwdG9wPw==)

What do you bros know about android?
I wanna learn to build my own kernels and roms for my phone. I don't like relying on others so much

Sent from my SPH-D700 using Tapatalk

RPM was horrible back in RH4.0 days. The more things change, the more they stay the same.


no, thank you.

Install either a linux distribution or run one inside of a VM (IMO ubuntu/debian (or mint) are way easier to get the environment up and running, in part because that's what the manuals are written for and the AOSP devs probably all use either one of those). If you don't understand a thing in here then a quick google shall provide an answer -- especially if you're using ubuntu.

It needs to be x86_64, even though android is x86, it has to be built on a 64bit machine.

Get familiar with apt-get/aptitude, now you must make an environment. You'll need: python 2.4-2.7 (and not higher unless that changed recently), sun JDK 6 (if you want to build 2.3+), or the open-jdk equivalent. Enable the 'partner' repositories, update and grab the JDK first.

EDIT2: you'll need about 12gb of free space on the partition you're building for android.

Grab a bunch of dependencies:


This also wouldn't hurt:


Or do it the Joklem way:


Grab the repo binary, imo it's less cruel than git:


Now make your working directory, for the record ~ in unix always refers to "/home/username", so ~/blah points to /home/username/blah, cd changes directories.


Initialize the repo:

You can also specify -b gingerbread to only get that branch, or get a specific branch that you want.

Download the sourcecode:

This might take an hour or three. Once it's done, and don't skip this step, import the android GNUPG key so that you can be sure that what you got is exactly the same shit as how it is on the repository, type:

You'll be on an empty line, paste this: (verify it there too http://source.android.com/source/downloading.html)

then, CTRL+D to signify EOF (end-of-file)

You now have an environment and the entire android sourcecode, but more importantly you have the toolchain required to build it and the kernel. That's the GNU compiler collection, to build android obviously the x86_64 to ARM cross-compiler is used. Look around on the xda-developers forums for ROMs and kernels that interest you, read a few on general build howtos and get used to the Unix environment by experimenting and fixing whatever errors pop up.

When building you'll need the toolchain in your PATH:
export PATH=$PATH:~/src/android/prebuilt/linux-x86/toolchain/arm-eabi-<version>/bin
this sets a variable the environment to look into that directory for the compiler binaries, otherwise you will get a command not found error.
to specify that you want to cross compile for ARM:
export ARCH=arm
this is "architecture = ARM"
export CROSS_COMPILE:arm-eabi-
where 'arm-eabi-' is the 'prefix' of the binaries in the above folder, i.e. they would be named arm-eabi-c or something. That's the default though.

Some other influential variables, especially when building the kernel, are CFLAGS and CXXFLAGS, those are the GCC optimization arguments.

For practice, build stock Android 2.3.3
prepare:


If all went well so far:

where ## is the number of cores (and threads) in your machine or number of cores+1, so if you're on a core i7, make -j9 to max out your cpu

That'll take a while and it will likely heat up your room and the adjacent room(edit3: if you have overheating issues, then run less threads, seriously, a thermal shutdown in the middle of a build sucks and 100% usage for nearly an hour will push it there if you've had overheating issues before, here's my global warming: http://i.imgur.com/vIBQS.jpg). When you're done, you can run it in an emulator - I forgot about that so google it mmkay?

As for building the kernel, you need to download an android kernel source code (the GNU GPL ensures that any dev that you see on xda-developers has to publish his full source code, so it won't be hard to find one), do the same but read up on kernel configuration and building instead of android. Use the same toolchain (all the export shit we did)

I wish many errors upon you because that's how terminal-fu is developed.

EDIT:
Once you're more comfortable from building other people's shit, you could start experimenting step by step. First with the kernel configuration/CFLAGS optimizations, then start merging interesting patches into kernel source trees, then maybe add a few lines of C code to the source. Fuck around, read some source files, try to understand some shit and piece it all together in a mental map, etc.

If you flash a kernel on your phone that panics or is a total dickwad, don't panic and just boot into recovery then restore your NAND, or better yet have a .zip package of the original kernel on your SDCard and just flash that then reboot. You can wipe your ROM/kernel partitions clean if you wished and as long as the bootloader and recovery partitions are intact, you can install from the SDCard or restore a backup, if you happened to forget then pop the SDCard in a PC and transfer the zips over. Easy as that.

I keep reading about NAND but what is it exactly?

flash memory, that 512mb or whatever it's size internal memory in your phone. the backup function in clockworkmod backs up the entire thing (beyond the recovery partition) on the SD card. works like system restore in windows

Oh and I forgot, before delving into android you might want to get some fu by compiling desktop linux shit. The kernel is relatively easy, just get the build dependencies, go to kernel.org, grab a sauce and some patches and configure a frankenkernel. Install and look at the dmesg (boot) log. Don't build packages and instead install it with Tehra's method. Hint: you need to make and put something else in the boot partition and also point grub to that or your system won't boot with that kernel. I suggest the "bfs patch" by Con Kolivas, succesfully build with it then start a huge load on your system (e.g. make the kernel with make -j64) then open up beefy programs, notice how smooth everything stays and realize how much power of customization you can have with one 260.4kb patch in the form of a text file

Chromium is also pretty beefy and can be a challenge in troubleshooting. You're likely to get errors saying that your packages are too new to build it. Get the source of the older versions, build, install and then you need to tell the OS to use those instead, of course a temporary solution is warranted.

Another would be to build GCC, the standard linux build tools.

Don't delve into program code heavily much (that's what programmers are for), instead start by understanding the overall architecture. What goes in, into what, and what comes out. The most basic (in terms of what makes this shit work) would be the unix pipe

http://pastebin.com/t2gw4W7X

The anatomy of a command and how it relates to the pipe, e.g.:

http://pastebin.com/MBFPjnzz

It's all basically a large collection of lego blocks and you can build whatever the fuck you want provided you have a plan.

Oh and understand why exactly this little guy is going to fuck your system through the ears and force you to reboot:


"function : shall spawn : and be piped through : and sent to the background, while true, do :"

Lego blocks example: so you have a stupid idea like wanting to download a dynamic image from the internet every minute and a half, extract two strings of text from it and write them into text files so that other programs or scripts can use the information? No problem:


But with great power, you need to learn to be careful about what you type in, and not to accidentally hit the enter key at a really bad moment:

Remembered the sticker under my laptop then remembered this post. PM me if you want to upgrade to 7

Druid: Meowth
« Steam »« Xfire »
Glorious Death Metal Music