在Android系统中,所有的应用程序进程以及系统服务进程SystemServer都是由Zygote进程孕育(fork)出来的,这也许就是为什么要把它称为Zygote(受精卵)的原因吧。由于Zygote进程在Android系统中有着如此重要的地位,本文将详细分析它的启动过程。
在前面一篇文章Android应用程序进程启动过程的源代码分析中,我们看到了,当ActivityManagerService启动一个应用程序的时候,就会通过Socket与Zygote进程进行通信,请求它fork一个子进程出来作为这个即将要启动的应用程序的进程;在前面两篇文章Android应用程序安装过程源代码分析和Android系统默认Home应用程序(Launcher)的启动过程源代码分析中,我们又看到了,系统中的两个重要服务PackageManagerService和ActivityManagerService,都是由SystemServer进程来负责启动的,而SystemServer进程本身是Zygote进程在启动的过程中fork出来的。
我们知道,Android系统是基于Linux内核的,而在Linux系统中,所有的进程都是init进程的子孙进程,也就是说,所有的进程都是直接或者间接地由init进程fork出来的。Zygote进程也不例外,它是在系统启动的过程,由init进程创建的。在系统启动脚本system/core/rootdir/init.rc文件中,我们可以看到启动Zygote进程的脚本命令:
- servicezygote/system/bin/app_process-Xzygote/system/bin--zygote--start-system-server
- socketzygotestream666
- onrestartwrite/sys/android_power/request_statewake
- onrestartwrite/sys/power/stateon
- onrestartrestartmedia
- onrestartrestartnetd
前面的关键字service告诉init进程创建一个名为"zygote"的进程,这个zygote进程要执行的程序是/system/bin/app_process,后面是要传给app_process的参数。
接下来的socket关键字表示这个zygote进程需要一个名称为"zygote"的socket资源,这样,系统启动后,我们就可以在/dev/socket目录下看到有一个名为zygote的文件。这里定义的socket的类型为unix domain socket,它是用来作本地进程间通信用的,具体可以参考前面一篇文章Android学习启动篇提到的一书《Linux内核源代码情景分析》的第七章--基于socket的进程间通信。前面我们说到的ActivityManagerService就是通这个socket来和zygote进程通信请求fork一个应用程序进程的了。
最后的一系列onrestart关键字表示这个zygote进程重启时需要执行的命令。
关于init.rc文件的更多信息,请参考system/core/init/readme.txt文件。
了解了这个信息之后,我们就知道Zygote进程要执行的程序便是system/bin/app_process了,它的源代码位于frameworks/base/cmds/app_process/app_main.cpp文件中,入口函数是main。在继续分析Zygote进程启动的过程之前,我们先来看看它的启动序列图:
下面我们就详细分析每一个步骤。
Step 1. app_process.main
这个函数定义在frameworks/base/cmds/app_process/app_main.cpp文件中:
- intmain(intargc,constchar*constargv[])
- {
- mArgC=argc;
- mArgV=argv;
- mArgLen=0;
- for(inti=0;i<argc;i++){
- mArgLen+=strlen(argv[i])+1;
- }
- mArgLen--;
- AppRuntimeruntime;
- constchar*arg;
- argv0=argv[0];
- argc--;
- argv++;
- inti=runtime.addVmArguments(argc,argv);
- if(i<argc){
- runtime.mParentDir=argv[i++];
- }
- if(i<argc){
- arg=argv[i++];
- if(0==strcmp("--zygote",arg)){
- boolstartSystemServer=(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;
- runtime.mArgC=argc-i;
- runtime.mArgV=argv+i;
- LOGV("Appprocessisstartingwithpid=%d,class=%s.\n",
- getpid(),runtime.getClassName());
- runtime.start();
- }
- }else{
- LOG_ALWAYS_FATAL("app_process:noclassnameor--zygotesupplied.");
- fprintf(stderr,"Error:noclassnameor--zygotesupplied.\n");
- app_usage();
- return10;
- }
- }
这个函数的主要作用就是创建一个AppRuntime变量,然后调用它的start成员函数。AppRuntime这个类我们在Android应用程序进程启动过程的源代码分析一文中已经有过介绍了,它同样是在frameworks/base/cmds/app_process/app_main.cpp文件中定义:
- classAppRuntime:publicAndroidRuntime
- {
- ......
- };
它约继承于AndroidRuntime类,AndroidRuntime类定义在frameworks/base/core/jni/AndroidRuntime.cpp文件中:
- ......
- staticAndroidRuntime*gCurRuntime=NULL;
- ......
- AndroidRuntime::AndroidRuntime()
- {
- ......
- assert(gCurRuntime==NULL);
- gCurRuntime=this;
- }
当AppRuntime对象创建时,会调用其父类AndroidRuntime的构造函数,而在AndroidRuntime类的构造函数里面,会将this指针保存在静态全局变量gCurRuntime中,这样,当其它地方需要使用这个AppRuntime对象时,就可以通过同一个文件中的这个函数来获取这个对象的指针:
- AndroidRuntime*AndroidRuntime::getRuntime()
- {
- returngCurRuntime;
- }
回到上面的main函数中,由于我们在init.rc文件中,设置了app_process启动参数--zygote和--start-system-server,因此,在main函数里面,最终会执行下面语句:
- runtime.start("com.android.internal.os.ZygoteInit",
- rtSystemServer);
这里的参数startSystemServer为true,表示要启动SystemServer组件。由于AppRuntime没有实现自己的start函数,它继承了父类AndroidRuntime的start函数,因此,下面会执行AndroidRuntime类的start函数。
Step 2.AndroidRuntime.start
这个函数定义在frameworks/base/core/jni/AndroidRuntime.cpp文件中:
- voidAndroidRuntime::start(constchar*className,constboolstartSystemServer)
- {
- ......
- char*slashClassName=NULL;
- char*cp;
- JNIEnv*env;
- ......
- if(startVm(&mJavaVM,&env)!=0)
- gotobail;
- if(startReg(env)<0){
- LOGE("Unabletoregisterallandroidnatives\n");
- gotobail;
- }
- jclassstringClass;
- jobjectArraystrArray;
- jstringclassNameStr;
- jstringstartSystemServerStr;
- stringClass=env->FindClass("java/lang/String");
- assert(stringClass!=NULL);
- strArray=env->NewObjectArray(2,stringClass,NULL);
- assert(strArray!=NULL);
- classNameStr=env->NewStringUTF(className);
- assert(classNameStr!=NULL);
- env->SetObjectArrayElement(strArray,0,classNameStr);
- startSystemServerStr=env->NewStringUTF(startSystemServer?
- "true":"false");
- env->SetObjectArrayElement(strArray,1,startSystemServerStr);
- jclassstartClass;
- jmethodIDstartMeth;
- slashClassName=strdup(className);
- for(cp=slashClassName;*cp!='\0';cp++)
- if(*cp=='.')
- *cp='/';
- startClass=env->FindClass(slashClassName);
- if(startClass==NULL){
- ......
- }else{
- startMeth=env->GetStaticMethodID(startClass,"main",
- "([Ljava/lang/String;)V");
- if(startMeth==NULL){
- ......
- }else{
- env->CallStaticVoidMethod(startClass,startMeth,strArray);
- ......
- }
- }
- ......
- }
这个函数的作用是启动Android系统运行时库,它主要做了三件事情,一是调用函数startVM启动虚拟机,二是调用函数startReg注册JNI方法,三是调用了com.android.internal.os.ZygoteInit类的main函数。
Step 3.ZygoteInit.main
这个函数定义在frameworks/base/core/java/com/android/internal/os/ZygoteInit.java文件中:
- publicclassZygoteInit{
- ......
- publicstaticvoidmain(Stringargv[]){
- try{
- ......
- registerZygoteSocket();
- ......
- ......
- if(argv[1].equals("true")){
- startSystemServer();
- }elseif(!argv[1].equals("false")){
- ......
- }
- ......
- if(ZYGOTE_FORK_MODE){
- ......
- }else{
- runSelectLoopMode();
- }
- ......
- }catch(MethodAndArgsCallercaller){
- ......
- }catch(RuntimeExceptionex){
- ......
- }
- }
- ......
- }
它主要作了三件事情,一个调用registerZygoteSocket函数创建了一个socket接口,用来和ActivityManagerService通讯,二是调用startSystemServer函数来启动SystemServer组件,三是调用runSelectLoopMode函数进入一个无限循环在前面创建的socket接口上等待ActivityManagerService请求创建新的应用程序进程。
Step 4.ZygoteInit.registerZygoteSocket
这个函数定义在frameworks/base/core/java/com/android/internal/os/ZygoteInit.java文件中:
- publicclassZygoteInit{
- ......
- privatestaticvoidregisterZygoteSocket(){
- if(sServerSocket==null){
- intfileDesc;
- try{
- Stringenv=System.getenv(ANDROID_SOCKET_ENV);
- fileDesc=Integer.parseInt(env);
- }catch(RuntimeExceptionex){
- ......
- }
- try{
- sServerSocket=newLocalServerSocket(
- createFileDescriptor(fileDesc));
- }catch(IOExceptionex){
- .......
- }
- }
- }
- ......
- }
这个socket接口是通过文件描述符来创建的,这个文件描符代表的就是我们前面说的/dev/socket/zygote文件了。这个文件描述符是通过环境变量ANDROID_SOCKET_ENV得到的,它定义为:
- publicclassZygoteInit{
- ......
- privatestaticfinalStringANDROID_SOCKET_ENV="ANDROID_SOCKET_zygote";
- ......
- }
那么,这个环境变量的值又是由谁来设置的呢?我们知道,系统启动脚本文件system/core/rootdir/init.rc是由init进程来解释执行的,而init进程的源代码位于system/core/init目录中,在init.c文件中,是由service_start函数来解释init.rc文件中的service命令的:
- voidservice_start(structservice*svc,constchar*dynamic_args)
- {
- ......
- pid_tpid;
- ......
- pid=fork();
- if(pid==0){
- structsocketinfo*si;
- ......
- for(si=svc->sockets;si;si=si->next){
- intsocket_type=(
- !strcmp(si->type,"stream")?SOCK_STREAM:
- (!strcmp(si->type,"dgram")?SOCK_DGRAM:SOCK_SEQPACKET));
- ints=create_socket(si->name,socket_type,
- si->perm,si->uid,si->gid);
- if(s>=0){
- publish_socket(si->name,s);
- }
- }
- ......
- }
- ......
- }
每一个service命令都会促使init进程调用fork函数来创建一个新的进程,在新的进程里面,会分析里面的socket选项,对于每一个socket选项,都会通过create_socket函数来在/dev/socket目录下创建一个文件,在这个场景中,这个文件便是zygote了,然后得到的文件描述符通过publish_socket函数写入到环境变量中去:
- staticvoidpublish_socket(constchar*name,intfd)
- {
- charkey[64]=ANDROID_SOCKET_ENV_PREFIX;
- charval[64];
- strlcpy(key+sizeof(ANDROID_SOCKET_ENV_PREFIX)-1,
- name,
- sizeof(key)-sizeof(ANDROID_SOCKET_ENV_PREFIX));
- snprintf(val,sizeof(val),"%d",fd);
- add_environment(key,val);
- fcntl(fd,F_SETFD,0);
- }
这里传进来的参数name值为"zygote",而ANDROID_SOCKET_ENV_PREFIX在system/core/include/cutils/sockets.h定义为:
- #defineANDROID_SOCKET_ENV_PREFIX"ANDROID_SOCKET_"
因此,这里就把上面得到的文件描述符写入到以"ANDROID_SOCKET_zygote"为key值的环境变量中。又因为上面的ZygoteInit.registerZygoteSocket函数与这里创建socket文件的create_socket函数是运行在同一个进程中,因此,上面的ZygoteInit.registerZygoteSocket函数可以直接使用这个文件描述符来创建一个Java层的LocalServerSocket对象。如果其它进程也需要打开这个/dev/socket/zygote文件来和Zygote进程进行通信,那就必须要通过文件名来连接这个LocalServerSocket了,参考Android应用程序进程启动过程的源代码分析一文中的Step
4,ActivityManagerService是通过Process.start函数来创建一个新的进程的,而Process.start函数会首先通过Socket连接到Zygote进程中,最终由Zygote进程来完成创建新的应用程序进程,而Process类是通过openZygoteSocketIfNeeded函数来连接到Zygote进程中的Socket的:
- publicclassProcess{
- ......
- privatestaticvoidopenZygoteSocketIfNeeded()
- throwsZygoteStartFailedEx{
- ......
- for(intretry=0
- ;(sZygoteSocket==null)&&(retry<(retryCount+1))
- ;retry++){
- ......
- try{
- sZygoteSocket=newLocalSocket();
- sZygoteSocket.connect(newLocalSocketAddress(ZYGOTE_SOCKET,
- LocalSocketAddress.Namespace.RESERVED));
- sZygoteInputStream
- =newDataInputStream(sZygoteSocket.getInputStream());
- sZygoteWriter=
- newBufferedWriter(
- newOutputStreamWriter(
- sZygoteSocket.getOutputStream()),
- 256);
- ......
- }catch(IOExceptionex){
- ......
- }
- }
- ......
- }
- ......
- }
这里的ZYGOTE_SOCKET定义为:
- publicclassProcess{
- ......
- privatestaticfinalStringZYGOTE_SOCKET="zygote";
- ......
- }
它刚好就是对应/dev/socket目录下的zygote文件了。
Android系统中的socket机制和binder机制一样,都是可以用来进行进程间通信,读者可以自己对比一下这两者的不同之处,Binder进程间通信机制可以参考Android进程间通信(IPC)机制Binder简要介绍和学习计划一文。
Socket对象创建完成之后,回到Step 3中的ZygoteInit.main函数中,startSystemServer函数来启动SystemServer组件。
Step 5.ZygoteInit.startSystemServer
这个函数定义在frameworks/base/core/java/com/android/internal/os/ZygoteInit.java文件中:
- publicclassZygoteInit{
- ......
- privatestaticbooleanstartSystemServer()
- throwsMethodAndArgsCaller,RuntimeException{
- Stringargs[]={
- "--setuid=1000",
- "--setgid=1000",
- "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,3001,3002,3003",
- "--capabilities=130104352,130104352",
- "--runtime-init",
- "--nice-name=system_server",
- "com.android.server.SystemServer",
- };
- ZygoteConnection.ArgumentsparsedArgs=null;
- intpid;
- try{
- parsedArgs=newZygoteConnection.Arguments(args);
- ......
- pid=Zygote.forkSystemServer(
- parsedArgs.uid,parsedArgs.gid,
- parsedArgs.gids,debugFlags,null,
- parsedArgs.permittedCapabilities,
- parsedArgs.effectiveCapabilities);
- }catch(IllegalArgumentExceptionex){
- ......
- }
- if(pid==0){
- handleSystemServerProcess(parsedArgs);
- }
- returntrue;
- }
- ......
- }
这里我们可以看到,Zygote进程通过Zygote.forkSystemServer函数来创建一个新的进程来启动SystemServer组件,返回值pid等0的地方就是新的进程要执行的路径,即新创建的进程会执行handleSystemServerProcess函数。
Step 6.ZygoteInit.handleSystemServerProcess
这个函数定义在frameworks/base/core/java/com/android/internal/os/ZygoteInit.java文件中:
- publicclassZygoteInit{
- ......
- privatestaticvoidhandleSystemServerProcess(
- ZygoteConnection.ArgumentsparsedArgs)
- throwsZygoteInit.MethodAndArgsCaller{
- closeServerSocket();
- RuntimeInit.zygoteInit(parsedArgs.remainingArgs);
- }
- ......
- }
由于由Zygote进程创建的子进程会继承Zygote进程在前面Step 4中创建的Socket文件描述符,而这里的子进程又不会用到它,因此,这里就调用closeServerSocket函数来关闭它。这个函数接着调用RuntimeInit.zygoteInit函数来进一步执行启动SystemServer组件的操作。
Step 7.RuntimeInit.zygoteInit
这个函数定义在frameworks/base/core/java/com/android/internal/os/RuntimeInit.java文件中:
- publicclassRuntimeInit{
- ......
- publicstaticfinalvoidzygoteInit(String[]argv)
- throwsZygoteInit.MethodAndArgsCaller{
- ......
- zygoteInitNative();
- ......
- StringstartClass=argv[curArg++];
- String[]startArgs=newString[argv.length-curArg];
- System.arraycopy(argv,curArg,startArgs,0,startArgs.length);
- invokeStaticMain(startClass,startArgs);
- }
- ......
- }
这个函数会执行两个操作,一个是调用zygoteInitNative函数来执行一个Binder进程间通信机制的初始化工作,这个工作完成之后,这个进程中的Binder对象就可以方便地进行进程间通信了,另一个是调用上面Step 5传进来的com.android.server.SystemServer类的main函数。
Step 8.RuntimeInit.zygoteInitNative
这个函数定义在frameworks/base/core/java/com/android/internal/os/RuntimeInit.java文件中:
- publicclassRuntimeInit{
- ......
- publicstaticfinalnativevoidzygoteInitNative();
- ......
- }
这里可以看出,函数zygoteInitNative是一个Native函数,实现在frameworks/base/core/jni/AndroidRuntime.cpp文件中,这里我们就不再细看了,具体可以参考Android应用程序进程启动过程的源代码分析一文的Step 9,完成这一步后,这个进程的Binder进程间通信机制基础设施就准备好了。
回到Step 7中的RuntimeInit.zygoteInitNative函数,下一步它就要执行com.android.server.SystemServer类的main函数了。
Step 9.SystemServer.main
这个函数定义在frameworks/base/services/java/com/android/server/SystemServer.java文件中:
- publicclassSystemServer
- {
- ......
- nativepublicstaticvoidinit1(String[]args);
- ......
- publicstaticvoidmain(String[]args){
- ......
- init1(args);
- ......
- }
- publicstaticfinalvoidinit2(){
- Slog.i(TAG,"EnteredtheAndroidsystemserver!");
- Threadthr=newServerThread();
- thr.setName("android.server.ServerThread");
- thr.start();
- }
- ......
- }
这里的main函数首先会执行JNI方法init1,然后init1会调用这里的init2函数,在init2函数里面,会创建一个ServerThread线程对象来执行一些系统关键服务的启动操作,例如我们在前面两篇文章Android应用程序安装过程源代码分析和Android系统默认Home应用程序(Launcher)的启动过程源代码分析中提到的PackageManagerService和ActivityManagerService。
这一步的具体执行过程可以参考Android应用程序安装过程源代码分析一文,这里就不再详述了。
这里执行完成后,层层返回,最后回到上面的Step 3中的ZygoteInit.main函数中,接下来它就要调用runSelectLoopMode函数进入一个无限循环在前面Step 4中创建的socket接口上等待ActivityManagerService请求创建新的应用程序进程了。
Step 10.ZygoteInit.runSelectLoopMode
这个函数定义在frameworks/base/core/java/com/android/internal/os/ZygoteInit.java文件中:
- publicclassZygoteInit{
- ......
- privatestaticvoidrunSelectLoopMode()throwsMethodAndArgsCaller{
- ArrayList<FileDescriptor>fds=newArrayList();
- ArrayList<ZygoteConnection>peers=newArrayList();
- FileDescriptor[]fdArray=newFileDescriptor[4];
- fds.add(sServerSocket.getFileDescriptor());
- peers.add(null);
- intloopCount=GC_LOOP_COUNT;
- while(true){
- intindex;
- ......
- try{
- fdArray=fds.toArray(fdArray);
- index=selectReadable(fdArray);
- }catch(IOExceptionex){
- thrownewRuntimeException("Errorinselect()",ex);
- }
- if(index<0){
- thrownewRuntimeException("Errorinselect()");
- }elseif(index==0){
- ZygoteConnectionnewPeer=acceptCommandPeer();
- peers.add(newPeer);
- fds.add(newPeer.getFileDesciptor());
- }else{
- booleandone;
- done=peers.get(index).runOnce();
- if(done){
- peers.remove(index);
- fds.remove(index);
- }
- }
- }
- }
- ......
- }
这个函数我们已经在Android应用程序进程启动过程的源代码分析一文的Step 5中分析过了,这就是在等待ActivityManagerService来连接这个Socket,然后调用ZygoteConnection.runOnce函数来创建新的应用程序,有兴趣的读者可以参考Android应用程序进程启动过程的源代码分析这篇文章,这里就不再详述了。
这样,Zygote进程就启动完成了,学习到这里,我们终于都对Android系统中的进程有了一个深刻的认识了,这里总结一下:
1. 系统启动时init进程会创建Zygote进程,Zygote进程负责后续Android应用程序框架层的其它进程的创建和启动工作。
2. Zygote进程会首先创建一个SystemServer进程,SystemServer进程负责启动系统的关键服务,如包管理服务PackageManagerService和应用程序组件管理服务ActivityManagerService。
3. 当我们需要启动一个Android应用程序时,ActivityManagerService会通过Socket进程间通信机制,通知Zygote进程为这个应用程序创建一个新的进程。
分享到:
相关推荐
"Android系统进程Zygote启动过程的源代码分析" 在 Android 系统中,所有的应用程序进程以及系统服务进程SystemServer都是由 Zygote 进程孕育(fork )出来的,这也许就是为什么要把它称为Zygote (受精卵)的原因吧...
(Android系统进程Zygote启动过程的源代码分析UML,Android系统默认Home应用程序(Launcher)的启动过程源代码分析uml,Android系统在新进程中启动自定义服务过程(startService)的原理分析UML,Android应用程序...
接下来,我们将依据Android 6.0版本的源码来详细分析Zygote进程的启动流程。 #### 主要步骤解析 ##### 1. 初始化阶段 初始化阶段主要是进行环境配置,设置参数等准备工作。这部分工作主要通过`ZygoteInit#main()`...
在内容上,《Android系统源代码情景分析(含CD光盘1张)》结合使用情景,全面、深入、细致地分析了Android系统的源代码,涉及到Linux内核层、硬件抽象层(HAL)、运行时库层(Runtime)、应用程序框架层...
其中,init 进程是 Android 系统启动的关键过程,负责初始化系统环境、挂载文件系统、启动系统服务等。 init 启动流程 init 进程的启动过程主要包括以下几个步骤:kernel 启动 init 进程、init 进程解析配置文件、...
### Android Dalvik虚拟机的启动过程源码分析 #### 一、概述 在深入探讨Dalvik虚拟机(Dalvik Virtual Machine, DVM)的启动过程之前,我们需要了解DVM的基本概念及其在Android系统中的作用。DVM是Android操作系统...
Android系统源代码是开源操作系统的基石,它基于Linux内核,为智能手机、平板电脑以及其他智能设备提供了一个完整的软件栈。本资源"Android系统源代码情景分析-源码"旨在帮助开发者深入理解Android的工作原理,通过...
《Android系统源代码情景分析》随书光盘内容(源代码) 目录如下: 第1篇 初识Android系统 第1章 准备知识 1.1 Linux内核参考书籍 1.2 Android应用程序参考书籍 1.3 下载、编译和运行Android源代码 ...
本文主要聚焦于Android应用程序的启动过程,特别是通过源代码分析来深入理解这一过程。我们将以点击手机屏幕上的应用程序图标启动MainActivity为例,来详细解析这一过程。 首先,启动过程始于用户点击Launcher...
《Android系统源代码情景分析》随书光盘内容(源代码) 目录如下: 第1篇 初识Android系统 第1章 准备知识 1.1 Linux内核参考书籍 1.2 Android应用程序参考书籍 1.3 下载、编译和运行Android源代码 1.3.1 下载...
此进程在Android系统中扮演着极其重要的角色,不仅因为它承担了启动系统的重任,还因为它是所有其他用户空间进程的祖先。 - **启动代码**位于 `system\core\init.c` 中的 `main` 函数。`init` 进程的启动过程可以...
综上所述,Zygote进程作为Android系统启动过程中的关键组件,不仅负责初始化ART虚拟机,还通过fork操作启动了多个重要的进程和服务。从Zygote进程的启动到`systemServer`的初始化,再到最终Home Activity的启动,...
《Android系统源代码分析》是由李俊编著的一本深入探讨Android操作系统的书籍,主要针对对Android内核、系统架构以及应用程序开发有浓厚兴趣的读者。这本书提供了对Android系统源代码的详尽解析,帮助读者理解...
Android系统源代码情景分析光盘资料 目录 第1篇初识Android系统 第1章 准备知识................................................................ 2 1.1 Linux内核参考书籍......................................
Android应用程序的启动过程是一个复杂而有序的序列,涉及到操作系统、系统服务和应用程序组件等多个层面。本文主要聚焦于Android应用程序的启动过程,特别是当用户点击手机屏幕上的应用程序图标时,如何从Launcher...
由于zygote的特殊地位,对它的源码分析有助于开发者深入了解Android系统的内存管理、进程创建、服务启动等底层机制,为优化应用性能和解决系统问题提供依据。 总的来说,zygote作为Android系统的心脏,负责管理和...
总结来说,Android开机启动源代码的研究涵盖了Bootloader、Kernel、Init进程、Service启动、HAL初始化等多个方面,理解这一过程对于Android开发者而言至关重要,有助于优化系统性能、调试问题以及实现自定义功能。...
Android系统启动涉及多个关键进程,包括Init进程、Zygote、SystemServer等。这些进程的启动与交互构成了Android设备从按下电源键到用户界面呈现的整个过程。 1. **INIT进程**: - **Main Function**:Init进程是...
《Android系统源代码情景分析》是一本深入探讨Android操作系统内核和系统层源代码的书籍。随书光盘包含了与书本内容紧密相关的源代码,为读者提供了实践和学习的宝贵资源。通过这本书,读者可以了解到Android系统的...