四大组件----Activity 的启动过程源码图解

一.zygote 进程

读音：[ˈzaɪgoʊt] 受精卵
Android 是基于 Linux 系统的，在系统启动后（即手机开机），Linux 内核在加载完成后就会启动一个 init 进程，在 Linux 中所有的进程都是由 init 进程直接或者间接 fork(分支) 出来的，因此 zygote 进程也是由 init 进程 fork 出来的。在Android 系统中每一个 app 都是一个单独的 zygote 进程。为了实现资源共享和拥有更快的启动速度，在有了第一个 zygote 进程后，系统开启新的进程都是由 zygote 进程 fork 出来。

二.SystemServer 进程

SystemServer 它是由 zygote 进程 fork 出来的。它的作用主要是开启系统中重要的各种服务，比如 ActivityManagerService ，PackageManagerService 等等。在 ZygoteInit 的 main 方法中可以看到:


   if (startSystemServer) {
                Runnable r = forkSystemServer(abiList, socketName, zygoteServer);
                // {@code r == null} in the parent (zygote) process, and {@code r != null} in the
                // child (system_server) process.
                if (r != null) {
                    r.run();
                    return;
                }
            }

三.C/S 架构

Activity的启动流程在 Android Framework 中使用的是客户端/服务器的架构，客户端就是一个个 app 应用进程，而服务器端就是 SystemServer 进程，为 app 进程提供各种系统服务。由于这两个是出于不同的进程，因此它们之间的通信就涉及到进程间的通信，也就是使用 Binder 的 IPC 机制。

四.Launcher 应用进程

Launcher 实际上就是显示主界面或者说桌面的应用进程(就是按 Home 键显示的界面)，因此它同样也有 Activity 。


/**
 * Default launcher application.
 */
public final class Launcher extends Activity
        implements View.OnClickListener, OnLongClickListener, LauncherModel.Callbacks,
                   View.OnTouchListener {
                       ...
                          @Override
    protected void onCreate(Bundle savedInstanceState) {
            setContentView(R.layout.launcher);
                   }
}

这里的 R.layout.launcher ，就是桌面的布局文件，里面就是显示着桌面的各种应用的图标和小部件。而点击图标实际上也是一个 onClick 方法。

/**
     * Launches the intent referred by the clicked shortcut.
     *
     * @param v The view representing the clicked shortcut.
     */
    public void onClick(View v) {
       ...

            boolean success = startActivitySafely(v, intent, tag);

        ...
    }

五.涉及的几个对象

(一).客户端（app 进程）

1.ApplicationThread

用来实现 ActivityManagerService 与 ActivityThread 之间的交互，服务端进程可以通过 ApplicationThread 对象的代理对象 ApplicationThreadProxy （或 IApplicationThread ）实现与 app 进程的交互，从而管理 Application 中的 Activity 的生命周期。

2.ActivityThread

app 启动的起点，也就是 UI 线程，会在 main 方法中会开启消息循环队列，从而实行对 Activity 的管理。

 public static void main(String[] args) {
       ...

        Looper.prepareMainLooper();

        ActivityThread thread = new ActivityThread();
        thread.attach(false);
       ...

    }

3.Instrumentation

读音； [ˌɪnstrəmɛnˈteʃən] ，手段
对 Activity 进行具体操作的操作类，每个应用程序只有一个 Instrumentation 对象，且在每个 Activity 中都有一个这个对象的引用，可以对 Activity 进行创建或者其他操作。

4. ActivityMangerProxy 或 IActivityManager

ActivityManagerServices 在 app 进程中的代理对象，app 进程可以通过这个对象实现与服务端进程的通信。 Android 8.0 之前并没有采用 AIDL，而是采用了类似 AIDL 的形式，用 AMS 的代理对象 ActivityManagerProxy 来与AMS进行进程间通信，Android 8.0 去除了 ActivityManagerNative 的内部类 ActivityManagerProxy ，代替它的则是 IActivityManager ，在ApplicationThreadProxy 也是一样，代替的是 IApplicationnThread 。

(二).服务端（SystemService 进程）

1. ActivityManagerServices (简称 AMS )

主要负责系统中所有 Activity 的生命周期，通过接收在 app 进程中的代理对象 ActivityMangerProxy （或 IApplicationManager ）传过来的信息从而进行一定的操作。

2.ApplicationThreadProxy (或IApplicationThread)

app 进程在服务端的代理对象，SystemService 进程可以通过这个对象实现与 ApplicationThread 的通信。

3.ActivityStack

用于管理 Activity 的栈的操作对象，其中记录了已经启动的 Activity 的先后关系状态等信息，通过 ActivityStack 可以判断是否需要启动新的进程。

4.ActivityRecord

ActivityStack 实际管理的对象，每个 Activity 在 ActivityStack 中都有一个对应的对象映射，用来记录管理 Activity 。

5.TaskRecord

用于记录 ActivityRecord 的栈，一个 Task 就是一系列 ActivityRecord 的集合，这与启动模式所说的相同。AMS 就是通过这个确保 Activity 的启动和退出的顺序。

总体关系如图 (Android 7.0)：

六.启动流程

1.首先系统启动后就会创建 zygote 进程，fork 出 SystemService 进程，进而开启各种系统服务，同时创建 Launcher 应用进程，显示桌面。
2.在 Launcher 应用进程中点击应用图标，app 进程的 ActivityMangerProxy 就会
通知 SystemService 启动应用的 MianActivity,如果这个应用进程还没有启动，就由 AMS 通知 Zygote 进程 fork 出应用进程，在这个时候就开启 ApplicationThread 和ActivityThread ，最后会通过
ActivityMangerProxy 与 AMS 进行“连接”，这个时候 AMS 保存一个 app 进程的代理对象 ApplicationThread，并开始创建 MainActivity 。
3.由于 AMS 负责所有 Activity 的管理，因此首先在 AMS 会执行一定的操作，部分流程如下：

4. 在 realstartActivityLocked 中会通过 ApplicationThreadProxy 回到 app 进程执行真正的启动操作。ApplicationThread 通过 scheduleLaunchActivity 方法启动 Activity 。在这个方法中会发送一个启动 Activity 的消息由 Handler 处理，接着转由 handleLaunchActivity 方法来实现，preformLaunchActivity 方法最终完成了 Activity 的创建和启动过程。并且 ActivityThread 通过 handleResumeActivity 方法来调用被启动 Activity 的 onResume 的生命周期。
5.preformLaunchActivity 主要完成：

1.从 ActivityClientActivity 获取代启动 Activity 的组建信息。
2.通过 instrumentation 的 newActivity 方法使用类加载器创建 Activity 对象。
3.通过 LoadedApk 的 make 方法尝试创建 Application.如果已经创建了就不会再重复创建，就是说一个应用程序只有一个 application 。创建 application 也是通过 Instrumentation 完成，通过类加载器实现。 application 创建完成后会通过 callApplicationCreate 来调用 Application 的 onCreate .
4.创建 ContextImpl 对象并通过 Activity 的 attach 方法完成一些重要的数据的初始化。这是 Context 的重要实现，ContextImpl 通过 Activity 的attach 方法来和 Activity 建立关联，在 attach 方法中， Activity 还会完成 Window 的创建并建立和 Window 的关联。
5.最后会调用 Instrumentation.callActivityOnCreate ，这时 Activity 的onCreate 就会被调用，Activity 就完成了整个启动的过程。

整体流程如下图：