Android系统启动流程

安卓系统体系结构

体系结构图

自上而下分别是：应用层(Application)-->framework层-->libraries层-->运行时层-->内核层(Linux core)
蓝色字体部分基于Java语言编写，其余颜色字体基于C/C++编写；

启动流程

1.启动Linux内核,加载配置文件

由BootLoader引导程序启动linux内核,初始化完成之后,就会启动一个init进程,这个init进程会加载一个配置文件init.rc.

int main(int argc, char **argv)
    {
        // 创建文件夹 挂载
        mount("tmpfs", "/dev", "tmpfs", 0, "mode=0755");
        mkdir("/dev/pts", 0755);
       
        // 打开日志
        log_init();
        
        INFO("reading config file\n");
        // 加载init.rc配置文件
        init_parse_config_file("/init.rc");
    
    }

2.初始化Android运行环境

这个配置文件会创建出许多的文件和文件夹，最重要的是这个配置文件会启动一个zygote进程,这个进程是Java进程的父进程，在这个进程中，会初始化Android运行时环境，同时通过调用ZygoteInit.java这个类，将程序从C级别带到了Java级别。

   int main(int argc, const char* const argv[])
    {
        ...
        // Android运行时环境
        AppRuntime runtime;
        ...
        // Next arg is startup classname or "--zygote"
        if (i < argc) {
            arg = argv[i++];
            if (0 == strcmp("--zygote", arg)) {
                bool startSystemServer = (i < argc) ? 
                        strcmp(argv[i], "--start-system-server") == 0 : false;
                setArgv0(argv0, "zygote");
                set_process_name("zygote");
                // 启动java代码
                runtime.start("com.android.internal.os.ZygoteInit",
             ...
    }

3.Zygote准备数据

里面首先为Dalvik设置堆内存大小，然后初始化Android系统启动时需要的类，四大组件，Dailog等，之后fork出一个SystemService进程；

public static void main(String argv[]) {
        try {
            VMRuntime.getRuntime().setMinimumHeapSize(5 * 1024 * 1024);

            // 加载Android依赖的类
            preloadClasses();
            //cacheRegisterMaps();
            preloadResources();
            ...

            if (argv[1].equals("true")) {
                // 启动系统服务
                startSystemServer();
            } else if (!argv[1].equals("false")) {
           ...
    }


    private static boolean startSystemServer()
         ...
            /* Request to fork the system server process */
            // 母进程开始分叉服务 启动SystemServer
            pid = Zygote.forkSystemServer(
                    parsedArgs.uid, parsedArgs.gid,
                    parsedArgs.gids, debugFlags, rlimits,
                    parsedArgs.permittedCapabilities,
                    parsedArgs.effectiveCapabilities);
        ...
    }

4.SystemService加载framework层（加载Native，开启系统服务）

加载jni库

public static void main(String[] args) {
           ... 
        // 加载jni库
        System.loadLibrary("android_servers");
        // 调用native方法,该方法启动Native世界
        init1(args);
    }
    native public static void init1(String[] args);

加载C代码的init1()方法，转调C代码的另外一个方法，system_init();，在这个方法里面又调用了SystemService的init2方法；

    extern "C" int system_init();
    
    static void android_server_SystemServer_init1(JNIEnv* env, jobject clazz)
    {    
     ···
        // 转调
        system_init();
    ···
    }

   extern "C" status_t system_init()
    {
        ...
        // 启动硬件的服务
        if (strcmp(propBuf, "1") == 0) {
            // Start the SurfaceFlinger
            SurfaceFlinger::instantiate();
        }
    
        
        
        AndroidRuntime* runtime = AndroidRuntime::getRuntime();
    
        LOGI("System server: starting Android services.\n");
        // 启动完硬件服务后，又回到Systemserver的init2方法
        runtime->callStatic("com/android/server/SystemServer", "init2");
        ...
    }

SystemServer的init2方法，init2()方法启动Android的Framework层，启动Android世界。在该方法中启动了一个ServerThread线程，init2()启动的线程ServerThread中的的run方法中通过一个Looper开启了Android中的各种服务比如LightService，PowerManagerService，BatteryService，WindowManagerService等，并将服务添加到ServiceManager中去管理，启动完各种服务后，调用ActivityManagerService.systemReady方法，

public static final void init2() {
            Slog.i(TAG, "Entered the Android system server!");
            Thread thr = new ServerThread();
            thr.setName("android.server.ServerThread");
            thr.start();
        }

 public void run() {
        ...
        // 开启Android各种服务并且添加到ServiceManager去管理
        Slog.i(TAG, "Device Policy");
        devicePolicy = new DevicePolicyManagerService(context);
        ServiceManager.addService(Context.DEVICE_POLICY_SERVICE, ottle = 

        ...
        // We now tell the activity manager it is okay to run third party
        // code.  It will call back into us once it has gotten to the state
        // where third party code can really run (but before it has actually
        // started launching the initial applications), for us to complete our
        // initialization.
        // 各种服务开启后调用ActivityManagerService.systemReady
        ((ActivityManagerService)ActivityManagerNative.getDefault())
                .systemReady(new Runnable() {
            public void run() {
                Slog.i(TAG, "Making services ready");

6.加载launcher应用程序

这个时候系统的基本服务已经准备完成，开始加载Launcher，启动HomeActivity，紧接着上面systemReady()方法

public void systemReady(final Runnable goingCallback) {
            ...
            // 打开第一个Activity
                mMainStack.resumeTopActivityLocked(null);
            }
        }

final boolean resumeTopActivityLocked(ActivityRecord prev) {
            // Find the first activity that is not finishing.
            // 没有已经打开的Activity, next为 null
            ActivityRecord next = topRunningActivityLocked(null);
    
            // Remember how we'll process this pause/resume situation, and ensure
            // that the state is reset however we wind up proceeding.
            final boolean userLeaving = mUserLeaving;
            mUserLeaving = false;
    
            if (next == null) {
                // There are no more activities!  Let's just start up the
                // Launcher...

                if (mMainStack) {
                    // 启动lucher应用的锁屏界面
                    return mService.startHomeActivityLocked();
                }
            }

这样用户就可以看到手机的桌面了。