从Android 8.0源码的角度剖析Android系统启动过程(2)

在从Android 8.0源码的角度剖析Android系统启动过程(1)一文中，我们介绍了Android系统启动过程中的init进程和Zygote进程的启动流程，本文将在此基础上，继续介绍SystemServer进程和Launcher进程的启动流程，其中，SystemServer进程由Zygote进程通过fork形式创建并启动，该进程主要用于启动系统中各种关键的系统服务，比如AMS、PMS、WMS等等，而Launcher进程就是我们的系统桌面启动器，当AMS服务被SystemServer进程启动后首先就会去启动该进程。随着Launcher进程被启动完毕，Android系统启动过程也执行完毕。

1. SystemServer进程

 SytemServer进程启动时序图如下：

 在分析Zygote进程启动过程中，我们了解到SystemServer进程是在在ZygoteInit的main方法中被创建的，在该方法中调用了ZygoteInit的startSystemServer方法，该方法又调用了Zygote的nativeForkSystemServer方法，这个方法是一个native方法，最终由它在native层通过调用fork函数实现在Zygote进程中创建SystemServer进程。如果pid=0，说明SystemServer进程被创建成功，此时当前代码逻辑运行在SystemServer子进程，接下来就会去调用ZygoteInit的handleSystemServerProcess方法进入SystemServer进程的启动过程。startSystemServer方法源码如下：

// Android8.0\frameworks\base\core\java\com\android\internal\os\ZygoteInit.java
private static boolean startSystemServer(String abiList, String socketName, 
                                         ZygoteServer zygoteServer)
    throws Zygote.MethodAndArgsCaller, RuntimeException {
    ...
        // SystemServer进程启动参数
        // 注意"com.android.server.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);

        // Zygote进程通过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);
        }
		// 关闭Server Socket
        // 注：SystemServer进程fork自Zygote进程，自然拥有一份Server Socket的副本
        //     但是由于Server Socket是用来监听AMS请求的，SystemServer用不到
        //     就将其关闭掉了
        zygoteServer.closeServerSocket();
        // 处理SystemServer进程
        handleSystemServerProcess(parsedArgs);
    }

    return true;
}

 接下来，我们看下ZygoteInit的handleSystemServerProcess方法。

// Android8.0\frameworks\base\core\java\com\android\internal\os\ZygoteInit.java
private static void handleSystemServerProcess(
    ZygoteConnection.Arguments parsedArgs)
    throws Zygote.MethodAndArgsCaller {
    ...
    ClassLoader cl = null;
    if (systemServerClasspath != null) {
        // 创建一个PathClassLoader
        // 注：PathClassLoader用于加载系统类和应用程序的类
        cl = createPathClassLoader(systemServerClasspath, parsedArgs.targetSdkVersion);

        Thread.currentThread().setContextClassLoader(cl);
    }
	// 进入SystemServer进程具体工作逻辑
    ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);
}

 handleSystemServerProcess方法主要完成两件事，一是创建一个PathClassLoader对象，该对象是一个类加载器，主要用于加载系统类和应用程序的类；二是调用ZygoteInit的zygoteInit方法进入下一步的处理，并将之前创建的PathClassLoader对象作为参数传入。其中，ZygoteInit的zygoteInit方法源码如下：

// Android8.0\frameworks\base\core\java\com\android\internal\os\ZygoteInit.java 
public static final void zygoteInit(int targetSdkVersion, String[] argv,
            ClassLoader classLoader) throws Zygote.MethodAndArgsCaller {
        if (RuntimeInit.DEBUG) {
            Slog.d(RuntimeInit.TAG, "RuntimeInit: Starting application from zygote");
        }

        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ZygoteInit");
        RuntimeInit.redirectLogStreams();

        RuntimeInit.commonInit();
		// 启动Binder线程池
        ZygoteInit.nativeZygoteInit();
		// 进入com.android.server.SystemServer类的main方法
        RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);
    }

 zygoteInit方法主要完成两个任务：(1)创建、启动Binder线程池。有了Binder线程池，SystemServer进程就可以通过Binder机制与其他进程进行通信；(2) 通过反射的方式调用SystemServer类的main方法，该方法最终完成各种系统服务的启动工作。接下来，我们重点分析以上两点。

1.1 启动Binder线程池

 从ZygoteInit的zygoteInit方法可知，Binder线程池的启动时通过调用ZygoteInit的nativeZygoteInit方法实现的，该方法是一个native方法，它的具体实现位于native层的AndroidRuntime.cpp源文件中。这里需要注意的是，AndroidRuntime.cpp中对nativeZygoteInit的注册是通过调用JNIEnv的RegisterNatives方法注册Java需要调用的Native方法，跟我们日常开发NDK流程有点不一样，即native层方法没有用"JNIEXPORT void JNICALL Java_..."标明。相关源码如下：

// \Android8.0\frameworks\base\core\jni\AndroidRuntime.cpp
// 注册nativeZygoteInit方法对应的native层方法
int register_com_android_internal_os_ZygoteInit(JNIEnv* env)
{
    const JNINativeMethod methods[] = {
        { "nativeZygoteInit", "()V",
            (void*) com_android_internal_os_ZygoteInit_nativeZygoteInit },
    };
    // 注册对应的native方法
    // 即将native层的nativeZygoteInit映射到
    // "com_android_internal_os_ZygoteInit_nativeZygoteInit"函数
    return jniRegisterNativeMethods(env, "com/android/internal/os/ZygoteInit",
        methods, NELEM(methods));
}

// \Android8.0\frameworks\base\core\jni\AndroidRuntime.cpp
static AndroidRuntime* gCurRuntime = NULL;
static void com_android_internal_os_ZygoteInit_nativeZygoteInit(JNIEnv* env, jobject clazz)
{
    gCurRuntime->onZygoteInit();
}

 从"com_android_internal_os_ZygoteInit_nativeZygoteInit"函数源码可知，它只有一行代码，即通过指针变量gCurRuntime调用AndroidRuntime中的onZygoteInit函数，但是遗憾的是，我在AndroidRuntime.cpp源文件中翻遍了都没有找到onZygoteInit函数。有没有可能该指针变量指向的是AndroidRuntime的子类？确实如此！还记得在上一篇文章中分析Init进程启动Zygote进程时在app_main.cpp的main函数中，调用了一个名为AppRuntime类的start函数进入了Zygote进程的初始化流程，而这个AppRuntime就是AndroidRuntime的子类，定义在app_main.cpp源文件中。AppRuntime$onZygoteInit函数源码如下：

// \Android8.0\frameworks\base\cmds\app_process.cpp$AppRuntime
class AppRuntime : public AndroidRuntime
{
	...
	virtual void onZygoteInit()
    {
        sp<ProcessState> proc = ProcessState::self();
        ALOGV("App process: starting thread pool.\n");
        // 创建Binder线程池
        proc->startThreadPool();
    }
}

 在AppRuntime$onZygoteInit函数中，最终调用ProcessState的startThreadPool函数首先判断线程池是否已经启动，如果没有，则将线程池状态mThreadPoolStarted属性设置为true，然后ProcessState的调用spawnPooledThread函数来创建、启动Binder线程池。ProcessState类中的源码如下：

// \Android8.0\frameworks\native\libs\binder\ProcessState.cpp
void ProcessState::startThreadPool()
{
    // 获取互斥锁
    AutoMutex _l(mLock);
    if (!mThreadPoolStarted) {
        // 将线程池状态设置为true
        mThreadPoolStarted = true;
        // 创建线程池，启动
        spawnPooledThread(true);
    }
}
// \Android8.0\frameworks\native\libs\binder\ProcessState.cpp
void ProcessState::spawnPooledThread(bool isMain)
{
    if (mThreadPoolStarted) {
        // 拼接Binder线程池名称 Binder:%d_%X
        String8 name = makeBinderThreadName();
        ALOGV("Spawning new pooled thread, name=%s\n", name.string());
        // 创建Binder线程池
        sp<Thread> t = new PoolThread(isMain);
        // 启动Binder线程池
        t->run(name.string());
    }
}

1.2 启动系统服务

 前面说到，在ZygoteInit的handleSystemServerProcess方法中会去调用RuntimeInit$applicationInit方法进入SystemServer进程的启动各种系统服务流程。RuntimeInit$applicationInit方法源码如下：

// Android8.0\frameworks\base\core\java\com\android\internal\os\RuntimeInit.java
protected static void applicationInit(int targetSdkVersion, String[] argv, 
                                      ClassLoader classLoader)
    throws Zygote.MethodAndArgsCaller {
    ...
    // 将SytemServer进程启动参数（ZygoteInit$startSystemServer）
    //  String args[] = {
    //      "--setuid=1000",
    //      "--setgid=1000",
    //      ...
    //      "--nice-name=system_server",
    //      "--runtime-args",
    //      "com.android.server.SystemServer",
    //   };
    // 存储到Arguments中
    final Arguments args;
    try {
        args = new Arguments(argv);
    } catch (IllegalArgumentException ex) {
        Slog.e(TAG, ex.getMessage());
        // let the process exit
        return;
    }
    
    // Remaining arguments are passed to the start class's static main
    // 调用startClass的main方法，该方法是一个静态方法
    // 这个startClass就是在startSystemServer中启动参数中传入的
    // “com.android.server.SystemServer”
    invokeStaticMain(args.startClass, args.startArgs, classLoader);
}

 RuntimeInit$applicationInit方法首先会将ZygoteInit $startSystemServer传递过来的SystemServer启动参数存储到Arguments中，然后调用`RuntimeInit$invokeStaticMain方法，该方法将通过反射的形式调用args.startClass表示类的main方法，而这个arg.startClass表示的类就是“com.android.server.SystemServer”。RuntimeInit$invokeStaticMain`方法源码如下：

// Android8.0\frameworks\base\core\java\com\android\internal\os\RuntimeInit.java
private static void invokeStaticMain(String className, String[] argv, ClassLoader classLoader)
    throws Zygote.MethodAndArgsCaller {
    Class<?> cl;

    try {
        // 通过类名全限定路径获取对应的Class对象
        cl = Class.forName(className, true, classLoader);
    } catch (ClassNotFoundException ex) {
        throw new RuntimeException(
            "Missing class when invoking static main " + className,
            ex);
    }

    Method m;
    try {
        // 通过Class对象获取className类的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);
    }

    // 抛出MethodAndArgsCaller异常
    // 并将m作为参数传出去，将被ZygoteInit.main函数捕获
    throw new Zygote.MethodAndArgsCaller(m, argv);
}

 在invokeStaticMain方法中，对“com.android.server.SystemServer”的main方法调用比较巧妙，它通过反射方式获取到SystemServer类的main方法信息后并没有直接去调用它，而是在方法的最后抛出了一个Zygote.MethodAndArgsCaller异常，并将代表"main"函数的Method的对象和相关参数传递进去。那么问题来了，又在哪里捕获这个Zygote.MethodAndArgsCaller异常？首先我们来分析捕获这个异常的地方。通常一个异常的抛出，要么由方法本身捕获，要么由调用它的上一级方法，甚至更上多级。因此，我们采用向上回溯方式，从当前方法(invokeStaticMain)向上查找到底哪个方法catch了Zygote.MethodAndArgsCaller异常，最终我们找到ZygoteInit的main方法对这个异常进行了捕获，而该main方法就是之前我们分析得到的，即启动SystemServer进程的入口！回顾下ZygoteInit的main方法：

// \Android8.0\frameworks\base\core\java\com\android\internal\os\ZygoteInit.java
public static void main(String argv[]) {
    ...
    try{
        // 启动SystemServer进程
        if (startSystemServer) {
            startSystemServer(abiList, socketName, zygoteServer);
        }
		...
    } catch (Zygote.MethodAndArgsCaller caller) {
        // 捕获ygote.MethodAndArgsCaller异常
        caller.run();
    }
    ...
}

// Android8.0\frameworks\base\core\java\com\android\
//     internal\os\Zygote.java$MethodAndArgsCaller 
public static class MethodAndArgsCaller extends Exception
            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() {
            try {
				// 调用m方法，传入参数为mArgs
				// mArgs=“com.android.server.SystemServer”
                mMethod.invoke(null, new Object[] { mArgs });
            } catch (IllegalAccessException ex) {
                throw new RuntimeException(ex);
            } catch (InvocationTargetException ex) {
                Throwable cause = ex.getCause();
                if (cause instanceof RuntimeException) {
                    throw (RuntimeException) cause;
                } else if (cause instanceof Error) {
                    throw (Error) cause;
                }
                throw new RuntimeException(ex);
            }
        }
}

 从上述源码可知，ZygoteInit的main方法捕获到Zygote.MethodAndArgsCaller异常后，会直接调用Zygote.MethodAndArgsCaller的run方法，再调用反射类Method的invoke方法对“com.android.server.SystemServer”类的main方法进行动态调用，SystemServer类将完成SystemServer进程的具体任务。接下来，我们分析SystemServer类的main方法，该方法实现很简单，就是new了一个SystemServer对象，然后调用它的run方法。相关源码如下：

// \Android8.0\frameworks\base\services\java\com\android\server\SystemServer.java
public static void main(String[] args) {
    // 创建一个SystemServer实例
    // 调用该实例的run方法
    new SystemServer().run();
}

private void run() {
    // Prepare the main looper thread (this thread).
    android.os.Process.setThreadPriority(
        android.os.Process.THREAD_PRIORITY_FOREGROUND);
    android.os.Process.setCanSelfBackground(false);
    // 创建当前线程Looper对象
    Looper.prepareMainLooper();

    // Initialize native services.
    // 加载系统库libandroid_servers.so
    System.loadLibrary("android_servers");
    
    // Initialize the system context.
    // 创建系统的Context
    createSystemContext();

    // Create the system service manager.
    // 创建系统服务管理器
    mSystemServiceManager = new SystemServiceManager(mSystemContext);
    mSystemServiceManager.setRuntimeRestarted(mRuntimeRestart);
    LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
    // Prepare the thread pool for init tasks that can be parallelized
    // 准备线程池
    SystemServerInitThreadPool.get();
    ...
    // 启动服务
    try {
        traceBeginAndSlog("StartServices");
        // 启动Bootstrap(引导)服务
        startBootstrapServices();
        // 启动Core(核心)服务
        startCoreServices();
        // 启动Other(其他)服务
        startOtherServices();
        SystemServerInitThreadPool.shutdown();
    } catch (Throwable ex) {
        Slog.e("System", "******************************************");
        Slog.e("System", "************ Failure starting system services", ex);
        throw ex;
    } finally {
        traceEnd();
    }
    ...
    // 开启消息循环
    Looper.loop();
}

 总的来说，SystemServer的run方法主要完成以下工作：

1. 创建当前线程的Looper对象，开启消息循环；
2. 创建系统服务管理器SystemServiceManager，用于对系统服务进行创建、启动以及生命周期管理；
3. 启动系统服务，包括引导服务、核心服务以及其他服务。

1.2.1 启动Bootstrap(引导)服务

 SystemServer的startBootstrapServices方法源码如下：

// \Android8.0\frameworks\base\services\java\com\android\server\SystemServer.java
private void startBootstrapServices() {
    ...
    // Installer服务
    traceBeginAndSlog("StartInstaller");
    Installer installer = mSystemServiceManager.startService(Installer.class);
    traceEnd();
	// AMS服务
    traceBeginAndSlog("StartActivityManager");
    mActivityManagerService = mSystemServiceManager.startService(
        ActivityManagerService.Lifecycle.class).getService();
    mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
    mActivityManagerService.setInstaller(installer);
    traceEnd();
    // PowerManagerService服务
    traceBeginAndSlog("StartPowerManager");
    mPowerManagerService = 	 
        mSystemServiceManager.startService(PowerManagerService.class);
    traceEnd();
	// LightsService服务
    traceBeginAndSlog("StartLightsService");
    mSystemServiceManager.startService(LightsService.class);
    traceEnd();
    mPackageManagerService = PackageManagerService.main(mSystemContext, installer,
                                                        mFactoryTestMode != 	
                                                        FactoryTest.FACTORY_TEST_OFF, 
                                                        mOnlyCore);
    // PMS服务
    mFirstBoot = mPackageManagerService.isFirstBoot();
    mPackageManager = mSystemContext.getPackageManager();
    ...
    // SensorService服务
    mSensorServiceStart = SystemServerInitThreadPool.get().submit(() -> {
        BootTimingsTraceLog traceLog = new BootTimingsTraceLog(
            SYSTEM_SERVER_TIMING_ASYNC_TAG, Trace.TRACE_TAG_SYSTEM_SERVER);
        traceLog.traceBegin(START_SENSOR_SERVICE);
        startSensorService();
        traceLog.traceEnd();
    }, START_SENSOR_SERVICE);
}

引导服务主要包括(部分)：

• Installer：系统安装APK时的服务类；

• ActivityManagerService：负责四大组件的启动、切换以及调度；

• PowerManagerService：计算系统中与Power相关的计算，决策系统该如何反应；

• LightsService：管理和显示背景LED;

• PackageManagerService：负责对APK的安装、解析、卸载等工作；

• SensorService：为系统提供各种感应器服务；

1.2.2 启动Core(核心)服务

 SystemServer的startCoreServices方法源码如下：

// \Android8.0\frameworks\base\services\java\com\android\server\SystemServer.java
private void startCoreServices() {
    // Records errors and logs, for example wtf()
    traceBeginAndSlog("StartDropBoxManager");
    mSystemServiceManager.startService(DropBoxManagerService.class);
    traceEnd();

    traceBeginAndSlog("StartBatteryService");
    // Tracks the battery level.  Requires LightService.
    mSystemServiceManager.startService(BatteryService.class);
    traceEnd();

    // Tracks application usage stats.
    traceBeginAndSlog("StartUsageService");
    mSystemServiceManager.startService(UsageStatsService.class);
    mActivityManagerService.setUsageStatsManager(
        LocalServices.getService(UsageStatsManagerInternal.class));
    traceEnd();

    traceBeginAndSlog("StartWebViewUpdateService");
    mWebViewUpdateService = 
        mSystemServiceManager.startService(WebViewUpdateService.class);
    traceEnd();
}

系统核心服务包括：

• DropBoxManagerService: 用于生成和管理系统运行时的一些日志文件；
• BatteryService: 管理电池相关的服务；
• UsageStatsService: 使用户使用每一个APP的频率，使用时长；
• WebViewUpdateService: WebView更新服务；

1.2.3 启动Other(其他)服务

 SystemServer的startOtherServices方法源码如下：

// \Android8.0\frameworks\base\services\java\com\android\server\SystemServer.java
private void startOtherServices() {
    ...
    // Camera Service
    if (!disableCameraService) {
          Slog.i(TAG, "Camera Service Proxy");
          traceBeginAndSlog("StartCameraServiceProxy");
          mSystemServiceManager.startService(CameraServiceProxy.class);
          traceEnd();
    }
    // VibratorService
    traceBeginAndSlog("StartVibratorService");
    vibrator = new VibratorService(context);
    ServiceManager.addService("vibrator", vibrator);
    traceEnd();
    // AlarmManagerService
    traceBeginAndSlog("StartAlarmManagerService");
    mSystemServiceManager.startService(AlarmManagerService.class);
    traceEnd();
    // StartInputManagerService
    traceBeginAndSlog("StartInputManagerService");
    inputManager = new InputManagerService(context);
    traceEnd();
	// WindowManagerService
    traceBeginAndSlog("SetWindowManagerService");
    mActivityManagerService.setWindowManager(wm);
    traceEnd();
	// BluetoothService
    traceBeginAndSlog("StartBluetoothService");
    mSystemServiceManager.startService(BluetoothService.class);
    traceEnd();
	// NetworkManagementService
    if (!disableNetwork) {
        traceBeginAndSlog("StartNetworkManagementService");
        try {
            networkManagement = NetworkManagementService.create(context);
            ServiceManager.addService(Context.NETWORKMANAGEMENT_SERVICE, 
                                      networkManagement);
        } catch (Throwable e) {
            reportWtf("starting NetworkManagement Service", e);
        }
        traceEnd();
    }
    // WIFI_SERVICE_CLASS
    traceBeginAndSlog("StartWifi");
    mSystemServiceManager.startService(WIFI_SERVICE_CLASS);
    traceEnd();
	// NotificationManagerService
    traceBeginAndSlog("StartNotificationManager");
    mSystemServiceManager.startService(NotificationManagerService.class);
    SystemNotificationChannels.createAll(context);
    notification = INotificationManager.Stub.asInterface(
        ServiceManager.getService(Context.NOTIFICATION_SERVICE));
    networkPolicy.bindNotificationManager(notification);
    traceEnd();
    ...
}

系统其他服务包括(部分)：

• CameraService: 摄像头相关服务；

• AlarmManagerService: 全局定时器管理服务；

• InputManagerSevice：管理输入事件服务；

• WindowManagerService：窗口管理服务；

• BluetoothService：蓝牙管理服务；

• WifiService：Wifi相关服务

• NotificationManagerService：通知管理服务；

• LocationManagerService：定位管理服务；

• AudioService：音频相关管理服务；

2. Launcher进程

 Launcher进程启动时序图如下：

 在从Android 8.0源码的角度剖析APK打包、安装过程一文中，我们曾谈到APK的安装、卸载都是由系统服务PackageManagerService(简称PMS)完成的。当PMS系统服务被SystemSystem进程启动后，它会去扫描/system/app等目录，将这些目录下的APK应用程序安装，其中就包括系统应用Launcher。Launcher又被称为桌面启动器，是Android系统不可缺少的部分，它提供一个可视化桌面允许我们与Android系统进行交互，比如为一个安装好的应用程序生成一个快捷方式、打开或删除一个应用等。在ActvityManagerService(简称AMS)被启动后，它就会去启动Launcher进程，具体入口在startOtherServices函数中，通过调用AMS的systemReady方法实现。相关源码如下：

// \Android8.0\frameworks\base\services\java\com\android\server\SystemServer.java
private void startOtherServices() {
    ...
    // 启动Launcher进程
    mActivityManagerService.systemReady(() -> {
        Slog.i(TAG, "Making services ready");
        traceBeginAndSlog("StartActivityManagerReadyPhase");
        mSystemServiceManager.startBootPhase(
            SystemService.PHASE_ACTIVITY_MANAGER_READY);
        traceEnd();
    }
    ...
    try {
        // 启动com.android.systemui.SystemUIService服务
        //  SystemUI是系统启动中第一个用户肉眼可见的应用，其功能包罗万象，
        // 比如开机后看到的锁屏界面，充电时充电界面，状态栏，导航栏，多任务栏等
        startSystemUi(context, windowManagerF);
     } catch (Throwable e) {
         reportWtf("starting System UI", e);
     }
     ...
}
// Android8.0\frameworks\base\services\core\java\com\android\server\am
// ActivityManagerService.java
public void systemReady(final Runnable goingCallback, BootTimingsTraceLog traceLog) {
    ...
    // 调用ActivityStackSupervisor的resumeFocusedStackTopActivityLocked方法
    mStackSupervisor.resumeFocusedStackTopActivityLocked();
    ...
}

 AMS的systemReady方法又调用了ActivityStackSupervisor的resumeFocusedStackTopActivityLocked方法，该方法又调用了ActivityStackSupervisor的resumeFocusedStackTopActivityLocked方法。

// \Android8.0\frameworks\base\services\core\java\com\android\server\am
// ActivityStackSupervisor.java
boolean resumeFocusedStackTopActivityLocked(
    ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
    if (targetStack != null && isFocusedStack(targetStack)) {
        // 调用ActivityStack的resumeTopActivityUncheckedLocked
        return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
    }
    final ActivityRecord r = mFocusedStack.topRunningActivityLocked();
    if (r == null || r.state != RESUMED) {
        mFocusedStack.resumeTopActivityUncheckedLocked(null, null);
    } else if (r.state == RESUMED) {
        // Kick off any lingering app transitions form the MoveTaskToFront operation.
        mFocusedStack.executeAppTransition(targetOptions);
    }
    return false;
}

 在上述方法中，调用了ActivityStack的resumeTopActivityUncheckedLocked，这个ActivityStack对象是用来描述Activity堆栈的。resumeTopActivityUncheckedLocked方法实现很简单，它继续调用了ActivityStack的resumeTopActivityInnerLocked，该方法源码如下：

// \Android8.0\frameworks\base\services\core\java\com\android\server\am
// ActivityStack.java
private boolean resumeTopActivityInnerLocked(ActivityRecord prev,
                                             ActivityOptions options) {
    if (!mService.mBooting && !mService.mBooted) {
        // Not ready yet!
        return false;
    }
    ...
    // mStackId == HOME_STACK_ID
    else if (!isHomeStack()){
		// Launching home next
		// 进入启动Launcher home
        if (DEBUG_STATES) Slog.d(TAG_STATES,
                        "resumeTopActivityLocked: Launching home next");
          return isOnHomeDisplay() &&
                   mStackSupervisor.resumeHomeStackTask(prev, "prevFinished");
     }    
}

 resumeTopActivityInnerLocked方法会判断当前mStackId属性是否等于HOME_STACK_ID，如果不等于，说明Launcher还没有被启动，就会去调用ActivityStackSupervisor的resumeHomeStackTask方法，该方法最终会去调用AMS的startHomeActivityLocked方法，由这个方法执行Launcher应用的主Activity。源码如下：

// \Android8.0\frameworks\base\services\core\java\com\android\server\am
// ActivityManagerService.java
boolean startHomeActivityLocked(int userId, String reason) {
    ...
    // 获取Launcher进程的Home的主Activity信息
    Intent intent = getHomeIntent();
    ...
    // ActivityStarter：启动Launcher
    mActivityStarter.startHomeActivityLocked(intent, aInfo, myReason);
    ...
}

Intent getHomeIntent() {
    // 设置Intent的Action属性
    // String mTopAction = Intent.ACTION_MAIN;
    Intent intent = new Intent(mTopAction, mTopData != null ? 
                               Uri.parse(mTopData) : null);
    intent.setComponent(mTopComponent);
    intent.addFlags(Intent.FLAG_DEBUG_TRIAGED_MISSING);
    // 设置Intent的Category属性
    if (mFactoryTest != FactoryTest.FACTORY_TEST_LOW_LEVEL) {
        intent.addCategory(Intent.CATEGORY_HOME);
    }
    return intent;
}

 AMS的startHomeActivityLocked方法首先会通过getHomeIntent方法获取一个Intent对象，并设置该Intent对象的Action属性值为Intent.ACTION_MAIN和Category属性值为Intent.CATEGORY_HOME，而这两个属性值恰好对得上Launcher应用源码的AndroidManifest.xml中名为"com.android.launcher2.Launcher"的Activity过滤条件，也就是说，这个Intent目的就是去启动Launcher的Home Activity，即"com.android.launcher2.Launcher"。然后，调用ActivityStarter的startHomeActivityLocked方法进入具体的启动流程，这个与启动一个普通的Activity差不多，就不在继续分析下去了，请参考文章《从Android 6.0源码的角度剖析Activity的启动过程》。至此，Launcher应用的启动分析完毕。Launcher2的AndroidMainfest.xml源码如下：

// \Android8.0\packages\apps\Launcher2\AndroidMainfest.xml
<application
             android:name="com.android.launcher2.LauncherApplication"
             android:label="@string/application_name"
             android:icon="@mipmap/ic_launcher_home"
             android:hardwareAccelerated="true"
             android:largeHeap="@bool/config_largeHeap"
             android:supportsRtl="true">
    <activity
              android:name="com.android.launcher2.Launcher"
              android:launchMode="singleTask"
              android:clearTaskOnLaunch="true"
              android:stateNotNeeded="true"
              android:resumeWhilePausing="true"
              android:theme="@style/Theme"
              android:windowSoftInputMode="adjustPan"
              android:screenOrientation="nosensor">
        <intent-filter>
            <action android:name="android.intent.action.MAIN" />
            <category android:name="android.intent.category.HOME" />
            <category android:name="android.intent.category.DEFAULT" />
            <category android:name="android.intent.category.MONKEY"/>
        </intent-filter>
    </activity>
</application>