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