Activity生命周期
由系统端ActivityRecord生命周期管理应用程序端的Activity生命周期。
enum ActivityState {
INITIALIZING,
STARTED,
RESUMED,
PAUSING,
PAUSED,
STOPPING,
STOPPED,
FINISHING,
DESTROYING,
DESTROYED,
RESTARTING_PROCESS
}
下图是系统端和应用程序端，Activity生命周期管理函数调用的逻辑示意图
image-20210711083436287.png
public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
public class ActivityTaskSupervisor implements RecentTasks.Callbacks {
realStartActivityLocked
realStartActivityLocked是启动Activity的入口函数。ClientTransaction，与Client的会话
proc.getThread()，即IApplicationThread 应用程序与服务端通信的线程，binder代理保存在服务端
r.appToken，即Token extends IApplicationToken.Stub，标识一个Activity窗口，binder代理保存在wm、am和客户端
// Create activity launch transaction.
final ClientTransaction clientTransaction = ClientTransaction.obtain(
proc.getThread(), r.appToken);
ActivityRecord
是客户端activity在服务端的实例代表，同时也是一个窗口令牌
/**
* An entry in the history stack, representing an activity.
*/
final class ActivityRecord extends WindowToken implements WindowManagerService.AppFreezeListener {
// Non-null only for application tokens.
// TODO: rename to mActivityToken
final ActivityRecord.Token appToken;
static class Token extends IApplicationToken.Stub {
private WeakReference weakActivity;
private final String name;
private final String tokenString;
// 对显示组件（客户端）而言，Token，是任意一个Binder的实例，
// 对显示组件（客户端）来说仅仅是一个创建窗口的令牌，没有其他的含义。
ActivityRecord初始化时赋值。
super(_service.mWindowManager, new Token(_intent).asBinder(), TYPE_APPLICATION,
mAtmService = _service;
appToken = (Token) token;
addCallback，先执行launch Activity，这是一个暂态
r.appToken 通过LaunchActivityItem从wm传递到应用端
clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
最终Activity生命周期状态：如果是resume状态，则ResumeActivityItem。不是，则PauseActivityItem，从create状态进入到pause状态
// Set desired final state.
final ActivityLifecycleItem lifecycleItem;
if (andResume) {
lifecycleItem = ResumeActivityItem.obtain(dc.isNextTransitionForward());
} else {
lifecycleItem = PauseActivityItem.obtain();
}
clientTransaction.setLifecycleStateRequest(lifecycleItem);
// Schedule transaction.
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
ClientLifecycleManager
服务端对Activity生命周期的事件转发管理类，通过IApplicationThread与应用程序的主线程对象ActivityThread通信
class ClientLifecycleManager {
* @see ClientTransaction
*/
void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
final IApplicationThread client = transaction.getClient();
transaction.schedule();
ClientTransaction
服务端与客户端的会话，对IApplicationThread的包装。封装callback和LifecycleStateRequest两个状态回调
public class ClientTransaction implements Parcelable, ObjectPoolItem {
/** A list of individual callbacks to a client. */
@UnsupportedAppUsage
private List 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;
}
- preExecute
- transaction message is scheduled
- execute 先callback再LifecycleStateRequest
- postExecute 报告状态给服务端
/**
* 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);
}
ActivityThread
应用程序主线程对象，执行服务端的管理请求
ApplicationThread 匿名服务，接收服务端的管理请求，并将消息通过Handler转发到应用程序主线程处理
/**
* This manages the execution of the main thread in an
* application process, scheduling and executing activities,
* broadcasts, and other operations on it as the activity
* manager requests.
*
* {@hide}
*/
public final class ActivityThread extends ClientTransactionHandler {
// An executor that performs multi-step transactions.
private final TransactionExecutor mTransactionExecutor = new TransactionExecutor(this);
private class ApplicationThread extends IApplicationThread.Stub {
ApplicationThread接收到服务端的会话，调用ActivityThread父类的scheduleTransaction
@Override
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
ActivityThread.this.scheduleTransaction(transaction);
}
ClientTransactionHandler
scheduleTransaction 和 executeTransaction都是调用到TransactionExecutor
/**
* Defines operations that a {@link android.app.servertransaction.ClientTransaction} or its items
* can perform on client.
* @hide
*/
public abstract class ClientTransactionHandler {
/** Prepare and schedule transaction for execution. */
void scheduleTransaction(ClientTransaction transaction) {
transaction.preExecute(this);
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
public void executeTransaction(ClientTransaction transaction) {
transaction.preExecute(this);
getTransactionExecutor().execute(transaction);
}
ApplicationThread转发消息到主线程
case EXECUTE_TRANSACTION:
final ClientTransaction transaction = (ClientTransaction) msg.obj;
mTransactionExecutor.execute(transaction);
TransactionExecutor
/**
* Class that manages transaction execution in the correct order.
* @hide
*/
public class TransactionExecutor {
* Resolve transaction.
* First all callbacks will be executed in the order they appear in the list. If a callback
* requires a certain pre- or post-execution state, the client will be transitioned accordingly.
* Then the client will cycle to the final lifecycle state if provided. Otherwise, it will
* either remain in the initial state, or last state needed by a callback.
*/
public void execute(ClientTransaction transaction) {
executeCallbacks(transaction);
executeLifecycleState(transaction);
}
/** Transition to the final state if requested by the transaction. */
private void executeLifecycleState(ClientTransaction transaction) {
final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
final IBinder token = transaction.getActivityToken();
final ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
// Execute the final transition with proper parameters.
lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
}
execute会在主线程执行相应的回调，一直到Activity对应的生命周期回调
postExecute将client端activity状态报告给server,封装相应的方法。S上是ActivityClientController,负责与服务端通信
/**
* Request to move an activity to resumed state.
* @hide
*/
public class ResumeActivityItem extends ActivityLifecycleItem {
@Override
public void execute(ClientTransactionHandler client, IBinder token,
PendingTransactionActions pendingActions) {
client.handleResumeActivity(token, true /* finalStateRequest */, mIsForward,
"RESUME_ACTIVITY");
}
@Override
public void postExecute(ClientTransactionHandler client, IBinder token,
PendingTransactionActions pendingActions) {
try {
// TODO(lifecycler): Use interface callback instead of AMS.
ActivityTaskManager.getService().activityResumed(token);
}
调用activity的attch方法将token传递给activity
这样token就保存在ams，wms和app中
Activity中Token主要用于在请求AMS服务时用于定位到具体到AMS中正确的ActivityRecord
public class LaunchActivityItem extends ClientTransactionItem {
@Override
public void execute(ClientTransactionHandler client, IBinder token,
PendingTransactionActions pendingActions) {
ActivityClientRecord r = new ActivityClientRecord(token, mIntent, mIdent, mInfo,
mOverrideConfig, mCompatInfo, mReferrer, mVoiceInteractor, mState, mPersistentState,
mPendingResults, mPendingNewIntents, mIsForward,
mProfilerInfo, client, mAssistToken, mFixedRotationAdjustments);
client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
以ResumeActivityItem为例
ActivityTask的resumeTopActivityInnerLocked是系统切换Activity的入口
启动与应用线程的scheduleTransaction
ActivityTask
final ClientTransaction transaction =
ClientTransaction.obtain(next.app.getThread(), next.appToken);
// Well the app will no longer be stopped.
// Clear app token stopped state in window manager if needed.
next.notifyAppResumed(next.stopped);
EventLogTags.writeWmResumeActivity(next.mUserId, System.identityHashCode(next),
next.getTask().mTaskId, next.shortComponentName);
transaction.setLifecycleStateRequest(
ResumeActivityItem.obtain(next.app.getReportedProcState(),
dc.isNextTransitionForward()));
mAtmService.getLifecycleManager().scheduleTransaction(transaction);
ActivityThread
/** Prepare and schedule transaction for execution. */
void scheduleTransaction(ClientTransaction transaction) {
transaction.preExecute(this);
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
TransactionExecutor
TransactionExecutor
executeCallbacks(transaction);
executeLifecycleState(transaction);
// Execute the final transition with proper parameters.
lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
ResumeActivityItem
public class ResumeActivityItem extends ActivityLifecycleItem {
@Override
public void execute(ClientTransactionHandler client, IBinder token,
PendingTransactionActions pendingActions) {
client.handleResumeActivity(token, true /* finalStateRequest */, mIsForward, "RESUME_ACTIVITY");
}
@Override
public void postExecute(ClientTransactionHandler client, IBinder token,
PendingTransactionActions pendingActions) {
try {
ActivityClient.getInstance().activityResumed(token);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
执行onResume的流程
handleResumeActivity
performResumeActivity
reportTopResumedActivityChanged
r.activity.performResume
// mResumed is set by the instrumentation
mInstrumentation.callActivityOnResume(this);// Instrumentation隔离Activity
activity.onResume();
postExecute响应系统进程的请求
ActivityClient.getInstance().activityResumed(token);
ActivityRecord
ActivityRecord.activityResumedLocked(token);// notifyAppResumedFinished
以ResumeActivityItem为例
startPausingLocked是系统将Activity的onPausede入口
将现在处于resumed状态的Activity切换到pausing状态
ActivityRecord prev = mResumedActivity;
mPausingActivity = prev;
mLastPausedActivity = prev;
prev.setState(PAUSING, "startPausingLocked");
pauseImmediately变量代表是否立即进入completePauseLocked，不用等待应用程序完成onPause，再通知系统
// If the caller said they don't want to wait for the pause, then complete the pause now.
if (prev.attachedToProcess()) {//当前Activity是有进程的
try {
EventLogTags.writeWmPauseActivity(prev.mUserId, System.identityHashCode(prev),
prev.shortComponentName, "userLeaving=" + userLeaving);
mAtmService.getLifecycleManager().scheduleTransaction(prev.app.getThread(),
prev.appToken, PauseActivityItem.obtain(prev.finishing, userLeaving,
prev.configChangeFlags, pauseImmediately));
if (pauseImmediately) {
// If the caller said they don't want to wait for the pause, then complete
// the pause now.
completePauseLocked(false, resuming);
return false;
} else {
prev.schedulePauseTimeout();//系统端对应用程序的onPause设置了一个定时器：预防client调用超时
/*mAtmService.mH.postDelayed(mPauseTimeoutRunnable, PAUSE_TIMEOUT);*/
return true;
}
PauseActivityItem
public class PauseActivityItem extends ActivityLifecycleItem {
@Override
public void execute(ClientTransactionHandler client, IBinder token, PendingTransactionActions pendingActions) {
client.handlePauseActivity(token, mFinished, mUserLeaving, mConfigChanges, pendingActions, "PAUSE_ACTIVITY_ITEM");
}
@Override
public void postExecute(ClientTransactionHandler client, IBinder token, PendingTransactionActions pendingActions) {
if (mDontReport) { 即系统端的pauseImmediately
return;
}
try {
// TODO(lifecycler): Use interface callback instead of AMS.
ActivityClient.getInstance().activityPaused(token);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
ActivityThread
handlePauseActivity
performPauseActivity
performPauseActivityIfNeeded
reportTopResumedActivityChanged
mInstrumentation.callActivityOnPause(r.activity);
activity.performPause()
onPause();
EventLogTags.writeWmOnPausedCalled(mIdent, getComponentName().getClassName(), "performPause");
postExecute 响应系统进程的请求
ActivityClient.getInstance().activityPaused(token);
ActivityRecord
final ActivityRecord r = ActivityRecord.forTokenLocked(token);
if (r != null) {
r.activityPaused(false);
}
通过响应系统进程请求，可知应用程序处理onPause状态并没有超时，移出定时器removePauseTimeout()
void activityPaused(boolean timeout) {
final ActivityStack stack = getStack();
if (stack != null) {
removePauseTimeout(); // mAtmService.mH.removeCallbacks(mPauseTimeoutRunnable);
if (stack.mPausingActivity == this) { 之前ing的Activity的，正是当前回调回来的Activity
mAtmService.deferWindowLayout();//暂停布局
try { //进一步完成onPause之后的处理
stack.completePauseLocked(true /* resumeNext */, null /* resumingActivity */);
} finally {
mAtmService.continueWindowLayout();//继续布局
}
return;
}
ActivityTask
makeFinishingLocked表示当前ActivityRecord需要销毁掉
void makeFinishingLocked() {
if (finishing) {
return;
}
finishing = true;
if (stopped) {
clearOptionsLocked();
}
}
completePauseLocked执行完这个函数后，mPausingActivity = null
void completePauseLocked(boolean resumeNext, ActivityRecord resuming) {
ActivityRecord prev = mPausingActivity;
if (prev != null) {
final boolean wasStopping = prev.isState(STOPPING);
prev.setState(PAUSED, "completePausedLocked"); //设置状态为ed。Activity在系统端进入Paused状态，可能需要将其加入stopping列表
if (prev.finishing) {//如果activity已经要finishing,直接调用completeFinishing
prev = prev.completeFinishing("completePausedLocked");
}
// If we were visible then resumeTopActivities will release resources before
// stopping.
prev.addToStopping(true /* scheduleIdle */, false /* idleDelayed */, "completePauseLocked");
mPausingActivity = null;
//这时，继续Activity 切换，启动下一个Activity
if (resumeNext) {//寻找焦点task，将其队头Activity设置为resume状态