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

服装学院的IT男2024-10-03 12:01

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

-- 服装学院的IT男
本篇已收录于Activity短暂的一生系列

欢迎一起学习讨论Android应用开发或者WMS

V：WJB6995

Q：707409815

正文

生命周期系列：

生命周期分析系列剩下最后一个 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 方法的，所以从这里开始跟流程

# Activity
    public void finish() {
        finish(DONT_FINISH_TASK_WITH_ACTIVITY);
    }
    private void finish(int finishTask) {
        ......
            
            if (ActivityClient.getInstance().finishActivity(mToken, resultCode, resultData,
                    finishTask)) {
                mFinished = true;
            }
        ......
    }

# ActivityClient
    public 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.
     */
    @Override
    public 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_activity
            EventLogTags.writeWmFinishActivity(mUserId, System.identityHashCode(this),
                    task.mTaskId, shortComponentName, reason);
            ......
            // 重点* 3. 返回Result
            finishActivityResults(resultCode, resultData, resultGrants);
            ......
            // Tell window manager to prepare for this one to be removed.
            / 重点* 4.设置不可见
            setVisibility(false);
            if (getTaskFragment().getPausingActivity() == null) {
                // 重点* 5. 打印2个log
                ProtoLog.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

# ActivityRecord
    void makeFinishingLocked() {

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

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

2.2 开始执行pause流程 -- wm_pause_activity

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

# TaskFragment

    void 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_activity
            EventLogTags.writeWmPauseActivity(prev.mUserId, System.identityHashCode(prev),
                    prev.shortComponentName, "userLeaving=" + userLeaving, reason);
            // 重点* 2. 构建并执行PauseActivityItem
            mAtmService.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. 遍历mStoppingActivities
                for (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的log
                        ProtoLog.v(WM_DEBUG_STATES, "Ready to stop: %s", s);
                        if (readyToStopActivities == null) {
                            readyToStopActivities = new ArrayList<>();
                        }
                        // 重点 * 2. 添加进集合
                        readyToStopActivities.add(s);
                        // 从集合中移除
                        mStoppingActivities.remove(i);
                    }
                }
                // 重点 * 3. 遍历readyToStopActivities
                final 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 的区别

# ActivityRecord
    boolean destroyIfPossible(String reason) {
        // 1. 设置状态为 FINISHING
        setState(FINISHING, "destroyIfPossible");
        // Make sure the record is cleaned out of other places.
        // 2. 从需要stop的集合中移除
        mTaskSupervisor.mStoppingActivities.remove(this);
        ......
        // 3. 设置 finishing = true
        makeFinishingLocked();
        // 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 方法处理后续流程

    ActivityRecord

      boolean destroyImmediately(String reason) {
      ......
      // 如果状态正在处于 destory 则return
      if (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);
      ......

          // log
          if (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::handleMessage
    ActivityTaskSupervisorHandler::handleMessageInner   -- IDLE_NOW_MSG
        ActivityTaskSupervisor$ActivityTaskSupervisorHandler::activityIdleFromMessage
            ActivityTaskSupervisor::activityIdleInternal
                ActivityTaskSupervisor::processStoppingAndFinishingActivities
                    ActivityRecord::destroyIfPossible
                        ActivityRecord::destroyImmediately
                                ActivityRecord::setState  FINISHING
                                ActivityRecord::makeFinishingLocked
                                ActivityRecord::destroyImmediately 构建执行 DestroyActivityItem

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

DestroyActivityItem 的定义如下：

# DestroyActivityItem

    private boolean mFinished;

    @Override
    public void execute(ClientTransactionHandler client, ActivityClientRecord r,
            PendingTransactionActions pendingActions) {
        Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityDestroy");
        // 执行下一步，第二个参数为mFinished
        client.handleDestroyActivity(r, mFinished, mConfigChanges,
                false /* getNonConfigInstance */, "DestroyActivityItem");
        Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
    }

    @Override
    public 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();
        }
        // 复制给mFinished
        instance.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
    @Override
    public void handleDestroyActivity(ActivityClientRecord r, boolean finishing, int configChanges,
            boolean getNonConfigInstance, String reason) {
        // 1. 主流程 onDestroy
        performDestroyActivity(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 移除View
                WindowManagerGlobal.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 流程

# ActivityThread
    void 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);
                // 拿到 Activity
                activityClass = r.activity.getClass();
                        r.activity.mConfigChangeFlags |= configChanges;
                //  当前场景finishing 为true
                if (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_DESTROY
                r.setState(ON_DESTROY);
                // 发送消息 PURGE_RESOURCES
                schedulePurgeIdler();
                ......
            }

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

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

# Activity
    final 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 为true
        mWindow.destroy();
        mFragments.dispatchDestroy();
        // 重点* 执行onDestroy
        onDestroy();
        // wm_on_destroy_called
        EventLogTags.writeWmOnDestroyCalled(mIdent, getComponentName().getClassName(),
                "performDestroy");
        ......
        Trace.traceEnd(Trace.TRACE_TAG_WINDOW_MANAGER);
    }

流程结束！

3.2.2 UI处理

相关的代码都在注释里加上了，创建 Activity 的时候也有一些 UI 的处理，当前 finish 自然也有对应的处理，不过不是当前主要分析的逻辑。

后续会出一篇专门介绍 创建和销毁 Activity 时 UI 的一些处理。

3.3 总结 -- 调用链整理

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

ActivityThread::handleDestroyActivity
    ActivityThread::performDestroyActivity       -- onDestroy流程
        Instrumentation::callActivityOnDestroy
            Activity::performDestroy
                Activity::onDestroy
    WindowManagerImpl::removeViewImmediate        -- UI处理
        WindowManagerGlobal::removeView
    ActivityClient::activityDestroyed            -- SystemService 进程处理

4 SystemService 进程处理 -- activityDestroyed

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

# ActivityClient
    public void activityDestroyed(IBinder token) {
        try {
            getActivityClientController().activityDestroyed(token);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }
# ActivityClientController
    @Override
    public 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) {
                    // 重点* 执行 destroyed
                    r.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位于RootTask
        if (isInRootTaskLocked()) {
            // 清理服务
            cleanUp(true /* cleanServices */, false /* setState */);

            // 从历史记录中移除该Activity，并传递销毁原因
            removeFromHistory(reason);
        }

        // 重点* 通知根窗口容器恢复焦点任务的顶层Activity
        mRootWindowContainer.resumeFocusedTasksTopActivities();

}

重点就是在最后执行了 RootWindowContainer::resumeFocusedTasksTopActivities .

因为已经有一个 Activity 执行完了finish 流程，那界面上面显示的 Activity 当然会有一些变化，所以执行一些这个流程，来确保屏幕内容的正常显示。

相关推荐
Dnelic-2 小时前
【单元测试】【Android】JUnit 4 和 JUnit 5 的差异记录
android·junit·单元测试·android studio·自学笔记
Eastsea.Chen5 小时前
MTK Android12 user版本MtkLogger
android·framework
长亭外的少年12 小时前
Kotlin 编译失败问题及解决方案：从守护进程到 Gradle 配置
android·开发语言·kotlin
建群新人小猿14 小时前
会员等级经验问题
android·开发语言·前端·javascript·php
1024小神16 小时前
tauri2.0版本开发苹果ios和安卓android应用，环境搭建和最后编译为apk
android·ios·tauri
兰琛16 小时前
20241121 android中树结构列表（使用recyclerView实现）
android·gitee
Y多了个想法16 小时前
RK3568 android11 适配敦泰触摸屏 FocalTech-ft5526
android·rk3568·触摸屏·tp·敦泰·focaltech·ft5526
NotesChapter17 小时前
Android吸顶效果，并有着ViewPager左右切换
android
_祝你今天愉快19 小时前
分析android ：The binary version of its metadata is 1.8.0, expected version is 1.5.
android
暮志未晚Webgl19 小时前
109. UE5 GAS RPG 实现检查点的存档功能
android·java·ue5
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07【目标跟踪】相机运动补偿08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10量化方法怎么选？如何评估量化后的大模型LLM？