上海天局信息技术有限责任公司

网站首页 > 天局论坛 > Android > Framework

Android启动过程——init,Zygote,SystemServer

2017-08-27 01:30:13 上海天局信息技术有限责任公司 已读

一、Android设备启动经历的三个阶段:Boot Loader;Linux Kernel;Android系统服务;每个阶段都有自己的启动画面。
1、Android中第一个被启动的进程——init,init进程的PID为1,其他的服务都由其进行创建。它是通过解析init.rc脚本来构建出系统的初始运行状态的。init进程是在系统启动启动过程中启动的。2、init.rc语法规则:1)Actions动作    一个Action实际上就是相应某个事件的过程。下面给出boot事件的脚本[plain] view plain copy

  1. /* \system\core\rootdir\init.rc*/  

  2.     on boot  

  3.     # basic network init  

  4.     ifup lo  

  5.     hostname localhost  

  6.     domainname localdomain  

  7.    

  8.     # set RLIMIT_NICE to allow priorities from 19 to -20  

  9.     setrlimit 13 40 40  

  10.    

  11.     # Memory management.  Basic kernel parameters, and allow the high  

  12.     # level system server to be able to adjust the kernel OOM driver  

  13.     # parameters to match how it is managing things.  

  14.     write /proc/sys/vm/overcommit_memory 1  

  15.     write /proc/sys/vm/min_free_order_shift 4  

  16.     chown root system /sys/module/lowmemorykiller/parameters/adj  

  17.     chmod 0220 /sys/module/lowmemorykiller/parameters/adj  

  18.     chown root system /sys/module/lowmemorykiller/parameters/minfree  

  19.     chmod 0220 /sys/module/lowmemorykiller/parameters/minfree  

  20.     ....  


语法规则:on  <trigger>        #触发条件      <command>   #执行命令      <command>   #执行命令       ........    当<trigger>所描述的触发事件产生时,便会依次执行各种command
Commands命令:ifup <interface>           使用网络接口<interface>成功连接hostname <name>       设置主机名为<name>domainname <name>  设置域名start <service>             如果该服务为运行的话,启动该服务stop <service>             如果该服务正在运行的话,停止该服务............. 
2)Services服务    Services是可执行程序,它们在特定选项的约束下会被init程序运行或者重启。先看个实例,下面是启动ServiceManager的脚本:


[plain] view plain copy

  1. /* \system\core\rootdir\init.rc*/  

  2. //组件     进程名            程序文件  

  3. service servicemanager /system/bin/servicemanager //service 表明SM是以服务的形式启动的  

  4.     class core  

  5.     user system                //表明进程是以系统用户system身份运行的  

  6.     group system              

  7.     critical                  /* 表明SM是系统中的一个关键服务,  

  8.                                * 在系统运行过程中,关键服务是不允许退出的;一旦退出,就会被系统重启;  

  9.                                * 而如果一个关键服务在4分钟内退出次数大于4,则系统会重启*/  

  10.     onrestart restart healthd /* 表明一旦SM被重启,这些进程zygote等也会被重启*/  

  11.     onrestart restart zygote  

  12.     onrestart restart media  

  13.     onrestart restart surfaceflinger  

  14.     onrestart restart drm  



语法规则:service  <name>  <pathname>  [<argument>]*            <option>            <option>            .........name         ---   Service服务名称pathname   ---  service服务所在的文件路径argument   ---  启动Service的参数option        ---  约束选项
options(约束选项)class <name>             为该Service指定一个class名。同一个class的所有服务必须同时启动或者停止;默认情况下所有Service的class均为"default"user  <username>      再启动服务前将用户切换至<username>,默认情况下用户都是rootgroup <groupname> [<groupname>]*  再启动服务前将用户组切换至<groupname>critical                       表明这是对设备至关重要的一个服务。如果它在四分钟内退出超过四次,则设备将重启进入恢复模式disabled                    此服务不会自动启动,而是需要通过显示调用服务名来启动oneshot                     在此服务退出时,不要主动去重启它onrestart                   当此服务重启时,执行这些命令

二、系统关键服务1、Zygote服务    Zygote依然是Android系统的核心,zygote是受精卵的意思,可以认为是Android framework大家族的祖先!Android中大多数应用进程和系统进程都是通过Zygote来生成的。

    zygote本身是一个应用层的程序,和驱动,内核模块之类的没点关系。zygote的启动由Linux的祖先init启动。zygote其最初的名字是app_process,通过直接调用pctrl把名字给改成了”zygote”

    来看一下Zygote进程在脚本中是被如何启动的:


[plain] view plain copy

  1. /* \system\core\rootdir\init.zygote64.rc */  

  2. service zygote /system/bin/app_process64 -Xzygote /system/bin --zygote --start-system-server  

  3. class main  

  4. socket zygote stream 660 root system  

  5. onrestart write /sys/android_power/request_state wake  

  6. onrestart write /sys/power/state on  

  7. onrestart restart media  

  8. onrestart restart netd  

   可以看到Zygote的class是main(ManagerService的class是core),其路径在/system/bin/app_process64(类似的还有32,32_64,64_32情况);后面跟的都是Zygote的参数。



0)Zygote总的启动过程

图片关键词

1)Zygote的源码路径在\frameworks\base\cmds\app_process文件夹中:图片关键词
2)先来看Android.mk文件:


[html] view plain copy

  1. LOCAL_PATH:= $(call my-dir)  

  2. include $(CLEAR_VARS)  

  3.   

  4. LOCAL_SRC_FILES:= \  

  5.     app_main.cpp  

  6.   

  7. LOCAL_LDFLAGS := -Wl,--version-script,art/sigchainlib/version-script.txt -Wl,--export-dynamic  

  8.   

  9. LOCAL_SHARED_LIBRARIES := \  

  10.     libdl \  

  11.     libcutils \  

  12.     libutils \  

  13.     liblog \  

  14.     libbinder \  

  15.     libandroid_runtime  

  16.   

  17. LOCAL_WHOLE_STATIC_LIBRARIES :libsigchain  

  18.   

  19. LOCAL_MODULE:app_process  

  20. LOCAL_MULTILIB :both  

  21. LOCAL_MODULE_STEM_32 :app_process32  

  22. LOCAL_MODULE_STEM_64 :app_process64  

  23. include $(BUILD_EXECUTABLE)  

  24.   

  25. # Create a symlink from app_process to app_process32 or 64  

  26. # depending on the target configuration.  

  27. include  $(BUILD_SYSTEM)/executable_prefer_symlink.mk  

  28.   

  29. # Build a variant of app_process binary linked with ASan runtime.  

  30. # ARM-only at the moment.  

  31. ifeq ($(TARGET_ARCH),arm)  

其涉及的主要文件是app_main.cpp;


3)app_main.cpp:


[cpp] view plain copy

  1. /** \frameworks\base\cmds\app_process\app_main.cpp **/  

  2. int main(int argc, charconst argv[])  

  3. {  

  4.     ......  

  5.     // 注意runtime是AppRuntime对象  

  6.     AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));  

  7.     /** 中间一系列代码用以解析传入参数argv  **/  

  8.    

  9.     ++i;  

  10.     /*** 这些参数正是在脚本中传入的Arguments**/  

  11.     while (i < argc) {  

  12.         const char* arg = argv[i++];  

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

  14.             zygote = true;  

  15.             /* 注意这里对名字进行了修改,原来的名称为app_process,这里更改为zygote 

  16.              * @value static const char ZYGOTE_NICE_NAME[] = "zygote";*/  

  17.             niceName = ZYGOTE_NICE_NAME;  

  18.         } else if (strcmp(arg, "--start-system-server") == 0) {  

  19.             startSystemServer = true;  

  20.         } else if (strcmp(arg, "--application") == 0) {  

  21.             application = true;  

  22.         } else if (strncmp(arg, "--nice-name=", 12) == 0) {  

  23.             niceName.setTo(arg + 12);  

  24.         } else if (strncmp(arg, "--", 2) != 0) {  

  25.             className.setTo(arg);  

  26.             break;  

  27.         } else {  

  28.             --i;  

  29.             break;  

  30.         }  

  31.     }  

  32.    

  33.     ......  

  34.     /** 传进来的参数 --zygote,则zygote值为true **/  

  35.     if (zygote) {  

  36.     // 下面接下来分析AppRuntime类的start方法时如何启动  

  37.         runtime.start("com.android.internal.os.ZygoteInit", args);  

  38.     } elseif (className) {  

  39.         runtime.start("com.android.internal.os.RuntimeInit", args);  

  40.     } else {  

  41.         ....  

  42.         return 10;  

  43.     }  

  44. }  



4)AppRuntime#start来看AppRuntime是如何启动Zygote的:


[cpp] view plain copy

  1.  /* 

  2.  * 这里启动Android Runtime.它实现了启动虚拟机,同时通过"className"来调用 

  3.  * 该类中的main函数("static void main(String[] args)"); 

  4.  */  

  5. /* \frameworks\base\core\jni\AndroidRuntime.cpp */  

  6. void AndroidRuntime::start(const char* className, const Vector<String8>& options)  

  7. {  

  8.     static const String8 startSystemServer("start-system-server");  

  9.     /* 

  10.      * 'startSystemServer == true' means runtime is obsolete and not run from 

  11.      * init.rc anymore, so we print out the boot start event here. 

  12.      */  

  13.     for (size_t i = 0; i < options.size(); ++i) {  

  14.         if (options[i] == startSystemServer) {  

  15.            const int LOG_BOOT_PROGRESS_START = 3000;  

  16.            LOG_EVENT_LONG(LOG_BOOT_PROGRESS_START,  ns2ms(systemTime(SYSTEM_TIME_MONOTONIC)));  

  17.         }  

  18.     }  

  19.    

  20.     // 设置环境变量ANDROID_ROOT为/system  

  21.     const char* rootDir = getenv("ANDROID_ROOT");  

  22.     if (rootDir == NULL) {  

  23.         rootDir = "/system";  

  24.         if (!hasDir("/system")) {  

  25.             LOG_FATAL("No root directory specified, and /android does not exist.");  

  26.             return;  

  27.         }  

  28.         setenv("ANDROID_ROOT", rootDir, 1);  

  29.     }  

  30.    

  31.     /*******开启虚拟机 **********/  

  32.     JniInvocation jni_invocation;  

  33.     jni_invocation.Init(NULL);  

  34.     JNIEnv* env;  

  35.     if (startVm(&mJavaVM, &env) != 0) {  

  36.         return;  

  37.     }  

  38.     onVmCreated(env);  

  39.    

  40.     /* 

  41.      * Register android functions. 

  42.      */  

  43.     if (startReg(env) < 0) {  

  44.         ALOGE("Unable to register all android natives\n");  

  45.         return;  

  46.     }  

  47.    

  48.     /* 

  49.      * 调用main函数 

  50.      * We want to call main() with a String array with arguments in it. 

  51.      * At present we have two arguments, the class name and an option string. 

  52.      * Create an array to hold them. 

  53.      */  

  54.     jclass stringClass;  

  55.     jobjectArray strArray;  

  56.     jstring classNameStr;  

  57.    

  58.     stringClass = env->FindClass("java/lang/String");  

  59.     assert(stringClass != NULL);  

  60.     strArray = env->NewObjectArray(options.size() + 1, stringClass, NULL);  

  61.     assert(strArray != NULL);  

  62.     classNameStr = env->NewStringUTF(className);  

  63.     assert(classNameStr != NULL);  

  64.     env->SetObjectArrayElement(strArray, 0, classNameStr);  

  65.    

  66.     for (size_t i = 0; i < options.size(); ++i) {  

  67.         jstring optionsStr = env->NewStringUTF(options.itemAt(i).string());  

  68.         assert(optionsStr != NULL);  

  69.         env->SetObjectArrayElement(strArray, i + 1, optionsStr);  

  70.     }  

  71.    

  72.     /* 

  73.      * 启动VM虚拟机,而且这个线程也会变成VM的主线程,当VM退出前该线程都不会退出 

  74.      */  

  75.     char* slashClassName = toSlashClassName(className);  

  76.     jclass startClass = env->FindClass(slashClassName);  

  77.     if (startClass == NULL) {  

  78.         ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);  

  79.         /* keep going */  

  80.     } else {  

  81.         jmethodID startMeth = env->GetStaticMethodID(startClass, "main",  

  82.             "([Ljava/lang/String;)V");  

  83.         if (startMeth == NULL) {  

  84.             ALOGE("JavaVM unable to find main() in '%s'\n", className);  

  85.             /* keep going */  

  86.         } else {  

  87.             env->CallStaticVoidMethod(startClass, startMeth, strArray);  

  88.    

  89. #if 0  

  90.             if (env->ExceptionCheck())  

  91.                 threadExitUncaughtException(env);  

  92. #endif  

  93.         }  

  94.     }  

  95.     free(slashClassName);  

  96.    

  97.     ALOGD("Shutting down VM\n");  

  98.     if (mJavaVM->DetachCurrentThread() != JNI_OK)  

  99.         ALOGW("Warning: unable to detach main thread\n");  

  100.     if (mJavaVM->DestroyJavaVM() != 0)  

  101.         ALOGW("Warning: VM did not shut down cleanly\n");  

  102. }  

 可以看到这里开启了VM虚拟机,使得Zygote进程最终也运行在虚拟机上,进而去预装载各种系统类,启动SystemServer(这是大部分Android系统服务的所在地),而逐步建立起各种SystemServer的运行环境。    上面代码主要完成了三件事情:1>调用了startVM来开启VM虚拟机                                              2>调用startReg来注册JNI方法                                              3>调用com.android.inernel.ZygoteInit类的main函数;
三、ZygoteInit:      一旦脚本中定义了Arguments——“--start-system-server”,ZygoteInit就会调用startSystemServer方法来进入SystemServer。
1、先接着上面来看,进入ZygoteInit#main方法:


[java] view plain copy

  1. /* @path: \frameworks\base\core\java\com\android\internal\os\ZygoteInit.java */  

  2. public static void main(String argv[]) {  

  3.     try {  

  4.         ......  

  5.         /*** 创建了一个socket接口,用来和ActivityManagerService(AMS)通讯 **/  

  6.         registerZygoteSocket(socketName);  

  7.         ......  

  8.    

  9.         // zygote的简单初始化  

  10.         SamplingProfilerIntegration.writeZygoteSnapshot();  

  11.    

  12.         // 启动后的进行一次初始化GC  

  13.         gc();  

  14.    

  15.         if (startSystemServer) {  

  16.         /*** 启动SystemServer组件 ***/  

  17.             startSystemServer(abiList, socketName);  

  18.         }  

  19.    

  20.         /** 进入一个无限循环,在前面创建的socket接口上等待AMS请求创建新的应用程序进程。 **/  

  21.         runSelectLoop(abiList);  

  22.    

  23.         // 关闭socket接口  

  24.         closeServerSocket();  

  25.     } catch (MethodAndArgsCaller caller) {  

  26.     } catch (RuntimeException ex) {  

  27.     ......  

  28.     }  

  29. }  

    上面main函数中主要完成三项工作的内容:



1> 调用registerZygoteSocket函数创建了一个socket接口,用来和ActivityManagerService通讯;2> 调用startSystemServer函数来启动SystemServer组件,将系统的关键服务启动起来;3> 调用runSelectLoopMode函数进入一个无限循环,等待AMS请求创建新的应用程序进程。
2、ZygoteInit#registerZygoteSocket方法:    该方法用来创建一个Server端的socket,用来等待Activity管理服务AMS请求Zygote进程来创建新的应用程序进程的。[java] view plain copy

  1. /** 

  2.  * @path: \frameworks\base\core\java\com\android\internal\os\ZygoteInit.java 

  3.  * 注册一个Server端的socket来实现zygote命令通信 

  4.  */  

  5. private static void registerZygoteSocket(String socketName) {  

  6.     if (sServerSocket == null) {  

  7.         int fileDesc;  

  8.         // @value private static final String ANDROID_SOCKET_PREFIX = "ANDROID_SOCKET_";  

  9.         final String fullSocketName = ANDROID_SOCKET_PREFIX + socketName;  

  10.         try {  

  11.             // 获得一个名称为fullSocketName的系统环境变量名  

  12.             String env = System.getenv(fullSocketName);  

  13.             // 将其转化为一个文件描述符,用来描述一个类型为AF_UNIX的socket  

  14.             fileDesc = Integer.parseInt(env);  

  15.         } catch (RuntimeException ex) {  

  16.             .......  

  17.         }  

  18.    

  19.         try {  

  20.         // 通过该文件描述符来创建Server端的socket  

  21.             sServerSocket = new LocalServerSocket(createFileDescriptor(fileDesc));  

  22.         } catch (IOException ex) {  

  23.             ......  

  24.         }  

  25.     }  

  26. }  


 上面代码完成了三件事情:1>调用System.getenv2>调用Integer.phraseInt3>通过该文件描述符来创建一个Server端的Socket(LocalServerSocket对象),等待AMS向Zygote进程发送的创建新应用程序进程的请求。
3、ZygoteInit#startSystemServer来创建System进程来启动SystemServer组件



[java] view plain copy

  1. /** 

  2.  * @path: \frameworks\base\core\java\com\android\internal\os\ZygoteInit.java 

  3.  * Prepare the arguments and fork for the system server process. 

  4.  */  

  5. private static boolean startSystemServer(String abiList, String socketName)  

  6.         throws MethodAndArgsCaller, RuntimeException {  

  7.     ......  

  8.     /* 保存System进程的相关启动参数 */  

  9.     String args[] = {  

  10.         "--setuid=1000",  

  11.         "--setgid=1000",  

  12.         "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1032,3001,3002,3003,3006,3007",  

  13.         "--capabilities=" + capabilities + "," + capabilities,  

  14.         "--runtime-init",  

  15.         "--nice-name=system_server",  

  16.         "com.android.server.SystemServer",// 这里是SystemServer所在的包的完整名称  

  17.     };  

  18.     ZygoteConnection.Arguments parsedArgs = null;  

  19.   

  20.     int pid;  

  21.   

  22.     try {  

  23.     // 解析参数值  

  24.         parsedArgs = new ZygoteConnection.Arguments(args);  

  25.         ZygoteConnection.applyDebuggerSystemProperty(parsedArgs);  

  26.         ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs);  

  27.   

  28.         /** 通过此函数来生成一个新的进程,用以承载各种系统服务, 

  29.          *  该函数最终实现调用底层的fork来产生一个新的进程, 

  30.          *  这个子进程就是Android系统的System进程  **/  

  31.         pid = Zygote.forkSystemServer(  

  32.                 parsedArgs.uid, parsedArgs.gid,  

  33.                 parsedArgs.gids,  

  34.                 parsedArgs.debugFlags,  

  35.                 null,  

  36.                 parsedArgs.permittedCapabilities,  

  37.                 parsedArgs.effectiveCapabilities);  

  38.         // 由前面args参数值可以看出System进程的UID(用户ID)和SID(用户组ID)均设置为1000  

  39.     } catch (IllegalArgumentException ex) {  

  40.         throw new RuntimeException(ex);  

  41.     }  

  42.   

  43.     /* pid=0 表示为子进程 */  

  44.     if (pid == 0) {  

  45.         if (hasSecondZygote(abiList)) {  

  46.             waitForSecondaryZygote(socketName);  

  47.         }  

  48.         /*** 子进程即是SystemServer所在进程,通过调用该函数来实现启动各种系统服务***/  

  49.         handleSystemServerProcess(parsedArgs);  

  50.     }  

  51.   

  52.     return true;  

  53. }  

    上面代码中通过调用Zygote.forkSystemServer来创建一个新的子进程(即Android系统中的System进程);进而通过调用函数handleSystemServerProcess来启动System进程,进而启动各种系统服务。




4、ZygoteInit#runSelectLoop:(这里源码是5.1,不再是runSelectLoopMode)


[java] view plain copy

  1. /** @path \frameworks\base\core\java\com\android\internal\os\ZygoteInit.java*/  

  2. private static void runSelectLoop(String abiList) throws MethodAndArgsCaller {  

  3.     ArrayList<FileDescriptor> fds = new ArrayList<FileDescriptor>();  

  4.     ArrayList<ZygoteConnection> peers = new ArrayList<ZygoteConnection>();  

  5.     // 创建一个大小为4的Socket文件描述符数组fdArray,表示Zygote进程最多能同时处理4个socket连接  

  6.     FileDescriptor[] fdArray = new FileDescriptor[4];  

  7.    

  8.     // 前面创建的Server端的Socket,该变量是静态成员变量,将其添加到文件描述符列表fds中  

  9.     fds.add(sServerSocket.getFileDescriptor());  

  10.     peers.add(null);  

  11.    

  12.     int loopCount = GC_LOOP_COUNT;  

  13.     /** 消息循环处理   **/  

  14.     while (true) {  

  15.         int index;  

  16.         // gc相关  

  17.         if (loopCount <= 0) {  

  18.             gc();  

  19.             loopCount = GC_LOOP_COUNT;  

  20.         } else {  

  21.             loopCount--;  

  22.         }  

  23.     

  24.         try {  

  25.         // 将fds中的socket转换到fdArray中  

  26.             fdArray = fds.toArray(fdArray);  

  27.             /** 调用selectReadable来监控fdArray中的Socket有数据可读 

  28.              * (有数据可读意味该socket接收到了一个连接或一个请求) */  

  29.             index = selectReadable(fdArray);  

  30.         } catch (IOException ex) {  

  31.             ......  

  32.         }  

  33.    

  34.         if (index < 0) {  

  35.             ......  

  36.         } else if (index == 0) {// 说明AMS与Zygote进程建立了新的连接,但此时并未请求创建新进程  

  37.         // 这里只是将连接描述符添加到fds数组中  

  38.             ZygoteConnection newPeer = acceptCommandPeer(abiList);  

  39.             peers.add(newPeer);  

  40.             fds.add(newPeer.getFileDescriptor());  

  41.         } else { // 说明AMS向Zygote进程发送了一个创建应用程序进程的请求  

  42.             boolean done;  

  43.             /** 调用runOnce来创建一个新的应用进程*/  

  44.             done = peers.get(index).runOnce();  

  45.    

  46.             // 处理完请求后,断开连接  

  47.             if (done) {  

  48.                 peers.remove(index);  

  49.                 fds.remove(index);  

  50.             }  

  51.         }  

  52.     }  

  53. }  

    这里是个通常模式的消息循环处理模式,通过静态成员函数selectReadable来判断系统保存的socket是否有数据可读。当AMS与Zygote进程通过socket建立连接,并且AMS向Zygote进程发送创建新的应用程序进程的请求时,调用ZygoteConnection.runOnce来创建新的进程。




四、System进程的启动过程

    前面3.3中分析ZygoteInit.startSystemServer中提到,系统调用handleSystemServerProcess方法来启动System进程。


1、ZygoteInit#handleSystemServerProcess:


[java] view plain copy

  1. /** @path: \frameworks\base\core\java\com\android\internal\os\ZygoteInit.java */  

  2. private static void handleSystemServerProcess(ZygoteConnection.Arguments parsedArgs)  

  3.         throws ZygoteInit.MethodAndArgsCaller {  

  4.     /* System进程是由System进程fork来的,因此它就会获得Zygote进程中前面创建的Server端Socket 

  5.      * 而实际System今进程中并不需要这个socket,因此将它关闭*/  

  6.     closeServerSocket();  

  7.    

  8.     // 设置名称  

  9.     if (parsedArgs.niceName != null) {  

  10.         Process.setArgV0(parsedArgs.niceName);  

  11.     }  

  12.    

  13.     final String systemServerClasspath = Os.getenv("SYSTEMSERVERCLASSPATH");  

  14.     if (systemServerClasspath != null) {  

  15.         performSystemServerDexOpt(systemServerClasspath);  

  16.     }  

  17.    

  18.     if (parsedArgs.invokeWith != null) {  

  19.         ....  

  20.     } else {  

  21.         ClassLoader cl = null;  

  22.         if (systemServerClasspath != null) {  

  23.             cl = new PathClassLoader(systemServerClasspath, ClassLoader.getSystemClassLoader());  

  24.             Thread.currentThread().setContextClassLoader(cl);  

  25.         }  

  26.    

  27.         /** 传递剩余的参数到SystemServer中,进一步启动System进程 */  

  28.         RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);  

  29.     }  

  30. }  

    上面代码中完成两件事:



1>调用closeServerSocket来关闭由Zygote进程中复制来的Socket2>调用RuntimeInit.zygoteInit方法来进一步启动System进程
2、RuntimeInit.zygoteInit():


[java] view plain copy

  1. /** @path: \frameworks\base\core\java\com\android\internal\os\RuntimeInit.java */  

  2. public static final void zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader)  

  3.         throws ZygoteInit.MethodAndArgsCaller {  

  4.     if (DEBUG) Slog.d(TAG, "RuntimeInit: Starting application from zygote");  

  5.    

  6.     // 将Sytem.out与err输出到log中  

  7.     redirectLogStreams();  

  8.     /** 设置System进程的时区和键盘布局等通用信息  */  

  9.     commonInit();  

  10.     /** 在System进程中创建一个Binder线程池,nativeZygoteInit会进而调用一个native方法来实现 */  

  11.     nativeZygoteInit();  

  12.     /** 转往执行SystemServer中的main函数*/  

  13.     applicationInit(targetSdkVersion, argv, classLoader);  

  14. }  

  15.    

  16. private static void applicationInit(int targetSdkVersion, String[] argv, ClassLoader classLoader)  

  17.         throws ZygoteInit.MethodAndArgsCaller {  

  18.     // If the application calls System.exit(), terminate the process  

  19.     // immediately without running any shutdown hooks.  It is not possible to  

  20.     // shutdown an Android application gracefully.  Among other things, the  

  21.     // Android runtime shutdown hooks close the Binder driver, which can cause  

  22.     // leftover running threads to crash before the process actually exits.  

  23.     nativeSetExitWithoutCleanup(true);  

  24.    

  25.     // We want to be fairly aggressive about heap utilization, to avoid  

  26.     // holding on to a lot of memory that isn't needed.  

  27.     VMRuntime.getRuntime().setTargetHeapUtilization(0.75f);  

  28.     VMRuntime.getRuntime().setTargetSdkVersion(targetSdkVersion);  

  29.    

  30.     final Arguments args;  

  31.     try {  

  32.         args = new Arguments(argv);  

  33.     } catch (IllegalArgumentException ex) {  

  34.         Slog.e(TAG, ex.getMessage());  

  35.         // let the process exit  

  36.         return;  

  37.     }  

  38.    

  39.     // Remaining arguments are passed to the start class's static main  

  40.     /** 由于System进程进入到SystemServer类的main函数中时,已经执行过很多代码了 

  41.      *  因此严格意义上,main已经不是System的入口函数; 

  42.      *  为了使得main看起来像System进程的入口函数,而使用该函数来巧妙地去调用它*/  

  43.     invokeStaticMain(args.startClass, args.startArgs, classLoader);  

  44. }  

   上面主要完成三件事情:



1>调用commonInit来设置System进程的时区和键盘布局等通用信息2>调用nativeZygoteInit在System进程中创建一个Binder线程池,nativeZygoteInit会进而调用一个native方法来实现 3>调用applicationInit,其实是调用invokeStaticMain来进入SystemServer中的main函数。

3、SystemServer#main:    在书中的分析中一般都是讲通过调用main函数,进而调用init1与init2函数;但是这里是基于Android5.1的源码,SystemServer貌似发生了很大的变化,不再存在init1与init2函数了。
(一)下面基于按照书上流程,基于Android4.2分析:1)先来看SystemServer#main函数:


[java] view plain copy

  1. /** @path \frameworks\base\services\java\com\android\server\SystemServer.java **/  

  2. native public static void init1(String[] args);  

  3.   

  4. public static void main(String[] args) {  

  5.     if (System.currentTimeMillis() < EARLIEST_SUPPORTED_TIME) {  

  6.         SystemClock.setCurrentTimeMillis(EARLIEST_SUPPORTED_TIME);  

  7.     }  

  8.   

  9.     ......  

  10.   

  11.     // Mmmmmm... more memory!  

  12.     dalvik.system.VMRuntime.getRuntime().clearGrowthLimit();  

  13.   

  14.     // The system server has to run all of the time, so it needs to be  

  15.     // as efficient as possible with its memory usage.  

  16.     VMRuntime.getRuntime().setTargetHeapUtilization(0.8f);  

  17.   

  18.     System.loadLibrary("android_servers");  

  19.     /** 看到这里调用了一个重要的方法 init1  **/  

  20.     init1(args);  

  21. }  

    main函数这里调用了重要的init1函数,该函数是个native本地方法。查到其本地实现方法在com_android_server_SystemServer.cpp文件中。



2)com_android_server_SystemServer#android_server_SystemServer_init1:


[java] view plain copy

  1. /** @path \frameworks\base\services\jni\com_android_server_SystemServer.cpp*/  

  2. extern "C" int system_init();  

  3.   

  4. static void android_server_SystemServer_init1(JNIEnv* env, jobject clazz)  

  5. {  

  6.     system_init();  

  7. }  

    看到android_server_SystemServer_init1函数仅仅是一个包装函数,进而调用system_init函数来启动一些系统服务。




3)init1函数的主体实现部分:system_init():


[cpp] view plain copy

  1. /** @path \frameworks\base\cmds\system_server\library\system_init.cpp*/  

  2. extern"C" status_t system_init()  

  3. {  

  4.     /** 前面Binder机制分析中分析 MediaServer的main函数时,其启动过程也是类似此几步流程 

  5.      *  http://blog.csdn.net/woliuyunyicai/article/details/46864567   */  

  6.     // 获取一个ProcessState实例  

  7.     sp<ProcessState> proc(ProcessState::self());  

  8.     // 一个ServiceManager实例  

  9.     sp<IServiceManager> sm = defaultServiceManager();  

  10.    

  11.     /** GrimReaper是一个死亡接收通知,具体代码见下 **/  

  12.     sp<GrimReaper> grim = new GrimReaper();  

  13.     // 设置SM的死亡接收通知  

  14.     sm->asBinder()->linkToDeath(grim, grim.get(), 0);  

  15.    

  16.     char propBuf[PROPERTY_VALUE_MAX];  

  17.     property_get("system_init.startsurfaceflinger", propBuf, "1");  

  18.     if (strcmp(propBuf, "1") == 0) {  

  19.         /*** 启动SurfaceFlinger  **/  

  20.         SurfaceFlinger::instantiate();  

  21.     }  

  22.    

  23.     property_get("system_init.startsensorservice", propBuf, "1");  

  24.     if (strcmp(propBuf, "1") == 0) {  

  25.         // 启动SensorService(传感器服务器)  

  26.         SensorService::instantiate();  

  27.     }  

  28.    

  29.     /** 这里开启Android runtime; 我们之所以需要做前面这些事情是因为, 

  30.      *  Android runtime初始化之前需要这些core system services事先已经被启动。 

  31.      *  其他一些服务仅需要在他们进程的main入口函数的开始(调用init函数初始化之前)进行启动即可**/  

  32.     AndroidRuntime* runtime = AndroidRuntime::getRuntime();  

  33.    

  34.     JNIEnv* env = runtime->getJNIEnv();  

  35.     if (env == NULL) {  

  36.         return UNKNOWN_ERROR;  

  37.     }  

  38.     jclass clazz = env->FindClass("com/android/server/SystemServer");  

  39.     if (clazz == NULL) {  

  40.         return UNKNOWN_ERROR;  

  41.     }  

  42.     /** 注意这里通过JNI调用SystemServer类中init2函数,进一步进行初始化 */  

  43.     jmethodID methodId = env->GetStaticMethodID(clazz, "init2""()V");  

  44.     if (methodId == NULL) {  

  45.         return UNKNOWN_ERROR;  

  46.     }  

  47.     env->CallStaticVoidMethod(clazz, methodId);  

  48.    

  49.     /** 开辟Binder线程池 */  

  50.     // ProcessState开辟线程池  

  51.     ProcessState::self()->startThreadPool();  

  52.     // IPCThreadState加入到线程池  

  53.     IPCThreadState::self()->joinThreadPool();  

  54.    

  55.     return NO_ERROR;  

  56. }  

  57.    

  58.    

  59. namespace android {  

  60. /** 

  61.  * This class is used to kill this process when the runtime dies. 

  62.  */  

  63. class GrimReaper : public IBinder::DeathRecipient {  

  64. public:  

  65.     GrimReaper() { }  

  66.    

  67.     /* 当ServiceManager死亡之后,就会调用binderDied函数 

  68.      * System进程通过调用kill函数来杀死自己 */  

  69.     virtual void binderDied(const wp<IBinder>& who)  

  70.     {  

  71.         kill(getpid(), SIGKILL);  

  72.     }  

  73. };  

  74.    

  75. // namespace android  

    上面代码中主要实现的功能是开启一些重要的系统服务如ServiceManager,SurfaceFlinger,SensorService(传感器服务)。这些服务需要在开启Android Runtime之前就已经被启动,因此放在init1函数中;初始化这些服务完成之后,使用JNI调用SystemServer类中的init2函数,继续进行初始化。


    下面回到SystemServer类中:


4)SystemServer#init2方法:


[java] view plain copy

  1. /** @path: \frameworks\base\services\java\com\android\server\SystemServer.java */    

  2. public static final void init2() {  

  3.     /** 这里创建了一个线程,所有工作都委托给该线程进行处理*/  

  4.     Thread thr = new ServerThread();  

  5.     thr.setName("android.server.ServerThread");  

  6.     thr.start();  

  7. }  


5)SystemServer#ServerThread完成的工作:



[java] view plain copy

  1. /** @path: \frameworks\base\services\java\com\android\server\SystemServer.java */   

  2. class ServerThread extends Thread {  

  3.     @Override  

  4.     public void run() {  

  5.     /*** 创建Looper消息循环  **/  

  6.         Looper.prepareMainLooper();  

  7.         // 设置进程参数  

  8.         android.os.Process.setThreadPriority(  

  9.                 android.os.Process.THREAD_PRIORITY_FOREGROUND);  

  10.         BinderInternal.disableBackgroundScheduling(true);  

  11.         android.os.Process.setCanSelfBackground(false);  

  12.    

  13.         // 检查上次是否尝试shutdown失败  

  14.         {  

  15.         ......  

  16.         }  

  17.    

  18.         ......  

  19.         /** 创建一个系统内共享的UI Handler,它至少能够被一下组件所使用: 

  20.          *  - WindowManagerPolicy 

  21.          *  - KeyguardViewManager 

  22.          *  - DisplayManagerService **/  

  23.         HandlerThread uiHandlerThread = new HandlerThread("UI");  

  24.         uiHandlerThread.start();  

  25.         Handler uiHandler = new Handler(uiHandlerThread.getLooper());  

  26.         uiHandler.post(new Runnable() {  

  27.             @Override  

  28.             public void run() {  

  29.                 android.os.Process.setThreadPriority(  

  30.                         android.os.Process.THREAD_PRIORITY_FOREGROUND);  

  31.                 android.os.Process.setCanSelfBackground(false);  

  32.             }  

  33.         });  

  34.    

  35.         /*** 创建一个仅供WindowManager共享的Handler线程 **/  

  36.         HandlerThread wmHandlerThread = new HandlerThread("WindowManager");  

  37.         wmHandlerThread.start();  

  38.         Handler wmHandler = new Handler(wmHandlerThread.getLooper());  

  39.         wmHandler.post(new Runnable() {  

  40.             @Override  

  41.             public void run() {  

  42.                 android.os.Process.setThreadPriority(  

  43.                         android.os.Process.THREAD_PRIORITY_DISPLAY);  

  44.                 android.os.Process.setCanSelfBackground(false);  

  45.             }  

  46.         });  

  47.    

  48.         // Critical services...  

  49.         boolean onlyCore = false;  

  50.         try {  

  51.             /** 创建Installer实例   **/  

  52.             Slog.i(TAG, "Waiting for installd to be ready.");  

  53.             installer = new Installer();  

  54.             installer.ping();  

  55.              

  56.             /*** 使用SM注册启动一些重要的服务,这里仅挑选了其中几个重要的Service**/  

  57.             // Power Manager  

  58.             power = new PowerManagerService();  

  59.             ServiceManager.addService(Context.POWER_SERVICE, power);  

  60.              

  61.             // Activity Manager  

  62.             context = ActivityManagerService.main(factoryTest);  

  63.    

  64.             // Display Manager  

  65.             display = new DisplayManagerService(context, wmHandler, uiHandler);  

  66.             ServiceManager.addService(Context.DISPLAY_SERVICE, display, true);  

  67.    

  68.             // Telephony Registry  

  69.             telephonyRegistry = new TelephonyRegistry(context);  

  70.             ServiceManager.addService("telephony.registry", telephonyRegistry);  

  71.             AttributeCache.init(context);  

  72.    

  73.             // Package Manager  

  74.             pm = PackageManagerService.main(context, installer,  

  75.                     factoryTest != SystemServer.FACTORY_TEST_OFF, onlyCore);  

  76.             ServiceManager.addService(Context.USER_SERVICE, UserManagerService.getInstance());  

  77.    

  78.             mContentResolver = context.getContentResolver();  

  79.    

  80.             // Content Manager  

  81.             contentService = ContentService.main(context, factoryTest == SystemServer.FACTORY_TEST_LOW_LEVEL);  

  82.             ActivityManagerService.installSystemProviders();  

  83.    

  84.             // Input Manager  

  85.             inputManager = new InputManagerService(context, wmHandler);  

  86.    

  87.             // Window Manager  

  88.             wm = WindowManagerService.main(context, power, display, inputManager,  

  89.                     uiHandler, wmHandler,  

  90.                     factoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL,  

  91.                     !firstBoot, onlyCore);  

  92.             ServiceManager.addService(Context.WINDOW_SERVICE, wm);  

  93.             ServiceManager.addService(Context.INPUT_SERVICE, inputManager);  

  94.    

  95.             ActivityManagerService.self().setWindowManager(wm);  

  96.    

  97.         } catch (RuntimeException e) {  

  98.         }  

  99.    

  100.         ......  

  101.         /** Looper消息处理 **/  

  102.         Looper.loop();  

  103.     }  

  104. }  


    上面线程主要完成的事情包括有创建Looper消息循环;以及启动一些系统的关键服务,比如ActivityManagerService、ContentService等,并将其注册到ServiceManager中。



    下面来看这几个重要的服务是如何启动的;


五、一些重要的系统服务Service:

1、 AMS(ActivityManagerService)Activity管理服务

     调用:ActivityManagerService.main(factoryTest)

其通过调用ActivityManagerService类中的静态方法main来启动的:


[java] view plain copy

  1. /** @path \frameworks\base\services\java\com\android\server\am\ActivityManagerService.java **/    

  2. public final class ActivityManagerService extends ActivityManagerNative  

  3.     implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {  

  4.      

  5.     static ActivityManagerService mSelf;     

  6.    

  7.     public static final Context main(int factoryTest) {  

  8.         /** 创建一个AThread线程 */  

  9.         AThread thr = new AThread();  

  10.         thr.start();  

  11.    

  12.         synchronized (thr) {  

  13.             while (thr.mService == null) {  

  14.                 try {  

  15.                     thr.wait();  

  16.                 } catch (InterruptedException e) {  

  17.                 }  

  18.             }  

  19.         }  

  20.    

  21.         // 将AThread中创建的AMS实例赋值给m,再赋值给AMS静态变量mSelf  

  22.         ActivityManagerService m = thr.mService;  

  23.         mSelf = m;  

  24.          

  25.         /** AMS两个最重要核心—— 

  26.          *  - ActivityStack:Activity的记录者与管理者,同时也为AMS管理系统运行情况提供了基础 

  27.          *  - ActivityTask**/  

  28.         ActivityThread at = ActivityThread.systemMain();  

  29.         mSystemThread = at;  

  30.         Context context = at.getSystemContext();  

  31.         context.setTheme(android.R.style.Theme_Holo);  

  32.         m.mContext = context;  

  33.         m.mFactoryTest = factoryTest;  

  34.         m.mMainStack = new ActivityStack(m, context, true);  

  35.          

  36.         m.mBatteryStatsService.publish(context);  

  37.         m.mUsageStatsService.publish(context);  

  38.          

  39.         synchronized (thr) {  

  40.             thr.mReady = true;  

  41.             thr.notifyAll();  

  42.         }  

  43.    

  44.         /*** 开始运行  ***/  

  45.         m.startRunning(nullnullnullnull);  

  46.          

  47.         return context;  

  48.     }  

  49.      

  50.     static class AThread extends Thread {  

  51.         ActivityManagerService mService;  

  52.         boolean mReady = false;  

  53.    

  54.         public AThread() {  

  55.             super("ActivityManager");  

  56.         }  

  57.    

  58.         public void run() {  

  59.         /** 创建消息Loopr循环 **/  

  60.             Looper.prepare();  

  61.    

  62.             android.os.Process.setThreadPriority(  

  63.                     android.os.Process.THREAD_PRIORITY_FOREGROUND);  

  64.             android.os.Process.setCanSelfBackground(false);  

  65.    

  66.             /** 在这里创建AMS实例,用以作为系统中的Activity管理服务 **/  

  67.             ActivityManagerService m = new ActivityManagerService();  

  68.    

  69.             synchronized (this) {  

  70.                 mService = m;  

  71.                 notifyAll();  

  72.             }  

  73.    

  74.             synchronized (this) {  

  75.                 while (!mReady) {  

  76.                     try {  

  77.                         wait();  

  78.                     } catch (InterruptedException e) {  

  79.                     }  

  80.                 }  

  81.             }   

  82.             Looper.loop();  

  83.         }  

  84.     }  

  85. }  


    可以看到进入ActivityManagerService.main函数之后,其会首先创建一个AThread线程,来创建AMS实例,用来作为系统中的Activity管理服务Service(注意这里并没有将其注册到SM中,需要等到PackageManagerService启动后,才进行注册)。


2、PMS(PackManagerService):Package管理服务:    调用:pm = PackageManagerService.main(context, installer,

                    factoryTest != SystemServer.FACTORY_TEST_OFF, onlyCore);

    也是通过调用PackageManagerService的main静态方法来实现的:


[java] view plain copy

  1. /** @path \frameworks\base\services\java\com\android\server\am\ActivityManagerService.java **/  

  2. public class PackageManagerService extends IPackageManager.Stub {  

  3.     public static final IPackageManager main(Context context, Installer installer,  

  4.             boolean factoryTest, boolean onlyCore) {  

  5.     // 创建PMS实例,并将其注册到SM中,且服务名称为package  

  6.         PackageManagerService m = new PackageManagerService(context, installer, factoryTest, onlyCore);  

  7.         ServiceManager.addService("package", m);  

  8.         return m;  

  9.     }  

  10. }  


3、ContentService(Content管理服务):


    调用:ContentService.main(context, factoryTest == SystemServer.FACTORY_TEST_LOW_LEVEL);


[java] view plain copy

  1. /** @path \frameworks\base\core\java\android\content\ContentService.java **/    

  2. public final class ContentService extends IContentService.Stub {  

  3.     public static ContentService main(Context context, boolean factoryTest) {  

  4.         ContentService service = new ContentService(context, factoryTest);  

  5.         ServiceManager.addService(ContentResolver.CONTENT_SERVICE_NAME, service);  

  6.         return service;  

  7.     }  

  8. }  


4、WindowManagerService(Window管理服务)


调用:

WindowManagerService.main(context, power, display, inputManager,

                    uiHandler, wmHandler,

                    factoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL,

                    !firstBoot, onlyCore);


通过main函数进入:


[java] view plain copy

  1. /** @path: \frameworks\base\services\java\com\android\server\wm\WindowManagerService.java **/    

  2. public class WindowManagerService extends IWindowManager.Stub  

  3.     implements Watchdog.Monitor, WindowManagerPolicy.WindowManagerFuncs,  

  4.     DisplayManagerService.WindowManagerFuncs, DisplayManager.DisplayListener {  

  5.      

  6.     public static WindowManagerService main(final Context context,  

  7.             final PowerManagerService pm, final DisplayManagerService dm,  

  8.             final InputManagerService im,  

  9.             final Handler uiHandler, final Handler wmHandler,  

  10.             final boolean haveInputMethods, final boolean showBootMsgs,  

  11.             final boolean onlyCore) {  

  12.         final WindowManagerService[] holder = new WindowManagerService[1];  

  13.         wmHandler.runWithScissors(new Runnable() {  

  14.             @Override  

  15.             public void run() {  

  16.                 holder[0] = new WindowManagerService(context, pm, dm, im,  

  17.                         uiHandler, haveInputMethods, showBootMsgs, onlyCore);  

  18.             }  

  19.         }, 0);  

  20.         return holder[0];  

  21.     }  

  22. }  

    当这些系统关键服务Service建立起来,并且注册到ServiceManager后,其他进行就可以通过SM来获取这些服务的代理对象(这与Binder通信机制相关),然后通过这些代理对象来使用系统提供的基础服务了。


Powered by MetInfo 5.3.17 ©2008-2021 www.metinfo.cn