ActivityManagerService启动activity流程简析（二）

Task.java

private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {       ...         // 1.获取栈顶的activity         ActivityRecord next = topRunningActivity(true /* focusableOnly */);       ...         //确保启动该activity的用户存在         if (!mAtmService.mAmInternal.hasStartedUserState(next.mUserId)) {             Slog.w(TAG, "Skipping resume of top activity " + next                     + ": user " + next.mUserId + " is stopped");             return false;         }       ...         //暂停当前运行的activity         boolean pausing = taskDisplayArea.pauseBackStacks(userLeaving, next);         if (mResumedActivity != null) {             if (DEBUG_STATES) Slog.d(TAG_STATES,                     "resumeTopActivityLocked: Pausing " + mResumedActivity);            //暂停栈顶已激活的activity             pausing |= startPausingLocked(userLeaving, false /* uiSleeping */, next);         }         if (pausing) {             if (DEBUG_SWITCH || DEBUG_STATES) Slog.v(TAG_STATES,                     "resumeTopActivityLocked: Skip resume: need to start pausing");                ...             if (next.attachedToProcess()) {                ...                 //启动目标Activity                 mAtmService.getAppWarningsLocked().onResumeActivity(next);                 next.app.setPendingUiCleanAndForceProcessStateUpTo(mAtmService.mTopProcessState);                 next.abortAndClearOptionsAnimation();                 transaction.setLifecycleStateRequest(                         ResumeActivityItem.obtain(next.app.getReportedProcState(),                                 dc.isNextTransitionForward()));                 mAtmService.getLifecycleManager().scheduleTransaction(transaction)                ...         } else {             // 进程无关联，需要启动目标activity所在进程             if (!next.hasBeenLaunched) {                 next.hasBeenLaunched = true;             } else {                 if (SHOW_APP_STARTING_PREVIEW) {                     next.showStartingWindow(null /* prev */, false /* newTask */,                             false /* taskSwich */);                 }                 if (DEBUG_SWITCH) Slog.v(TAG_SWITCH, "Restarting: " + next);             }             if (DEBUG_STATES) Slog.d(TAG_STATES, "resumeTopActivityLocked: Restarting " + next);             mStackSupervisor.startSpecificActivity(next, true, true);         }         return true;     }

获取栈顶已激活的activity进行暂停。

final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping,             ActivityRecord resuming) {        ...         //获取栈顶已激活的activity         ActivityRecord prev = mResumedActivity;         ...         if (prev.attachedToProcess()) {             if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Enqueueing pending pause: " + prev);             try {                 EventLogTags.writeWmPauseActivity(prev.mUserId, System.identityHashCode(prev),                         prev.shortComponentName, "userLeaving=" + userLeaving);                ...               //通过Binder机制向应用进程发送消息                 mAtmService.getLifecycleManager().scheduleTransaction(prev.app.getThread(),                         prev.appToken, PauseActivityItem.obtain(prev.finishing, userLeaving,                                 prev.configChangeFlags, pauseImmediately));             } catch (Exception e) {                 Slog.w(TAG, "Exception thrown during pause", e);                 mPausingActivity = null;                 mLastPausedActivity = null;                 mLastNoHistoryActivity = null;             }         } else {             mPausingActivity = null;             mLastPausedActivity = null;             mLastNoHistoryActivity = null;         }        ...     }

如果栈顶已激活activity的进程存在，开始执行状态转换。

ClientLifecycleManager.java。

void scheduleTransaction(@NonNull IApplicationThread client, @NonNull IBinder activityToken,             @NonNull ActivityLifecycleItem stateRequest) throws RemoteException {        //获取ActivityThread代理         final ClientTransaction clientTransaction = transactionWithState(client, activityToken,                 stateRequest);         scheduleTransaction(clientTransaction);     }

获取activityThread代理。

void scheduleTransaction(ClientTransaction transaction) throws RemoteException {         final IApplicationThread client = transaction.getClient();         transaction.schedule();         if (!(client instanceof Binder)) {             // 如果client不是Binder实例，则进行回收，在ActivityThread中执行             transaction.recycle();         }     }

ClientTransaction.java.

public void schedule() throws RemoteException {        mClient.scheduleTransaction(this);     }

按以下顺序安排事务：

1.主线程调用preExecute，触发所有需要在真正调度事务前执行完毕的工作。
2.发送事务的message到主线程。
3.主线程调用TransactionExecutor.execute，执行所有回调以及必要的生命周期事务。

mClient是ActivityThread的Binder对象，ActivityThread继承ClientTransactionHandler。

ClientTransactionHandler.java

void scheduleTransaction(ClientTransaction transaction) {         transaction.preExecute(this);         sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);    }

ActivityThread接收到消息后，会调用TransactionExecutor.execute执行生命周期转换。

TransactionExecutor.java

public void execute(ClientTransaction transaction) {      ...         executeCallbacks(transaction);         executeLifecycleState(transaction);         mPendingActions.clear();     }

检查目标状态并执行。

private void executeLifecycleState(ClientTransaction transaction) {         final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();         if (lifecycleItem == null) {             return;         }         final IBinder token = transaction.getActivityToken();         final ActivityClientRecord r = mTransactionHandler.getActivityClient(token);         if (DEBUG_RESOLVER) {             Slog.d(TAG, tId(transaction) + "Resolving lifecycle state: "                     + lifecycleItem + " for activity: "