Android 系统启动 — Launcher启动

总体流程

Android系统启动.png

源码解析

Zygote进程启动

首先，启动触发是在linux环境的C++文件内。

• bootloader启动
• init.app # main
  init.app有兴趣的可以研究一下，我仅梳理了一个流程

if (bootscript.empty()) {
    parser.ParseConfig("/init.rc");
    parser.set_is_system_etc_init_loaded(parser.ParseConfig("/system/etc/init"));
    parser.set_is_vendor_etc_init_loaded(parser.ParseConfig("/vendor/etc/init"));
    parser.set_is_odm_etc_init_loaded(parser.ParseConfig("/odm/etc/init"));
} else {
    parser.ParseConfig(bootscript);
    parser.set_is_system_etc_init_loaded(true);
    parser.set_is_vendor_etc_init_loaded(true);
    parser.set_is_odm_etc_init_loaded(true);
}

在这个方法中会解析init.rc

...
import /init.${ro.zygote}.rc
...

针对系统引入不同的zygote.rc 文件

• init.zygote32.rc
• init.zygote32_64.rc
• init.zygote64.rc
• init.zygote64_32.rc

# init.zygote32.rc
# 启动zygote服务 该服务的绝对路径 ..参数（ 最后一个参数是告诉Zygote服务，自身启动后要启动systemServer）
service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server
    class main
    priority -20
    user root
    group root readproc
    socket zygote stream 660 root system
    onrestart write /sys/android_power/request_state wake
    onrestart write /sys/power/state on
    onrestart restart audioserver
    onrestart restart cameraserver
    onrestart restart media
    onrestart restart netd
    onrestart restart wificond
    writepid /dev/cpuset/foreground/tasks

• 启动Zygote进程的入口函数是app_main.cpp
  app_main.cpp#main

int main(int argc, char* const argv[]){
    ...
    AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
    ...
    // 解析参数，参数都会塞到 args[] 内
    while (i < argc) {
        const char* arg = argv[i++];
        if (strcmp(arg, "--zygote") == 0) { // 是否是要启动zygote进程
            zygote = true;
            niceName = ZYGOTE_NICE_NAME;
        } else if (strcmp(arg, "--start-system-server") == 0) { // 启动后是否需要开启SystemServer
            startSystemServer = true;
        }
        ...
    }
    ...
    if (zygote) { // 如果是zygote进程，则启动ZygoteInit.java
        runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
    } else if (className) { // 这个是启动 RuntimeInit.java
        runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
    }
}

• AppRuntime#start()

class AppRuntime : public AndroidRuntime

因为AppRuntime是继承自AndroidRuntime，所以这里我们直接看AndroidRuntime#start()

• AndroidRuntime#start()
  AndroidRuntime.cpp

void AndroidRuntime::start(const char* className, const Vector& options, bool zygote){
    ...
    JNIEnv* env;
    // 启动虚拟机 for Zygote
    if (startVm(&mJavaVM, &env, zygote) != 0) {
        return;
    }
    onVmCreated(env);
    //注册android的native方法
    if (startReg(env) < 0) {
        ALOGE("Unable to register all android natives\n");
        return;
    }
    ...
    // 找入口类（ZygoteInit.java）
    jclass startClass = env->FindClass(slashClassName);
    // 找入口 main 方法
    jmethodID startMeth = env->GetStaticMethodID(startClass, "main","([Ljava/lang/String;)V");
    // 执行 ZygoteInit#main()
    env->CallStaticVoidMethod(startClass, startMeth, strArray);
    ...
}

下面的逻辑就走到Java环境了，java的源码文件路径就不贴了，在Android Studio中都可以直接看到

• ZygoteInit#main

    public static void main(String argv[]) {
        ZygoteServer zygoteServer = new ZygoteServer();
        ...
        // 标记 zygote 启动开始. 确保在这个期间创建新线程会抛出错误.
        ZygoteHooks.startZygoteNoThreadCreation();
        final Runnable caller;
        try {
            // 开启DDMS
            RuntimeInit.enableDdms();
            // 解析参数
            boolean startSystemServer = false;
            String socketName = "zygote";
            String abiList = null;
            boolean enableLazyPreload = false;
            for (int i = 1; i < argv.length; i++) {
                if ("start-system-server".equals(argv[i])) {
                    startSystemServer = true;    // 需要在Zygote完成后启动SystemServer
                } else if ("--enable-lazy-preload".equals(argv[i])) {
                    enableLazyPreload = true;    // 支持懒加载
                } else if (argv[i].startsWith(ABI_LIST_ARG)) {
                    abiList = argv[i].substring(ABI_LIST_ARG.length());
                } else if (argv[i].startsWith(SOCKET_NAME_ARG)) {
                    socketName = argv[i].substring(SOCKET_NAME_ARG.length());
                } else {
                    throw new RuntimeException("Unknown command line argument: " + argv[i]);
                }
            }
            // 注册名字为：zygote 的Socket服务，其他进程籍此与其通信
            zygoteServer.registerServerSocket(socketName);
            if (!enableLazyPreload) {
                /* 开启预加载
                       beginIcuCachePinning();
                       preloadClasses();
                       preloadResources();
                       nativePreloadAppProcessHALs();
                       preloadOpenGL();
                       preloadSharedLibraries();
                       preloadTextResources();
                       WebViewFactory.prepareWebViewInZygote();
                       endIcuCachePinning();
                       warmUpJcaProviders();
                */
                preload(bootTimingsTraceLog);
            } else {
                Zygote.resetNicePriority();
            }
            // 清理一些内存出来，一般只在fork新进程前有效
            gcAndFinalize();
            // 放开线程创建的报错限制，取消Zygote启动的标记，与方法开始时的标记对应
            ZygoteHooks.stopZygoteNoThreadCreation();
            // 开始创建SystemServer进程
            if (startSystemServer) {
                Runnable r = forkSystemServer(abiList, socketName, zygoteServer);
                if (r != null) {
                    r.run();
                    return;
                }
            }
            // 开启一个SelectLoop，用来处理Socket传递过来的消息 — fork 新进程的消息
            // Zygote主进程在上面startSystemServer内就已经退出了，所以是在子进程fork完成后才走到这里的
            // loop一直都在Zygote的主进程内
            caller = zygoteServer.runSelectLoop(abiList);
        } catch (Throwable ex) {
            throw ex;
        } finally {
            zygoteServer.closeServerSocket();
        }
        // 在子进程中才能走到这里，Zygote的主进程是不会走到这里的。
        if (caller != null) {
            caller.run();
        }
    }

SystemServer 进程启动

现在我们来看下forkSystemServer的过程

• ZygoteInit#forkSystemServer()

private static Runnable forkSystemServer(String abiList, String socketName, ZygoteServer zygoteServer) {
        ...
        // 硬编码的命令行去启动SystemServer
        String args[] = {
            "--setuid=1000",
            "--setgid=1000",
            "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1021,1023,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 {
            parsedArgs = new ZygoteConnection.Arguments(args);
            ZygoteConnection.applyDebuggerSystemProperty(parsedArgs);
            ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs);
            // fork SystemServer 进程
            pid = Zygote.forkSystemServer(
                    parsedArgs.uid, parsedArgs.gid,
                    parsedArgs.gids,
                    parsedArgs.debugFlags,
                    null,
                    parsedArgs.permittedCapabilities,
                    parsedArgs.effectiveCapabilities);
        } catch (IllegalArgumentException ex) {
            throw new RuntimeException(ex);
        }

        /* For child process */
        if (pid == 0) {
            if (hasSecondZygote(abiList)) {
                waitForSecondaryZygote(socketName);
            }

            zygoteServer.closeServerSocket();
            // 看这里，返回的是个啥呢？
            return handleSystemServerProcess(parsedArgs);
        }
        return null;
    }

• ZygoteInit#handleSystemServerProcess()

 private static Runnable handleSystemServerProcess(ZygoteConnection.Arguments parsedArgs) {
       ...
       return ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);
 }

• ZygoteInit#zygoteInit()

public static final Runnable zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader) {
        ...
        return RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);
}

• RuntimeInit#applicationInit()

protected static Runnable applicationInit(int targetSdkVersion, String[] argv,ClassLoader classLoader) {
        ...
        // startClass = com.android.server.SystemServer  有兴趣的同学，可以看看详细的参数解析逻辑
        return findStaticMain(args.startClass, args.startArgs, classLoader);
}

• RuntimeInit#findStaticMain

// 实际就是找 com.android.server.SystemServer 的main方法
private static Runnable findStaticMain(String className, String[] argv, ClassLoader classLoader) {
        Class cl = Class.forName(className, true, classLoader);
        ...
        Method m = cl.getMethod("main", new Class[] { String[].class });
         ...
        return new MethodAndArgsCaller(m, argv);
}

static class MethodAndArgsCaller implements Runnable {
        /** method to call */
        private final Method mMethod;

        /** argument array */
        private final String[] mArgs;

        public MethodAndArgsCaller(Method method, String[] args) {
            mMethod = method;
            mArgs = args;
        }

        public void run() {
                // 无处不在的反射调用
                mMethod.invoke(null, new Object[] { mArgs });
        }
}

可以看到这一些列的操作都是在SystemServer进程fork完成后，去执行SystemServer#main方法

• SystemServer#main

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

  private void run() {
        try {
            // 设置系统属性
            ... 
            // 创建looper
            Looper.prepareMainLooper();
            // 初始化 mSystemContext
            createSystemContext();
            // 创建 systemServiceManager. 用来管理系统服务的创建及生命周期
            mSystemServiceManager = new SystemServiceManager(mSystemContext);
            mSystemServiceManager.setRuntimeRestarted(mRuntimeRestart);
            ...
        } 

        // 启动服务
        try {
            // 开启BootStrap服务，AMS就是在这里启动的，有兴趣可以看下源码
            startBootstrapServices();
            // 启动核心服务，绑定AMS
            startCoreServices();
            // 这里也是启动一些非交叉的服务，绑定AMS，并在这里启动Launcher应用，我们继续往下看
            startOtherServices();
        }
        Looper.loop();
        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

Launcher 启动

我们来看下Launcher应用是怎么启动的哈

• SystemServer#startOtherServices

private void startOtherServices() {
    ...
    // 很长很长很长的服务启动逻辑，有兴趣的可以看下，电话、输入输出、闹铃的等等服务器都在这里启动的
    ...
    // 最后一个方法
    mActivityManagerService.systemReady(() -> {
        // 这里是做了一些后续的服务启动逻辑
        mActivityManagerService.startObservingNativeCrashes(); // Native崩溃
        mWebViewUpdateService.prepareWebViewInSystemServer();  // 浏览器
        mSystemServiceManager.startService(CarServiceHelperService.class); // 汽车服务
        startSystemUi(context, windowManagerF);  // 系统UI
        Watchdog.getInstance().start();   // 看门狗
        ...
    }
}

• ActivityManagerService#systemReady()

 public void systemReady(final Runnable goingCallback, TimingsTraceLog traceLog) {
         ...
         // 开始启动桌面应用
         startHomeActivityLocked(currentUserId, "systemReady");    
 }

到这里就开始启动桌面应用了，后面就是Activity的启动逻辑了。