一、写在前面

前面写了《从源码看Application的启动流程》，接下来该看看Activity的生命周期了。ActivityManagerService在attachApplicationLocked()方法里面调用thread.bindApplication()启动Application之后，会继续往下走，继续启动Activity。

二、大致流程

image

三、源码分析(基于API28)

• 注：说明基本上都写在代码注释里面了。

先看ActivityManagerService的attachApplicationLocked()方法里面，通知ActivityThread创建并启动了Application，接下来也该创建Activity了。

1. AMS进程

// 类：ActivityManagerService
private final boolean attachApplicationLocked(IApplicationThread thread,
        int pid, int callingUid, long startSeq) {
    // ...
    // 通知ActivityThread创建并启动Application
    // Application的启动不在此文讨论，跳过。
    thread.bindApplication(...);
    // ...
    // normalMode就是是否有Activity正在等待着运行
    // 此文讨论的是从桌面点击图标启动应用，就是需要启动Activity。
    if (normalMode) {
        try {
            if (mStackSupervisor.attachApplicationLocked(app)) {...}
        }
    }
    // ...
}

// 类：ActivityStackSupervisor
// Supervisor是管理者的意思，我们用的比较多的单词是Manager，意思应该是差不多，就是Activity堆栈的管理。
boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
    // ...
    // ActivityRecord主要是保存Activity的运行状态信息，有了ActivityRecord才能启动Activity
    final ActivityRecord top = stack.topRunningActivityLocked();
    // ...
    // 启动Activity
    if (realStartActivityLocked(...)
    // ...
}

// 类：ActivityStackSupervisor
final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
        boolean andResume, boolean checkConfig) throws RemoteException {
    // ...
    // 创建Activity的启动事务。
    // 把Activity的启动和生命周期等信息放到一个事务里面，然后把事务丢给应用进程ActivityThread去自己玩耍。
    final ClientTransaction clientTransaction = ClientTransaction.obtain(app.thread, r.appToken);
    // 添加callback，其实就是添加一个ClientTransactionItem，这里item就是callback吧，有点别扭。
    // ActivityThread拿到ClientTransaction去执行的时候，会把这些item也全部执行一遍。
    // 这里添加的是LaunchActivityItem，继承于ClientTransactionItem。
    clientTransaction.addCallback(LaunchActivityItem.obtain(...));

    // 设置Activity启动之后的最终状态。
    final ActivityLifecycleItem lifecycleItem;
    if (andResume) {
        // 本文讨论的是从桌面点击打开应用的情况，最终状态也就是onResume了，自然对应ResumeActivityItem。
        lifecycleItem = ResumeActivityItem.obtain(mService.isNextTransitionForward());
    } else {
        lifecycleItem = PauseActivityItem.obtain();
    }
    // 把ResumeActivityItem设置进去事务里面，后面应用进程会拿出来处理的。
    clientTransaction.setLifecycleStateRequest(lifecycleItem);

    // 通知应用经常执行事务
    // mService是ActivityManagerService
    // getLifecycleManager()返回是ClientLifecycleManager
    mService.getLifecycleManager().scheduleTransaction(clientTransaction);
    // ...
}

// 类：ClientLifecycleManager
void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
    // ...
    transaction.schedule();
    // ...
}

// 类：ClientTransaction
public void schedule() throws RemoteException {
    // 这里的mClient就是IApplicationThread，也就是回到应用进程了。
    mClient.scheduleTransaction(this);
}

2. 应用进程

以下回到应用进程自己玩耍了：

// 类：ActivityThread.ApplicationThread
// 这是IApplicationThread的代理类，应用进程和AMS之间就是通过这个类通讯的。
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
    ActivityThread.this.scheduleTransaction(transaction);
}

// 类：ClientTransactionHandler
// 这是ActivityThread的父类，事务的handler
// 前面AMS创建了用于启动Activity的事务，通过IApplicationThread丢给了应用进程，最终会交给这个类去执行事务
void scheduleTransaction(ClientTransaction transaction) {
    // ...
    // 丢给主线程去执行
    sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}

// 类：ActivityThread.H
public void handleMessage(Message msg) {
        switch (msg.what) {
            case EXECUTE_TRANSACTION:
                // 类似于把任务丢给线程池去执行吧，这里把ClientTransaction丢给TransactionExecutor去执行。
                final ClientTransaction transaction = (ClientTransaction) msg.obj;
                mTransactionExecutor.execute(transaction);
                // ...
                break;
        }
    }
}

// 类：TransactionExecutor
public void execute(ClientTransaction transaction) {
    // ...
    // 执行callback列表，就是刚才在AMS添加的LaunchActivityItem。
    executeCallbacks(transaction);
    // 执行生命周期
    executeLifecycleState(transaction);
    // ...
}

这里有两个主要的方法，onCreate()方法是在executeCallbacks()里面的，onStart()和onResume()则在executeLifecycleState()里面。这里先看executeCallbacks()。

分支1：executeCallbacks(transaction)

// 类：TransactionExecutor
public void executeCallbacks(ClientTransaction transaction) {
    // 拿到item列表，其实也就是只有一个，前面在AMS只添加了一个。
    final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
    // ...
    final int size = callbacks.size();
    for (int i = 0; i < size; ++i) {
        // 这个item就是前面AMS添加的LaunchActivityItem
        final ClientTransactionItem item = callbacks.get(i);
        // ...
        item.execute(mTransactionHandler, token, mPendingActions);
        // ...
    }
}

// 类：LaunchActivityItem
public void execute(ClientTransactionHandler client, IBinder token, PendingTransactionActions pendingActions) {
    // ...
    // ClientTransactionHandler是ActivityThread的父类，执行事务的handler。
    // handleLaunchActivity是个虚拟方法，具体实现在ActivityThread类里面。
    client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
    // ...
}

// 类：ActivityThread
public Activity handleLaunchActivity(ActivityClientRecord r,
        PendingTransactionActions pendingActions, Intent customIntent) {
    // ...
    // 熟悉的perform
    final Activity a = performLaunchActivity(r, customIntent);
    // ...
}

// 类：ActivityThread
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    // ...
    // 通过反射创建Activity，和创建Application一样一样的。
    ContextImpl appContext = createBaseContextForActivity(r);
    Activity activity = null;
    try {
        java.lang.ClassLoader cl = appContext.getClassLoader();
        activity = mInstrumentation.newActivity(
                cl, component.getClassName(), r.intent);
    }
    // ...
    // 调用onCreate方法。
    mInstrumentation.callActivityOnCreate(activity, r.state);
    // ...
    // 上面调用完onCreate方法之后，把状态设置为ON_CREATE。
    r.setState(ON_CREATE);
    // ...
}

// 类：Instrumentation
public void callActivityOnCreate(Activity activity, Bundle icicle) {
    // ...
    // 熟悉的perform
    activity.performCreate(icicle);
    // ...
}

// 类：Activity 
final void performCreate(Bundle icicle, PersistableBundle persistentState) {
    // ...
    // onCreate方法就在这里调用啦啦啦
    onCreate(icicle);
    // ...
}

分支2：executeLifecycleState(transaction)

分析完onCreate()之后，接着上面的上面继续看onStart()和onResume()，也就是executeLifecycleState()方法。

// 类：TransactionExecutor
private void executeLifecycleState(ClientTransaction transaction) {
    // ...
    // 前面AMS里面把ResumeActivityItem设置到事务里面了，意思是最终状态是resume，现在拿出来处理。
    // 所以这个lifecycleItem就是ResumeActivityItem。
    // 前面的代码：clientTransaction.setLifecycleStateRequest(lifecycleItem);
    final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
    // ...
    // 先循环判断一下这个开始状态和最终状态之间有没有其它状态，有的话处理一下。
    // 这里我们知道我们的开始状态是onCreate，最终状态是onResume，这中间还有一个onStart等着回调呢。
    // 注意第二个参数叫finish，传入的是ON_RESUME，也就是最有一个状态是ON_RESUME。
    // 注意第三个参数叫excludeLastState，意思是是否排除最后一个状态，传入了true，也就是排除了ON_RESUME。
    cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */);
    // 上面排除了ON_RESUME状态，所以最终在这里执行了。
    lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
    // ...
}

这里又有分支了，onStart()在cycleToPath()里面，onResume在lifecycleItem.execute()里面。我们先看cycleToPath()，后面再看lifecycleItem.execute()。

分支2-1：cycleToPath()

// 类：TransactionExecutor
private void cycleToPath(ActivityClientRecord r, int finish,
        boolean excludeLastState) {
    // ActivityClientRecord保存这Activity的状态信息，之前已经设置为了ON_CREATE了还记得么么么
    // 所以start就是ON_CREATE
    final int start = r.getLifecycleState();
    // 拿到start和finish之间的状态列表
    final IntArray path = mHelper.getLifecyclePath(start, finish, excludeLastState);
    // 执行start和finish之间的状态列表
    performLifecycleSequence(r, path);
}

// 类：TransactionExecutorHelper
// 由前面可以知道start是ON_CREATE，finish是ON_RESUME
public static final int ON_CREATE = 1;
public static final int ON_START = 2;
public static final int ON_RESUME = 3;
public IntArray getLifecyclePath(int start, int finish, boolean excludeLastState) {
    // ...
    mLifecycleSequence.clear();
    if (finish >= start) {
        // 我们的start=1，finish=3，所以这个列表添加了两个状态，ON_START和ON_RESUME
        for (int i = start + 1; i <= finish; i++) {
            mLifecycleSequence.add(i);
        }
    }
    // ...
    // excludeLastState传入的是true，所以去掉最后一个，剩下的就只有ON_START了。
    if (excludeLastState && mLifecycleSequence.size() != 0) {
        mLifecycleSequence.remove(mLifecycleSequence.size() - 1);
    }
    return mLifecycleSequence;
}

// 类：TransactionExecutor
// 前面计算出了要执行的状态列表，这里就去执行吧。
private void performLifecycleSequence(ActivityClientRecord r, IntArray path) {
    final int size = path.size();
    for (int i = 0, state; i < size; i++) {
        state = path.get(i);
        switch (state) {
            case ON_START:
                // mTransactionHandler和前面一样，是ActivityThread的父类
                // handleStartActivity()的具体实现在ActivityThread类中
                mTransactionHandler.handleStartActivity(r, mPendingActions);
                break;
            // ...
        }
    }
}

// 类：ActivityThread
public void handleStartActivity(ActivityClientRecord r,
        PendingTransactionActions pendingActions) {
    final Activity activity = r.activity;
    // ...
    activity.performStart("handleStartActivity");
    // 设置当前状态为ON_START
    r.setState(ON_START);
    // ...
}

// 类：Activity
final void performStart(String reason) {
    // ...
    mInstrumentation.callActivityOnStart(this);
    // ...
}

// 类：Instrumentation
public void callActivityOnStart(Activity activity) {
    // 又走完一个生命周期
    activity.onStart();
}

分支2-2：lifecycleItem.execute()

回调完了开始状态和最终状态之间的状态(也就是onStart)之后，也该回调最终状态onResume了，也就是前面留下来的lifecycleItem.execute(mTransactionHandler, token, mPendingActions);，lifecycleItem就是ResumeActivityItem。

// 类：ResumeActivityItem
public void execute(ClientTransactionHandler client, IBinder token, PendingTransactionActions pendingActions) {
    // 同样的配方，还是回到ActivityThread里面去
    client.handleResumeActivity(token, true /* finalStateRequest */, mIsForward, "RESUME_ACTIVITY");
}

// 类：ActivityThread
public void handleResumeActivity(IBinder token, boolean finalStateRequest, boolean isForward, String reason) {
    // ...
    final ActivityClientRecord r = performResumeActivity(token, finalStateRequest, reason);
    // ...
}

// 类：ActivityThread
public ActivityClientRecord performResumeActivity(IBinder token, boolean finalStateRequest, String reason) {
    final ActivityClientRecord r = mActivities.get(token);
    // ...
    try {
        // ...
        r.activity.performResume(r.startsNotResumed, reason);
        // ...
        // 设置当前状态为ON_RESUME
        r.setState(ON_RESUME);
    }
    // ...
}

// 类：Activity
final void performResume(boolean followedByPause, String reason) {
    // ...
    mInstrumentation.callActivityOnResume(this);
    // ...
}

// 类：Instrumentation
public void callActivityOnResume(Activity activity) {
    // 这里设了个mResumed变量，但是我们调用不到哈哈哈
    // 我们应该用lifecycle.currentState.isAtLeast(xxx)来判断生命周期。
    activity.mResumed = true;
    // 至此，Activity的onCreate、onStart和onResume都回调完了
    activity.onResume();
    // ...
}

四、写在最后

上次画时序图画得很爽，但是现在看来好像没多大的用处，就不画详细的时序图了，画个大概的流程就行了。
以上都是通过其它人的博客、视频教程等等途径去学习，然后加入自己粗糙的理解，不免有错，具体还要靠自己的去分析。
源码太多了，不可能每一行都去读懂它的意思，只能有针对性的去找你想要看的那部分代码，大致了解清楚整个主流程就可以了。然后多看几遍，多捋几遍，慢慢的就越来越熟悉了，等熟悉之后再一个点一个点的细看，不出一百年，必懂，还搞不懂你尽管从棺材了爬出来找我。