「安卓framework基础篇9」从WMS到BufferQueue第三篇 - Activity生命周期回调方法的执行原理-TransactionSchedule(基于AOSP13)
上篇我们分析了系统桌面启动时，创建ActivityRecord并挂载到WMS层级树上的过程，本篇咱们先不继续往下分析，我们先了解一下TransactionSchedule这个机制，因为AMS进程调用APP进程执行声明周期回调方法就是用TransactionSchedule机制实现的，是在binder调用基础上又进行了一次封装，先弄懂这个才能继续往下学习Activity生命周期回调方法的执行过程。
以后台app重新进入前台为例分析TransactionSchedule的运行过程
后台app进入前台过程中，会调到ActivityTaskSupervisor.java 的 schedulePauseActivity方法：
void schedulePauseActivity(ActivityRecord prev, boolean userLeaving, boolean pauseImmediately, String reason) { // 省略 try { // 省略 // 这里开始构造Transaction的请求内容，这里设置了PauseActivityItem这个类作为当前Activity的目标状态 mAtmService.getLifecycleManager().scheduleTransaction(prev.app.getThread(), prev.token, PauseActivityItem.obtain(prev.finishing, userLeaving, prev.configChangeFlags, pauseImmediately)); } // 省略 }
经过aidl调用后，会调到APP进程的ClientTransactionHandler.java的scheduleTransaction方法：
void scheduleTransaction(ClientTransaction transaction) { transaction.preExecute(this); // 将消息发送给app进程的主线程用ActivityThread.java类的handleMessage方法来处理消息 sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction); }
ActivityThread.java类的handleMessage方法：
public void handleMessage(Message msg) { // 省略 switch (msg.what) { // 省略 case EXECUTE_TRANSACTION: final ClientTransaction transaction = (ClientTransaction) msg.obj; // 开始处理消息 mTransactionExecutor.execute(transaction); // 省略 } }
最终会TransactionExecutor的cycleToPath方法：
private void cycleToPath(ActivityClientRecord r, int finish, boolean excludeLastState, ClientTransaction transaction) { // 省略 // 核心方法，根据Activity的当前生命周期和目标生命周期，计算要执行当前生命周期和目标生命周期之间的哪些生命周期回调方法 final IntArray path = mHelper.getLifecyclePath(start, finish, excludeLastState); // 省略 }
下面这个方法是核心中的核心，用于计算从目前的生命周期到目标生命周期中间还要经过哪些生命周期
TransactionExecutorHelper 的 getLifecyclePath方法：
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(); 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 { // just go there 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; }
生命周期枚举值：
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;
以从onStop - 3 到 onResume - 4 为例（后台app重新回到前台）：
public IntArray getLifecyclePath(int start, int finish, boolean excludeLastState) { // 省略 mLifecycleSequence.clear(); if (finish >= start) { // 省略 } else { // finish < start, can't just cycle down if (start == ON_PAUSE && finish == ON_RESUME) { // 省略 // 当前命中的是这个分支 } else if (start <= ON_STOP && finish >= ON_START) { // 将开始状态与结束状态间的所有声明周期加入集合 for (int i = start + 1; i <= ON_STOP; i++) { mLifecycleSequence.add(i); } // 将onRestart生命周期加入集合 mLifecycleSequence.add(ON_RESTART); // 将ON_START生命周期与目标生命周期间的生命周期加入集合 for (int i = ON_START; i <= finish; i++) { mLifecycleSequence.add(i); } } else { // 省略 } } } // 移除最后一个生命周期，因为最后一个生命周期要由对应的ActivityLifecycleItem对象来执行 if (excludeLastState && mLifecycleSequence.size() != 0) { mLifecycleSequence.remove(mLifecycleSequence.size() - 1); } return mLifecycleSequence; }
TransactionExecutor 的 performLifecycleSequence方法：
privatevoidperformLifecycleSequence(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 */); 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); } } }
以从onStop - 3 到 onResume - 4 为例，上面的方法会执行 ON_RESTART 和 ON_START 这两个生命周期。
执行完以上中间的声明周期后，最后会执行目标生命周期：ActivityLifecycleItem对象的 execute 方法。
总结一下，从以上的分析中可以看出，变更生命周期时，AOSP只定义了目标生命周期的ActivityLifecycleItem对象，将ActivityLifecycleItem对象交给服务端的TransactionExecutor.java后，由TransactionExecutor.java计算出当前所处生命周期与目标生命周期中间所有需要执行的生命周期方法，执行完中间的所有周期方法后最后才会执行目标生命周期方法。
