Android系统启动流程

一、Android系统架构§

    Android系统架构分为五层，从上到下依次是应用层、应用框架层、系统运行层、硬件抽象层和Linux内核层。

1.应用层§

系统内置的应用程序或是开发者开发的应用程序

2.应用框架层(Java Framework)§

应用框架层为应用程序提供了系统API，代码是java编写的所以又叫Java Framework，主要包括如下组件:

• ActivityManager：管理应用的生命周期以及导航键返回功能。
• LocationManager：提供地理位置和定位服务。
• PackageManager：关联所有安装的应用程序。
• NotificationManager：关联应用程序的通知。
• ResourceManager：管理提供应用程序的非代码资源。
• TelephonyManager：管理所有移动设备的功能。
• WindowManager：管理所有开启的窗口程序。
• ContentProvider：内容提供器，使不同程序之间共享数据。
• View System：视图系统，构建应用程序的基本组件。

3.系统运行层§

Native层，系统运行层分为两个部分，分别是C/C++程序库和Android Runtime库。

a.C/C++程序库§

C/C++程序库能被Android系统中不同的组件使用提供服务，主要的C/C++程序库如下

• OpenGL ES：3D绘图函数库
• Libc：从BSD继承来的标准C系统函数库，专门为基于嵌入式Linux的设备定制。
• Media Framework：多媒体库，支持多种常用的音频、视频格式录制和回放。
• SQLite：轻型的关系型数据库引擎
• SGL：底层的2D图形渲染引擎
• SSL：安全套接层，是为网络通信提供安全及数据完整性的一种安全协议
• FreeType：可移植的字体引擎，它提供统一的接口来访问多种字体格式文件

b.Android Runtime库§

    运行时库又分为核心库和ART(5.0系统之后，Dalvik虚拟机被ART取代)。核心库提供了Java语言核心库的大多数功能，这样开发者可以使用Java语言来编写Android应用。相较于JVM，Dalvik虚拟机是专门为移动设备定制的，允许在有限的内存中同时运行多个虚拟机的实例，并且每一个Dalvik 应用作为一个独立的Linux 进程执行。独立的进程可以防止在虚拟机崩溃的时候所有程序都被关闭。而替代Dalvik虚拟机的ART 的机制与Dalvik 不同。在Dalvik下，应用每次运行的时候，字节码都需要通过即时编译器转换为机器码，这会拖慢应用的运行效率，而在ART 环境中，应用在第一次安装的时候，字节码就会预先编译成机器码，使其成为真正的本地应用。

4.硬件抽象层§

    硬件抽象层是位于操作系统内核与硬件电路之间的接口层，其目的在于将硬件抽象化，为了保护硬件厂商的知识产权，它隐藏了特定平台的硬件接口细节，为操作系统提供虚拟硬件平台，使其具有硬件无关性，可在多种平台上进行移植。 从软硬件测试的角度来看，软硬件的测试工作都可分别基于硬件抽象层来完成，使得软硬件测试工作的并行进行成为可能。通俗来讲，就是将控制硬件的动作放在硬件抽象层中。

5.Linux内核层§

    Android 的核心系统服务基于Linux 内核，在此基础上添加了部分Android专用的驱动。系统的安全性、内存管理、进程管理、网络协议栈和驱动模型等都依赖于该内核。

二、Android系统源码§

1.源码下载§

阅读Android系统源码可以访问网站:http://androidxref.com/

2.源码目录§

3.应用层源码§

    应用层位于整个Android系统的最上层，开发者开发的应用程序以及系统内置的应用程序都是在应用层。对应的源码目录packages。

4.应用框架层部分§

    应用框架层是系统的核心部分，一方面向上提供接口给应用层调用，另一方面向下与C/C++程序库以及硬件抽象层等进行衔接。 应用框架层的主要实现代码在/frameworks/base和/frameworks/av目录下，其中/frameworks/base目录结构

5.C/C++程序库部分§

    系统运行库层（Native)中的 C/C++程序库的类型繁多，功能强大，C/C++程序库并不完全在一个目录中，几个常用且比较重要的C/C++程序库所在的目录位置。

6.Android运行时库§

    Android运行时库的代码放在art/目录中。

7.硬件抽象层的§

    HAL的代码在hardware/目录中，这一部分是手机厂商改动最大的一部分，根据手机终端所采用的硬件平台会有不同的实现。

三、init启动流程§

init进程是Android系统中用户空间的第一个进程，主要负责创建Zygote(孵化器)和属性服务等功能。源码位于system/core/init下

1.按下开机键后发生什么？§

• 启动电源以及系统启动: 当电源按下时引导芯片代码会从预定义的地方（固化在ROM）开始执行，加载引导程序BootLoader到RAM，然后执行。

• 引导程序Bootloader: 引导程序是在Android系统开始运行前的一个小程序，主要作用就是把系统OS拉起来并运行。

• Linux Kernel启动: 内核启动，设置缓存，被包含存储器，计划列表，加载驱动。当内核完成系统设置，它首先会在系统中寻找init文件，然后启动root进程或者系统的第一个进程init。

• init进程启动: init进程主要用来初始化和启动属性服务，并且启动Zygote进程。

2.init进程核心流程§

Linux系统的用户进程，是所有用户进程的鼻祖，进程号为1，它有许多重要的职责，比如创建Zygote孵化器和属性服务等。并且它是由多个源文件组成的，对应源码目录system/core/init中

int main(int argc, char** argv) {
    if (!strcmp(basename(argv[0]), "ueventd")) {
        return ueventd_main(argc, argv);
    }
    if (!strcmp(basename(argv[0]), "watchdogd")) {
        return watchdogd_main(argc, argv);
    }
    umask(0);
    add_environment("PATH", _PATH_DEFPATH);
    bool is_first_stage = (argc == 1) || (strcmp(argv[1], "--second-stage") != 0);
    // 创建文件并挂载
    if (is_first_stage) {
        mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755");
        mkdir("/dev/pts", 0755);
        mkdir("/dev/socket", 0755);
        mount("devpts", "/dev/pts", "devpts", 0, NULL);
        #define MAKE_STR(x) __STRING(x)
        mount("proc", "/proc", "proc", 0, "hidepid=2,gid=" MAKE_STR(AID_READPROC));
        mount("sysfs", "/sys", "sysfs", 0, NULL);
    }
    open_devnull_stdio();
    klog_init();
    klog_set_level(KLOG_NOTICE_LEVEL);
    NOTICE("init %s started!\n", is_first_stage ? "first stage" : "second stage");
    if (!is_first_stage) {
        // Indicate that booting is in progress to background fw loaders, etc.
        close(open("/dev/.booting", O_WRONLY | O_CREAT | O_CLOEXEC, 0000));
        // 1.初始化属性相关资源
        property_init();
        process_kernel_dt();
        process_kernel_cmdline();
        export_kernel_boot_props();
    }
 ...
    // 2.启动属性服务
    start_property_service();
    const BuiltinFunctionMap function_map;
    Action::set_function_map(&function_map);
    Parser& parser = Parser::GetInstance();
    parser.AddSectionParser("service",std::make_unique<ServiceParser>());
    parser.AddSectionParser("on", std::make_unique<ActionParser>());
    parser.AddSectionParser("import", std::make_unique<ImportParser>());
    // 解析init.rc配置文件
    parser.ParseConfig("/init.rc");//3
   ...   
       while (true) {
        if (!waiting_for_exec) {
            am.ExecuteOneCommand();
            restart_processes();
        }
        int timeout = -1;
        if (process_needs_restart) {
            timeout = (process_needs_restart - gettime()) * 1000;
            if (timeout < 0)
                timeout = 0;
        }
        if (am.HasMoreCommands()) {
            timeout = 0;
        }
        bootchart_sample(&timeout);
        epoll_event ev;
        int nr = TEMP_FAILURE_RETRY(epoll_wait(epoll_fd, &ev, 1, timeout));
        if (nr == -1) {
            ERROR("epoll_wait failed: %s\n", strerror(errno));
        } else if (nr == 1) {
            ((void (*)()) ev.data.ptr)();
        }
    }
    return 0;
}

调用property_init初始化属性，调用start_property_service启动属性服务，调用parser.ParseConfig(“/init.rc”)解析init.rc

四、Zygote启动流程§

关Zygote: 在Android系统中，DVM(Dalivk虚拟机)，应用程序进程已经运行的系统关键服务的SystemServer进程都是Zygote进程创建的，也称zygote为孵化器。zygote通过fork的方式创建应用进程和SystemServer进程，因为zygote进程启动时会创建DVM，因此fork创建的进程在内部都可以获取一个DVM的实例拷贝。

1.AppRuntime§

    init启动zygote时调用了app_main.cpp的main函数中的AppRuntime的start启动zygote进程，代码位置frameworks/base/cmds/app_process/app_main.cpp

int main(int argc, char* const argv[])
{
...

    AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
   ...
     Vector<String8> args;
    if (!className.isEmpty()) {
        args.add(application ? String8("application") : String8("tool"));
        runtime.setClassNameAndArgs(className, argc - i, argv + i);
    } else {
        // We're in zygote mode.
        maybeCreateDalvikCache();
        if (startSystemServer) {
            //1.startSystemServer为true的话(默认为true)，将”start-system-server”放入启动的参数args
            args.add(String8("start-system-server"));
        }
        char prop[PROP_VALUE_MAX];
        if (property_get(ABI_LIST_PROPERTY, prop, NULL) == 0) {
            LOG_ALWAYS_FATAL("app_process: Unable to determine ABI list from property %s.",
                ABI_LIST_PROPERTY);
            return 11;
        }
        String8 abiFlag("--abi-list=");
        abiFlag.append(prop);
        args.add(abiFlag);
        for (; i < argc; ++i) {
            args.add(String8(argv[i]));
        }
    }
    if (!niceName.isEmpty()) {
        runtime.setArgv0(niceName.string());
        set_process_name(niceName.string());
    }
    if (zygote) {
        //2.调用runtime的start函数来启动zygote进程，并将args传入，这样启动zygote进程后，zygote进程会将SystemServer进程启动
        runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
    } else if (className) {
        runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
    } else {
        fprintf(stderr, "Error: no class name or --zygote supplied.\n");
        app_usage();
        LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");
        return 10;
    }
}

    AppRuntime声明也在app_main.cpp中，它继承AndroidRuntime，也就是我们调用start其实是调用AndroidRuntime的start函数，代码位置：frameworks/base/core/jni/AndroidRuntime.cpp

void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{
    ...
    /* start the virtual machine */
    JniInvocation jni_invocation;
    jni_invocation.Init(NULL);
    JNIEnv* env;
    //1.调用startVm函数创建DVM
    if (startVm(&mJavaVM, &env, zygote) != 0) {
        return;
    }
    onVmCreated(env);
    //2.调用startReg函数为DVM注册JNI
    if (startReg(env) < 0) {
        ALOGE("Unable to register all android natives\n");
        return;
    }
    jclass stringClass;
    jobjectArray strArray;
    jstring classNameStr;

    stringClass = env->FindClass("java/lang/String");
    assert(stringClass != NULL);
    //创建数组
    strArray = env->NewObjectArray(options.size() + 1, stringClass, NULL);
    assert(strArray != NULL);
    //从app_main的main函数得知className为com.android.internal.os.ZygoteInit
    classNameStr = env->NewStringUTF(className);
    assert(classNameStr != NULL);
    env->SetObjectArrayElement(strArray, 0, classNameStr);

    for (size_t i = 0; i < options.size(); ++i) {
        jstring optionsStr = env->NewStringUTF(options.itemAt(i).string());
        assert(optionsStr != NULL);
        env->SetObjectArrayElement(strArray, i + 1, optionsStr);
    }
    char* slashClassName = toSlashClassName(className);
    jclass startClass = env->FindClass(slashClassName);
    if (startClass == NULL) {
        ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);
        /* keep going */
    } else {
    	//3.找到ZygoteInit的main函数
        jmethodID startMeth = env->GetStaticMethodID(startClass, "main", "([Ljava/lang/String;)V");
        if (startMeth == NULL) {
            ALOGE("JavaVM unable to find main() in '%s'\n", className);
            /* keep going */
        } else {
        	//4.通过JNI调用ZygoteInit的main函数
            env->CallStaticVoidMethod(startClass, startMeth, strArray);
			//if 0
            if (env->ExceptionCheck())
                threadExitUncaughtException(env);
			//endif
        	}
    	}
  	...
}

    通过JNI调用ZygoteInit的main函数，因为ZygoteInit的main函数是Java编写的，因此需要通过JNI调用。

2.Zygote在Java侧§

代码位于：frameworks/base/core/java/com/android/internal/os/ZygoteInit.java

public static void main(String argv[]) {
    ...
    try {
        ...       
        //1.注册Zygote用的Socket
        registerZygoteSocket(socketName);
        ...
        //2.预加载类和资源
        preload();
        ...
        if (startSystemServer) {
        	//3.启动SystemServer进程
            startSystemServer(abiList, socketName);
        }
        Log.i(TAG, "Accepting command socket connections");
        //4.等待客户端请求
        runSelectLoop(abiList);
        closeServerSocket();
    } catch (MethodAndArgsCaller caller) {
        caller.run();
    } catch (RuntimeException ex) {
        Log.e(TAG, "Zygote died with exception", ex);
        closeServerSocket();
        throw ex;
    }
}

ZygoteInit的mian函数主要做了四件事

a.调用registerZygoteSocket方法§

    调用registerZygoteSocket方法创建了一个Server端的Socket，socket的name为zygote，当Zygote进程将SystemServer进程启动后，就会在这个服务端的Socket上来等待ActivityManagerService请求Zygote进程来创建新的应用程序进程。

private static void registerZygoteSocket(String socketName) {
     if (sServerSocket == null) {
         int fileDesc;
         final String fullSocketName = ANDROID_SOCKET_PREFIX + socketName;
         try {
             String env = System.getenv(fullSocketName);
             fileDesc = Integer.parseInt(env);
         } catch (RuntimeException ex) {
             throw new RuntimeException(fullSocketName + " unset or invalid", ex);
         }
         try {
             FileDescriptor fd = new FileDescriptor();
             fd.setInt$(fileDesc);
             //1.创建一个LocalServerSocket，也就是Server端的socket
             sServerSocket = new LocalServerSocket(fd);
         } catch (IOException ex) {
             throw new RuntimeException(
                     "Error binding to local socket '" + fileDesc + "'", ex);
         }
     }

b.调用preload方法§

调用preload方法用来预加载类和资源。

c.调用startSystemServer方法§

调用startSystemServer方法启动SystemServer进程

 private static boolean startSystemServer(String abiList, String socketName)
            throws MethodAndArgsCaller, RuntimeException {
     ...
     /* Hardcoded command line to start the system server */
     //1.创建args数组，SystemServer进程的用户id和用用户组id都设置为1000，并且拥有用户组1001-1010，1018,1021,1032，3001-3010的权限。进程名为system_server，启动类名为com.android.server.SystemServer。
     String args[] = { "--setuid=1000", "--setgid=1000"
         , "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1021,1032,3001,3002,3003,3006,3007,3009,3010"
         , "--capabilities=" + capabilities + "," + capabilities
         , "--nice-name=system_server", "--runtime-args", "com.android.server.SystemServer",
                     };
     ZygoteConnection.Arguments parsedArgs = null;

     int pid;
        
     try {
         //2.封装args为parsedArgs对象。
         parsedArgs = new ZygoteConnection.Arguments(args);
         ZygoteConnection.applyDebuggerSystemProperty(parsedArgs);
         ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs);
            
         //3.调用Zygote的forkSystemServer函数在当前进程创建一个子进程，如果返回的pid为0，表示在新创建的子进程中执行
         pid = Zygote.forkSystemServer(
             parsedArgs.uid, parsedArgs.gid,
             parsedArgs.gids,
             parsedArgs.debugFlags,
             null,       
             parsedArgs.permittedCapabilities,       
             parsedArgs.effectiveCapabilities);   
     } catch (IllegalArgumentException ex) {   
         throw new RuntimeException(ex);   
     }
     //如果返回的pid为0，表示在新创建的子进程中执行   
     if (pid == 0) {
         if (hasSecondZygote(abiList)) {
             waitForSecondaryZygote(socketName);
         } 
         //4.执行handleSystemServerProcess函数启动SystemServer进程。
         handleSystemServerProcess(parsedArgs);  
     }   
     return true;   
 }

d.调用runSelectLoop方法§

启动SystemServer进程后，调用runSelectLoop函数

private static void runSelectLoop(String abiList) throws MethodAndArgsCaller {    
    ArrayList<FileDescriptor> fds = new ArrayList<FileDescriptor>();
    ArrayList<ZygoteConnection> peers = new ArrayList<ZygoteConnection>();
    //1.sServerSocket是在registerZygoteSocket函数中创建的服务端Socket，调用sServerSocket.getFileDescriptor()用来获得该Socket的fd字段的值并添加到fd列表fds中。
    fds.add(sServerSocket.getFileDescriptor());    
    peers.add(null);
    //2.无限循环用来等待ActivityManagerService请求Zygote进程创建新的应用程序进程
    while (true) {    
        StructPollfd[] pollFds = new StructPollfd[fds.size()];
        //3.通过遍历fds存储的信息转移到pollFds数组中。
        for (int i = 0; i < pollFds.length; ++i) {
            pollFds[i] = new StructPollfd();
            pollFds[i].fd = fds.get(i);
            pollFds[i].events = (short) POLLIN;   
        }
        try {
            Os.poll(pollFds, -1);
        } catch (ErrnoException ex) {
            throw new RuntimeException("poll failed", ex);  
        }
        //4.遍历pollFds，
        for (int i = pollFds.length - 1; i >= 0; --i) {
            if ((pollFds[i].revents & POLLIN) == 0) {
                continue;  
            }
            //5.如果i==0则说明，服务端socket与客户端连接上，也就是zygote进程与ActivityManagerService建立了连接
            if (i == 0) {
                //6.调用acceptCommandPeer函数得到ZygoteConnection类对象，添加到socket连接列表peers中，并将ZygoteConnection的fd添加到fd列表fds中，以便可以接收到ActivityManagerService的请求。
                ZygoteConnection newPeer = acceptCommandPeer(abiList);
                peers.add(newPeer);
                fds.add(newPeer.getFileDesciptor());
            } else {
                //6.如果i值大于0，则说明ActivityManagerService向Zygote进程发送了一个创建应用进程的请求，因此调用ZygoteConnection的runOnce函数来创建一个新的应用程序进程。并在成功创建后将这个连接从Socket连接列表peers和fd列表fds中清除。
                boolean done = peers.get(i).runOnce();
                if (done) {
                    peers.remove(i);
                    fds.remove(i);   
                }   
            }   
        }   
    }
}

Zygote总结§

1. 创建AppRuntime并调用start方法，启动zygote进程
2. 创建DVM并为DVM注册JNI
3. 通过调用JNI调用ZygoteInit的mian函数进入Zygote的Java框架层。
4. 通过registerZygoteSocket函数创建服务端Socket。
5. 启动SystemServer进程。
6. 并通过runSelectLoop函数等待ActivityManagerService的请求来创建新的应用程序进程。

五、SystemServer启动流程§

1.SystemServer进程启动过程§

ZygoteInit.java的starSystemServer函数中调用handleSystemServerProcess函数启动了SystemServer进程。

private static void handleSystemServerProcess(
          ZygoteConnection.Arguments parsedArgs)
          throws ZygoteInit.MethodAndArgsCaller {
    //1.SyetemServer进程是复制了Zygote进程的地址空间，因此也会得到Zygote进程创建的Socket，这个Socket对于SyetemServer进程没有用处，因此需要关闭该Socket。  
    closeServerSocket();
    ...
      if (parsedArgs.invokeWith != null) {
         ...
      } else {
          ClassLoader cl = null;
          if (systemServerClasspath != null) {
              cl = createSystemServerClassLoader(systemServerClasspath,
                                                 parsedArgs.targetSdkVersion);
              Thread.currentThread().setContextClassLoader(cl);
          }
          //2.调用RuntimeInit的zygoteInit函数
          RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);
      }
  }

RuntimeInit.java代码位置：frameworks/base/core/java/com/android/internal/os/RuntimeInit.java。

public static final void zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader)
            throws ZygoteInit.MethodAndArgsCaller {
        if (DEBUG) Slog.d(TAG, "RuntimeInit: Starting application from zygote");
        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "RuntimeInit");
        redirectLogStreams();
        commonInit();
    //1.nativeZygoteInit函数，启动Binder线程池。
        nativeZygoteInit();
    //2.调用applicationInit函数
        applicationInit(targetSdkVersion, argv, classLoader);
    }

a.调用nativeZygoteInit方法§

nativeZygoteInit函数对应的JNI文件，frameworks/base/core/jni/AndroidRuntime.cpp

static const JNINativeMethod gMethods[] = {
    { "nativeFinishInit", "()V",
        (void*) com_android_internal_os_RuntimeInit_nativeFinishInit },
    { "nativeZygoteInit", "()V",
        (void*) com_android_internal_os_RuntimeInit_nativeZygoteInit },
    { "nativeSetExitWithoutCleanup", "(Z)V",
        (void*) com_android_internal_os_RuntimeInit_nativeSetExitWithoutCleanup },
};

通过JNI的gMethods数组，可以看出nativeZygoteInit函数对应的是JNI文件AndroidRuntime.cpp的com_android_internal_os_RuntimeInit_nativeZygoteInit函数。

...
static AndroidRuntime* gCurRuntime = NULL;
...
static void com_android_internal_os_RuntimeInit_nativeZygoteInit(JNIEnv* env, jobject clazz)
{
   gCurRuntime->onZygoteInit();
}

gCurRuntime是AndroidRuntime的指针，AndroidRuntime的子类AppRuntime在app_main.cpp中定义，AppRuntime的onZygoteInit函数，代码位置：frameworks/base/cmds/app_process/app_main.cpp

virtual void onZygoteInit()
   {
       sp<ProcessState> proc = ProcessState::self();
       ALOGV("App process: starting thread pool.\n");
       proc->startThreadPool();
   }

调用startThreadPool方法启动一个Binder线程池，SystemServer使用Binder与其他进程进行通信。

b.调用applicationInit方法§

private static void applicationInit(int targetSdkVersion, String[] argv, ClassLoader 
classLoader)        
    throws ZygoteInit.MethodAndArgsCaller {
    ...    
    invokeStaticMain(args.startClass, args.startArgs, classLoader);    
}

private static void invokeStaticMain(String className, String[] argv, ClassLoader classLoader)
         throws ZygoteInit.MethodAndArgsCaller {
     Class<?> cl;
     try {
         //1.className为com.android.server.SystemServer，反射得到SystemServer类
         cl = Class.forName(className, true, classLoader);//1
     } catch (ClassNotFoundException ex) {
         throw new RuntimeException(
                 "Missing class when invoking static main " + className,
                 ex);
     }
     Method m;
     try {
         //2.得到SystemServer中的main函数。
         m = cl.getMethod("main", new Class[] { String[].class });
     } catch (NoSuchMethodException ex) {
         throw new RuntimeException(
                 "Missing static main on " + className, ex);
     } catch (SecurityException ex) {
         throw new RuntimeException(
                 "Problem getting static main on " + className, ex);
     }
     int modifiers = m.getModifiers();
     if (! (Modifier.isStatic(modifiers) && Modifier.isPublic(modifiers))) {
         throw new RuntimeException(
                 "Main method is not public and static on " + className);
     }
    //3.将找到的main函数传入到MethodAndArgsCaller异常中并抛出该异常。截获MethodAndArgsCaller异常的代码在ZygoteInit.java的main函数中
     throw new ZygoteInit.MethodAndArgsCaller(m, argv);
 }

代码位置：frameworks/base/core/java/com/android/internal/os/ZygoteInit.java

public static void main(String argv[]) {
     ...
          closeServerSocket();
      } catch (MethodAndArgsCaller caller) {
    	 //1.调用了MethodAndArgsCaller的run方法。
          caller.run();
      } catch (RuntimeException ex) {
          Log.e(TAG, "Zygote died with exception", ex);
          closeServerSocket();
          throw ex;
      }
  }

 public void run() {
        try {
            //mMethod就是SystemServer的main函数。
            mMethod.invoke(null, new Object[] { mArgs });
        } catch (IllegalAccessException ex) {
         ...
        }
    }
}

2.解析SyetemServer进程§

SystemServer的main函数代码地址：frameworks/base/services/java/com/android/server/SystemServer.java

public static void main(String[] args) {
    new SystemServer().run();    
}

       ...
           //1.加载libandroid_servers.so。
           System.loadLibrary("android_servers");
       ...
           //2.创建SystemServiceManager
           mSystemServiceManager = new SystemServiceManager(mSystemContext);
           LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
       ...    
        try {
           Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "StartServices");
           //3.startBootstrapServices函数调用SystemServiceManager启动了ActivityManagerService、PowerManagerService、PackageManagerService等服务。
           startBootstrapServices();
            //4.启动了BatteryService、UsageStatsService和WebViewUpdateService。
           startCoreServices();
            //5.启动了CameraService、AlarmManagerService、VrManagerService等服务
           startOtherServices();
       } catch (Throwable ex) {
           Slog.e("System", "******************************************");
           Slog.e("System", "************ Failure starting system services", ex);
           throw ex;
       } finally {
           Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
       }
       ...
   }

    Android官方把系统服务分为了三种类型，分别是引导服务、核心服务和其他服务，其中其他服务为一些非紧要和一些不需要立即启动的服务。系统服务大约有80多个，父类都是SystemServer。

a.startService方法启动服务§

如启动PowerManagerService会调用如下代码

mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);

startService函数代码位置：frameworks/base/services/core/java/com/android/server/SystemServiceManager.java

public <T extends SystemService> T startService(Class<T> serviceClass) {
  ...
            final T service;
            try {
                Constructor<T> constructor = serviceClass.getConstructor(Context.class);
                //1.创建SystemService，这里的SystemService是PowerManagerService，
                service = constructor.newInstance(mContext);
            } catch (InstantiationException ex) {
                throw new RuntimeException("Failed to create service " + name
                        + ": service could not be instantiated", ex);
            }
...
            // Register it.
    		//2.将PowerManagerService添加到mServices中，这里mServices是一个存储SystemService类型的ArrayList.
            mServices.add(service);
            // Start it.
            try {
                //3.调用PowerManagerService的onStart函数启动PowerManagerService。
                service.onStart();
            } catch (RuntimeException ex) {
                throw new RuntimeException("Failed to start service " + name
                        + ": onStart threw an exception", ex);
            }
    		//4.返回service
            return service;
        } finally {
            Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER)
        }
    }

b.其他方法启动服务§

除了SystemServiceManager的starService方法启动，也可以用其他方法启动，如以PackageManagerService为例。

mPackageManagerService = PackageManagerService.main(mSystemContext
    ,installer, mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);

public static PackageManagerService main(Context context, Installer installer,
        boolean factoryTest, boolean onlyCore) {
    // Self-check for initial settings.
    PackageManagerServiceCompilerMapping.checkProperties();
    //1.直接创建PackageManagerService
    PackageManagerService m = new PackageManagerService(context, installer,
            factoryTest, onlyCore);
    m.enableSystemUserPackages();
    // Disable any carrier apps. We do this very early in boot to prevent the apps from being
    // disabled after already being started.
    CarrierAppUtils.disableCarrierAppsUntilPrivileged(context.getOpPackageName(), m,
            UserHandle.USER_SYSTEM);
    //2.将PackageManagerService注册到ServiceManager中
    ServiceManager.addService("package", m);
    return m;
}

c.还有有的服务直接注册在ServiceManager中§

ServiceManager用来管理系统中的各种Service，用于系统C/S架构中的Binder机制通信：Client端要使用某个Service，则需要到ServiceManager查下Service的相关信息，然后根据Service的相关信息与所在的Server进程建立通讯通路，这样Client端酒可以使用service了。

telephonyRegistry = new TelephonyRegistry(context);
ServiceManager.addService("telephony.registry", telephonyRegistry);

总结SystemServer进程§

1. 启动Binder线程池，这样就可以与其他进程进行通信。
2. 创建SystemServiceManager用于对系统服务进程的创建，启动和生命周期管理。
3. 启动各种系统服务。

六、Launcher和Android启动流程§

Android系统启动的最后一步就是启动一个系统已经安装的Launcher应用程序。Launcher启动过程中会会请求PackageManagerService返回系统中已经安装的应用程序信息，将这些信息封装成一个快捷图标显示在屏幕。

一、Launcher启动流程§

    SystemServer进程启动的过程会启动PackageManagerService，PackageManagerService启动后会将系统中的应用程序安装完成。同事SystemServer启动的时候会启动ActivityManagerService，ActivityManagerService会将Launcher启动起来，具体代码在SystemServer.java中调用了mActivityManagerService.systemReady。

private void startOtherServices() {
    ...
    mActivityManagerService.systemReady(new Runnable() {    
        @Override    
        public void run() {   
            Slog.i(TAG, "Making services ready");    
            mSystemServiceManager.startBootPhase(        
                SystemService.PHASE_ACTIVITY_MANAGER_READY);
            ...
        }
        ...
    }                                       
}

startOtherServices函数中，会调用ActivityManagerService的systemReady函数： frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

public void systemReady(final Runnable goingCallback) {
...
synchronized (this) {
           ...
            mStackSupervisor.resumeFocusedStackTopActivityLocked();
            mUserController.sendUserSwitchBroadcastsLocked(-1, currentUserId);
        }
    }

systemReady函数中调用了ActivityStackSupervisor的resumeFocusedStackTopActivityLocked函数：frameworks/base/services/core/java/com/android/server/am/ActivityStackSupervisor.java

boolean resumeFocusedStackTopActivityLocked(ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
        if (targetStack != null && isFocusedStack(targetStack)) {
            return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);//1
        }
        final ActivityRecord r = mFocusedStack.topRunningActivityLocked();
        if (r == null || r.state != RESUMED) {
            mFocusedStack.resumeTopActivityUncheckedLocked(null, null);
        }
        return false;
    }

    调用ActivityStack的resumeTopActivityUncheckedLocked函数，ActivityStack对象是用来描述Activity堆栈的，resumeTopActivityUncheckedLocked函数如下所示。 frameworks/base/services/core/java/com/android/server/am/ActivityStack.java

boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
       if (mStackSupervisor.inResumeTopActivity) {
           // Don't even start recursing.
           return false;
       }
       boolean result = false;
       try {
           // Protect against recursion.
           mStackSupervisor.inResumeTopActivity = true;
           if (mService.mLockScreenShown == ActivityManagerService.LOCK_SCREEN_LEAVING) {
               mService.mLockScreenShown = ActivityManagerService.LOCK_SCREEN_HIDDEN;
               mService.updateSleepIfNeededLocked();
           }
           result = resumeTopActivityInnerLocked(prev, options);
       } finally {
           mStackSupervisor.inResumeTopActivity = false;
       }
      return result;
   }

private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
   ...
   return isOnHomeDisplay() &&
          mStackSupervisor.resumeHomeStackTask(returnTaskType, prev, "prevFinished");
   ...                 
}

boolean resumeHomeStackTask(int homeStackTaskType, ActivityRecord prev, String reason) {
    ...
    if (r != null && !r.finishing) {
        mService.setFocusedActivityLocked(r, myReason);
        return resumeFocusedStackTopActivityLocked(mHomeStack, prev, null);
    }
    return mService.startHomeActivityLocked(mCurrentUser, myReason);//1
}

boolean startHomeActivityLocked(int userId, String reason) {
     if (mFactoryTest == FactoryTest.FACTORY_TEST_LOW_LEVEL
             && mTopAction == null) {//1
         return false;
     }
     Intent intent = getHomeIntent();//2
     ActivityInfo aInfo = resolveActivityInfo(intent, STOCK_PM_FLAGS, userId);
     if (aInfo != null) {
         intent.setComponent(new ComponentName(aInfo.applicationInfo.packageName, aInfo.name));
         aInfo = new ActivityInfo(aInfo);
         aInfo.applicationInfo = getAppInfoForUser(aInfo.applicationInfo, userId);
         ProcessRecord app = getProcessRecordLocked(aInfo.processName,
                 aInfo.applicationInfo.uid, true);
         if (app == null || app.instrumentationClass == null) {//3
             intent.setFlags(intent.getFlags() | Intent.FLAG_ACTIVITY_NEW_TASK);
             mActivityStarter.startHomeActivityLocked(intent, aInfo, reason);//4
         }
     } else {
         Slog.wtf(TAG, "No home screen found for " + intent, new Throwable());
     }
     return true;
 }

    注释1处的mFactoryTest代表系统的运行模式，系统的运行模式分为三种，分别是非工厂模式、低级工厂模式和高级工厂模式，mTopAction则用来描述第一个被启动Activity组件的Action，它的值为Intent.ACTION_MAIN。因此注释1的代码意思就是mFactoryTest为FactoryTest.FACTORY_TEST_LOW_LEVEL（低级工厂模式）并且mTopAction=null时，直接返回false。注释2处的getHomeIntent函数如下所示。

Intent getHomeIntent() {
    Intent intent = new Intent(mTopAction, mTopData != null ? Uri.parse(mTopData) : null);
    intent.setComponent(mTopComponent);
    intent.addFlags(Intent.FLAG_DEBUG_TRIAGED_MISSING);
    if (mFactoryTest != FactoryTest.FACTORY_TEST_LOW_LEVEL) {
        intent.addCategory(Intent.CATEGORY_HOME);
    }
    return intent;
}

    getHomeIntent函数中创建了Intent，并将mTopAction和mTopData传入。mTopAction的值为Intent.ACTION_MAIN，并且如果系统运行模式不是低级工厂模式则将intent的Category设置为Intent.CATEGORY_HOME。我们再回到ActivityManagerService的startHomeActivityLocked函数，假设系统的运行模式不是低级工厂模式，在注释3处判断符合Action为Intent.ACTION_MAIN，Category为Intent.CATEGORY_HOME的应用程序是否已经启动，如果没启动则调用注释4的方法启动该应用程序。

二、Android系统启动流程§

1. 启动电源以及系统启动: 当按下电源时引导芯片代码从预定义的地方开始执行，加载引导程序Bootloader到RAM，然后执行。
2. 引导程序Bootloader: 引导程序Bootloader是在Android操作系统运行前的一个小程序，主要作用就是把系统OS拉起来。
3. Linux内核启动: 内核启动时，设置缓存，被保护存储器，计划列表，加载驱动，当内核完成系统设置，它首先绘制系统文件中寻找init.rc文件，并启动init进程。
4. init进程启动: 初始化和启动属性服务，并启动Zygote进程。
5. Zygote进程启动: 创建JavaVM并为JavaVM注册JNI，创建服务Socket，启动SystemServer进程。
6. SystemServer进程启动: 启动Binder线程池，创建SystemServiceManager，并启动各种系统服务。
7. Launcher启动: 被SystemServer进程启动的ActivityManagerService会启动Launcher，Launcher启动后会将已经安装应用的快捷图片显示在界面上。