Activity生命周期流程（基于AOSP 13）
Activity生命周期
1、Activity生命周期定义
Activity生命周期管理，在APP侧和AMS侧各有对应的记录实现。
系统端使用ActivityRecord记录与管理应用程序端的Activity，其中mState标记当前Activity的生命周期。
enum State {
INITIALIZING,
STARTED,
RESUMED,
PAUSING,
PAUSED,
STOPPING,
STOPPED,
FINISHING,
DESTROYING,
DESTROYED,
RESTARTING_PROCESS
}
APP侧则使用ActivityClientRecord保存与记录，mLifecycleState标记Activity的生命周期状态，其定义在ActivityLifecycleItem中。
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;
Activity的生命周期：
2、每个生命周期做了什么？
参考链接：
3、应用生命周期管理机制：事务 ClientTransaction
3.1 ClientTransaction相关类说明
ClientTransaction 是包含了一系列要执行的事务项的事务。我们可以通过调用它的 addCallback方法来添加一个事务项，也可以多次调用来添加多个事务项。addCallback 接收的参数类型为 ClientTransactionItem，而这个 ClientTransactionItem 有多个子类。
另外可以通过 ClientTransactionItem 的 setLifecycleStateRequest 方法设置 Activity 执行完后最终的生命周期状态，其参数的类型为 ActivityLifecycleItem。ActivityLifecycleItem 也是继承自 ClientTransactionItem。同时，ActivityLifecycleItem 也有多个子类，它的每个子类都对应了 Activity 的一个生命周期事件。
AMS中可以在完成 callback 与 lifeCycleStateRequest 的设置之后，便通过调用 mService.getLifecycleManager().scheduleTransaction(clientTransaction)方法开启事务项的执行。
public class ClientTransaction implements Parcelable, ObjectPoolItem {
/** A list of individual callbacks to a client. */
@UnsupportedAppUsage
private List<ClientTransactionItem> mActivityCallbacks;
/**
* Final lifecycle state in which the client activity should be after the transaction is
* executed.
*/
private ActivityLifecycleItem mLifecycleStateRequest;
/** Target client. */
private IApplicationThread mClient;
/** Target client activity. Might be null if the entire transaction is targeting an app. */
private IBinder mActivityToken;
/** Get the target client of the transaction. */
public IApplicationThread getClient() {
return mClient;
}
ClientTransactionItem 有多个实现类，这些实现类对应了 Activity 中不同的执行流程。
例如：在 Activity 启动时如果不需要重新创建 Activity ，则会通过
addCallback添加了一个NewIntentItem来执行 Activity 的onNewIntennt方法。而当需要重新创建 Activity 时，则传入的是一个LaunchActivityItem，用来创建并启动Activity。
ClientTransactionItem 的所有子类或相关类均在 frameworks/base/core/java/android/app/servertransaction/ 目录下。 ActivityLifecycleItem 继承自 ClientTransactionItem ，且其子类均为 Activity 生命周相关的实现，例如，StartActivityItem、ResumeActivityItem、DestroyActivityItem 等。这里将 Activity 的生命周期以及其它相关方法以面向对象的思想封装成了一个个的对象来执行。
3.2 服务端发起事务
getLifecycleManager 返回了一个 ClientLifecycleManager 的实例
// frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
private final ClientLifecycleManager mLifecycleManager;
ClientLifecycleManager getLifecycleManager() {
return mLifecycleManager;
}
scheduleTransaction 方法核心代码是调用了 ClientTransaction 的 schedule 方法
// frameworks/base/services/core/java/com/android/server/wm/ClientLifecycleManager.java
void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
final IApplicationThread client = transaction.getClient();
transaction.schedule();
// ...
}
在 schedule 方法中通过mClient调用了scheduleTransaction， 这里的mClient即为 IApplicationThread，即调用到客户端scheduleTransaction方法。
// frameworks/base/core/java/android/app/servertransaction/ClientTransaction.java
private IApplicationThread mClient;
/**
* Schedule the transaction after it was initialized. It will be send to client and all its
* individual parts will be applied in the following sequence:
* 1. The client calls {@link #preExecute(ClientTransactionHandler)}, which triggers all work
* that needs to be done before actually scheduling the transaction for callbacks and
* lifecycle state request.
* 2. The transaction message is scheduled.
* 3. The client calls {@link TransactionExecutor#execute(ClientTransaction)}, which executes
* all callbacks and necessary lifecycle transitions.
*/
public void schedule() throws RemoteException {
mClient.scheduleTransaction(this);
}
3.3 客户端执行事务
来看 ApplicationThread 中 scheduleTransaction 方法的实现
// frameworks/base/core/java/android/app/ActivityThread#ApplicationThread
@Override
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
ActivityThread.this.scheduleTransaction(transaction);
}
这个方法中又调用了 ActivityThread 的 scheduleTransaction 。而 scheduleTransaction 的源码在ActivityThread 的父类 ClientTransactionHandler 中，这里将 transaction 作为参数调用了 sendMessage 方法。最终将 ClientTransaction 与 EXECUTE_TRANSACTION 打包成一个 Message ,并且将这个 Message 设置成了异步消息，最终通过 mH 发送了出去，这里的 mH 是一个继承自 Handler 的 H 类，位于 ActivityThread 类的内部。
// frameworks/base/core/java/android/app/ClientTransactionHandler.java
void scheduleTransaction(ClientTransaction transaction) {
transaction.preExecute(this);
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
注意点：Message 被设置为异步消息后具有优先执行权，因为 Activity 的启动涉及到 Activity 的创建以及生命周期的调用，所有这里发送出来的 Message 不应该被其他 Message 阻塞，不然肯定会影响到 Activity 的启动，造成卡顿问题。
H 内部处理，搜索 EXECUTE_TRANSACTION 可以看到如下代码：
// frameworks/base/core/java/android/app/ActivityThread#H
public void handleMessage(Message msg) {
switch (msg.what) {
case EXECUTE_TRANSACTION:
final ClientTransaction transaction = (ClientTransaction) msg.obj;
mTransactionExecutor.execute(transaction);
// ...
break;
}
}
这里的代码很简单，通过 Message 拿到 ClientTransaction 后，然后通过 TransactionExecutor 的 execute 方法来执行 ClientTransaction。看一下 TransactionExecutor 中 execute 源码：
// frameworks/base/core/java/android/app/servertransaction/TransactionExecutor.java
public void execute(ClientTransaction transaction) {
// ...
// 执行 callback
executeCallbacks(transaction);
// 执行 lifecycleState
executeLifecycleState(transaction);
mPendingActions.clear();
}
这个方法里的执行逻辑可以分为两部分：
- 通过 executeCallbacks 方法执行所有被添加进来的 ClientTransactionItem
- 通过 executeLifecycleState 方法将 Activity 的生命周期执行到指定的状态
3.3.1 执行回调：executeCallbacks()
executeCallbacks 方法中的逻辑比较简单
public void executeCallbacks(ClientTransaction transaction) {
// ...
final int size = callbacks.size();
for (int i = 0; i < size; ++i) {
// ...
final ClientTransactionItem item = callbacks.get(i);
item.execute(mTransactionHandler, token, mPendingActions);
// ...
cycleToPath(r, postExecutionState, shouldExcludeLastTransition, transaction);
}
}
}
在 executeCallbacks 中遍历了所有的 ClientTransactionItem 并执行了 ClientTransactionItem 的 execute 方法。
3.3.2 执行生命周期：executeLifecycleState()
executeLifecycleState中会将 Activity 执行到指定的生命周期状态。
private void executeLifecycleState(ClientTransaction transaction) {
final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
// ...
// 第二个参数为执行完时的生命周状态
cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */, transaction);
// Execute the final transition with proper parameters.
lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
}
这段代码的关键点在于 cycleToPath 。同时，通过 lifecycleItem.getTargetState() 作为结束时的生命周期状态。例如在Activity启动时并且Activity是需要新创建的，setLifecycleStateRequest 设置的是一个 ResumeActivityItem，它的 getTargetState 返回的是一个ON_RESUME，如第一节所定义，代码如下:
// frameworks/base/core/java/android/app/servertransaction/ResumeActivityItem.java
@Override
public int getTargetState() {
return ON_RESUME;
}
@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;
可以看到 ON_RESUME 的值为 3。接着来看 cycleToPath 源码：
private void cycleToPath(ActivityClientRecord r, int finish, boolean excludeLastState,
ClientTransaction transaction) {
// 获取当前 Activity 的生命周期状态，即开始时的状态
final int start = r.getLifecycleState();
// 获取要执行的生命周期数组
final IntArray path = mHelper.getLifecyclePath(start, finish, excludeLastState);
// 按顺序执行 Activity 的生命周期
performLifecycleSequence(r, path, transaction);
}
在这个方法中，首先获取了当前 Activity 生命周期状态，即开始执行 getLifecyclePath 时 Activity 的生命周期状态。之后通过当前生命周期状态和目标生命周期状态，填充中间缺失的状态。最后再按顺序依次执行所有生命周期。下面看下在getLifecyclePath怎么补齐中间状态。
// frameworks/base/core/java/android/app/servertransaction/TransactionExecutorHelper.java
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) {
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();
// 以Activity 启动举例：执行到这里的 start 状态为 ON_CREATE，结束状态为 ON_RESUME
if (finish >= start) {
if (start == ON_START && finish == 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);
} else {
// 会走到这里的逻辑，将 ON_START 与 ON_RESUME 添加到数组
for (int i = start + 1; i <= finish; i++) {
mLifecycleSequence.add(i);
}
}
} else { // finish < start, can't just cycle down
if (start == ON_PAUSE && finish == ON_RESUME) {
// Special case when we can just directly go to resumed state.
mLifecycleSequence.add(ON_RESUME);
} else if (start <= ON_STOP && finish >= 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 {
// 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;
}
重点在于，getLifecyclePath 中会根据当前状态和目标状态，补全其中剩余的状态，例如应用启动中，start 为 ON_CREATE（值为 1），而 finish 的值为 ON_RESUME(值为 2)。因此，执行完 getLifecyclePath 后，会得到一个包含了 ON_START 与 ON_RESUME 的数组。接下来执行performLifecycleSequence 中的代码。
/** Transition the client through previously initialized state sequence. */
private void performLifecycleSequence(ActivityClientRecord r, IntArray path,
ClientTransaction transaction) {
final int size = path.size();
// 遍历数组，执行 Activity 的生命周
for (int i = 0, state; i < size; i++) {
state = path.get(i);
switch (state) {
case ON_CREATE:
mTransactionHandler.handleLaunchActivity(r, mPendingActions,
null /* customIntent */);
break;
case ON_START:
mTransactionHandler.handleStartActivity(r, mPendingActions,
null /* activityOptions */);
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 */,
false /* autoEnteringPip */, 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);
}
}
}
在 performLifecycleSequence 方法中则是遍历了这个path数组，按顺序执行对应的生命周期业务逻辑。
4、应用侧Activity状态同步AMS
4.1 ActivityClientController 相关类
AMS 中 ActivityClientController 继承自aidl接口IActivityClientController.Stub，是IActivityClientController的具体实现，通过binder与应用侧 ActivityClient 进行通信。在ActivityClient到ActivityClientController的通路上定义了Activity生命周期回调到AMS的各种接口。
4.2 同步生命周期到服务侧
在生命周期事务执行到 executeLifecycleState() 切换生命周期中，在执行ActivityLifecycleItem的execute()中将应用侧生命周期切换到目标值后，会调用ActivityLifecycleItem的postExecute()，会将生命周期同步到AMS侧。
private void executeLifecycleState(ClientTransaction transaction) {
final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
// ...
// 第二个参数为执行完时的生命周状态
cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */, transaction);
// Execute the final transition with proper parameters.
lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
}
例如在PauseActivityItem.postExecute()中，就是通过ActivityClient告知AMS对应Activity的生命周期变化。
public void postExecute(ClientTransactionHandler client, IBinder token,
PendingTransactionActions pendingActions) {
if (mDontReport) {
return;
}
// TODO(lifecycler): Use interface callback instead of actual implementation.
ActivityClient.getInstance().activityPaused(token);
}
ActivityClient内就是通过getActivityClientController() 获取ActivityClientController的binder对象，binder调用到ActivityClientController.activityPaused()
//frameworks\base\core\java\android\app\ActivityClient.java
public void activityPaused(IBinder token) {
try {
getActivityClientController().activityPaused(token);
} catch (RemoteException e) {
e.rethrowFromSystemServer();
}
}
ActivityClientController中就是调用ActivityRecord的activityPaused()方法，其他的状态同步也是类似的情况
//frameworks\base\services\core\java\com\android\server\wm\ActivityClientController.java
public void activityPaused(IBinder token) {
final long origId = Binder.clearCallingIdentity();
synchronized (mGlobalLock) {
Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, "activityPaused");
final ActivityRecord r = ActivityRecord.forTokenLocked(token);
if (r != null) {
r.activityPaused(false);
}
Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);
}
Binder.restoreCallingIdentity(origId);
}
