[Galaxy Y GT-S5360 and Duos 6102 Q&A, Help & Troubl] D_Rising_Pheonix:
What is a kernel? If you spend any

time reading Android forums,

blogs, how-to posts or online

discussion you'll soon hear people

talking about the kernel. A kernel

isn't something unique to Android

-- iOS and MacOS have one,

Windows has one, BlackBerry's

QNX has one, in fact all high level

operating systems have one. The

one we're interested in is Linux, as

it's the one Android uses. Let's try

to break down what it is and what

it does.

Android devices use the Linux

kernel, but it's not the exact same

kernel other Linux-based

operating systems use. There's a

lot of Android specific code built

in, and Google's Android kernel

maintainers have their work cut

out for them. OEMs have to

contribute as well, because they

need to develop hardware drivers

for the parts they're using for the

kernel version they're using. This

is why it takes a while for

independent Android developers

and hackers to port new versions

to older devices and get

everything working. Drivers

written to work with the

Gingerbread kernel on a phone

won't necessarily work with the Ice

Cream Sandwich kernel. And

that's important, because one of

the kernel's main functions is to

control the hardware. It's a whole

lot of source code, with more

options while building it than you

can imagine, but in the end it's

just the intermediary between the

hardware and the software.

When software needs the

hardware to do anything, it sends

a request to the kernel. And when

we say anything , we mean anything.

From the brightness of the

screen, to the volume level, to

initiating a call through the radio,

even what's drawn on the display

is ultimately controlled by the

kernel. For example -- when you

tap the search button on your

phone, you tell the software to

open the search application. What

happens is that you touched a

certain point on the digitizer,

which tells the software that

you've touched the screen at

those coordinates. The software

knows that when that particular

spot is touched, the search dialog

is supposed to open. The kernel

is what tells the digitizer to look

(or listen, events are "listened"

for) for touches, helps figure out

where you touched, and tells the

system you touched it. In turn,

when the system receives a touch

event at a specific point from the

kernel (through the driver) it

knows what to draw on your

screen. Both the hardware and

the software communicate both

ways with the kernel, and that's

how your phone knows when to do

something. Input from one side is

sent as output to the other,

whether it's you playing Angry

Birds, or connecting to your car's

Bluetooth.

It sounds complicated, and it is.

But it's also pretty standard

computer logic -- there's an action

of some sort generated for every

event. Without the kernel to

accept and send information,

developers would have to write

code for every single event for

every single piece of hardware in

your device. With the kernel, all

they have to do is communicate

with it through the Android system

API's, and hardware developers

only have to make the device

hardware communicate with the

kernel. The good thing is that you

don't need to know exactly how or

why the kernel does what it does,

just understanding that it's the

go-between from software to

hardware gives you a pretty good

grasp of what's happening under

the glass. Sort of gives a whole

new outlook towards those fellows

who stay up all night to work on

kernels for your phone, doesn't

it?

:screwy::(:D:(:D:(:(