在Android中，activity具有不同的生命周期，在不同的生命周期执行不同的操作。本文从源代码的角度分析各个生命周期的调用执行。
本文以android 13为例进行源代码分析。
1，在frameworks/base/core/java/android/app/servertransaction/ActivityLifecycleItem.java中
public abstract class ActivityLifecycleItem extends ActivityTransactionItem {
@IntDef(prefix = { "UNDEFINED", "PRE_", "ON_" }, value = {
UNDEFINED,
PRE_ON_CREATE,
ON_CREATE,
ON_START,
ON_RESUME,
ON_PAUSE,
ON_STOP,
ON_DESTROY,
ON_RESTART
})
@Retention(RetentionPolicy.SOURCE)
public @interface LifecycleState{}
public static final int UNDEFINED = -1;
public static final int PRE_ON_CREATE = 0;
public static final int ON_CREATE = 1;
public static final int ON_START = 2;
public static final int ON_RESUME = 3;
public static final int ON_PAUSE = 4;
public static final int ON_STOP = 5;
public static final int ON_DESTROY = 6;
public static final int ON_RESTART = 7;
/** A final lifecycle state that an activity should reach. */
@LifecycleState
public abstract int getTargetState();
/** Called by subclasses to make sure base implementation is cleaned up */
@Override
public void recycle() {
}
}
在 ActivityLifecycleItem 抽象类中定义了9种状态。这个抽象类有很多的子类，是AMS管理Activity生命周期的事务类。
状态之间的跳转不是随意的，例如不能从ON_CREATE直接跳转到ON_PAUSE状态，状态之间的跳转收到AMS的管理。当Activity在这些状态之间切换的时候，就会回调对应的生命周期。
下面从ActivityThread的main函数分析起，看Activity的生命周期执行。
2，在frameworks/base/core/java/android/app/ActivityThread.java中
public static void main(String[] args) {
Looper.prepareMainLooper(); // Looper.prepareMainLooper()为当前线程（即主线程）准备了一个Looper，Looper是Android中用于处理消息循环（如UI事件）的类。
ActivityThread thread = new ActivityThread(); //创建ActivityThread的实例，并通过调用其attach方法将其附加到系统服务中。这里第一个参数为false，表示这不是系统服务进程。
thread.attach(false, startSeq); //调用ActivityThread的attach方法，第一个参数为false，表示不是system server进程，tartSeq参数用于传递启动序列号，可能用于调试或跟踪目的
Looper.loop(); //Looper.loop()方法使得当前线程进入一个无限循环，等待并处理消息队列中的消息。这是Android应用UI线程的核心，所有UI更新和事件处理都发生在这里。
}
上面的代码调用 attach 函数。
private void attach(boolean system, long startSeq) {
if (!system) {
RuntimeInit.setApplicationObject(mAppThread.asBinder()); //通过RuntimeInit.setApplicationObject设置应用的Binder对象，以便AMS可以与之通信。
final IActivityManager mgr = ActivityManager.getService(); //获取AMS服务，并调用attachApplication方法通知AMS应用进程已经准备好。这是通过Binder IPC（跨进程通信）完成的。
try {
mgr.attachApplication(mAppThread, startSeq);//通知AMS,app进程已经准备好，binder跨进程通信。
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
}
上面的代码调用了AMS的 attachApplication 函数。
3，在frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java中
@Override
public final void attachApplication(IApplicationThread thread, long startSeq) {
if (thread == null) {
throw new SecurityException("Invalid application interface");
}
synchronized (this) {
int callingPid = Binder.getCallingPid();
final int callingUid = Binder.getCallingUid();
final long origId = Binder.clearCallingIdentity();
attachApplicationLocked(thread, callingPid, callingUid, startSeq); //调用attachApplicationLocked
Binder.restoreCallingIdentity(origId);
}
}
private boolean attachApplicationLocked(@NonNull IApplicationThread thread, int pid, int callingUid, long startSeq) {
// See if the top visible activity is waiting to run in this process...
if (normalMode) {
try {
//ATMS启动activity，调用ActivityTaskManagerInternal抽象类的attachApplication方法，会走到其实现类ActivityTaskManagerService.java中的attachApplication函数。
didSomething = mAtmInternal.attachApplication(app.getWindowProcessController());
} catch (Exception e) {
Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);
badApp = true;
}
}
}
上面的代码调用ATMS的attachApplication函数。
4，在frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java中
@Override
public boolean attachApplication(WindowProcessController wpc) throws RemoteException {//此处的attachApplication是抽象类ActivityTaskManagerInternal中attachApplication函数的实现
synchronized (mGlobalLockWithoutBoost) {
if (Trace.isTagEnabled(TRACE_TAG_WINDOW_MANAGER)) {
Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, "attachApplication:" + wpc.mName);
}
try {
return mRootWindowContainer.attachApplication(wpc);//调用RootWindowContainer类的attachApplication函数
} finally {
Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);
}
}
}
5，在frameworks/base/services/core/java/com/android/server/wm/RootWindowContainer.java中
boolean attachApplication(WindowProcessController app) throws RemoteException {
try {
return mAttachApplicationHelper.process(app); //执行AttachApplicationHelper类的process函数
} finally {
mAttachApplicationHelper.reset();
}
}
private final AttachApplicationHelper mAttachApplicationHelper = new AttachApplicationHelper();
private class AttachApplicationHelper implements Consumer<Task>, Predicate<ActivityRecord> {
boolean process(WindowProcessController app) throws RemoteException {
mApp = app;
for (int displayNdx = getChildCount() - 1; displayNdx >= 0; --displayNdx) {
getChildAt(displayNdx).forAllRootTasks(this);//对每个根任务调用forAllRootTasks(this),在forAllRootTasks中isRootTask() ? callback.test(this) : false;
if (mRemoteException != null) {
throw mRemoteException;
}
}
if (!mHasActivityStarted) {
ensureActivitiesVisible(null /* starting */, 0 /* configChanges */,
false /* preserveWindows */);
}
return mHasActivityStarted;
}
@Override
public boolean test(ActivityRecord r) {
if (r.finishing || !r.showToCurrentUser() || !r.visibleIgnoringKeyguard
|| r.app != null || mApp.mUid != r.info.applicationInfo.uid
|| !mApp.mName.equals(r.processName)) {
return false;
}
try {
//调用ActivityTaskSupervisor.java类中的realStartActivityLocked
if (mTaskSupervisor.realStartActivityLocked(r, mApp,
mTop == r && r.getTask().canBeResumed(r) /* andResume */,
true /* checkConfig */)) {
mHasActivityStarted = true;
}
} catch (RemoteException e) {
Slog.w(TAG, "Exception in new application when starting activity " + mTop, e);
mRemoteException = e;
return true;
}
return false;
}
}
上面的代码中调用ActivityTaskSupervisor.java类中的realStartActivityLocked函数。
6，在frameworks/base/services/java/com/android/server/wm/ActivityTaskSupervisor.java中
boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc, boolean andResume, boolean checkConfig) throws RemoteException {
// Create activity launch transaction.
final ClientTransaction clientTransaction = ClientTransaction.obtain(proc.getThread(), r.token);//创建ClientTransaction：通过ClientTransaction.obtain方法创建一个ClientTransaction对象，用于封装启动Activity的IPC请求。Activity的token用于唯一标识Activity
// Set desired final state.
final ActivityLifecycleItem lifecycleItem;
if (andResume) { //andResume为传递的参数
lifecycleItem = ResumeActivityItem.obtain(isTransitionForward);
} else {
lifecycleItem = PauseActivityItem.obtain();
}
clientTransaction.setLifecycleStateRequest(lifecycleItem); //通过clientTransaction.setLifecycleStateRequest方法设置Activity的生命周期状态
// Schedule transaction.
mService.getLifecycleManager().scheduleTransaction(clientTransaction); //通过mService.getLifecycleManager().scheduleTransaction(clientTransaction)方法将封装好的ClientTransaction对象调度到目标进程中。这实际上是通过IPC机制，将启动Activity的请求发送到目标进程。
}
7，在frameworks/base/services/core/java/com/android/server/wm/ClientLifecycleManager.java中
void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
final IApplicationThread client = transaction.getClient();
transaction.schedule(); //调用ClientTransaction类的schedule函数
if (!(client instanceof Binder)) {
// If client is not an instance of Binder - it's a remote call and at this point it is
// safe to recycle the object. All objects used for local calls will be recycled after
// the transaction is executed on client in ActivityThread.
transaction.recycle();
}
}
8，在frameworks/base/core/java/android/app/servertransaction/ClientTransaction.java中
public void schedule() throws RemoteException {
mClient.scheduleTransaction(this); //mClient为IApplicationThread对象
}
9, 在frameworks/base/core/java/android/app/ActivityThread.java中
public final class ActivityThread extends ClientTransactionHandler implements ActivityThreadInternal {
@Override
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
ActivityThread.this.scheduleTransaction(transaction); //已有类定义public final class ActivityThread extends ClientTransactionHandler，代码会进一步走到ClientTransactionHandler类的scheduleTransaction
}
}
10，在frameworks/base/core/java/android/app/ClientTransactionHandler.java中
public abstract class ClientTransactionHandler {
/** Prepare and schedule transaction for execution. */
void scheduleTransaction(ClientTransaction transaction) {
transaction.preExecute(this);
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);//在ActivityThread类中定义有class H extends Handler
}
}
11，在frameworks/base/core/java/android/app/ActivityThread.java中
class H extends Handler {
public static final int EXECUTE_TRANSACTION = 159;
public void handleMessage(Message msg) {
if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
switch (msg.what) {
case EXECUTE_TRANSACTION:
final ClientTransaction transaction = (ClientTransaction) msg.obj;
mTransactionExecutor.execute(transaction);//调用 TransactionExecutor 类的execute函数
if (isSystem()) {
// Client transactions inside system process are recycled on the client side
// instead of ClientLifecycleManager to avoid being cleared before this
// message is handled.
transaction.recycle();
}
// TODO(lifecycler): Recycle locally scheduled transactions.
break;
}
}
}
上面的代码调用 TransactionExecutor 类的execute函数。
12，在frameworks/base/core/java/android/app/servertransaction/TransactionExecutor.java中
public void execute(ClientTransaction transaction) {
if (DEBUG_RESOLVER) Slog.d(TAG, tId(transaction) + "Start resolving transaction");
final IBinder token = transaction.getActivityToken();
if (token != null) {
final Map<IBinder, ClientTransactionItem> activitiesToBeDestroyed =
mTransactionHandler.getActivitiesToBeDestroyed();
final ClientTransactionItem destroyItem = activitiesToBeDestroyed.get(token);
if (destroyItem != null) {
if (transaction.getLifecycleStateRequest() == destroyItem) {
// It is going to execute the transaction that will destroy activity with the
// token, so the corresponding to-be-destroyed record can be removed.
activitiesToBeDestroyed.remove(token);
}
if (mTransactionHandler.getActivityClient(token) == null) {
// The activity has not been created but has been requested to destroy, so all
// transactions for the token are just like being cancelled.
Slog.w(TAG, tId(transaction) + "Skip pre-destroyed transaction:\n"
+ transactionToString(transaction, mTransactionHandler));
return;
}
}
}
if (DEBUG_RESOLVER) Slog.d(TAG, transactionToString(transaction, mTransactionHandler));
executeCallbacks(transaction);//调用TransactionExecutor类的executeCallbacks函数
executeLifecycleState(transaction);
mPendingActions.clear();
if (DEBUG_RESOLVER) Slog.d(TAG, tId(transaction) + "End resolving transaction");
}
上面的代码调用TransactionExecutor类的executeCallbacks函数和executeLifecycleState函数。
首先看下executeLifecycleState函数。
/** Transition to the final state if requested by the transaction. */
private void executeLifecycleState(ClientTransaction transaction) {
final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest(); //获取当前事务中的生命周期状态请求
if (lifecycleItem == null) {
// No lifecycle request, return early.
return;
}
final IBinder token = transaction.getActivityToken();//通过transaction.getActivityToken()获取与当前事务相关联的Activity的令牌（IBinder）。这个令牌用于在后续步骤中识别具体的Activity实例
final ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
if (DEBUG_RESOLVER) {
Slog.d(TAG, tId(transaction) + "Resolving lifecycle state: "
+ lifecycleItem + " for activity: "
+ getShortActivityName(token, mTransactionHandler));
}
if (r == null) {
// Ignore requests for non-existent client records for now.
return;
}
// Cycle to the state right before the final requested state.
//通过cycleToPath(r, lifecycleItem.getTargetState(), true, transaction);方法，将Activity的状态变更到最终请求状态之前的状态。
//这里的逻辑是为了确保Activity按照正确的顺序通过生命周期的各个状态，excludeLastState参数为真表示排除最终请求的状态本身，只到达其前一个状态。
cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */, transaction); //调用cycleToPath函数。
// Execute the final transition with proper parameters.
//通过lifecycleItem.execute(mTransactionHandler, token, mPendingActions);执行最终的生命周期转换。这一步会根据lifecycleItem中包含的指令（如启动、暂停、恢复等）来更新Activity的状态。
lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);//通过lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);执行生命周期转换后的后续操作。这可能包括清理资源、更新UI等。
}
下面看下executeCallbacks函数。
/** Cycle through all states requested by callbacks and execute them at proper times. */
@VisibleForTesting
public void executeCallbacks(ClientTransaction transaction) { //由于在ActivityTaskSupervisor.java中，clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent)，此处执行的就是添加的callback
final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
if (callbacks == null || callbacks.isEmpty()) {
// No callbacks to execute, return early.
return;
}
if (DEBUG_RESOLVER) Slog.d(TAG, tId(transaction) + "Resolving callbacks in transaction");
final IBinder token = transaction.getActivityToken();
ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
// In case when post-execution state of the last callback matches the final state requested
// for the activity in this transaction, we won't do the last transition here and do it when
// moving to final state instead (because it may contain additional parameters from server).
final ActivityLifecycleItem finalStateRequest = transaction.getLifecycleStateRequest();
final int finalState = finalStateRequest != null ? finalStateRequest.getTargetState()
: UNDEFINED;
// Index of the last callback that requests some post-execution state.
final int lastCallbackRequestingState = lastCallbackRequestingState(transaction);
final int size = callbacks.size();
for (int i = 0; i < size; ++i) {
final ClientTransactionItem item = callbacks.get(i); //获取到LaunchActivityItem对象,callbacks的内容是在ActivityTaskSupervisor.java中添加的
if (DEBUG_RESOLVER) Slog.d(TAG, tId(transaction) + "Resolving callback: " + item);
final int postExecutionState = item.getPostExecutionState();
final int closestPreExecutionState = mHelper.getClosestPreExecutionState(r,
item.getPostExecutionState());
if (closestPreExecutionState != UNDEFINED) {
cycleToPath(r, closestPreExecutionState, transaction); //调用cycleToPath函数。
}
item.execute(mTransactionHandler, token, mPendingActions);//执行LaunchActivityItem的execute函数
item.postExecute(mTransactionHandler, token, mPendingActions);
if (r == null) {
// Launch activity request will create an activity record.
r = mTransactionHandler.getActivityClient(token);
}
if (postExecutionState != UNDEFINED && r != null) {
// Skip the very last transition and perform it by explicit state request instead.
final boolean shouldExcludeLastTransition =
i == lastCallbackRequestingState && finalState == postExecutionState;
cycleToPath(r, postExecutionState, shouldExcludeLastTransition, transaction); //调用cycleToPath函数。
}
}
}
上面的两个函数都会调用cycleToPath函数，接着看下cycleToPath函数。
private TransactionExecutorHelper mHelper = new TransactionExecutorHelper();
/** Transition the client between states. */
@VisibleForTesting
public void cycleToPath(ActivityClientRecord r, int finish, ClientTransaction transaction) {
cycleToPath(r, finish, false /* excludeLastState */, transaction);
}
/**
* Transition the client between states with an option not to perform the last hop in the
* sequence. This is used when resolving lifecycle state request, when the last transition must
* be performed with some specific parameters.
*/
private void cycleToPath(ActivityClientRecord r, int finish, boolean excludeLastState,
ClientTransaction transaction) {
final int start = r.getLifecycleState();
if (DEBUG_RESOLVER) {
Slog.d(TAG, tId(transaction) + "Cycle activity: "
+ getShortActivityName(r.token, mTransactionHandler)
+ " from: " + getStateName(start) + " to: " + getStateName(finish)
+ " excludeLastState: " + excludeLastState);
}
final IntArray path = mHelper.getLifecyclePath(start, finish, excludeLastState); //调用 getLifecyclePath 函数
performLifecycleSequence(r, path, transaction); //调用 performLifecycleSequence 函数
}
上面的代码调用了 TransactionExecutorHelper类的 getLifecyclePath 函数和 performLifecycleSequence 函数。
首先看下 getLifecyclePath 函数。
14，在frameworks/base/core/java/android/app/servertransaction/TransactionExecutorHelper.java中
//getLifecyclePath返回一个IntArray，这个数组可能代表了Activity生命周期状态的一个序列。方法接收三个参数：start（起始状态），finish（结束状态），以及excludeLastState（是否排除最后一个状态）。
@VisibleForTesting
public IntArray getLifecyclePath(int start, int finish, boolean excludeLastState) {
if (start == UNDEFINED || finish == UNDEFINED) {
throw new IllegalArgumentException("Can't resolve lifecycle path for undefined state");
}
if (start == ON_RESTART || finish == ON_RESTART) { //ON_RESTART状态在生命周期路径中不是有效的起点或终点，因为它是一个中间状态，通常不会直接由外部调用者指定。
throw new IllegalArgumentException(
"Can't start or finish in intermittent RESTART state");
}
if (finish == PRE_ON_CREATE && start != finish) {
throw new IllegalArgumentException("Can only start in pre-onCreate state");
}
mLifecycleSequence.clear(); //清除之前可能存在的生命周期序列
if (finish >= start) { //检查finish状态是否大于或等于start状态。如果是，则按照正常的生命周期顺序添加状态。
if (start == ON_START && finish == ON_STOP) { //处理特殊情况，即从ON_START状态直接转换到ON_STOP状态。在这种情况下，不需要经过ON_RESUME和ON_PAUSE状态，因此直接将ON_STOP状态添加到序列中。
// A case when we from start to stop state soon, we don't need to go
// through the resumed, paused state.
mLifecycleSequence.add(ON_STOP); //对于从ON_START到ON_STOP的转换，由于Activity在ON_STOP时不会经过ON_RESUME和ON_PAUSE，所以直接添加ON_STOP。
} else {
// just go there
for (int i = start + 1; i <= finish; i++) { //通过循环将需要经过的生命周期状态添加到mLifecycleSequence中
mLifecycleSequence.add(i); //对于其他正常的情况（finish大于等于start），通过一个循环将start和finish之间的所有状态（不包括start，但包括finish）添加到序列中。
}
}
} else { // finish < start, can't just cycle down
//处理finish小于start的情况，这通常意味着Activity正在经历某种重启或重新创建的过程。
if (start == ON_PAUSE && finish == ON_RESUME) {
// Special case when we can just directly go to resumed state.
mLifecycleSequence.add(ON_RESUME); //如果需要从ON_PAUSE直接转换到ON_RESUME（这通常不是正常流程，但这里作为特殊情况处理），则直接添加ON_RESUME。
} else if (start <= ON_STOP && finish >= ON_START) { //这通常意味着Activity需要停止、重启，然后达到某个状态。代码首先添加从当前状态到ON_STOP的所有状态，然后添加ON_RESTART，最后添加从ON_START到目标状态的所有状态。
// Restart and go to required state.
// Go to stopped state first.
for (int i = start + 1; i <= ON_STOP; i++) {
mLifecycleSequence.add(i);
}
// Restart
mLifecycleSequence.add(ON_RESTART);
// Go to required state
for (int i = ON_START; i <= finish; i++) {
mLifecycleSequence.add(i);
}
} else { //处理其他所有情况，即start和finish之间的关系不符合上述任何特殊情况。这通常意味着Activity需要完全销毁并重新创建。代码首先添加从当前状态到ON_DESTROY的所有状态，然后添加从ON_CREATE到目标状态的所有状态。
// Relaunch and go to required state
// Go to destroyed state first.
for (int i = start + 1; i <= ON_DESTROY; i++) {
mLifecycleSequence.add(i);
}
// Go to required state
for (int i = ON_CREATE; i <= finish; i++) {
mLifecycleSequence.add(i);
}
}
}
// Remove last transition in case we want to perform it with some specific params.
if (excludeLastState && mLifecycleSequence.size() != 0) {
mLifecycleSequence.remove(mLifecycleSequence.size() - 1);
}
return mLifecycleSequence; //返回构建好的生命周期状态序列
}
下面再看下 performLifecycleSequence 函数。
15，frameworks/base/core/java/android/app/servertransaction/TransactionExecutor.java中
private void performLifecycleSequence(ActivityClientRecord r, IntArray path,
ClientTransaction transaction) {
final int size = path.size();
for (int i = 0, state; i < size; i++) {
state = path.get(i);
if (DEBUG_RESOLVER) {
Slog.d(TAG, tId(transaction) + "Transitioning activity: "
+ getShortActivityName(r.token, mTransactionHandler)
+ " to state: " + getStateName(state));
}
switch (state) {
case ON_CREATE:
mTransactionHandler.handleLaunchActivity(r, mPendingActions,
null /* customIntent */);
break;
case ON_START:
mTransactionHandler.handleStartActivity(r, mPendingActions,
null /* activityOptions */); //ActivityThread 继承自 ClientTransactionHandler, 此处调用会走到ActivityThread的 handleStartActivity 函数。
break;
case ON_RESUME:
mTransactionHandler.handleResumeActivity(r, false /* finalStateRequest */,
r.isForward, "LIFECYCLER_RESUME_ACTIVITY");
break;
case ON_PAUSE:
mTransactionHandler.handlePauseActivity(r, false /* finished */,
false /* userLeaving */, 0 /* configChanges */, mPendingActions,
"LIFECYCLER_PAUSE_ACTIVITY");
break;
case ON_STOP:
mTransactionHandler.handleStopActivity(r, 0 /* configChanges */,
mPendingActions, false /* finalStateRequest */,
"LIFECYCLER_STOP_ACTIVITY");
break;
case ON_DESTROY:
mTransactionHandler.handleDestroyActivity(r, false /* finishing */,
0 /* configChanges */, false /* getNonConfigInstance */,
"performLifecycleSequence. cycling to:" + path.get(size - 1));
break;
case ON_RESTART:
mTransactionHandler.performRestartActivity(r, false /* start */);
break;
default:
throw new IllegalArgumentException("Unexpected lifecycle state: " + state);
}
}
}
上面的代码根据state的不同通过ClientTransactionHandler类型的对象mTransactionHandler分别调用了handleLaunchActivity,handleStartActivity,handleResumeActivity,handlePauseActivity,handleStopActivity,handleDestroyActivity,performRestartActivity等函数。
private ClientTransactionHandler mTransactionHandler;
/** Initialize an instance with transaction handler, that will execute all requested actions. */
public TransactionExecutor(ClientTransactionHandler clientTransactionHandler) {
mTransactionHandler = clientTransactionHandler;
}
上面代码中ClientTransactionHandler为一个抽象类。
16, 在frameworks/base/core/java/android/app/ClientTransactionHandler.java中
public abstract class ClientTransactionHandler {
/** Perform activity start. */
public abstract void handleStartActivity(@NonNull ActivityClientRecord r,
PendingTransactionActions pendingActions, ActivityOptions activityOptions);
public abstract void handleResumeActivity(@NonNull ActivityClientRecord r,
boolean finalStateRequest, boolean isForward, String reason);
...
}
上面的抽象类被ActivityThread类继承，所以handleStartActivity等函数会走到ActivityThread类的相应函数中。
17，在frameworks/base/core/java/android/app/ActivityThread.java中
public void handleStartActivity(ActivityClientRecord r,PendingTransactionActions pendingActions, ActivityOptions activityOptions) {
// Start
activity.performStart("handleStartActivity"); //调用activity.performStart("handleStartActivity")，这是Activity生命周期中onStart方法的实际执行点，传入一个字符串参数用于调试。
r.setState(ON_START); //将ActivityClientRecord的状态更新为ON_START，表示Activity现在处于onStart阶段。
}
public void handleResumeActivity(ActivityClientRecord r, boolean finalStateRequest, boolean isForward, String reason) {
if (!performResumeActivity(r, finalStateRequest, reason)) {
return;
}
}
public boolean performResumeActivity(ActivityClientRecord r, boolean finalStateRequest, String reason) {
r.activity.performResume(r.startsNotResumed, reason); //调用Activity的performResume()方法，传入是否从非恢复状态开始以及恢复的原因。
r.setState(ON_RESUME); //将Activity的状态更新为ON_RESUME，并清除之前可能存在的状态信息。
}
经过上面的步骤就走到了Activity的onStart和onResume等函数中。
