Android 系统分析

转载：http://blog.csdn.net/innost/article/details/6041412

ANDROID搞了大概5个月了，总感觉到它的这个java封装非常的不爽。这次下载了Froyo的源码，准备好好分析下Android的运行流程。一直有个暗想--能否替换掉JAVA层？搞android最麻烦的就是老记不住它那几个文件的位置，这里将给出详细的路径，方便其他看客了解。

没有固定的顺序，不过大概就是从启动开始的一些东西吧。我的想法是对android了解越多，才越可能在此基础上做最好最完善的改动。真的很不喜欢它的java层。

 

一 用户空间init

我这里不分析linux启动的那第一个程序init。

 init代码在/system/core/init/init.c。感兴趣的可从main函数开始分析

android的其他重要进程都是init加载init.rc配置文件来fork的。其中，最重要的init.rc位于source/system/core/rootdir下。

init.rc有它特有的语法，可google一下就知道了。

 

二 zygote的诞生

 

zygote程序是有app_process弄出来的，app_process的启动在init.rc中有对应行。

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

//第一个zygote是这个服务的名字，实际启动的程序位于system/bin下的app_process,后面是这个程序的启动参数
    socket zygote stream 666

//这个表示init将创建一个unix域的socket，666是rwx的读写执行权限。
    onrestart write /sys/android_power/request_state wake
    onrestart write /sys/power/state on
    onrestart restart media

其中，app_process位于/frameworks/base/cmds/app_process/app_main.cpp中。

下面分析它的mian函数。

 

[cpp] view plain copy print ?

1. int main(int argc, const char* const argv[])  
2. {  
3. //argc =  5   
4. //argv=["/system/bin/app_process" "-Xzygote" "/system/bin" "--zygote" "--start-system-server"]     
5.  // These are global variables in ProcessState.cpp   
6.     mArgC = argc; //全局变量   
7.     mArgV = argv; //全局变量   
8.       
9.     mArgLen = 0;  
10.     for (int i=0; i<argc; i++) {  
11.         mArgLen += strlen(argv[i]) + 1;  
12.     }  
13.     mArgLen--;  
14.   
15.     AppRuntime runtime;//定义AppRuntime   
16.     const char *arg;  
17.     const char *argv0;  
18.   
19.     argv0 = argv[0]; //argv0="/system/bin/app_process"   
20.   
21.     // Process command line arguments   
22.     // ignore argv[0]   
23.     argc--;  
24.     argv++;  
25.   
26.     // Everything up to '--' or first non '-' arg goes to the vm   
27.       
28.     int i = runtime.addVmArguments(argc, argv);//将参数加到虚拟机，待会分析,应该是把-Xzygote加入虚拟机了   
29.   
30.     // Next arg is parent directory   
31.     if (i < argc) {  
32.         runtime.mParentDir = argv[i++]; //设置父目录为/system/bin    
33.     }  
34.  //   
35.     // Next arg is startup classname or "--zygote"   
36.     if (i < argc) {  
37.         arg = argv[i++];  
38.         if (0 == strcmp("--zygote", arg)) {  
39.             bool startSystemServer = (i < argc) ?   
40.                     strcmp(argv[i], "--start-system-server") == 0 : false;//正常情况是true   
41.             setArgv0(argv0, "zygote");  
42.             set_process_name("zygote");  
43.             runtime.start("com.android.internal.os.ZygoteInit",  
44.                 startSystemServer);//启动java的zygoteInit   
45.         } else {  
46.             set_process_name(argv0);  
47.   
48.             runtime.mClassName = arg;  
49.   
50.             // Remainder of args get passed to startup class main()   
51.             runtime.mArgC = argc-i;  
52.             runtime.mArgV = argv+i;  
53.   
54.             LOGV("App process is starting with pid=%d, class=%s./n",  
55.                  getpid(), runtime.getClassName());  
56.             runtime.start();  
57.         }  
58.     } else {  
59.         LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");  
60.         fprintf(stderr, "Error: no class name or --zygote supplied./n");  
61.         app_usage();  
62.         return 10;  
63.     }  
64.   
65. }  

int main(int argc, const char* const argv[]) { //argc = 5 //argv=["/system/bin/app_process" "-Xzygote" "/system/bin" "--zygote" "--start-system-server"] // These are global variables in ProcessState.cpp mArgC = argc; //全局变量 mArgV = argv; //全局变量 mArgLen = 0; for (int i=0; i<argc; i++) { mArgLen += strlen(argv[i]) + 1; } mArgLen--; AppRuntime runtime;//定义AppRuntime const char *arg; const char *argv0; argv0 = argv[0]; //argv0="/system/bin/app_process" // Process command line arguments // ignore argv[0] argc--; argv++; // Everything up to '--' or first non '-' arg goes to the vm int i = runtime.addVmArguments(argc, argv);//将参数加到虚拟机，待会分析,应该是把-Xzygote加入虚拟机了 // Next arg is parent directory if (i < argc) { runtime.mParentDir = argv[i++]; //设置父目录为/system/bin } // // 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;//正常情况是true setArgv0(argv0, "zygote"); set_process_name("zygote"); runtime.start("com.android.internal.os.ZygoteInit", startSystemServer);//启动java的zygoteInit } 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(); } } else { LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied."); fprintf(stderr, "Error: no class name or --zygote supplied./n"); app_usage(); return 10; } }

从上面代码注释可以看出，很多工作都交给了Runtime对象来处理，这个runtime对象也是在这个cpp文件中定义的。我们来看一下。

 

[cpp:collapse] + expand source view plain copy print ?

1. class AppRuntime : public AndroidRuntime //基类是AndroidRuntime，待会分析下是干嘛的   
2. {  
3. public:  
4.     AppRuntime()  
5.         : mParentDir(NULL)  
6.         , mClassName(NULL)  
7.         , mArgC(0)  
8.         , mArgV(NULL)  
9.     {  
10.     }  
11.   
12. #if 0   
13.     // this appears to be unused   
14.     const char* getParentDir() const  
15.     {  
16.         return mParentDir;  
17.     }  
18. #endif   
19.   
20.     const char* getClassName() const  
21.     {  
22.         return mClassName;  
23.     }  
24.   
25.     virtual void onStarted() //下面几个onXXX应该是回调用的，可能是JNI回调   
26.     {  
27.         sp<ProcessState> proc = ProcessState::self();  
28.         if (proc->supportsProcesses()) {  
29.             LOGV("App process: starting thread pool./n");  
30.             proc->startThreadPool();  
31.         }  
32.           
33.         app_init(mClassName, mArgC, mArgV);  
34.   
35.         if (ProcessState::self()->supportsProcesses()) {  
36.             IPCThreadState::self()->stopProcess();  
37.         }  
38.     }  
39.   
40.     virtual void onZygoteInit()  
41.     {  
42.         sp<ProcessState> proc = ProcessState::self();  
43.         if (proc->supportsProcesses()) {  
44.             LOGV("App process: starting thread pool./n");  
45.             proc->startThreadPool();  
46.         }         
47.     }  
48.   
49.     virtual void onExit(int code)  
50.     {  
51.         if (mClassName == NULL) {  
52.             // if zygote   
53.             if (ProcessState::self()->supportsProcesses()) {  
54.                 IPCThreadState::self()->stopProcess();  
55.             }  
56.         }  
57.   
58.         AndroidRuntime::onExit(code);  
59.     }  
60.   
61.       
62.     const char* mParentDir;  
63.     const char* mClassName;  
64.     int mArgC;  
65.     const char* const* mArgV;  
66. };  
67.   
68. }  

class AppRuntime : public AndroidRuntime //基类是AndroidRuntime，待会分析下是干嘛的 { public: AppRuntime() : mParentDir(NULL) , mClassName(NULL) , mArgC(0) , mArgV(NULL) { } #if 0 // this appears to be unused const char* getParentDir() const { return mParentDir; } #endif const char* getClassName() const { return mClassName; } virtual void onStarted() //下面几个onXXX应该是回调用的，可能是JNI回调 { sp<ProcessState> proc = ProcessState::self(); if (proc->supportsProcesses()) { LOGV("App process: starting thread pool./n"); proc->startThreadPool(); } app_init(mClassName, mArgC, mArgV); if (ProcessState::self()->supportsProcesses()) { IPCThreadState::self()->stopProcess(); } } virtual void onZygoteInit() { sp<ProcessState> proc = ProcessState::self(); if (proc->supportsProcesses()) { LOGV("App process: starting thread pool./n"); proc->startThreadPool(); } } virtual void onExit(int code) { if (mClassName == NULL) { // if zygote if (ProcessState::self()->supportsProcesses()) { IPCThreadState::self()->stopProcess(); } } AndroidRuntime::onExit(code); } const char* mParentDir; const char* mClassName; int mArgC; const char* const* mArgV; }; }

其中，基类AndroidRuntime.h在frameworks/base/include/android_runtime/AndroidRuntime.h中定义。大概看看里边都定义了些什么。

 

[cpp:collapse] + expand source view plain copy print ?

1. namespace android {  
2. //这个类是与java虚拟机交互的一个类。   
3. //估计java虚拟机由它启动了       
4. class AndroidRuntime  
5. {  
6. public:  
7.     AndroidRuntime();  
8.     virtual ~AndroidRuntime();  
9.   
10.     /** 
11.      * Register a set of methods in the specified class. 
12.      */  
13.     static int registerNativeMethods(JNIEnv* env,  
14.         const char* className, const JNINativeMethod* gMethods, int numMethods);  
15.   
16.     /** 
17.      * Call a static Java function that takes no arguments and returns void. 
18.      */  
19.     status_t callStatic(const char* className, const char* methodName);  
20.   
21.     /** 
22.      * Call a class's static main method with the given arguments, 
23.      */  
24.     status_t callMain(const char* className, int argc, const char* const argv[]);  
25.   
26.     /** 
27.      * Find a class, with the input either of the form  
28.      * "package/class" or "package.class". 
29.      */  
30.     static jclass findClass(JNIEnv* env, const char* className);  
31.   
32.     int addVmArguments(int argc, const char* const argv[]);  
33.   
34.     void start(const char *classname, const bool startSystemServer);  
35.     void start();       // start in android.util.RuntimeInit   
36.   
37.     static AndroidRuntime* getRuntime();  
38.       
39.     /** 
40.      * This gets called after the JavaVM has initialized.  Override it 
41.      * with the system's native entry point. 
42.      */  
43.     virtual void onStarted() = 0;  
44.   
45.     /** 
46.      * This gets called after the JavaVM has initialized after a Zygote 
47.      * fork. Override it to initialize threads, etc. Upon return, the 
48.      * correct static main will be invoked. 
49.      */  
50.     virtual void onZygoteInit() {};  
51.   
52.   
53.     /** 
54.      * Called when the Java application exits.  The default 
55.      * implementation calls exit(code). 
56.      */  
57.     virtual void onExit(int code);  
58.   
59.     /** create a new thread that is visible from Java */  
60.     static void createJavaThread(const char* name, void (*start)(void *),  
61.         void* arg);  
62.   
63.     /** return a pointer to the VM running in this process */  
64.     static JavaVM* getJavaVM() { return mJavaVM; }  
65.   
66.     /** return a pointer to the JNIEnv pointer for this thread */  
67.     static JNIEnv* getJNIEnv();  
68.   
69. private:  
70.     static int startReg(JNIEnv* env);  
71.     int startVm(JavaVM** pJavaVM, JNIEnv** pEnv);  
72.   
73.     Vector<JavaVMOption> mOptions;  
74.   
75.     /* JNI JavaVM pointer */  
76.     static JavaVM* mJavaVM;  
77.   
78.     /* 
79.      * Thread creation helpers. 
80.      */  
81.     static int javaCreateThreadEtc(  
82.                                 android_thread_func_t entryFunction,   
83.                                 void* userData,  
84.                                 const char* threadName,  
85.                                 int32_t threadPriority,  
86.                                 size_t threadStackSize,  
87.                                 android_thread_id_t* threadId);  
88.     static int javaThreadShell(void* args);  
89. };  
90.   
91. // Returns the Unix file descriptor for a ParcelFileDescriptor object   
92. extern int getParcelFileDescriptorFD(JNIEnv* env, jobject object);  
93.   
94. }  

namespace android { //这个类是与java虚拟机交互的一个类。 //估计java虚拟机由它启动了 class AndroidRuntime { public: AndroidRuntime(); virtual ~AndroidRuntime(); /** * Register a set of methods in the specified class. */ static int registerNativeMethods(JNIEnv* env, const char* className, const JNINativeMethod* gMethods, int numMethods); /** * Call a static Java function that takes no arguments and returns void. */ status_t callStatic(const char* className, const char* methodName); /** * Call a class's static main method with the given arguments, */ status_t callMain(const char* className, int argc, const char* const argv[]); /** * Find a class, with the input either of the form * "package/class" or "package.class". */ static jclass findClass(JNIEnv* env, const char* className); int addVmArguments(int argc, const char* const argv[]); void start(const char *classname, const bool startSystemServer); void start(); // start in android.util.RuntimeInit static AndroidRuntime* getRuntime(); /** * This gets called after the JavaVM has initialized. Override it * with the system's native entry point. */ virtual void onStarted() = 0; /** * This gets called after the JavaVM has initialized after a Zygote * fork. Override it to initialize threads, etc. Upon return, the * correct static main will be invoked. */ virtual void onZygoteInit() {}; /** * Called when the Java application exits. The default * implementation calls exit(code). */ virtual void onExit(int code); /** create a new thread that is visible from Java */ static void createJavaThread(const char* name, void (*start)(void *), void* arg); /** return a pointer to the VM running in this process */ static JavaVM* getJavaVM() { return mJavaVM; } /** return a pointer to the JNIEnv pointer for this thread */ static JNIEnv* getJNIEnv(); private: static int startReg(JNIEnv* env); int startVm(JavaVM** pJavaVM, JNIEnv** pEnv); Vector<JavaVMOption> mOptions; /* JNI JavaVM pointer */ static JavaVM* mJavaVM; /* * Thread creation helpers. */ static int javaCreateThreadEtc( android_thread_func_t entryFunction, void* userData, const char* threadName, int32_t threadPriority, size_t threadStackSize, android_thread_id_t* threadId); static int javaThreadShell(void* args); }; // Returns the Unix file descriptor for a ParcelFileDescriptor object extern int getParcelFileDescriptorFD(JNIEnv* env, jobject object); }

AndroidRuntime类主要是和java打交道，而且好像只能由framework调用才能起作用，一般我自己的jni库都不用AndroidRuntime里边定义的方便函数，虽然都是static。原因如下（必须看看它的实现文件才知道原因）

[cpp] view plain copy print ?

1. //看来系统有一个全局的mJavaVM   
2. JavaVM* AndroidRuntime::mJavaVM = NULL;  
3. //整个系统范围内，第一次调用构造函数的应该就是在app_process中的吧？！   
4. AndroidRuntime::AndroidRuntime()  
5. {  
6.     SkGraphics::Init();  
7.     // this sets our preference for 16bit images during decode   
8.     // in case the src is opaque and 24bit   
9.     SkImageDecoder::SetDeviceConfig(SkBitmap::kRGB_565_Config);  
10.     // This cache is shared between browser native images, and java "purgeable"   
11.     // bitmaps. This globalpool is for images that do not either use the java   
12.     // heap, or are not backed by ashmem. See BitmapFactory.cpp for the key   
13.     // java call site.   
14.     SkImageRef_GlobalPool::SetRAMBudget(512 * 1024);  
15.     // There is also a global font cache, but its budget is specified in code   
16.     // see SkFontHost_android.cpp   
17.   
18.     // Pre-allocate enough space to hold a fair number of options.   
19.     mOptions.setCapacity(20);  
20.   
21.     assert(gCurRuntime == NULL);        // one per process   
22.     gCurRuntime = this;  
23. }  
24. //刚才那几个onXXX函数就是在这里调用的，估计是java层调用的   
25. static void com_android_internal_os_RuntimeInit_finishInit(JNIEnv* env, jobject clazz)  
26. {  
27.     gCurRuntime->onStarted();  
28. }  
29.   
30. static void com_android_internal_os_RuntimeInit_zygoteInit(JNIEnv* env, jobject clazz)  
31. {  
32.     gCurRuntime->onZygoteInit();  
33. }  
34.   
35. static jint com_android_internal_os_RuntimeInit_isComputerOn(JNIEnv* env, jobject clazz)  
36. {  
37.     return 1;  
38. }  
39.   
40. static void com_android_internal_os_RuntimeInit_turnComputerOn(JNIEnv* env, jobject clazz)  
41. {  
42. }  
43.   
44. static jint com_android_internal_os_RuntimeInit_getQwertyKeyboard(JNIEnv* env, jobject clazz)  
45. {  
46.     char* value = getenv("qwerty");  
47.     if (value != NULL && strcmp(value, "true") == 0) {  
48.         return 1;  
49.     }  
50.       
51.     return 0;  
52. }  
53. //略去一些   
54. int AndroidRuntime::addVmArguments(int argc, const char* const argv[])  
55. {  
56.     int i;  
57.       
58.     for (i = 0; i<argc; i++) {  
59.         if (argv[i][0] != '-') {  
60.             return i;  
61.         }  
62.         if (argv[i][1] == '-' && argv[i][2] == 0) {  
63.             return i+1;  
64.         }  
65.   //此时虚拟机还没有起来，先把这些options保存起来   
66.         JavaVMOption opt;  
67.         memset(&opt, 0, sizeof(opt));  
68.         opt.optionString = (char*)argv[i];  
69.         mOptions.add(opt);  
70.     }  
71.     return i;  
72. }  

//看来系统有一个全局的mJavaVM JavaVM* AndroidRuntime::mJavaVM = NULL; //整个系统范围内，第一次调用构造函数的应该就是在app_process中的吧？！ AndroidRuntime::AndroidRuntime() { SkGraphics::Init(); // this sets our preference for 16bit images during decode // in case the src is opaque and 24bit SkImageDecoder::SetDeviceConfig(SkBitmap::kRGB_565_Config); // This cache is shared between browser native images, and java "purgeable" // bitmaps. This globalpool is for images that do not either use the java // heap, or are not backed by ashmem. See BitmapFactory.cpp for the key // java call site. SkImageRef_GlobalPool::SetRAMBudget(512 * 1024); // There is also a global font cache, but its budget is specified in code // see SkFontHost_android.cpp // Pre-allocate enough space to hold a fair number of options. mOptions.setCapacity(20); assert(gCurRuntime == NULL); // one per process gCurRuntime = this; } //刚才那几个onXXX函数就是在这里调用的，估计是java层调用的 static void com_android_internal_os_RuntimeInit_finishInit(JNIEnv* env, jobject clazz) { gCurRuntime->onStarted(); } static void com_android_internal_os_RuntimeInit_zygoteInit(JNIEnv* env, jobject clazz) { gCurRuntime->onZygoteInit(); } static jint com_android_internal_os_RuntimeInit_isComputerOn(JNIEnv* env, jobject clazz) { return 1; } static void com_android_internal_os_RuntimeInit_turnComputerOn(JNIEnv* env, jobject clazz) { } static jint com_android_internal_os_RuntimeInit_getQwertyKeyboard(JNIEnv* env, jobject clazz) { char* value = getenv("qwerty"); if (value != NULL && strcmp(value, "true") == 0) { return 1; } return 0; } //略去一些 int AndroidRuntime::addVmArguments(int argc, const char* const argv[]) { int i; for (i = 0; i<argc; i++) { if (argv[i][0] != '-') { return i; } if (argv[i][1] == '-' && argv[i][2] == 0) { return i+1; } //此时虚拟机还没有起来，先把这些options保存起来 JavaVMOption opt; memset(&opt, 0, sizeof(opt)); opt.optionString = (char*)argv[i]; mOptions.add(opt); } return i; }

该cpp位置在/frameworks/base/core/jni/AndroidRuntime.cpp中。

 回到app_process的main中，此处已运到到runtime.start("com.android.internal.os.ZygoteInit", startSystemServer)这句话来了，应进去看看start到底干了什么。

说来说去，不如看代码分析。