一、framework.jar反编译为smali文件

1、下载smali-1.2.6.jar和baksmali-1.2.6.jar这两个工具（下载地址：http://code.google.com/p/smali/downloads/list）

2、将framework.jar中的classes.dex解压出来（好像不解压，直接用framework.jar也行）

3、使用baksmali.jar对classes.dex进行反编译（前提是安装了jdk，并且设置好了环境变量），执行命令：

java -jar baksmali-1.2.6.jar classes.dex -o out/

其中classes.dex是要反编译的文件，out/是要把反编译后的文件存放到的文件夹，如果不是在当前目录下，那么baksmali-1.2.6.jar还要加上路径

这样就OK了，在out文件夹中可以看到一堆扩展名为.smali的文件，用记事本就可以打开它们，从中可以窥到一些信息。但是与.java文件还是有一些不同，我也不太清楚这是什么结构。

二、smali文件回编译为classes.dex

1、一条命令就OK了：java -jar smali-1.2.6.jar out/ -o classes.dex

2、再把编译好的classes.dex放回到framework.jar中就行了（可以使用winrar、winzip之类的工具作为辅助）。

三、framework.jar反编译为.class和.java文件

1、下载以下工具：

（1）dex2jar（http://code.google.com/p/dex2jar/）

（2）xjad（http://www.skycn.com/soft/41898.html）或jd-gui（http://java.decompiler.free.fr/?q=jdgui）

2、使用dex2jar对framework.jar进行转换，执行命令：dex2jar.bat framework.jar   将会生成一个framework.jar.dex2jar.jar

3、直接对该jar文件解压，可以看到里面都是.class文件了

4、如果还需要转换成.java文件，可以使用xjad或jd-gui，均可将class文件变为java文件。

注：dex2jar工具也可以处理.dex文件，因此也可以不直接处理framework.jar。而是先将framework.jar解压，生成classes.dex后再处理也行。

转

a. Bootloader显示的Android机器人图像

b. 开机文字("A N D R I O D")

Android 系统启动后，读取 /initlogo.rle（一张565 rle压缩的位图），如果读取成功，测在/dev/graphics/fb0显示Logo图片；如果读取失败，则将/dev/tty0设为TEXT模式，并打开/dev/tty0，输出文本“A N D R I O D”字样。

相关代码：

/system/core/init/init.c
/system/core/init/init.h
/system/core/init/init.rc
/system/core/init/logo.c

*.rle文件的制作步骤:
1. 使用GIMP或者Advanced Batch Converter软件，将图象转换为RAW格式；
2. 使用android自带的rgb2565工具，将RAW格式文件转换为RLE格式(如：rgb2565 -rle < initlogo.raw > initlogo.rle)。

c. Android平台图形系统启动

Android的系统登录动画类似于Windows系统的滚动条，是由前景和背景两张PNG图片组成。前景图片（android-logo-mask.png）上的Android文字部分镂空，背景图片（android-logo-shine.png）则是简单的纹理。系统登录时，前景图片在最上层显示，程序代码控制背景图片连续滚动，透过前景图片文字镂空部分滚动显示背景纹理，从而实现动画效果。

相关代码：
frameworks/base/cmds/bootanimation/BootAnimation.h
frameworks/base/cmds/bootanimation/BootAnimation.cpp

frameworks/base/core/res/assets/images/android-logo-mask.png
Android默认的前景图片，文字部分镂空，大小256×64
frameworks/base/core/res/assets/images/ android-logo-shine.png
Android默认的背景图片，有动感效果，大小512×64

1. 制作当前屏幕像素的图片(模拟器默认为320*480)
使用PS制作一张320*480的图片，保存时选“保存为 Web 所用格式”，然后在弹开的窗口上，“预设”项选择“PNG-24”，保存为android_logo.png
注：好像只支持png-24，其他格式生成的rle文件显示不正常，有兴趣大家可以再验证一下。

2. 将图片转换为raw格式
使用linux下的ImageMagick自带的convert命令，进行raw格式转换，命令为：
  convert -depth 8 android_logo.png rgb:android_logo.raw
注：ubuntu 10.04 默认已经安装ImgageMagick工具，如果当前系统没有安装，可以执行下面的命令安装：
  sudo apt-get install imagemagick

3. 将raw格式转化为rle文件
需要用到android编译后的rgb2565工具，在android/out/host/linux-x86/bin目录下(android为当前源码所在目录)，转换命令如下：
rgb2565 -rle < android_logo.raw > initlogo.rle
到目前为止，启动需要显示的图像已经做好了，就是initlogo.rle，注意文件名必须是这个，如果想改文件名，需要修改android/system/core/init/init.h中的宏：
#define INIT_IMAGE_FILE "/initlogo.rle"
============================================================================================

下面需要将initlogo.rle加入的android文件系统中
4. 找到ramdisk.img文件(android/out/target/product/generic/ramdisk.img)，将文件名改为ramdisk.img.gz，然后使用下面的命令解压：
gunzip ramdisk.img.gz
解压后得到ramdisk.img，可能有人要问，怎么文件名又改回去了？其实不然，使用file ramdisk.img查看一下就知道了：
解压前：ramdisk.img: gzip compressed data, from Unix
解压后：ramdisk.img: ASCII cpio archive (SVR4 with no CRC)
跑题了，还是说正事儿。

5. 使用cpio提取文件：
新建一个temp目录：
mkdir temp
cd temp
cpio -i -F ../ramdisk.img

6. 导出文件列表：
cpio -i -t -F ../ramdisk.img > list      
注：list是一个文本文件，里面存储了ramdisk.img的文件结构，我们需要在这个文件中加入initlogo.rle这一行，修改后的文件如下：
data
default.prop
dev
init
init.goldfish.rc
init.rc
initlogo.rle
proc
sbin
sbin/adbd
sys
system

7. 生成ramdisk.img
cpio -o -H newc -O ramdisk.img < list
注：根据list文件的描述,生成ramdisk.img文件

8. 用ramdisk.img覆盖sdk目录下的ramdisk.img(android-sdk-windows/platforms/android-2.1/images/ramdisk.img)，最好先备份一下。

9. 启动模拟器，就可以看到我们自己做的的开机界面了。
/////////////////////////
开机图片设置 的下载地址为：http://docs.google.com/leaf?id=0 ... TIzOGQ5OWQ3&amp;hl=en

init 文件下载地址 http://docs.google.com/leaf?id=0 ... 2RiYjZjNjM2&amp;hl=en

split_bootimg.pl 下载地址：http://android-dls.com/files/linux/split_bootimg.zip

T卡文件下载地址：http://docs.google.com/leaf?id=0 ... GVjYzVhMjg4&amp;hl=en

开机图片设置 软件原理：
     根据android 系统 开机LOGO和开机动画的存放路径：/initlogo.rle 和 /data/local/bootanimation.zip 在init.rc 中 建立两个链接：
/initlogo.rle ->/data/data/com.android.e139.gallery/initlogo.rle 和 /data/local/bootanimation.zip ->/data/data/com.android.e139.gallery/bootanimation.zip 
来完成开机LOGO和开机动画的动态设定

安装要求：

1.本apk文件只能安装在android 2.1 或 2.0的操作系统 中
2.必须修改android 根目录下面的两个文件：init.rc 和 init 功能才能实现设置开机LOGO和开机动画的功能

修改init.rc 和 init 的方法：

1.修改 init.rc 和init文件需要修改手机中的 boot.img
导出方法：
cat /dev/mtd/mtd2 > /sdcard/root.img

然后

adb pull /sdcard/root.img ./

这样就把root.img拷贝到本地目录下了。

boot.img的组成结构是

+—————–+
| boot header | 1 page
+—————–+
| kernel | n pages
+—————–+
| ramdisk | m pages
+—————–+
| second stage | o pages
+—————–+

那我们要做的就是把这几个部分分别分离出来

我们现在先进行镜像分离。用命令

./split_bootimg.pl boot.img

成功执行后，可以得到两个文件，一个是boot.img-kernel，另一个是boot.img-ramdisk.gz。我们这里以修改ramdisk为例，所以将其解包

mkdir ramdisk

cd ramdisk

gzip -dc ../boot.img-ramdisk.gz | cpio -i

cd ..

2.进入ramdisk 修改init.rc 在init.rc 中增加：

on logo-init

    mkdir /data 0775 system system

# We chown/chmod /data again so because mount is run as root + defaults
    mount yaffs2 mtd@userdata /data nosuid nodev
    chown system system /data
    #for other user can read this dir
    chmod 0775 /data

    symlink /data/data/com.android.e139.gallery/initlogo.rle /initlogo.rle

on early-boot
# copy file   
    symlink /data/data/com.android.e139.gallery/bootanimation.zip /data/local/bootanimation.zip
    chmod 0666 /data/local/bootanimation.zip

再将已经下载的init文件覆盖到目录下面的init文件
3.生成新img 回到ramdisk 的上一级目录后执行：
mkbootfs ./ramdisk | gzip > ramdisk-new.gz mkbootimg --cmdline 'no_console_suspend=1 console=null' --kernel boot.img-kernel --ramdisk ramdisk-new.gz -o boot-new.img
就会重新生成 boot-new.img
3.刷入新img

生成了新的img后，我们如何在系统上应用我们的新boot.img呢？首先，把img文件放到sdcard上去

adb push ./boot_new.img /sdcard

然后执行这两个操作

cat /dev/zero > /dev/mtd/mtd2
flash_image boot /sdcard/mynewimage.img

执行第一个操作时，可能会提示你

write: No space left on device

这个信息没关系，不用管它。两个命令都执行后，最后adb shell reboot即可。如果重启顺利，那么恭喜你，你刷成功了.

安装步骤：
1.按上面的步骤修改手机中的init.rc 和init文件
2.把下载的T卡文件放到T卡中
3.安装 开机图片设置.apk文件

修改boot.img的方法参考：http://www.kunli.info/2009/09/14/how-to-modify-ramdisk-android/ 和
http://android-dls.com/wiki/index.php?title=HOWTO:_Unpack,_Edit,_and_Re-Pack_Boot_Images

1.System Services

首先我要声明一下，我讲的System Services并非Android 开发应用程序时，所涉及的Service（后台应用服务程序）的概念。

我要讲的System Services是Android操作系统Java应用程序下层的，伴随操作系统启动而运行的系统后台服务程序。

它是Android系统运行的基石，它配合binder（Android多进程通讯方法）、dalvik虚拟机和Android应用程序构成了一个多进程

交互通讯，交互服务的Android系统。

2.浏览一下Android系统的service

启动shell

adb shell

执行下面指令

#service list

Found 47 services:
0    phone: [com.android.internal.telephony.ITelephony]
1    iphonesubinfo: [com.android.internal.telephony.IPhoneSubInfo]
2    simphonebook: [com.android.internal.telephony.IIccPhoneBook]
3    isms: [com.android.internal.telephony.ISms]
4    appwidget: [com.android.internal.appwidget.IAppWidgetService]
42    SurfaceFlinger: [android.ui.ISurfaceComposer]
43    media.audio_policy: [android.media.IAudioPolicyService]
46    media.audio_flinger: [android.media.IAudioFlinger]
#

从结果看来Android后台有很多的service，他们是分散在不同进程中的线程实体（有点绕嘴，但是我认为这样说比较确切）。

3.什么是Service Manager

里面理解一下就可以了，Service manager是管理以上services的一个进程，他是实际存在的。

您可以在adb shell中运行ps看看进程列表就知道了。

源代码位于：

frameworks/base/cmds/servicemanager

执行方式：

他是用c和c++语言编写的natvie可以执行文件。在Android中称之为EXECUTABLE，这个名称很重要因为Android.mk文件中

用这个名字来确定他是可以执行的二进制文件。

4.探究一下Service Manager的启动过程和方法

开始有点复杂了，也该开始进入真正的Linux阶段了。

众所周知Linux的启动和文件系统的加载需要一个ramdisk，ramdisk负责让Linux kernel加载第一个进程init进程

在Android的ramdisk中就有这样一个可执行文件init，

在深入一下，我们可以去看一下

system/core/init/init.c

int main(int argc, char **argv)
{
    。。。。。。
    parse_config_file("/init.rc");

    。。。。。。

对的，没看错。这个文件会编译出一个init的二进制可执行文件，并且去读init.rc文件。

至此，我们称init.rc文件为Android启动配置脚本。

现在我们打开init.rc文件，（如果您不知道init.rc，请参考google吧）

## Daemon processes to be run by init.
##
service servicemanager /system/bin/servicemanager
    user system
    critical
    onrestart restart zygote
    onrestart restart media

看到吗，servicemanager 是init通过init.rc加载的第一个进程

接下来启动了zygote和media

4.system server进程

继续阅读init.rc

servicemanager进程运行起来以后，我们就可以应用binder来应用servicemanager提供的服务函数去创建

system-server和mediaserver了，下面是init.rc中的代码

service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server

#system-server的创建是通过app_process这个二进制程序去加载的
    socket zygote stream 666
    onrestart write /sys/android_power/request_state wake
    onrestart write /sys/power/state on
    onrestart restart media

service media /system/bin/mediaserver   #mediaserver的启动代码比较简单，看看就知道了不用参数就创建了
    user media
    group system audio camera graphics inet net_bt net_bt_admin

5.回过头再看系统的进程列表

# ps
USER     PID   PPID  VSIZE  RSS     WCHAN    PC         NAME
root      1     0     296    204   c009a694 0000c93c S /init
root      2     0     0      0     c004dea0 00000000 S kthreadd
root      25    1     728    316   c003d444 afe0d6ac S /system/bin/sh
system    26    1     796    256   c019a810 afe0ca7c S /system/bin/servicemanager
root      30    1     82860  26580 c009a694 afe0cba4 S zygote
media     31    1     20944  3184  ffffffff afe0ca7c S /system/bin/mediaserver
root      32    1     784    280   c0209468 afe0c7dc S /system/bin/installd
keystore  33    1     1616   396   c01a65a4 afe0d40c S /system/bin/keystore
root      34    1     728    272   c003d444 afe0d6ac S /system/bin/sh
root      35    1     824    332   c00b7dd0 afe0d7fc S /system/bin/qemud
root      37    1     1308   152   ffffffff 0000eca4 S /sbin/adbd
root      44    34    780    304   c0209468 afe0c7dc S /system/bin/qemu-props
system    52    30    158356 37804 ffffffff afe0ca7c S system_server
app_1     92    30    108640 20580 ffffffff afe0da04 S com.android.inputmethod.pinyin
radio     93    30    122852 23340 ffffffff afe0da04 S com.android.phone
app_1     98    30    143244 34888 ffffffff afe0da04 S android.process.acore

有点复杂了，请大家跟上思路。我们注意观察进程列表的PID和PPID，我们要通过实际的列表去理清他们的亲缘关系。

servicemanager是init的子进程

mediaserver是init的子进程

zygote是init的子进程

system_server和所有的java应用程序是zygote的子进程

休息一下我们看看他们的应用程序代码方式

Java script caller (executable)
frameworks/base/cmds/app_process/
app_main.cpp

app_process是android系统下面基于命令行的java的应用程序的调用工具

system_server executable（c/c++写的程序）

frameworks/base/cmds/system_server/

system_main.cpp
library/system_init.cpp

SystemServer （java程序）
frameworks/base/services/java/com/android/server/
SystemServer.java

Zygote （java程序）
frameworks/base/core/java/com/android/internal/os/
ZygoteInit.java

6.分析具体的调用过程（很痛苦）

app_main 调用 zygoteInit

p { margin-bottom: 0.21cm; }

/ Next arg is startup classname or "--zygote"

if ( i < argc ) {

arg = argv [ i ++];

if ( 0 == strcmp ( "--zygote" , arg )) {

bool startSystemServer = ( i < argc ) ?

strcmp ( argv [ i ], "--start-system-server" ) == 0 : false ;

setArgv0 ( argv0 , "zygote" );

set_process_name ( "zygote" );

runtime. start ( "com.android.internal.os.ZygoteInit" ,

startSystemServer );

} else {

set_process_name ( argv0 );

runtime. mClassName = arg ;

// Remainder of args get passed to startup class main ()

runtime. mArgC = argc - i ;

runtime. mArgV = argv + i ;

LOGV ( "App process is starting with pid=%d, class=%s. /n " ,

getpid (), runtime. getClassName ());

runtime. start ();

}

}

Zygote 分裂出 system_server

p { margin-bottom: 0.21cm; }

public static void main ( String argv []) {

try {

// Start profiling the zygote initialization.

if ( argv [ 1 ] . equals ( "true" )) {

startSystemServer ();

}

Log. i ( TAG, "Accepting command socket connections" );

if ( ZYGOTE_FORK_MODE ) {

runForkMode ();

} else {

runSelectLoopMode ();

}

}

frameworks/base/core/java/com/android/internal/os/
ZygoteInit.java

p { margin-bottom: 0.21cm; }

private static boolean startSystemServer()

throws MethodAndArgsCaller, RuntimeException {

/* Hardcoded command line to start the system server */

try {

/* Request to fork the system server process */

pid = Zygote. forkSystemServer (

parsedArgs. uid , parsedArgs. gid ,

parsedArgs. gids , debugFlags, null );

} catch ( IllegalArgumentException ex) {

throw new RuntimeException (ex);

}

/* For child process */

if (pid == 0 ) {

handleSystemServerProcess(parsedArgs);

}

return true ;

}

1.如果大家还能看到这里请复习一下 Linux的两个系统调用 fork和exec

frameworks/base/services/java/com/android/server/SystemService.java

p { margin-bottom: 0.21cm; }

public static void main ( String [] args ) {

if ( SamplingProfilerIntegration. isEnabled ()) {

SamplingProfilerIntegration. start ();

timer = new Timer ();

timer . schedule ( new TimerTask () {

@ Override

public void run () {

SamplingProfilerIntegration. writeSnapshot ( "system_server" );

}

} , SNAPSHOT_INTERVAL, SNAPSHOT_INTERVAL );

}

VMRuntime. getRuntime () . setTargetHeapUtilization ( 0 .8f );

System . loadLibrary ( "android_servers" );

init1 ( args );------------------>

}

public static final void init2 () {

Log. i ( TAG, "Entered the Android system server!" );

Thread thr = new ServerThread ();

thr. setName ( "android.server.ServerThread" );-------------->

thr.start();

}

红色的部分最后会执行我们上面列出的jni代码

frameworks/base/cmds/system_server/
library/system_init.cpp

Init2 这里启动了java的system service

p { margin-bottom: 0.21cm; }

class ServerThread extends Thread {

@ Override

public void run () {

Log. i ( TAG, "System Content Providers" );

ActivityManagerService. installSystemProviders ();

Log. i ( TAG, "Battery Service" );

battery = new BatteryService ( context );

ServiceManager. addService ( "battery" , battery );

Log. i ( TAG, "Hardware Service" );

hardware = new HardwareService ( context );

ServiceManager. addService ( "hardware" , hardware );

Log. i ( TAG, "Alarm Manager" );

AlarmManagerService alarm = new AlarmManagerService ( context );

ServiceManager. addService ( Context . ALARM_SERVICE , alarm );

}

}

原创文章欢迎转载，转载请注明住处rickleaf

7. 整理Android系统启动流程

至此System Service的服务环境启动起来了

8. 最后引用霍金的一句话：“懂与不懂都是收获”

http://blog.csdn.net/rickleaf/article/details/6369720

Android从2008年开始到本文写的2011年，短短三年的时间里成为手机行业首屈一指的操作系统，在平板电脑，GPS PND甚至工业控制等领域也迅速流行起来。

越来越多的CPU厂商提供完整的Android解决方案使得Android的编译方法千差万别。

本文从Google原生态的Android系统入手，试图跳过所有的CPU厂商从Android自带的ARM QEMU入手一步步的编译出定制的Android系统。

（本文原创：欢迎转载请注明出处和作者 Ricky.Wu rickleaf.wu@gmail.com）

资源

Android 2.1 r2
Android Goldfish kernel 2.6.29
ubuntu 10.04 LTS AMD64

下载源代码

安装工具包

安装必要的工具包

$sudo apt-get install git-core gnupg flex bison gperf build-essential zip curl zlib1g-dev libc6-dev  lib32ncurses5-dev ia32-libs x11proto-core-dev libx11-dev lib32readline5-dev lib32z-dev

安装64bit Linux编译32位系统需要的工具包

$ sudo apt-get install gcc-multilib g++-multilib libc6-i386 libc6-dev-i386

看需要安装下面工具包

$ sudo apt-get install make gcc g++ libc6-dev  patch texinfo
 Zlib1g-dev valgrind python

下载源代码

下载repo工具，更改为可执行权限，并确保安装路径包含在PATH中
$ curl http://android.git.kernel.org/repo > ~/bin/repo
$ chmod a+x ~/bin/repo
建立Android工作目录
$cd ~
$mkdir android_platform
下载Android 2.1 r2源代码
$repo init -u git://android.git.kernel.org/platform/manifest.git /
-b android-2.1_r2
$repo sync

定制化Vendor

Android系统的vendor

记下Android系统的代码仓库网页
http://android.git.kernel.org/
网页浏览platform/vendor目录

vendor目录的作用

vendor的英文单词有“提供商”的意思，我们结合刚才看到的Android源码仓库中的vendor子目录就可以看出，在Google的Android原始代码里vendor目录包含了CPU硬件提供商的一些信息。
Android系统作为开放的手持设备操作系统，在发布之初必须要提供配置接口给CPU提供商，这样Android的系统才能在不同的CPU上运行。
实际上vendor目录就是Android系统预留给我们加入定制化信息的目录。在这个目录中可以完成对系统默认应用程序的添加移除、及其背光，GPS和OpenGL硬件适应层的vendor库文件或者代码。

加入自己的vendor目录

参考sample和htc dream建立rickleaf作为一个新的cpu厂商，在rickleaf建立一个heaven的目录作为厂商的一个特别设备

Android.mk

在android的platform代码中，如果你的代码需要编译或者一些二进制文件和库需要复制到目标板，就必须有个Android.mk文件来管理。
Vendor里面的Android.mk文件主要负责编译CPU厂商的特定代码和复制文件到目标半
Heaven中的Android.mk文件内容如下：

BoardConfig.mk

这个文件负责对Android系统的一些配置，包括如下等
ARM CPU的版本
Audio的架构类型
GPS的适应层名字
是否vendor有自己的init.rc文件
Android的image类型(inand需要yaffs2的image，mmc需要ext3或者ext4（android2.3）的image
如果在platform中加入了自己的模块，也可以加入配置机制，并且在这个文件中决定是否加入到系统中来

Heaven下面BoardConfig.mk的内容

AndroidProducts.mk

这个文件为PRODUCT_MAKEFILES指定一个mk文件
在指定的mk文件中完成对Android系统中APP层面的一些配置，下面简单列举：
添加默认的Android应用程序
采用哪种dpi
采用哪种图资
为android添加vendor的信息
加入默认铃声

PRODUCT_PROPERTY_OVERRIDES
修改一些默认的property设置，关于什么是property请大家去浏览google的文档，可以粗略的理解为类似注册表的东西驻留在内存中，可以供应用程序读写

PRODUCT_PACKAGES
PRODUCT_COPY_FILES
Android通过以上两个变量来对android packages和一些系统文件进行添加和移除

PRODUCT_LOCALES
这个变有两个作用一个是加入系统支持的语言类型；另一个是决定默认用哪一种图资，比如ldpi,mdpi还是hdpi

PRODUCT_BRAND
厂商名字
PRODUCT_NAME
产品名字
PRODUCT_DEVICE
设备名字

Linux kernel集成化

获得内核源代码

克隆kernel到android_platform根目录
$ git clone git://android.git.kernel.org/kernel/common.git kernel
切换kernel分支到2.6.29
$ cd kernel
$ git checkout -b android-goldfish-2.6.29 origin/android-goldfish-2.6.29

增加kernel编译到系统

修改platform下面的build

------------------------------- core/Makefile --------------------------------

index 2f316ca..7a92961 100644

@@ -288,6 +288,9 @@ endif

 INSTALLED_BOOTIMAGE_TARGET := $(PRODUCT_OUT)/boot.img

+kernel: $(INSTALLED_BOOTIMAGE_TARGET)

+.PHONY:kernel

+

 ifeq ($(TARGET_BOOTIMAGE_USE_EXT2),true)

 tmp_dir_for_image := $(call intermediates-dir-for,EXECUTABLES,boot_img)/bootimg

 INTERNAL_BOOTIMAGE_ARGS += --tmpdir $(tmp_dir_for_image)

AndroidBoard.mk

kernel配置

make kernelconfig

make kernelgconfig

Android系统的编译命令集

Android编译命令

执行环境配置命令
$ . build/envsetup.sh （.后面有空格）
当前终端会多出一些命令：
- croot:   Changes directory to the top of the tree.
- m:       Makes from the top of the tree.
- mm:      Builds all of the modules in the current directory.
- mmm:     Builds all of the modules in the supplied directories.
- cgrep:   Greps on all local C/C++ files.
- jgrep:   Greps on all local Java files.
- resgrep: Greps on all local res/*.xml files.
- godir:   Go to the directory containing a file.

—help查看帮助

编译模块

使用mmm来编译指定目录的模块，如编译Launcher：
$ mmm packages/apps/Launcher/
编完之后生成两个文件：
out/target/product/heaven/data/app/LauncherTests.apk
out/target/product/heaven/system/app/Launcher.apk
可以使用
$ make snod
重新生成system.img，再运行模拟器

选择product编译

按照如下图的方式，可以选择heaven这个Product

用OpenJDK骗过Android的

既然我们在虚拟系统编译，就不用非要去安装官方推荐的java sdk 1.5了。

只要我们在out目录建立这个文件就可以了

编译整个系统

make -j2 (2表示我有的两个cpu)

模拟器加载Android系统

创建Heaven模拟环境

创建标准Android 2.1模拟器命名为heaven
更改~/.android/avd/heaven/config.ini文件
hw.lcd.density=240
sdcard.size=64M
skin.name=WVGA800-L
skin.path=platforms/android-2.1/skins/WVGA800-L
vm.heapSize=24
image.sysdir.1=platforms/android-2.1/heaven/
更改以后，我们只要我们把我们编译好的image放到SDK的
platforms/android-2.1/heaven/目录就可以用emualtor了

把out目录中编译好的zimage改名成qemu-kernel放到Heaven仿真目录中
重新冷启动emulator
emulator -avd heaven -wipe-data
这时候heaven的emualtor的所以image都是我们自己生成的了，当然也可以调试apk到这个emulator

加入kernel logo

手机的about信息

http://blog.csdn.net/rickleaf/article/details/6369065

如： PRODUCT_LOCALES := en_US zh_CN 默认语言是英语； 

4.2、在persist.sys.language 和persist.sys.country 里指定语言，如下：

PRODUCT_PROPERTY_OVERRIDES := / 
persist.sys.language=zh / 
persist.sys.country=CN /

rickleaf我测试后发现需要再添加两个值，算是对原作者的补充吧

ro.product.locale.language=zh /

ro.product.locale.region=CN

（在编译的时候一定要删除system下面的build.prop，在编译才有效，否则这个文件不会被更新）

build.prop文件的处理是在system/core/init/property_service.c。 


第二部分 多语言定制的方法 


1、多语言定制的实现步骤 

1)进入build/target/product目录，在languages_full.mk或languages_small.mk文件中， 修改PRODUCT_LOCALES的值，来定制语言,比如PRODUCT_LOCALES := en_US zh_CN zh_TW en_GB fr_FR it_IT de_DE es_ES； 

2)相同目录下，修改full.mk文件的 
$(call inherit-product, build/target/product/languages_small|full.mk)语句来切换所使用的文件; 

3)重新编译即可。 

2、设置默认语言的实现步骤 
1)进入build/target/product目录，修改文件core.mk的PRODUCT_PROPERTY_OVERRIDES 值，例如，欲修改为默认中文，则增加 
“/ persist.sys.language=zh / persist.sys.country=CN”，增加后的语句如PRODUCT_PROPERTY_OVERRIDES := / 

ro.config.notification_sound=OnTheHunt.ogg / 

ro.config.alarm_alert=Alarm_Classic.ogg / persist.sys.language=zh / persist.sys.country=CN 
2)重新编译即可。 

3、与多语言定制相关的字段及其所在的文件 

PREVIOUS_BUILD_CONFIG out/target/product/dream/previous_build_config.mk 

NO_FALLBACK_FONT的定义 device/htc/dream-sapphire/BoardConfigCommon.mk 

NO_FALLBACK_FONT的调用 frameworks/base/data/fonts/Android.mk 

extra_locales CUSTOM_LOCALES nodpi mdpi hdpi build/core/product_config.mk 

PRODUCT_PROPERTY_OVERRIDES build/target/product 
build.prop out/target/product/generic/system

首先确保机器已经root了，还安装了busybox和Emulator。

启动Emulator，然后输入命令：

# ip route show
172.18.0.0/16 dev eth0 src 172.18.3.80
default via 172.18.1.170 dev eth0

有井号的行是命令，没有的是输出结果。上述命令用于显示手机当前的路由。下面的命令删除手机的默认路由。如果出错，说明可能没有安装好busybox。

查看路由只需要普通权限，删除、添加、修改路由都需要超级用户权限。

# su ip route del default

然后，添加默认路由和一条通往内网另一个网段的路由

# su route add default gw 172.18.1.252
# su route add -net 192.30.1.0 netmask 255.255.255.0 gw 172.18.1.170

最后查看新的路由设置，下面的结果表示设置成功了。

#ip route show
192.30.1.0/24 via 172.18.1.170 dev eth0
172.18.0.0/16 dev eth0 src 172.18.3.80
default via 172.18.1.252 dev eth0

当前我使用的busybox有个问题就是命令返回出错结果，它也不会提示任何信息。此外，使用手机键盘输入实在麻烦，解决的一个办法是使用SSH，通过电脑来控制手机。

注意：不同版本的emulator， busybox， 命令稍微有差异，例如最近升级后，su命令需要而且只要首次单独执行一次，此后都不用su， 其次，route add 命令的格式也与电脑版本Linux更接近，需要用route add -net 此类的语法了。

近期升级后，我手机上修改路由的语句变成了：
su
ip route del default
route add -net 0.0.0.0 netmask 0.0.0.0 gw 172.18.1.252
route add -net 192.30.1.0 netmask 255.255.255.0 gw 172.18.1.170

make uImage

make help

Cleaning targets:
  clean		  - Remove most generated files but keep the config and
                    enough build support to build external modules
  mrproper	  - Remove all generated files + config + various backup files
  distclean	  - mrproper + remove editor backup and patch files

Configuration targets:
  config	  - Update current config utilising a line-oriented program
  nconfig         - Update current config utilising a ncurses menu based program
  menuconfig	  - Update current config utilising a menu based program
  xconfig	  - Update current config utilising a QT based front-end
  gconfig	  - Update current config utilising a GTK based front-end
  oldconfig	  - Update current config utilising a provided .config as base
  localmodconfig  - Update current config disabling modules not loaded
  localyesconfig  - Update current config converting local mods to core
  silentoldconfig - Same as oldconfig, but quietly, additionally update deps
  randconfig	  - New config with random answer to all options
  defconfig	  - New config with default answer to all options
  allmodconfig	  - New config selecting modules when possible
  allyesconfig	  - New config where all options are accepted with yes
  allnoconfig	  - New config where all options are answered with no

Other generic targets:
  all		  - Build all targets marked with [*]
* vmlinux	  - Build the bare kernel
* modules	  - Build all modules
  modules_install - Install all modules to INSTALL_MOD_PATH (default: /)
  firmware_install- Install all firmware to INSTALL_FW_PATH
                    (default: $(INSTALL_MOD_PATH)/lib/firmware)
  dir/            - Build all files in dir and below
  dir/file.[oisS] - Build specified target only
  dir/file.lst    - Build specified mixed source/assembly target only
                    (requires a recent binutils and recent build (System.map))
  dir/file.ko     - Build module including final link
  modules_prepare - Set up for building external modules
  tags/TAGS	  - Generate tags file for editors
  cscope	  - Generate cscope index
  kernelrelease	  - Output the release version string
  kernelversion	  - Output the version stored in Makefile
  headers_install - Install sanitised kernel headers to INSTALL_HDR_PATH
                    (default: /data/EN3/freescale/i.MX536/i.MX53-QSB-Android-Release3.3/src/kernel_imx/usr)

Static analysers
  checkstack      - Generate a list of stack hogs
  namespacecheck  - Name space analysis on compiled kernel
  versioncheck    - Sanity check on version.h usage
  includecheck    - Check for duplicate included header files
  export_report   - List the usages of all exported symbols
  headers_check   - Sanity check on exported headers
  headerdep       - Detect inclusion cycles in headers

Kernel packaging:
  rpm-pkg         - Build both source and binary RPM kernel packages
  binrpm-pkg      - Build only the binary kernel package
  deb-pkg         - Build the kernel as an deb package
  tar-pkg         - Build the kernel as an uncompressed tarball
  targz-pkg       - Build the kernel as a gzip compressed tarball
  tarbz2-pkg      - Build the kernel as a bzip2 compressed tarball

Documentation targets:
 Linux kernel internal documentation in different formats:
  htmldocs        - HTML
  pdfdocs         - PDF
  psdocs          - Postscript
  xmldocs         - XML DocBook
  mandocs         - man pages
  installmandocs  - install man pages generated by mandocs
  cleandocs       - clean all generated DocBook files

Architecture specific targets (arm):
* zImage        - Compressed kernel image (arch/arm/boot/zImage)
  Image         - Uncompressed kernel image (arch/arm/boot/Image)
* xipImage      - XIP kernel image, if configured (arch/arm/boot/xipImage)
  uImage        - U-Boot wrapped zImage
  bootpImage    - Combined zImage and initial RAM disk
                  (supply initrd image via make variable INITRD=<path>)
  install       - Install uncompressed kernel
  zinstall      - Install compressed kernel
                  Install using (your) ~/bin/installkernel or
                  (distribution) /sbin/installkernel or
                  install to $(INSTALL_PATH) and run lilo

ellip;… ………………

可以看到很多编译相关的命令，如：make, make all, make clean, make uImage等等

经过测试发现运行make命令之后，在make menuconfig中配置成<M>的驱动模块都可以加入编译，但是再make uImage生成uImage文件烧到板子上的时候，在目标板上的文件系统里怎么也找不到那些*.ko文件，看了一上午android filesystem相关的资料，总算是找到了解决办法，就是通过修改android生成的ramdisk.img，用脚本把这些*.ko文件导入到android的filesystem中，下面代码就是实现整个过程的脚本：

#!/bin/sh
MAKE_KERNEL=$1

#root dir
KERNEL_DIR=$(pwd)

#out dir
OUT_DIR=${KERNEL_DIR}/．．／．．/out

#modules install path
RAMDISK_DIR=ramdisk
INSTALL_MOD_PATH=${OUT_DIR}/tmp/${RAMDISK_DIR}

#echo "make kernel?(y,n)";read MAKE_KERNEL

echo    "******************************"
echo    "*        Make Kernel         *"
echo    "******************************"
if [ "$MAKE_KERNEL"x = "n"x ]; then
	echo "*** skip ***"
else
	make -j4
	make uImage -j4
	cp arch/arm/boot/uImage ${OUT_DIR}
fi


echo    "******************************"
echo    "*    Install modules         *"
echo    "******************************"
	cd ${OUT_DIR}
	[ -e "tmp" ] || { echo "mkdir tmp"; mkdir tmp; }
	cp ./ramdisk.img ./tmp
	
#上一次退出状态: 判断ramdisk.img是否存在
case "$?" in
	"0")
		cd tmp
		mv ramdisk.img ramdisk.img.gz
		cd ./${RAMDISK_DIR}
		gunzip ramdisk.img.gz
		[ -e "${RAMDISK_DIR}" ] || { echo "mkdir ${RAMDISK_DIR}"; mkdir ${RAMDISK_DIR}; }
		cd ${RAMDISK_DIR}
		cpio -i -F ../ramdisk.img
		cd ${KERNEL_DIR}
		make modules_install             #重点在这里，在kernel目录下运行此命令时，会把相关的*.ko文件install到由INSTALL_MOD_PATH指定的目录下！！
		cd ${INSTALL_MOD_PATH}
		find . | cpio -o -H newc | gzip > ../ramdisk.img
		cd ..

		echo    "******************************"
		echo    "*    Make uramdisk.img       *"
		echo    "******************************"
		mkimage -A arm -O linux -T ramdisk -C none -a 0x70308000 -n "Android Root Filesystem" -d ./ramdisk.img ./uramdisk.img	
		mv uramdisk.img ./..
		cd ..
		rm -rf ./tmp
		cd ${KERNEL_DIR}
		echo "***OKAY***"
		;;

	"1")
		echo "ramdisk.img文件不存在！！！！！！"
		rm -rf ./tmp
		cd ${KERNEL_DIR}
		;;
esac

经过这样的处理就可以向android源码生成的ramdisk.img中install任何我们自己的东西了，把uImage和uramdisk.img一起烧到板子上，通过串口查看，得到了我想要的东西，如下：

lrwxrwxrwx radio    radio             2011-07-06 08:58 build -> /data/EN3/freescale/i.MX536/i.MX53-QSB-Android-Release3.3/src/kernel_imx
-rw-r--r-- radio    radio          81 2011-07-06 08:58 modules.isapnpmap
-rw-r--r-- radio    radio          74 2011-07-06 08:58 modules.ofmap
-rw-r--r-- radio    radio          43 2011-07-06 08:58 modules.seriomap
-rw-r--r-- radio    radio        2908 2011-07-06 08:58 modules.dep.bin
-rw-r--r-- radio    radio        1671 2011-07-06 08:58 modules.symbols.bin
lrwxrwxrwx radio    radio             2011-07-06 08:58 source -> /data/EN3/freescale/i.MX536/i.MX53-QSB-Android-Release3.3/src/kernel_imx
-rw-r--r-- radio    radio         141 2011-07-06 08:58 modules.inputmap
-rw-r--r-- radio    radio       11595 2011-07-06 08:58 modules.builtin
-rw-r--r-- radio    radio          99 2011-07-06 08:58 modules.pcimap
-rw-r--r-- radio    radio        1072 2011-07-06 08:58 modules.symbols
drwxr-xr-x radio    radio             2011-07-06 08:58 kernel
-rw-r--r-- radio    radio       13189 2011-07-06 08:58 modules.builtin.bin
-rw-r--r-- radio    radio        3795 2011-07-06 08:58 modules.alias.bin
-rw-r--r-- radio    radio         189 2011-07-06 08:58 modules.usbmap
-rw-r--r-- radio    radio        1189 2011-07-06 08:58 modules.dep
-rw-r--r-- radio    radio        4404 2011-07-06 08:58 modules.alias
-rw-r--r-- radio    radio        1042 2011-07-06 08:58 modules.order
-rw-r--r-- radio    radio          69 2011-07-06 08:58 modules.ccwmap
-rw-r--r-- radio    radio          73 2011-07-06 08:58 modules.ieee1394map

相关的*.ko驱动模块就在kernel目录下!

此举主要是应消费者要求，之前有消费者在HTC的Facebook页面上抱怨没有提供相关设备，如Evo 4G的源代码共享。用户 Gregory Marton写道，“我很失望HTc违背了GNU公共许可，没有公布Evo 4G操作系统源代码的更改部分。作为一家公司，不能说等它完 备了再发布出来，这就违背了你们签订的协议。既然在我的手机上发布了二进制代码，就需要公开其所有源代码，我们希望能看到改动的部分。”

该协议要求任何修改代码的一方都需要将其公开。HTC在用户发帖之初并未作出回应，而对应产品Desire Z于11月在英国发布，Flyer则在5月发布。

Google支持的Android项目已经遵循GNU的公开协议GPL公布了手机OS的代码。

同时在5月，HTC还许诺对启动加载程序进行解锁，以便开发者在自己的手机上安装非官方的软件等。然而，截止到7月11日“要安装新的软件仍然需要进行大 量测试，面临很多挑战。”据悉，HTC Sensation 4G和EVO 3D上使用的启动加载程序，将于8月在美国成为首款获解锁的程序。

进入 HTC 开发者页面: http://developer.htc.com/

1.copy_dir

语法：copy_dir <src-dir> <dst-dir> [<timestamp>]

<src-dir>表示原文件夹，<dst-dir>表示目的文件夹，[<timestamp>]表示时间戳

作用：将<src-dir>文件夹中的内容复制到<dst-dir>文件夹中。<dst-dir>文件夹中的原始内容将会保存不变，除非<src-dir>文件夹中有相同的内容，这样<dst-dir>中的内容将被覆盖

举例：copy_dir PACKAGE:system SYSTEM:（将升级包中的system文件夹复制到手机中）

2.format

语法：format <root>

<root>表示要格式化的分区

作用：格式化一个分区

举例：format SYSTEM:（将手机/system分区完全格式化）

注意：格式化之后的数据是不可以恢复的

3.delete

语法：delete <file1> [... <fileN>]

<file1> [... <fileN>]表示要格式化的文件，可以是多个文件用空格隔开

作用：删除文件1，2到n

举例：delete SYSTEM:app/Calculator.apk（删除手机systen文件夹中app中的Calculator.apk文件）

4.delete_recursive

语法：delete_recursive <file-or-dir1> [... <file-or-dirN>]

<file-or-dir1> [... <file-or-dirN>]表示要删除的文件或文件夹，可以使多个，中间用空格隔开

作用：删除文件或者目录，删除目录时会将目录中的所有内容全部删除

举例：delete_recursive DATA:dalvik-cache（删除/data/dalvik-cache文件夹下的所有内容）

5.run_program

语法：run_program <program-file> [<args> ...]

<program-file>表示要运行的程序，[<args> ...]表示运行程序所加的参数

作用：运行终端程序

举例：run_program PACKAGE:install_busybox.sh（执行升级包中的install_busybox.sh脚本）

6.set_perm

语法：set_perm <uid> <gid> <mode> <path> [... <pathN>]

<uid>表示用户名称，<gid>表示用户组名称，<mode>，表示权限模式，<path> [... <pathN>]表示文件路径，可以使多个，用空格隔开

作用：设置单个文件或目录的所有者和权限，像linux中的chmod、chown或chgrp命令一样，只是集中在了一个命令当中

举例：set_perm 0 2000 0550 SYSTEM:etc/init.goldfish.sh（设置手机system中的etc/init.goldfish.sh的用户为root，用户组为shell，所有者以及所属用户组成员可以进行读取和执行操作，其他用户无操作权限）

7.set_perm_recursive

语法：set_perm_recursive <uid> <gid> <dir-mode> <file-mode> <path> [... <pathN>]

<uid>表示用户，<gid>表示用户组，<dir-mode>表示文件夹的权限，<file-mode>表示文件的权限，<path> [... <pathN>]表示文件夹的路径，可以多个，用空格分开

作用：设置文件夹及文件夹中的文件的所有者和用户组

举例：set_perm_recursive 0 0 0755 0644 SYSTEM:app（设置手机system/app文件夹及其中文件的用户为root，用户组为root，app文件夹权限为所有者可以进行读、写、执行操作，其他用户可以进行读取和执行操作，其中的文件的权限为所有者可以进行读写操作，其他用户可以进行读取操作）

8.show_progress

语法：show_progress <fraction> <duration>

<表示一个小部分> <表示一个小部分的持续时间>

作用：为下面进行的程序操作显示进度条，进度条会根据<duration>进行前进，当操作时间是确定的时候会更快

举例：show_progress 0.1 0（显示进度条当操作完成后前进10%）

9.symlink

语法：symlink <link-target> <link-path>

<link-target>表示链接到的目标，<link-path>表示快捷方式的路径

作用：相当于linux中的ln命令，将<link-target>在<link-path>处创建一个软链接，<link-target>的格式应为绝对路径（或许相对路径也可以），<link-path>为“根目录：路径”的形式

举例：symlink /system/bin/su SYSTEM:xbin/su（在手机中system中的xbin中建立一个/system/bin/su的快捷方式）

android文件系统和分区的定义方式（根据android的源代码的root.c获得）：

更新部分update-script命令：

1.assert <boolexpr>

作用：此命令用来判断表达式boolexpr的正确与否，当表达式错误时程序终止执行

※此作用有待验证

2.write_radio_image <src-image>

作用：将基带部分的镜像写入手机，<src-image>表示镜像文件

举例：write_radio_image PACKAGE:radio.img

3.write_hboot_image <src-image>

作用：将系统bootloader镜像写入手机，<src-image>表示镜像位置，此命令在直到在所有的程序安装结束之后才会起作用

举例：write_hboot_image PACKAGE:hboot.img

4.write_raw_image <src-image> <dest-root>

作用：将boot.img写入手机，里面包含了内核和ram盘

举例：write_raw_image PACKAGE:boot.img BOOT:

更新手机常识理解：

编译环境的搭建

JDK安装
a) JDK是Ubuntu下使用Android SDK，编译源代码等必备的软件包，首先我们现来装这个

b) 从sun官方网站下载最新版的JDK，一般是个.bin的文件，笔者下载的是jdk-6u20-linux-i586.bin（根据文件不同，命令的也会有所变化，大家在使用的时候要注意，主要是文件名和路径的变化）。

c) 由于JDK运行时会在当前目录下安装，所以在安装前，先把它移动到你想要安装的目录，比如笔者将其安装在/usr/lib/jvm/java目录下，如果你也想安装在相同目录，可以照着我下面的命令来做

代码：

sudo –i

cd /usr/lib

mkdir jvm

cd jvm

mkdir java

cd java

cp “jdk-6u20-linux-i586.bin所在目录“/jdk-6u20-linux-i586.bin /usr/lib/jvm/java

chmod u+x jdk-6u20-linux-i586.bin

jdk-6u20-linux-i586.bin

此时会出现JDK的安装提示说明，按着回车不放，提示说明会持续滚动，www.linuxidc.com直到屏幕提示需要输入Yes/NO，输入YES后，即开始安装，安装完成后提示按回车继续，按完回车后，安装即告成功

d) 与Windows不同，Ubuntu是没有注册表的，故安装完成后，我们需要把我们安装JDK的目录告诉系统，故在刚才的终端里执行如下命令（如果是新开的终端，没有执行过“sudo -i”,则需要在命令前+“sudo”获得权限）

代码：

gedit /etc/environment

此时在会弹出一个文本编辑器，里面显示

代码：

PATH＝”……”

其中省略号部分是其默认的路径，这里我们不要动它，我们需要对这个进行一些修改，将我们的JDK安装路径写进去，告诉系统我们的JDK装在哪里，去哪里调用，故做如下修改：

i. 在原有的 PATH＝”……” 的省略号里面添加：

代码：

PATH＝”……:/usr/lib/jvm/java/jdk1.6.0_20/bin”

ii. 添加两行，输入如下内容：

代码：

CLASSPATH=.:/usr/lib/jvm/java/jdk1.6.0_20/lib

JAVA_HOME=/usr/lib/jvm/java/jdk1.6.0_20

最后生成如下形式：

代码：

PATH＝”……:/usr/lib/jvm/java/jdk1.6.0_20/bin”

CLASSPATH=.:/usr/lib/jvm/java/jdk1.6.0_20/lib

JAVA_HOME=/usr/lib/jvm/java/jdk1.6.0_20

其中，省略号部分是文件原有内容，我们在后面新加了一部分内容和两个新行。修改完成后保存退出。

e) Ubuntu有可能会自带JDK或者安装多个JDK，此时需要将我们安装的这个设置为默认

i. 首先，将我们的JDK安装目录加入到JDK的选择菜单，执行如下代码：

代码：

update-alternatives –install /usr/bin/java java /usr/lib/jvm/java/jdk1.6.0_12/bin/java 300

update-alternatives –install /usr/bin/javac javac /usr/lib/jvm/java/jdk1.6.0_12/bin/javac 300

ii. 其次，通过命令来选择默认的JDK，执行如下代码：

代码：

update-alternatives –config java

iii. 最后，再来检查一下系统当前的JDK版本，输入以下代码查看：

代码：

java -version

f) 至此，JDK即告安装成功。

Android SDK安装
a) 既然是做rom，那肯定需要调试和测试的工具，Android的官方SDK同样提供官方版本，我们直接下载安装即可。

b) 去谷歌的官网下载最新的SDK版本，前几天刚跟新了支持2.2的r6，不过SDK的官方网站在墙后，我们只能FQ过去下载，这点比较无奈。官方提供Windows，Mac OS X，Linux三个版本，毫无疑问，我们需要下载Linux的版本。

c) SDK不需要安装，直接解压就可以使用。建议放在主目录下，方便调用。

d) 为了方便adb命令的使用，我们同样需要将adb命令所在的目录添加到系统环境变量中去，这样，在任何目录下都能直接调用adb，不需要现cd到SDK目录，这样会比较方便，实现方法如下：

代码：

sudo gedit ~/.bashrc

用文本编辑器打开.bashrc文件，然后在最后添加一行：

代码：

export PATH=${PATH}:<你sdk的目录>/tools

这里的需要将你sdk的安装目录添写进去，保存后即可。

e) 把手机连上usb，然后在终端中输入：

代码：

adb devices

会列出所有连接在电脑上的Android设备，如果看到一串数字和字母的序列号的显示的话，即表示SDK安装成功。

软件安装
a) 配置源，更新源之类的问题就不再说了，直接说我们需要的软件，从同步源码到编译rom我们总计需要用到以下几个软件，有部分软件在我们更新过程中可能已经自动安装了，但这不影响我们工作，我把所有需要用到的程序列了出来：

? git-core

? gnupg

? flex

? bison

? gperf

? libsdl-dev

? libesd0-dev

? libwxgtk2.6-dev

? build-essential

? zip

? curl

? libncurses5-dev

? zlib1g-dev

? valgrind

? libreadline5-dev

b) 以上这些程序均通过apt-get命令来安装，比如要安装git-core软件，我们通过输入如下命令来实现：

代码：

sudo apt-get install git-core

c) 其它软件的安装过程类似，替换掉最后的软件名称即可。

d) 安装完所有软件后，编译CyanogenMod所需要的所有环境均搭建完成了。

源码同步
repo的安装
a) CyanogenMod的源码地址是http://github.com/cyanogen/android，你可以通过网址右上角的Download Source来下载源码。不过我们并不推荐这种方式下载，因为源码的变化较为频繁，每次一旦源码有变化，我们就需要重新下载完整的源码包，既费时又费力，效率也很低，故推荐通过repo同步的方式来做，在同步过程中，仅会同步源码的变化部分，效率较高。

b) Repo的安装

i. repo的安装比较方便，之需要下载一个文件，并设置成可执行权限，并添加到系统环境中去即可，具体命令如下：

代码：

cd ~

mkdir bin

在你的home根目录下创建名为bin的文件夹。

代码：

sudo gedit ~./bashrc

打开你的环境变量配置文件，在最后加一行：

代码：

export PATH=$PATH:~/bin

修改后保存文件退出，关闭终端，重新打开一个终端，输入如下命令验证路径是否成功添加到环境变量中去了：

代码：

echo $PATH

确认完后，开始安装repo，执行如下命令：

代码：

curl http://Android.git.kernel.org/repo > ~/bin/repo
chmod a+x ~/bin/repo

通过curl命令将repo下载到bin中，并将其权限修改为可执行文件，至此repo的安装结束。

Repo的配置和同步
i. 在主目录下新建一个文件夹，作为源码的存放目录

代码：

cd ~

mkdir cyanogenmod

cd cyanogenmod

ii. 在cyanogenmod目录执行repo命令，设定需要同步的源码内容：

代码：

repo init -u git://github.com/cyanogen/Android.git -b eclair

网址即为cyanogenmod的地址，-b表示我们选择需要同步的分支，cyanogenmod有不少分支，比如dount，eclair，以后还会有froyo，我们目前需要编译的是2.1，即eclair，则通过-b eclair来选择2.1的分支。

iii. 在配置过程中，会让你选择名字和邮箱，这个会显示在你最后编译出来的rom的基础信息里，可以选择你喜欢的来写

iv. 配置完成后，就可以开始同步源码了:

代码：

repo sync

同步的过程会比较长，建议在晚上睡觉前开始同步，一般早上起来就能好了。

编译环境的设置
编译环境的建立
a) 同步玩源码后，首先需要建立编译环境，CM的源码把这些命令都写成了脚本，我们只需运行相应的脚本即可，首先，先cd到源码的根目录，然后执行如下命令：

代码：

./build/envsetup.sh

执行后，屏幕上会显示：

代码：

including vendor/cyanogen/vendorsetup.sh

此时，编译环境设置成功。

专属文件的提取
a) 虽然Android系统是开源的，但有部分Dream的专属文件是不开源的，所以并不包含在源码树中。但如果希望rom能在Dream真机上运行，又需要这些文件，所以需要将这些文件提取出来，在CM中，这个操作比较简单，Steve已经给我们做好脚本了。

b) 首先你要确保安装成功了上述所有软件，然后，将Dream通过usb连接到电脑上。

c) cd到源码的/vendor/htc/dream_sapphire目录，然后执行脚本：

代码：

./extract-files.sh

d) 这个操作会调用adb命令，从你的手机里pull所需要的专属文件到vendor目录。

编译文件的修改
a) 默认的编译过程包含了所有的语言和程序，但其实我们并不需要这些，可以通过编译文件的修改来定义需要输出的语言和软件

b) 打开/vendor/cyanogen/products 目录下的cyanogen.mk文件，里面定义了要输出的软件和语言，对于不需要的软件，可以直接删除。但不建议在这里修改，可以从最后的输出目录里删除不需要的，直接在这里改容易出错

c) 在文件的最后，有一行”PRODUCT_LOCALES”,这里就包含了rom支持的语言类型，默认有几十种，编译出来后，软件会比较大，一般我们只需要保留其中的常用语言即可，笔者选择保留了en_US,zh_CN和zh_TW这三种语言，编译出来的软件就小了很多。

Kernel编译
1. kernel是Android的核心，也是最重要的部分，虽然CM源码中自带了编译完成的kernel，但既然是自主编译，那你肯定想改改kernel的信息吧，比如kernel的名字，比如打上BFS补丁、超频补丁等等，那你就需要自己来编译kernel了。

2. 编译kernel也非常简单，首先你需要一个kernel的配置文件，CM提供了现成的，直接去/kernel-msm/arch/arm/configs 目录里找，有个配置文件叫cyanogen_msm_defconfig，这个就是我们需要的配额之文件了（如果是给Nexus编译kernel的话，需要选择cyanogen_mahimahi_defconfig）。将它复制到/kernel-msm 的根目录，然后重命名为 .config

3. 用文本编辑器打开.config,其中有一条参数为CONFIG_LOCALVERSION=”-cyanogenmod”，这里即为kernel编译完成后显示的名字，可以把cyanogenmod改成任意你喜欢的名字。

4. 设置完成后，就可以开始编译了。先cd到/kernel-msm目录，然后执行如下命令

代码：

export ARCH=arm

export CROSS_COMPILE=arm-eabi-

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

这些命令定义了编译kernel时所需要用到的环境和设置。注意第三条命令在输入的时候，路径要和自己实际安放源码的路径一致，另外，每次编译kernel前，都需要重新输入这三个命令。

5. 命令输入完后，就可以开始make了：

代码：

make -j3

make就是开始编译的命令，后面的参数-j3表示用于编译的cpu核心数量，一般是cpu核心数量+1，比如双核cpu，就用-j3这个参数。

6. 编译过程根据配置不同而有所不同，笔者笔记本用的T6400是双核2G的，一般编译kernel的时间在10分钟内。编译后的kernel生成在/kernel-msm/arch/arm/boot/目录下，名字叫zImage

CyanogenMod编译
1. 编译完kernel后，就可以开始编译主菜CM了。编译前需要先生成一个buildspec.mk文件，来定义需要编译的rom的基本信息。先cd到源码的根目录，新建一个空文件，名字叫buildspec.mk，并用记事本打开，输入如下信息：

代码：

TARGET_PRODUCT:=cyanogen_dream_sapphire

TARGET_BUILD_VARIANT:=eng

TARGET_BUILD_TYPE:=release

TARGET_PREBUILT_KERNEL:=kernel/arch/arm/boot/zImage

a) 第一条命令表示需要编译的rom的选择，我们现在编译的是G1的rom，故选择cyanogen_dream_sapphire；

b) 第二条命令表示编译的rom的种类，有eng和userdebug两个类型可选，我们当然选在eng；

c) 第三个命令表示编译的rom的类型，我们选择release

d) 第四个命令表示基于哪个kernel来编译rom，如果不设这个命令，则会基于自带的kernel来编译，既然我们自己编译了kernel，那当然用我们自己的，故设置了已经编译好的kernel的目录，供make过程调用。

2. buildspec.mk文件建立好后，就可以开始编译rom了，cd到源码根目录，然后使用命令：

代码：

make -j3

开始编译源码，源码的编译过程会比较长，试配置不同，需要的时间也不一样，笔者的T6400编译完整的CM差不多需要2个小时。

3. 编译完成后，我们的成品就在/out/target/product目录中，里面包含了system.img,recovery.img,boot.img和system文件夹等，到这里，有点制作rom经验的朋友就不需要我再多说了吧。可以在fastboot里直接刷system.img,和boot.img；也可以将system文件夹和boot.img打包成zip包，添加更新脚本并签名，通过recovery刷到机器里，至此，我们自己编译的CyanogenMod for HTC Dream就大功告成了。

-----------------------

转

安装在设备中的每一个Android包文件（.apk）都会被分配到一个属于自己的统一的Linux用户ID，并且为它创建一个沙箱，以防止影响其他应用程序（或者其他应用程序影响它）。用户ID 在应用程序安装到设备中时被分配，并且在这个设备中保持它的永久性。

通过Shared User id,拥有同一个User id的多个APK可以配置成运行在同一个进程中.所以默认就是可以互相访问任意数据. 也可以配置成运行成不同的进程, 同时可以访问其他APK的数据目录下的数据库和文件.就像访问本程序的数据一样.

对于一个APK来说，如果要使用某个共享UID的话，必须做三步：

1、在Manifest节点中增加android:sharedUserId属性。

2、在Android.mk中增加LOCAL_CERTIFICATE的定义。

如果增加了上面的属性但没有定义与之对应的LOCAL_CERTIFICATE的话，APK是安装不上去的。提示错误是：Package com.test.MyTest has no signatures that match those in shared user android.uid.system; ignoring!也就是说，仅有相同签名和相同sharedUserID标签的两个应用程序签名都会被分配相同的用户ID。例如所有和media/download相关的APK都使用android.media作为sharedUserId的话，那么它们必须有相同的签名media。

3、把APK的源码放到packages/apps/目录下，用mm进行编译。

举例说明一下。

系统中所有使用android.uid.system作为共享UID的APK，都会首先在manifest节点中增加android:sharedUserId="android.uid.system"，然后在Android.mk中增加LOCAL_CERTIFICATE := platform。可以参见Settings等

系统中所有使用android.uid.shared作为共享UID的APK，都会在manifest节点中增加android:sharedUserId="android.uid.shared"，然后在Android.mk中增加LOCAL_CERTIFICATE := shared。可以参见Launcher等

系统中所有使用android.media作为共享UID的APK，都会在manifest节点中增加android:sharedUserId="android.media"，然后在Android.mk中增加LOCAL_CERTIFICATE := media。可以参见Gallery等。

另外，应用创建的任何文件都会被赋予应用的用户标识，并且正常情况下不能被其他包访问。当通过getSharedPreferences（String，int）、openFileOutput（String、int）或者openOrCreate Database（String、int、SQLiteDatabase.CursorFactory）创建一个新文件时，开发者可以同时或分别使用MODE_WORLD_READABLE和MODE_WORLD_RITEABLE标志允许其他包读/写此文件。当设置了这些标志后，这个文件仍然属于自己的应用程序，但是它的全局读/写和读/写权限已经设置，所以其他任何应用程序可以看到它。

关于签名：

build/target/product/security目录中有四组默认签名供Android.mk在编译APK使用：

1、testkey：普通APK，默认情况下使用。

2、platform：该APK完成一些系统的核心功能。经过对系统中存在的文件夹的访问测试，这种方式编译出来的APK所在进程的UID为system。

3、shared：该APK需要和home/contacts进程共享数据。

4、media：该APK是media/download系统中的一环。

应用程序的Android.mk中有一个LOCAL_CERTIFICATE字段，由它指定用哪个key签名，未指定的默认用testkey.

参考文档：

Android中如何修改系统时间（应用程序获得系统权限）

http://blog.csdn.net/liujian885/archive/2010/03/22/5404834.aspx

Android-sharedUserId数据权限

http://wallage.blog.163.com/blog/static/17389624201011010539408/

Runtime.exec权限问题

http://blog.csdn.net/yihua0001/archive/2010/07/23/5758980.aspx

关于签名

http://blog.csdn.net/duandianGG/archive/2010/07/21/5752568.aspx

        本来以为就没有办法在应用程序这一层改系统时间了，后来在网上搜了好久，知道这个目的还是可以达到的。

        第一个方法简单点，不过需要在Android系统源码的环境下用make来编译：

        1. 在应用程序的AndroidManifest.xml中的manifest节点中加入android:sharedUserId="android.uid.system"这个属性。

        2. 修改Android.mk文件，加入LOCAL_CERTIFICATE := platform这一行

        3. 使用mm命令来编译，生成的apk就有修改系统时间的权限了。

        第二个方法麻烦点，不过不用开虚拟机跑到源码环境下用make来编译：

        1. 同上，加入android:sharedUserId="android.uid.system"这个属性。

        2. 使用eclipse编译出apk文件，但是这个apk文件是不能用的。

        3. 用压缩软件打开apk文件，删掉META-INF目录下的CERT.SF和CERT.RSA两个文件。

        4. 使用目标系统的platform密钥来重新给apk文件签名。这步比较麻烦，首先找到密钥文件，在我的Android源码目录中的位置是"build/target/product/security"，下面的platform.pk8和platform.x509.pem两个文件。然后用Android提供的Signapk工具来签名，signapk的源代码是在"build/tools/signapk"下，用法为"signapk platform.x509.pem platform.pk8 input.apk output.apk"，文件名最好使用绝对路径防止找不到，也可以修改源代码直接使用。

        这样最后得到的apk和第一个方法是一样的。

        最后解释一下原理，首先加入android:sharedUserId="android.uid.system"这个属性。通过Shared User id,拥有同一个User id的多个APK可以配置成运行在同一个进程中。那么把程序的UID配成android.uid.system，也就是要让程序运行在系统进程中，这样就有权限来修改系统时间了。

        只是加入UID还不够，如果这时候安装APK的话发现无法安装，提示签名不符，原因是程序想要运行在系统进程中还要有目标系统的platform key，就是上面第二个方法提到的platform.pk8和platform.x509.pem两个文件。用这两个key签名后apk才真正可以放入系统进程中。第一个方法中加入LOCAL_CERTIFICATE := platform其实就是用这两个key来签名。

        这也有一个问题，就是这样生成的程序只有在原始的Android系统或者是自己编译的系统中才可以用，因为这样的系统才可以拿到platform.pk8和platform.x509.pem两个文件。要是别家公司做的Android上连安装都安装不了。试试原始的Android中的key来签名，程序在模拟器上运行OK，不过放到G3上安装直接提示"Package ... has no signatures that match those in shared user android.uid.system"，这样也是保护了系统的安全。

        最最后还说下，这个android:sharedUserId属性不只可以把apk放到系统进程中，也可以配置多个APK运行在一个进程中，这样可以共享数据，应该会很有用的。

USER     PID   PPID  VSIZE  RSS     WCHAN    PC         NAME

root      1     0     296    212   c00b0124 0000d9ec S /init

... ...

shell     2183  1     3372   184   ffffffff 0000eca4 S /sbin/adbd

root      2204  1859  832    336   00000000 afe0c7dc R ps

看一下倒数第二行，adbd所在进程的父进程是root，本身的user是shell。对于一个发布状态的产品，这个是最正常不过了。但现在开发中遇到这样一个需求，产品已经处在发布状态（编译模式已经改成user）的情况下，因为BSP需要处理一些内核上的东西，需要在PC上执行adb shell后具有root权限。也就是这种效果：

USER     PID   PPID  VSIZE  RSS     WCHAN    PC         NAME

root      1     0     296    212   c00b0124 0000d9ec S /init

... ...

root      1911  1     3376   184   ffffffff 0000eca4 S /sbin/adbd

root      2198  2197  828    332   00000000 afe0c7dc R ps

要达到这个效果，就是要在启动adbd时，以root用户启动。那么，先看一下在Android中怎么启动adbd。

可以看一下Android系统根目录下的/init.rc的片段：

... ...

# adbd is controlled by the persist.service.adb.enable system property

service adbd /sbin/adbd

    disabled

# adbd on at boot in emulator

on property:ro.kernel.qemu=1

    start adbd

on property:persist.service.adb.enable=1

    start adbd

on property:persist.service.adb.enable=0

    stop adbd

... ...

这里定义了一个触发器，只要persist.service.adb.enable值被置为1，就会启动/sbin/adbd。

怎么样设置persist.service.adb.enable的值呢？这里涉及到一个属性服务/system/core/init/property_service.c。看下面的东西之前先看一下我之前翻译过来的这篇StevGuo的文档，他对属性服务描述得很仔细，也很有条理。

http://blog.csdn.net/a345017062/archive/2010/12/17/6083026.aspx

今天搜资料的时候才发现网上N多人翻译了这篇文章，有点儿晕晕的。。。

我们继续。。。

通过阅读上面的文档，我们知道了属性服务启动时加载了四个文件，这四个文件里面都可以设置系统属性，还可以通过APK设置系统属性。但我把这些方式都，结果都一样，adbd是启动起来了，用户都是shell，还是没有root权限的。看来差异应该在编译模式上，是改为user编译模式后，系统改变了adbd启动时的权限。在build目录下搜索一下，发现了main.mk中有这样的代码片段

## user/userdebug ##

user_variant := $(filter userdebug user,$(TARGET_BUILD_VARIANT))

enable_target_debugging := true

ifneq (,$(user_variant))

  # Target is secure in user builds.

  ADDITIONAL_DEFAULT_PROPERTIES += ro.secure=1

  tags_to_install := user

  ifeq ($(user_variant),userdebug)

    # Pick up some extra useful tools

    tags_to_install += debug

  else

    # Disable debugging in plain user builds.

    enable_target_debugging :=

  endif

  # TODO: Always set WITH_DEXPREOPT (for user builds) once it works on OSX.

  # Also, remove the corresponding block in config/product_config.make.

  ifeq ($(HOST_OS)-$(WITH_DEXPREOPT_buildbot),linux-true)

    WITH_DEXPREOPT := true

  endif

  # Disallow mock locations by default for user builds

  ADDITIONAL_DEFAULT_PROPERTIES += ro.allow.mock.location=0

else # !user_variant

  # Turn on checkjni for non-user builds.

  ADDITIONAL_BUILD_PROPERTIES += ro.kernel.android.checkjni=1

  # Set device insecure for non-user builds.

  ADDITIONAL_DEFAULT_PROPERTIES += ro.secure=0

  # Allow mock locations by default for non user builds

  ADDITIONAL_DEFAULT_PROPERTIES += ro.allow.mock.location=1

endif # !user_variant

ifeq (true,$(strip $(enable_target_debugging)))

  # Target is more debuggable and adbd is on by default

  ADDITIONAL_DEFAULT_PROPERTIES += ro.debuggable=1 persist.service.adb.enable=1

  # Include the debugging/testing OTA keys in this build.

  INCLUDE_TEST_OTA_KEYS := true

else # !enable_target_debugging

  # Target is less debuggable and adbd is off by default

  ADDITIONAL_DEFAULT_PROPERTIES += ro.debuggable=0 persist.service.adb.enable=0

endif # !enable_target_debugging

这段代码我大致解释一下：

主要通过判断当前的编译模式来给几个属性赋予不同的值，然后把属性存储在ADDITIONAL_DEFAULT_PROPERTIES这个变量中，这个变量在后面是要写到根目录下的/default.prop中去，在系统启动时被属性服务加载的。也就是说我们在/default.prop中看到的几个属性的值是在这里设置的。

只看两个属性ro.secure，persist.service.adb.enable。当前是user模式的话，编译系统会把ro.secure置为1，把persist.service.adb.enable置为0.也就是说，用user模式编译出来的系统运行在安全模式下，adbd默认关闭。即使通过设置属性的方式打开，adbd进程的用户也是shell，不具有root权限。这样，普通用户或者开发者拿到一个机器后，通过PC运行adb shell时，是以shell用户登录机器的。

好了，现在把ro.secure置为0，再重新编译，只要设置属性persist.service.adb.enable的值为1，adbd进程就会以root用户的身份启动。

http://blog.csdn.net/a345017062/article/details/6254402

system，Android系统类库，基于bionic类库开发，包含工具类库（libcutils），LOG类库（liblog），压缩类库（libzipfile）类。

主要功能有：

一、完成Android初始化（init）。

解析init.rc并开启系统初始化时需要加载的程序（parser.c），初始化设备（devices.c），开启属性服务（property_service.c）等。

二、开启Android系统的一些基础服务。

1、系统的设备服务（vold）。比如完成SD卡挂载、卸载管理，从内核处接收事件建立设备结点等。

三、SHELL程序及相应的toolbox。

四、ADB程序。

五、logcat系统。

可以说，bionic和system两个文件里的东西完成了Android对Linux的封装，在这两个文件夹的基础上构建起了Android系统的两大核心模块：Dalvik和Framework。Dalvik是一个基础纯C的VM，这个网上有比较详细的说明。重点一层层地分析一下Framework。

最底层就是几大模块:

1、utils工具库（frameworks/base/libs/utils/目录下）

这个类库基于bionic编译写，提供了一些对bionic里面的基础C/C++类库中的高层次封装。Framework中的C++程序大量使用这里的类库来封装更高层的系统功能。

2、binder库（framewoks/base/libs/binder/目录下）

这个与OpenBinder开源项目相似，提供了一种进程通信机制。C++和Java层都大量使用了这种机制。它把通信双方分为服务提供者和使用者两种角色。提供者内部有注册的服务接口，使用者去查找调用。

3、ui库（frameworks/base/libs/ui/目录下）

这个库主要提供了UI绘制和视频输出两类接口，整个系统的输出框架都是以这个库为基础，通过它与FrameBuffer通信。

4、surfaceflinger库（frameworks/base/libs/surfaceflinger/目录下）

对ui库的更高层次的封装，通过binder机制对Android系统中的上层模块提供输出服务。

5、audioflinger库（frameworks/base/libs/audioflinger/目录下）

音频输出基础类库，上层模块通过这个库与驱动还有打交导输出声音。

6、大量开源库（external/目录下）

这几大模块构成了整个Framework的基础。围绕这几大模块，就可以构建一个真正的操作系统的上层模块，创建应用程序运行环境了。比较典型的有：

多媒休服务，提供给音视频播放和录制服务。

服务管理，维护和管理系统中存在的大量服务提供程序，应用程序通过binder机制通过服务管理中心的servicemanager来访问和使用这些服务，比如电源、蓝牙、Wifi等模块都以服务的形式存在于系统中供应用程序调用。

运行时环境，初始化应用程序的运行环境，并加载第一个应用程序，Launcher。

应用程序运行时环境创建完成后，系统就算正式启动起来了。当一个应用程序被加载到系统中时，它和系统打交导最多的就是系统提供的开发API了。主要集中在frameworks/base/core/目录下。

转