【Android 源码分析】Activity生命周期之onDestroy

忽然有一天，我想要做一件事：去代码中去验证那些曾经被“灌输”的理论。

– 服装学院的IT男

本篇已收录于Activity短暂的一生系列
欢迎一起学习讨论Android应用开发或者WMS
V：WJB6995
Q：707409815

正文

生命周期系列：

Activity生命周期之onPause
onCreate,onStart,onResume-1
onCreate,onStart,onResume-2
Activity生命周期之onStop-1
Activity生命周期之onStop-2
Activity生命周期之onDestory

生命周期分析系列剩下最后一个 onDestroy 了，但是之前分析的桌面冷启动案例没有 onDestroy 这一步，所以写了个App, 有2个 Activity ，操作为：
MainActivity 启动 MainActivity2 ，然后按back键，这样就会触发 MainActivity2 的 onDestroy。

对应的Events日志如下:

// MainActivity2 触发 finish （writeWmFinishActivity）
04-02 19:11:46.665 13550 18317 I wm_finish_activity: [0,105165904,12,com.example.myapplication/.MainActivity2,app-request]
//  MainActivity2 触发 pause
04-02 19:11:46.671 13550 18317 I wm_pause_activity: [0,105165904,com.example.myapplication/.MainActivity2,userLeaving=false,finish]
//  MainActivity2 应用端执行生命周期onPause
04-02 19:11:46.680 19818 19818 I wm_on_paused_called: [105165904,com.example.myapplication.MainActivity2,performPause]
//  MainActivity2 添加到stop计划
04-02 19:11:46.681 13550 18317 I wm_add_to_stopping: [0,105165904,com.example.myapplication/.MainActivity2,completeFinishing]
04-02 19:11:46.687 13550 18317 I wm_set_resumed_activity: [0,com.example.myapplication/.MainActivity,resumeTopActivity]
04-02 19:11:46.700 13550 18317 I wm_resume_activity: [0,183091121,12,com.example.myapplication/.MainActivity]
04-02 19:11:46.713 19818 19818 I wm_on_restart_called: [183091121,com.example.myapplication.MainActivity,performRestartActivity]
04-02 19:11:46.714 19818 19818 I wm_on_start_called: [183091121,com.example.myapplication.MainActivity,handleStartActivity]
04-02 19:11:46.715 19818 19818 I wm_on_resume_called: [183091121,com.example.myapplication.MainActivity,RESUME_ACTIVITY]
04-02 19:11:46.715 19818 19818 I wm_on_top_resumed_gained_called: [183091121,com.example.myapplication.MainActivity,topWhenResuming]
// MainActivity2 触发 destroy
04-02 19:11:47.092 13550 13571 I wm_destroy_activity: [0,105165904,12,com.example.myapplication/.MainActivity2,finish-imm:idle]
// MainActivity2 执行 onStop
04-02 19:11:47.128 19818 19818 I wm_on_stop_called: [105165904,com.example.myapplication.MainActivity2,LIFECYCLER_STOP_ACTIVITY]
// MainActivity2 执行 onDestroy
04-02 19:11:47.130 19818 19818 I wm_on_destroy_called: [105165904,com.example.myapplication.MainActivity2,performDestroy]

现在开始消消乐

04-03 15:02:41.806 31569 31732 D AutofillManagerService: onBackKeyPressed()
04-03 15:02:41.808 31569 32057 V WindowManager: Finishing activity r=ActivityRecord{6dbc456 u0 com.example.myapplication/.MainActivity2} t8}, result=0, data=null, reason=app-request
04-03 15:02:41.808 31569 32057 I wm_finish_activity: [0,115065942,8,com.example.myapplication/.MainActivity2,app-request]

1. 应用端触发finish – wm_finish_activity

按back键是会触发 Activity::finish 方法的，所以从这里开始跟流程

# Activitypublic void finish() {finish(DONT_FINISH_TASK_WITH_ACTIVITY);}private void finish(int finishTask) {......if (ActivityClient.getInstance().finishActivity(mToken, resultCode, resultData,finishTask)) {mFinished = true;}......}# ActivityClientpublic boolean finishActivity(IBinder token, int resultCode, Intent resultData,int finishTask) {try {return getActivityClientController().finishActivity(token, resultCode, resultData,finishTask);} catch (RemoteException e) {throw e.rethrowFromSystemServer();}}

然后就要开始跨进程交给 SystemService 端处理了

2. SystemService 端处理

# ActivityClientController/*** This is the internal entry point for handling Activity.finish().** @param token      The Binder token referencing the Activity we want to finish.* @param resultCode Result code, if any, from this Activity.* @param resultData Result data (Intent), if any, from this Activity.* @param finishTask Whether to finish the task associated with this Activity.* @return Returns true if the activity successfully finished, or false if it is still running.*/@Overridepublic boolean finishActivity(IBinder token, int resultCode, Intent resultData,int finishTask) {......final long origId = Binder.clearCallingIdentity();Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, "finishActivity");try {......// 主流程r.finishIfPossible(resultCode, resultData, resultGrants,"app-request", true /* oomAdj */);res = r.finishing;......} finally {Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);Binder.restoreCallingIdentity(origId);}......}

# ActivityRecord@FinishRequest int finishIfPossible(int resultCode, Intent resultData,NeededUriGrants resultGrants, String reason, boolean oomAdj) {// log ProtoLog.v(WM_DEBUG_STATES, "Finishing activity r=%s, result=%d, data=%s, "+ "reason=%s", this, resultCode, resultData, reason);......try {mTaskSupervisor.mNoHistoryActivities.remove(this);// 重点* 1. 设置为正在 finish makeFinishingLocked();// Make a local reference to its task since this.task could be set to null once this// activity is destroyed and detached from task.final Task task = getTask();// 重点* 2. 第一个events ：wm_finish_activityEventLogTags.writeWmFinishActivity(mUserId, System.identityHashCode(this),task.mTaskId, shortComponentName, reason);......// 重点* 3. 返回ResultfinishActivityResults(resultCode, resultData, resultGrants);......// Tell window manager to prepare for this one to be removed./ 重点* 4.设置不可见setVisibility(false);if (getTaskFragment().getPausingActivity() == null) {// 重点* 5. 打印2个logProtoLog.v(WM_DEBUG_STATES, "Finish needs to pause: %s", this);if (DEBUG_USER_LEAVING) {Slog.v(TAG_USER_LEAVING, "finish() => pause with userLeaving=false");}// 重点* 6.开始执行pause逻辑getTaskFragment().startPausing(false /* userLeaving */, false /* uiSleeping */,null /* resuming */, "finish");......}......} finally {mAtmService.continueWindowLayout();}}

1. 设置当前 Activity 正在 finish (ActivityRecord下的变量finishing为true)
1. 这里打印了第1个 MainActivity2 的 events 日志：wm_finish_activity
1. ActivityResults 相关，当前不关心
1. 设置 Activity 不可见
1. 这里有2个日志打印，都表示在处理 finish 之前需要先执行 pause（那下一步肯定是触发 pause）
1. 开始执行 MainActivity2 的 pause

2.1 makeFinishingLocked

# ActivityRecordvoid makeFinishingLocked() {if (finishing) {return;}// 表示当前Activity正在执行finish流程finishing = true;......}

这里 finishing 还是挺重要的，后面判断是否要 destory 这个 Activity 就会用到这个变量。

2.2 开始执行pause流程 – wm_pause_activity

pause 流程之前已经看过了，这边直接执行了 TaskFragment::startPausing ，那下一步肯定就是直接调用 TaskFragment::schedulePauseActivity 然后构建执行 PauseActivityItem 了

# TaskFragmentvoid schedulePauseActivity(ActivityRecord prev, boolean userLeaving,boolean pauseImmediately, String reason) {// Proto日志ProtoLog.v(WM_DEBUG_STATES, "Enqueueing pending pause: %s", prev);try {// 重点* 1. 输出events 日志 wm_pause_activityEventLogTags.writeWmPauseActivity(prev.mUserId, System.identityHashCode(prev),prev.shortComponentName, "userLeaving=" + userLeaving, reason);// 重点* 2. 构建并执行PauseActivityItemmAtmService.getLifecycleManager().scheduleTransaction(prev.app.getThread(),prev.token, PauseActivityItem.obtain(prev.finishing, userLeaving,prev.configChangeFlags, pauseImmediately));} catch (Exception e) {......}}

1. 打印第2个 MainActivity2 的events 日志： wm_pause_activity
1. 构建执行 PauseActivityItem 事务

2.3 addToStopping 流程 – wm_add_to_stopping

下一步的 events 日志为：wm_add_to_stopping 也就是 MainActivity2 的 addToStopping 流程。

这个之前在【Activity生命周期之onStop】分析过，可能场景不同逻辑不完全一致，但是核心逻辑都是一样的，就不再跟了，

肯定是将 MainActivity2 添加到 ActivityTaskSupervisor 下的 mStoppingActivities 集合。

再下面的就是 MainActivity 的一些生命周期处理，当前也不是分析重点。

2.4 触发销毁 – wm_destroy_activity

整个 events 日志里没有 wm_stop_activity 而是换成了 wm_destroy_activity ,但是有 wm_on_stop_called 和 wm_on_destroy_called 说明会执行 onStop 和onDestroy。

这个是符合我已知信息的，但是没有 wm_stop_activity 让我有点意外，那说明没有构建 StopActivityItem ，也就是说 onStop 可能是那个在 TransactionExecutorHelper::getLifecyclePath 触发的，这个方法会打log，在日志中确实搜到了这段log：

 D TransactionExecutor: tId:-185591831 Cycle activity: .MainActivity2 from: ON_PAUSE to: ON_DESTROY excludeLastState: true

wm_destroy_activity 日志打印的方法在 ActivityRecord::destroyImmediately 方法，加上堆栈后得到以下信息

04-08 11:18:26.452 12717 12883 E biubiubiu:   destroyImmediately: ActivityRecord{630bcae u0 com.example.myapplication/.MainActivity2} t12 f}}
04-08 11:18:26.452 12717 12883 E biubiubiu: java.lang.Exception
04-08 11:18:26.452 12717 12883 E biubiubiu: 	at com.android.server.wm.ActivityRecord.destroyImmediately(ActivityRecord.java:3732)
04-08 11:18:26.452 12717 12883 E biubiubiu: 	at com.android.server.wm.ActivityRecord.destroyIfPossible(ActivityRecord.java:3675)
04-08 11:18:26.452 12717 12883 E biubiubiu: 	at com.android.server.wm.ActivityTaskSupervisor.processStoppingAndFinishingActivities(ActivityTaskSupervisor.java:1959)
04-08 11:18:26.452 12717 12883 E biubiubiu: 	at com.android.server.wm.ActivityTaskSupervisor.activityIdleInternal(ActivityTaskSupervisor.java:1403)
04-08 11:18:26.452 12717 12883 E biubiubiu: 	at com.android.server.wm.ActivityTaskSupervisor$ActivityTaskSupervisorHandler.activityIdleFromMessage(ActivityTaskSupervisor.java:2426)
04-08 11:18:26.452 12717 12883 E biubiubiu: 	at com.android.server.wm.ActivityTaskSupervisor$ActivityTaskSupervisorHandler.handleMessageInner(ActivityTaskSupervisor.java:2459)
04-08 11:18:26.452 12717 12883 E biubiubiu: 	at com.android.server.wm.ActivityTaskSupervisor$ActivityTaskSupervisorHandler.handleMessage(ActivityTaskSupervisor.java:2401)
04-08 11:18:26.452 12717 12883 E biubiubiu: 	at android.os.Handler.dispatchMessage(Handler.java:106)
04-08 11:18:26.452 12717 12883 E biubiubiu: 	at android.os.Looper.loopOnce(Looper.java:210)
04-08 11:18:26.452 12717 12883 E biubiubiu: 	at android.os.Looper.loop(Looper.java:297)
04-08 11:18:26.452 12717 12883 E biubiubiu: 	at android.os.HandlerThread.run(HandlerThread.java:67)
04-08 11:18:26.452 12717 12883 E biubiubiu: 	at com.android.server.ServiceThread.run(ServiceThread.java:44)

可以看到是熟悉的 ActivityTaskSupervisor::processStoppingAndFinishingActivities 方法触发的。
看一下代码：

# ActivityTaskSupervisor/*** Processes the activities to be stopped or destroyed. This should be called when the resumed* 处理要停止或销毁的Activity。这应该在resumed时调用* activities are idle or drawn.*/private void processStoppingAndFinishingActivities(ActivityRecord launchedActivity,boolean processPausingActivities, String reason) {// 准备要执行 Stop 的Activity 集合 ArrayList<ActivityRecord> readyToStopActivities = null;// 重点 * 1. 遍历mStoppingActivitiesfor (int i = mStoppingActivities.size() - 1; i >= 0; --i) {// 获取到ActivityRecord （当前分析场景就1个）final ActivityRecord s = mStoppingActivities.get(i);final boolean animating = s.isAnimating(TRANSITION | PARENTS,ANIMATION_TYPE_APP_TRANSITION | ANIMATION_TYPE_RECENTS)|| s.inTransition();// 日志ProtoLog.v(WM_DEBUG_STATES, "Stopping %s: nowVisible=%b animating=%b "+ "finishing=%s", s, s.nowVisible, animating, s.finishing);// 条件满足才执行if (!animating || mService.mShuttingDown) {......// 打印 准备stop的logProtoLog.v(WM_DEBUG_STATES, "Ready to stop: %s", s);if (readyToStopActivities == null) {readyToStopActivities = new ArrayList<>();}// 重点 * 2. 添加进集合readyToStopActivities.add(s);// 从集合中移除mStoppingActivities.remove(i);}}// 重点 * 3. 遍历readyToStopActivitiesfinal int numReadyStops = readyToStopActivities == null ? 0 : readyToStopActivities.size();for (int i = 0; i < numReadyStops; i++) {final ActivityRecord r = readyToStopActivities.get(i);// 4. 检查该ActivityRecord对象是否在历史记录中。  if (r.isInHistory()) {// 如果该ActivityRecord对象正在结束（可能是用户或系统触发的结束操作）。if (r.finishing) {// TODO(b/137329632): Wait for idle of the right activity, not just any.// 重点* 4.1 尝试执行destroy  （finish流程）r.destroyIfPossible(reason);} else {// 重点* 4.2 尝试停止它 （stop流程）r.stopIfPossible();}}}......}

这个方法在分析 stop 流程已经看过了，区别在于最后执行的逻辑不同，因为在前面介绍 SystemService 端处理finish 时，开始就会执行 ActivityRecord::finishIfPossible ，然后触发
ActivityRecord::makeFinishingLocked 将 finishing 设置为true，表示这个Activity 正在执行 finish 流程，所以在执行到这个方法时，就会直接走 ActivityRecord::destroyIfPossible

这里就是finish 和 stop 的区别

# ActivityRecordboolean destroyIfPossible(String reason) {// 1. 设置状态为 FINISHINGsetState(FINISHING, "destroyIfPossible");// Make sure the record is cleaned out of other places.// 2. 从需要stop的集合中移除mTaskSupervisor.mStoppingActivities.remove(this);......// 3. 设置 finishing = truemakeFinishingLocked();// 4. 尝试立即销毁（正常返回false）final boolean activityRemoved = destroyImmediately("finish-imm:" + reason);......ProtoLog.d(WM_DEBUG_CONTAINERS, "destroyIfPossible: r=%s destroy returned "+ "removed=%s", this, activityRemoved);return activityRemoved;}

1. 这里将 ActivityRecord 的状态设置为 FINISHING
1. 从stop列表中移除
1. 设置 finishing = true （不过当前场景 finishing 已经为true了）
1. 执行 destroyImmediately 方法处理后续流程

# ActivityRecordboolean destroyImmediately(String reason) {......// 如果状态正在处于 destory 则returnif (isState(DESTROYING, DESTROYED)) {ProtoLog.v(WM_DEBUG_STATES, "activity %s already destroying, skipping "+ "request with reason:%s", this, reason);return false;}// events 日志：wm_destroy_activity  EventLogTags.writeWmDestroyActivity(mUserId, System.identityHashCode(this),task.mTaskId, shortComponentName, reason);......// logif (DEBUG_SWITCH) Slog.i(TAG_SWITCH, "Destroying: " + this);// 构建执行 Destroy 事务mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(), token,DestroyActivityItem.obtain(finishing, configChangeFlags));......}

1. 打印了 events 日志：wm_destroy_activity
1. 构建执行DestroyActivityItem （注意这里第一个参数，当前场景为true）

那后续的逻辑就又到应用端处理了，服务端整理的堆栈如下：

ActivityTaskSupervisorHandler::handleMessageActivityTaskSupervisorHandler::handleMessageInner   -- IDLE_NOW_MSGActivityTaskSupervisor$ActivityTaskSupervisorHandler::activityIdleFromMessageActivityTaskSupervisor::activityIdleInternalActivityTaskSupervisor::processStoppingAndFinishingActivitiesActivityRecord::destroyIfPossibleActivityRecord::destroyImmediatelyActivityRecord::setState  FINISHINGActivityRecord::makeFinishingLockedActivityRecord::destroyImmediately 构建执行 DestroyActivityItem

3. 应用端处理处理finish – wm_on_stop_called, wm_on_destroy_called

DestroyActivityItem 的定义如下：

# DestroyActivityItemprivate boolean mFinished;@Overridepublic void execute(ClientTransactionHandler client, ActivityClientRecord r,PendingTransactionActions pendingActions) {Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityDestroy");// 执行下一步，第二个参数为mFinishedclient.handleDestroyActivity(r, mFinished, mConfigChanges,false /* getNonConfigInstance */, "DestroyActivityItem");Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);}@Overridepublic int getTargetState() {return ON_DESTROY;}public static DestroyActivityItem obtain(boolean finished, int configChanges) {DestroyActivityItem instance = ObjectPool.obtain(DestroyActivityItem.class);if (instance == null) {instance = new DestroyActivityItem();}// 复制给mFinishedinstance.mFinished = finished;instance.mConfigChanges = configChanges;return instance;}

3.1 onStop – wm_on_stop_called

前面说过这个流程的onStop 是通过 TransactionExecutorHelper::getLifecyclePath 方法触发的，执行时机在触发 DestroyActivityItem::execute 之前。
如果对这点有疑问的参考【Activity生命周期之onCreate,onStart,onResume】的Activity 生命周期事务跨进程处理方式详解
onStop 流程也在【onStop】讲过了。

最终会输出 events日志：wm_on_stop_called 并执行 Activity 的onStop

当然日志的打印顺序能更直观的证明

在这里插入图片描述

3.2 onDestroy – wm_on_destroy_called

根据 DestroyActivityItem::execute 的定义直接看 ActivityThread::handleDestroyActivity 方法

# ActivityThread@Overridepublic void handleDestroyActivity(ActivityClientRecord r, boolean finishing, int configChanges,boolean getNonConfigInstance, String reason) {// 1. 主流程 onDestroyperformDestroyActivity(r, finishing, configChanges, getNonConfigInstance, reason);// 2. 视图相关处理cleanUpPendingRemoveWindows(r, finishing);WindowManager wm = r.activity.getWindowManager();View v = r.activity.mDecor;if (v != null) {if (r.activity.mVisibleFromServer) {mNumVisibleActivities--;}IBinder wtoken = v.getWindowToken();if (r.activity.mWindowAdded) {if (r.mPreserveWindow) {// ......需要保留Window} else {......// 立即移除当前视图 （触发WindowManagerGlobal移除）wm.removeViewImmediate(v);}}if (wtoken != null && r.mPendingRemoveWindow == null) {// 后续会触发 ViewRootImpl::doDie 移除ViewWindowManagerGlobal.getInstance().closeAll(wtoken,r.activity.getClass().getName(), "Activity");} else if (r.mPendingRemoveWindow != null) {......}r.activity.mDecor = null;}......if (finishing) {// 3. 通知 SystemService 端ActivityClient.getInstance().activityDestroyed(r.token);}mSomeActivitiesChanged = true;}

做了三件事：

1. 执行到 Activity 的 onDestroy
1. 处理UI相关的移除
1. 通知 SystemService 端这个 Activity 已经 Destroy 了，后续该干啥干啥

3.2.1 onDestroy 流程

# ActivityThreadvoid performDestroyActivity(ActivityClientRecord r, boolean finishing,int configChanges, boolean getNonConfigInstance, String reason) {Class<? extends Activity> activityClass = null;// 日志if (localLOGV) Slog.v(TAG, "Performing finish of " + r);// 拿到 ActivityactivityClass = r.activity.getClass();r.activity.mConfigChangeFlags |= configChanges;//  当前场景finishing 为trueif (finishing) {r.activity.mFinished = true;}// 如果需要则执行pause逻辑performPauseActivityIfNeeded(r, "destroy");// 如果还没stop， 则需要执行stop逻辑if (!r.stopped) {callActivityOnStop(r, false /* saveState */, "destroy");}......try {r.activity.mCalled = false;// * 主流程mInstrumentation.callActivityOnDestroy(r.activity);......} ......// 设置ActivityClientRecord状态-- ON_DESTROYr.setState(ON_DESTROY);// 发送消息 PURGE_RESOURCESschedulePurgeIdler();......}

个人感觉比较重要的地方都加了注释，然后继续看主流程

# Instrumentationpublic void callActivityOnDestroy(Activity activity) {activity.performDestroy();}

# Activityfinal void performDestroy() {if (Trace.isTagEnabled(Trace.TRACE_TAG_WINDOW_MANAGER)) {Trace.traceBegin(Trace.TRACE_TAG_WINDOW_MANAGER, "performDestroy:"+ mComponent.getClassName());}dispatchActivityPreDestroyed();mDestroyed = true;// 设置Window 下 mDestroyed 为truemWindow.destroy();mFragments.dispatchDestroy();// 重点* 执行onDestroyonDestroy();// wm_on_destroy_calledEventLogTags.writeWmOnDestroyCalled(mIdent, getComponentName().getClassName(),"performDestroy");......Trace.traceEnd(Trace.TRACE_TAG_WINDOW_MANAGER);}

流程结束！

3.2.2 UI处理

相关的代码都在注释里加上了，创建 Activity 的时候也有一些 UI 的处理，当前 finish 自然也有对应的处理，不过不是当前主要分析的逻辑。
后续会出一篇专门介绍创建和销毁 Activity 时 UI 的一些处理。

3.3 总结 – 调用链整理

应用端处理的调用链如下：

ActivityThread::handleDestroyActivityActivityThread::performDestroyActivity       -- onDestroy流程Instrumentation::callActivityOnDestroyActivity::performDestroyActivity::onDestroyWindowManagerImpl::removeViewImmediate        -- UI处理WindowManagerGlobal::removeViewActivityClient::activityDestroyed            -- SystemService 进程处理

4 SystemService 进程处理 – activityDestroyed

应用端已经执行完 Destroy 流程了，自然也要通知到 SystemService 进程做对应的后续处理。

# ActivityClientpublic void activityDestroyed(IBinder token) {try {getActivityClientController().activityDestroyed(token);} catch (RemoteException e) {e.rethrowFromSystemServer();}}
# ActivityClientController@Overridepublic void activityDestroyed(IBinder token) {if (DEBUG_SWITCH) Slog.v(TAG_SWITCH, "ACTIVITY DESTROYED: " + token);final long origId = Binder.clearCallingIdentity();synchronized (mGlobalLock) {Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, "activityDestroyed");try {final ActivityRecord r = ActivityRecord.forTokenLocked(token);if (r != null) {// 重点* 执行 destroyedr.destroyed("activityDestroyed");}} finally {Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);Binder.restoreCallingIdentity(origId);}}}

这里有一些log和加了Trace, 但是重点就是执行了 ActivityRecord::destroyed 方法

# ActivityRecord/*** 此方法仅应在Activity被销毁且完成时，由客户端通过Binder调用*/void destroyed(String reason) {// 移除销毁超时定时器removeDestroyTimeout();// 日志ProtoLog.d(WM_DEBUG_CONTAINERS, "activityDestroyedLocked: r=%s", this);// 检查状态if (!isState(DESTROYING, DESTROYED)) {// 不符合预期，抛出异常throw new IllegalStateException("Reported destroyed for activity that is not destroying: r=" + this);}// 如果Activity位于RootTaskif (isInRootTaskLocked()) {// 清理服务cleanUp(true /* cleanServices */, false /* setState */);// 从历史记录中移除该Activity，并传递销毁原因removeFromHistory(reason);}// 重点* 通知根窗口容器恢复焦点任务的顶层ActivitymRootWindowContainer.resumeFocusedTasksTopActivities();}

重点就是在最后执行了 RootWindowContainer::resumeFocusedTasksTopActivities .
因为已经有一个 Activity 执行完了finish 流程，那界面上面显示的 Activity 当然会有一些变化，所以执行一些这个流程，来确保屏幕内容的正常显示。