开篇

本篇以android-11.0.0_r25作为基础解析

咱们在之前的几篇Activity发动流程剖析中现已了解了Activity一半的生命周期，接下来这篇文章咱们就来剖析一下Activity毁掉相关的生命周期

前几期文章回忆：

Android源码剖析 – Activity发动流程（上）

Android源码剖析 – Activity发动流程（中）

Android源码剖析 – Activity发动流程（下）

触发毁掉

已然要剖析Activity毁掉流程，那咱们就从最常见的进口Activity.finish下手

public void finish() {
    finish(DONT_FINISH_TASK_WITH_ACTIVITY);
}

默许的finish办法调用了另一个同名重载办法，承受一个int类型的参数标明是否需求在毁掉Activity的一起毁掉Task，该参数有以下三种：

• DONT_FINISH_TASK_WITH_ACTIVITY：默许参数，表明在毁掉Activity的时分不要毁掉Task

• FINISH_TASK_WITH_ROOT_ACTIVITY：当Activity为跟Activity的时分，毁掉的一起毁掉Task，一起这个使命也会从最近使命中移除

• FINISH_TASK_WITH_ACTIVITY：毁掉Activity的时分一起毁掉Task，但不会从最近使命中移除

private void finish(int finishTask) {
    if (mParent == null) {
        //当finish后才可能会触发onActivityResult回调
        //这儿预备将result回来给之前调用startActivityForResult的Activity
        int resultCode;
        Intent resultData;
        synchronized (this) {
            resultCode = mResultCode;
            resultData = mResultData;
        }
        try {
            //两个Activity可能处于不同进程中，做进程间通信的预备
            if (resultData != null) {
                resultData.prepareToLeaveProcess(this);
            }
            //调用ATMS毁掉Activity
            if (ActivityTaskManager.getService()
                    .finishActivity(mToken, resultCode, resultData, finishTask)) {
                mFinished = true;
            }
        } catch (RemoteException e) {
            // Empty
        }
    } else {
        mParent.finishFromChild(this);
    }
    // Activity was launched when user tapped a link in the Autofill Save UI - Save UI must
    // be restored now.
    if (mIntent != null && mIntent.hasExtra(AutofillManager.EXTRA_RESTORE_SESSION_TOKEN)) {
        restoreAutofillSaveUi();
    }
}

onActivityResult回调是在对应Activity resume时才可能触发，详细进程后边会剖析，将ActivityRecord.Token和Result作为参数调用ATMS.finishActivity办法

public final boolean finishActivity(IBinder token, int resultCode, Intent resultData,
        int finishTask) {
    // Refuse possible leaked file descriptors
    //回传的ResultIntent中不答应包含fd，避免走漏
    if (resultData != null && resultData.hasFileDescriptors()) {
        throw new IllegalArgumentException("File descriptors passed in Intent");
    }
    final ActivityRecord r;
    synchronized (mGlobalLock) {
        //获取ActivityRecord并保证其在栈中
        r = ActivityRecord.isInStackLocked(token);
        //为null说明已被移出ActivityStack，视作已被finish
        if (r == null) {
            return true;
        }
    }
    // Carefully collect grants without holding lock
    //检查调用方（即待finish的Activity）是否能授予result所对应Activity package访问uri的权限
    final NeededUriGrants resultGrants = collectGrants(resultData, r.resultTo);
    synchronized (mGlobalLock) {
        // Sanity check in case activity was removed before entering global lock.
        if (!r.isInHistory()) {
            return true;
        }
        // Keep track of the root activity of the task before we finish it
        final Task tr = r.getTask();
        final ActivityRecord rootR = tr.getRootActivity();
        // Do not allow task to finish if last task in lockTask mode. Launchable priv-apps can
        // finish.
        //LockTask形式下，假如此为终究一个Task，则不答应被毁掉
        //详见：https://developer.android.com/work/dpc/dedicated-devices/lock-task-mode
        if (getLockTaskController().activityBlockedFromFinish(r)) {
            return false;
        }
        // TODO: There is a dup. of this block of code in ActivityStack.navigateUpToLocked
        // We should consolidate.
        //IActivityController分发Activity状况改变
        if (mController != null) {
            // Find the first activity that is not finishing.
            //寻觅该Activity毁掉后的下一个顶层Activity
            final ActivityRecord next =
                    r.getRootTask().topRunningActivity(token, INVALID_TASK_ID);
            if (next != null) {
                // ask watcher if this is allowed
                boolean resumeOK = true;
                try {
                    resumeOK = mController.activityResuming(next.packageName);
                } catch (RemoteException e) {
                    mController = null;
                    Watchdog.getInstance().setActivityController(null);
                }
                if (!resumeOK) {
                    return false;
                }
            }
        }
        // note down that the process has finished an activity and is in background activity
        // starts grace period
        //设置Activity毁掉的最新时间
        if (r.app != null) {
            r.app.setLastActivityFinishTimeIfNeeded(SystemClock.uptimeMillis());
        }
        final long origId = Binder.clearCallingIdentity();
        try {
            boolean res;
            final boolean finishWithRootActivity =
                    finishTask == Activity.FINISH_TASK_WITH_ROOT_ACTIVITY;
            if (finishTask == Activity.FINISH_TASK_WITH_ACTIVITY
                    || (finishWithRootActivity && r == rootR)) { //需求一起毁掉Task
                // If requested, remove the task that is associated to this activity only if it
                // was the root activity in the task. The result code and data is ignored
                // because we don't support returning them across task boundaries. Also, to
                // keep backwards compatibility we remove the task from recents when finishing
                // task with root activity.
                //移除Task
                mStackSupervisor.removeTask(tr, false /*killProcess*/,
                        finishWithRootActivity, "finish-activity");
                res = true;
                // Explicitly dismissing the activity so reset its relaunch flag.
                r.mRelaunchReason = RELAUNCH_REASON_NONE;
            } else { //不需求一起毁掉Task
                r.finishIfPossible(resultCode, resultData, resultGrants,
                        "app-request", true /* oomAdj */);
                res = r.finishing;
            }
            return res;
        } finally {
            Binder.restoreCallingIdentity(origId);
        }
    }
}

这个办法里分了两个case，当需求一起毁掉Task的时分，直接调用ActivityStackSupervisor.removeTask，当不需求一起毁掉Task的时分，调用ActivityRecord.finishIfPossible

咱们先看需求一起毁掉Task的case

void removeTask(Task task, boolean killProcess, boolean removeFromRecents, String reason) {
    if (task.mInRemoveTask) {
        // Prevent recursion.
        return;
    }
    task.mInRemoveTask = true;
    try {
        //履行Task移除操作
        task.performClearTask(reason);
        //对Task履行杀进程，从最近使命列表移除等操作
        cleanUpRemovedTaskLocked(task, killProcess, removeFromRecents);
        //封闭LockTask形式
        mService.getLockTaskController().clearLockedTask(task);
        //告诉Task状况发生改变
        mService.getTaskChangeNotificationController().notifyTaskStackChanged();
        //将最近使命持久化保存
        if (task.isPersistable) {
            mService.notifyTaskPersisterLocked(null, true);
        }
    } finally {
        task.mInRemoveTask = false;
    }
}

本篇文章咱们首要重视的是Activity毁掉流程，至于进程的封闭，最近使命列表的更新咱们在这儿就不关怀了，而这儿Activity毁掉的要点在于Task.performClearTask办法

/** Completely remove all activities associated with an existing task. */
void performClearTask(String reason) {
    // Broken down into to cases to avoid object create due to capturing mStack.
    if (getStack() == null) {
        forAllActivities((r) -> {
            if (r.finishing) return;
            // Task was restored from persistent storage.
            r.takeFromHistory();
            removeChild(r);
        });
    } else {
        forAllActivities((r) -> {
            if (r.finishing) return;
            // TODO: figure-out how to avoid object creation due to capture of reason variable.
            r.finishIfPossible(Activity.RESULT_CANCELED,
                    null /* resultData */, null /* resultGrants */, reason, false /* oomAdj */);
        });
    }
}

咱们看后半部分代码能够发现，这个办法对Task中一切未毁掉的Activity都履行了ActivityRecord.finishIfPossible办法，这样途径就和上面ATMS.finishActivity办法中第二个case统一了

/**
 * Finish activity if possible. If activity was resumed - we must first pause it to make the
 * activity below resumed. Otherwise we will try to complete the request immediately by calling
 * {@link #completeFinishing(String)}.
 * @return One of {@link FinishRequest} values:
 * {@link #FINISH_RESULT_REMOVED} if this activity has been removed from the history list.
 * {@link #FINISH_RESULT_REQUESTED} if removal process was started, but it is still in the list
 * and will be removed from history later.
 * {@link #FINISH_RESULT_CANCELLED} if activity is already finishing or in invalid state and the
 * request to finish it was not ignored.
 */
@FinishRequest int finishIfPossible(int resultCode, Intent resultData,
        NeededUriGrants resultGrants, String reason, boolean oomAdj) {
    //避免重复毁掉
    if (finishing) {
        return FINISH_RESULT_CANCELLED;
    }
    //此Activity不在使命栈中
    if (!isInStackLocked()) {
        return FINISH_RESULT_CANCELLED;
    }
    final ActivityStack stack = getRootTask();
    //应该调整顶部Activity
    final boolean mayAdjustTop = (isState(RESUMED) || stack.mResumedActivity == null)
            && stack.isFocusedStackOnDisplay();
    //应该调整大局焦点
    final boolean shouldAdjustGlobalFocus = mayAdjustTop
            // It must be checked before {@link #makeFinishingLocked} is called, because a stack
            // is not visible if it only contains finishing activities.
            && mRootWindowContainer.isTopDisplayFocusedStack(stack);
    //暂停布局作业
    mAtmService.deferWindowLayout();
    try {
        //设置当时Activity状况为finishing
        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();
        //获取上一个ActivityRecord
        ActivityRecord next = task.getActivityAbove(this);
        //传递FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET：重置该Task时清除此Activity
        if (next != null) {
            if ((intent.getFlags() & Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET) != 0) {
                // If the caller asked that this activity (and all above it)
                // be cleared when the task is reset, don't lose that information,
                // but propagate it up to the next activity.
                next.intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET);
            }
        }
        //暂停输入事情分发
        pauseKeyDispatchingLocked();
        // We are finishing the top focused activity and its task has nothing to be focused so
        // the next focusable task should be focused.
        //应该调整顶部Activity，但此Task没有Activity能够被运行在顶部，将焦点转移至下一个可聚集的Task
        if (mayAdjustTop && ((ActivityStack) task).topRunningActivity(true /* focusableOnly */)
                == null) {
            task.adjustFocusToNextFocusableTask("finish-top", false /* allowFocusSelf */,
                        shouldAdjustGlobalFocus);
        }
        //将Result信息写入到对应ActivityRecord中，待后边resume的时分触发onActivityResult回调
        finishActivityResults(resultCode, resultData, resultGrants);
        //终止Task
        final boolean endTask = task.getActivityBelow(this) == null
                && !task.isClearingToReuseTask();
        final int transit = endTask ? TRANSIT_TASK_CLOSE : TRANSIT_ACTIVITY_CLOSE;
        if (isState(RESUMED)) {
            if (endTask) {
                //告诉Task移除已开端
                mAtmService.getTaskChangeNotificationController().notifyTaskRemovalStarted(
                        task.getTaskInfo());
            }
            // Prepare app close transition, but don't execute just yet. It is possible that
            // an activity that will be made resumed in place of this one will immediately
            // launch another new activity. In this case current closing transition will be
            // combined with open transition for the new activity.
            //预备Activity转场动画
            mDisplayContent.prepareAppTransition(transit, false);
            // When finishing the activity preemptively take the snapshot before the app window
            // is marked as hidden and any configuration changes take place
            //更新Task快照
            if (mAtmService.mWindowManager.mTaskSnapshotController != null) {
                final ArraySet<Task> tasks = Sets.newArraySet(task);
                mAtmService.mWindowManager.mTaskSnapshotController.snapshotTasks(tasks);
                mAtmService.mWindowManager.mTaskSnapshotController
                        .addSkipClosingAppSnapshotTasks(tasks);
            }
            // Tell window manager to prepare for this one to be removed.
            //设置可见性
            setVisibility(false);
            if (stack.mPausingActivity == null) {
                //开端暂停此Activity
                stack.startPausingLocked(false /* userLeaving */, false /* uiSleeping */,
                        null /* resuming */);
            }
            if (endTask) {
                //屏幕固定功用
                mAtmService.getLockTaskController().clearLockedTask(task);
                // This activity was in the top focused stack and this is the last activity in
                // that task, give this activity a higher layer so it can stay on top before the
                // closing task transition be executed.
                //更新窗口层级
                if (mayAdjustTop) {
                    mNeedsZBoost = true;
                    mDisplayContent.assignWindowLayers(false /* setLayoutNeeded */);
                }
            }
        } else if (!isState(PAUSING)) {
            ... //正常不会进入此case
        }
        return FINISH_RESULT_REQUESTED;
    } finally {
        //康复布局作业
        mAtmService.continueWindowLayout();
    }
}

这个办法中，咱们需求重视一下关于Result信息的处理，这儿调用了finishActivityResults办法，将Result信息写入到对应ActivityRecord中，待后边resume的时分触发onActivityResult回调

/**
 * Sets the result for activity that started this one, clears the references to activities
 * started for result from this one, and clears new intents.
 */
private void finishActivityResults(int resultCode, Intent resultData,
        NeededUriGrants resultGrants) {
    // Send the result if needed
    if (resultTo != null) {
        if (resultTo.mUserId != mUserId) {
            if (resultData != null) {
                resultData.prepareToLeaveUser(mUserId);
            }
        }
        if (info.applicationInfo.uid > 0) {
            mAtmService.mUgmInternal.grantUriPermissionUncheckedFromIntent(resultGrants,
                    resultTo.getUriPermissionsLocked());
        }
        resultTo.addResultLocked(this, resultWho, requestCode, resultCode, resultData);
        resultTo = null;
    }
    // Make sure this HistoryRecord is not holding on to other resources,
    // because clients have remote IPC references to this object so we
    // can't assume that will go away and want to avoid circular IPC refs.
    results = null;
    pendingResults = null;
    newIntents = null;
    setSavedState(null /* savedState */);
}
//将Result成果增加到results列表中
void addResultLocked(ActivityRecord from, String resultWho,
        int requestCode, int resultCode,
        Intent resultData) {
    ActivityResult r = new ActivityResult(from, resultWho,
            requestCode, resultCode, resultData);
    if (results == null) {
        results = new ArrayList<ResultInfo>();
    }
    results.add(r);
}

这个办法很简单，便是将Result信息增加到ActivityRecord.results列表中

然后咱们持续沿着finish主线链路走，后边有一个isState的判别，正常来说，ActivityRecord的state应该为RESUMED，详细为什么咱们能够回忆一下之前剖析的Activity发动流程，在ActivityStackSupervisor.realStartActivityLocked办法终究，会调用ActivityStack.minimalResumeActivityLocked，在这个办法中，会将ActivityRecord的state设置为RESUMED，由于ClientTransaction的履行是经过Handler.sendMessage进行的，所以早在Activity onCreate之前，ActivityRecord的状况就现已被设为了RESUMED

根据以上剖析，咱们会走进isState(RESUMED)这个case中，接着调用ActivityStack.startPausingLocked办法暂停Activity

/**
 * Start pausing the currently resumed activity.  It is an error to call this if there
 * is already an activity being paused or there is no resumed activity.
 *
 * @param userLeaving True if this should result in an onUserLeaving to the current activity.
 * @param uiSleeping True if this is happening with the user interface going to sleep (the
 * screen turning off).
 * @param resuming The activity we are currently trying to resume or null if this is not being
 *                 called as part of resuming the top activity, so we shouldn't try to instigate
 *                 a resume here if not null.
 * @return Returns true if an activity now is in the PAUSING state, and we are waiting for
 * it to tell us when it is done.
 */
final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping,
        ActivityRecord resuming) {
    //已有Activity正在暂停中
    if (mPausingActivity != null) {
        if (!shouldSleepActivities()) {
            // Avoid recursion among check for sleep and complete pause during sleeping.
            // Because activity will be paused immediately after resume, just let pause
            // be completed by the order of activity paused from clients.
            completePauseLocked(false, resuming);
        }
    }
    //上一个已resume的Activity
    ActivityRecord prev = mResumedActivity;
    //既没有已resume的Activity，也没有正在resume的Activity
    //从栈顶找一个Activity康复
    if (prev == null) {
        if (resuming == null) {
            mRootWindowContainer.resumeFocusedStacksTopActivities();
        }
        return false;
    }
    //不能暂停一个正在resume的Activity
    if (prev == resuming) {
        return false;
    }
    //设置各种状况
    mPausingActivity = prev;
    mLastPausedActivity = prev;
    mLastNoHistoryActivity = prev.isNoHistory() ? prev : null;
    prev.setState(PAUSING, "startPausingLocked");
    prev.getTask().touchActiveTime();
    clearLaunchTime(prev);
    //更新计算信息
    mAtmService.updateCpuStats();
    boolean pauseImmediately = false;
    ... //当时流程下pauseImmediately一直为false
    if (prev.attachedToProcess()) {
        try {
            //调度Pause生命周期业务
            mAtmService.getLifecycleManager().scheduleTransaction(prev.app.getThread(),
                    prev.appToken, PauseActivityItem.obtain(prev.finishing, userLeaving,
                            prev.configChangeFlags, pauseImmediately));
        } catch (Exception e) {
            // Ignore exception, if process died other code will cleanup.
            mPausingActivity = null;
            mLastPausedActivity = null;
            mLastNoHistoryActivity = null;
        }
    } else {
        mPausingActivity = null;
        mLastPausedActivity = null;
        mLastNoHistoryActivity = null;
    }
    // If we are not going to sleep, we want to ensure the device is
    // awake until the next activity is started.
    //获取Wakelock，保证设备awake状况直到下一个Activity发动
    if (!uiSleeping && !mAtmService.isSleepingOrShuttingDownLocked()) {
        mStackSupervisor.acquireLaunchWakelock();
    }
    if (mPausingActivity != null) {
        // Have the window manager pause its key dispatching until the new
        // activity has started.  If we're pausing the activity just because
        // the screen is being turned off and the UI is sleeping, don't interrupt
        // key dispatch; the same activity will pick it up again on wakeup.
        if (!uiSleeping) {
            //暂停输入事情分发
            prev.pauseKeyDispatchingLocked();
        }
        if (pauseImmediately) { //不会进入此case
            // If the caller said they don't want to wait for the pause, then complete
            // the pause now.
            completePauseLocked(false, resuming);
            return false;
        } else {
            //设置超时监听（500ms内没有完结便视为超时）
            prev.schedulePauseTimeout();
            return true;
        }
    } else {
        // This activity failed to schedule the
        // pause, so just treat it as being paused now.
        //未能成功暂停此Activity，从栈顶找一个Activity康复
        if (resuming == null) {
            mRootWindowContainer.resumeFocusedStacksTopActivities();
        }
        return false;
    }
}

能够看到，和Activity发动流程相似，该办法里面调用了ClientLifecycleManager.scheduleTransaction办法来调度Activity暂停的生命周期，详细是怎样调度的能够看我之前的文章 Android源码剖析 – Activity发动流程（下），里面剖析了ClientTransaction业务是怎样被调度履行的

了解完后咱们就能够知道，生命周期业务的履行也就相当于分别调用ActivityLifecycleItem的preExecute、execute、postExecute办法，而PauseActivityItem没有重写preExecute办法，所以咱们就顺次剖析其execute、postExecute办法就好了

public void execute(ClientTransactionHandler client, IBinder token,
        PendingTransactionActions pendingActions) {
    client.handlePauseActivity(token, mFinished, mUserLeaving, mConfigChanges, pendingActions,
            "PAUSE_ACTIVITY_ITEM");
}

ClientTransactionHandler这个咱们之前说过，这是一个抽象类，被ActivityThread继承实现，所以这儿实际上便是调用ActivityThread.handlePauseActivity办法

handlePauseActivity

public void handlePauseActivity(IBinder token, boolean finished, boolean userLeaving,
        int configChanges, PendingTransactionActions pendingActions, String reason) {
    ActivityClientRecord r = mActivities.get(token);
    if (r != null) {
        ...
        r.activity.mConfigChangeFlags |= configChanges;
        performPauseActivity(r, finished, reason, pendingActions);
        // Make sure any pending writes are now committed.
        //保证一切大局使命都被处理完结
        if (r.isPreHoneycomb()) {
            QueuedWork.waitToFinish();
        }
        //更新标记
        mSomeActivitiesChanged = true;
    }
}
/**
 * Pause the activity.
 * @return Saved instance state for pre-Honeycomb apps if it was saved, {@code null} otherwise.
 */
private Bundle performPauseActivity(ActivityClientRecord r, boolean finished, String reason,
        PendingTransactionActions pendingActions) {
    ... //反常状况检查
    if (finished) {
        r.activity.mFinished = true;
    }
    // Pre-Honeycomb apps always save their state before pausing
    //是否需求保存状况信息（Android 3.0前无论是否finish都会触发保存）
    final boolean shouldSaveState = !r.activity.mFinished && r.isPreHoneycomb();
    if (shouldSaveState) {
        //回调Activity的onSaveInstanceState办法
        callActivityOnSaveInstanceState(r);
    }
    performPauseActivityIfNeeded(r, reason);
    ...//回调OnActivityPausedListener，现在看来只要NFC部分有注册这个回调
    ... //Android 3.0之前的特别处理
    //回来保存状况的Bundle
    return shouldSaveState ? r.state : null;
}
private void performPauseActivityIfNeeded(ActivityClientRecord r, String reason) {
    //已暂停，直接回来
    if (r.paused) {
        // You are already paused silly...
        return;
    }
    // Always reporting top resumed position loss when pausing an activity. If necessary, it
    // will be restored in performResumeActivity().
    //陈述resume状况改变
    reportTopResumedActivityChanged(r, false /* onTop */, "pausing");
    try {
        r.activity.mCalled = false;
        //回调Activity的onPause办法
        mInstrumentation.callActivityOnPause(r.activity);
        if (!r.activity.mCalled) {
            //必需要调用super.onPause办法
            throw new SuperNotCalledException("Activity " + safeToComponentShortString(r.intent)
                    + " did not call through to super.onPause()");
        }
    } catch ...
    //设置状况
    r.setState(ON_PAUSE);
}

这一条调用链路看下来仍是很简单的，和之前咱们剖析过的其他生命周期调用是一个套路，这儿显现调用了callActivityOnSaveInstanceState办法保存状况信息

private void callActivityOnSaveInstanceState(ActivityClientRecord r) {
    r.state = new Bundle();
    r.state.setAllowFds(false);
    if (r.isPersistable()) {
        r.persistentState = new PersistableBundle();
        mInstrumentation.callActivityOnSaveInstanceState(r.activity, r.state,
                r.persistentState);
    } else {
        mInstrumentation.callActivityOnSaveInstanceState(r.activity, r.state);
    }
}

经过Instrumentation调用Activity.performSaveInstanceState办法

final void performSaveInstanceState(@NonNull Bundle outState) {
    //分发PreSaveInstanceState事情，履行一切注册的ActivityLifecycleCallbacks的onActivityPreSaveInstanceState回调
    dispatchActivityPreSaveInstanceState(outState);
    //回调onSaveInstanceState
    onSaveInstanceState(outState);
    //保存受办理的Dialog的状况
    saveManagedDialogs(outState);
    //同享元素动画相关
    mActivityTransitionState.saveState(outState);
    //保存权限恳求状况
    storeHasCurrentPermissionRequest(outState);
    //分发PostSaveInstanceState事情，履行一切注册的ActivityLifecycleCallbacks的onActivityPostSaveInstanceState回调
    dispatchActivityPostSaveInstanceState(outState);
}

终究回调Activity.onSaveInstanceState办法

protected void onSaveInstanceState(@NonNull Bundle outState) {
    //保存窗口信息
    outState.putBundle(WINDOW_HIERARCHY_TAG, mWindow.saveHierarchyState());
    outState.putInt(LAST_AUTOFILL_ID, mLastAutofillId);
    //保存Fragment状况
    Parcelable p = mFragments.saveAllState();
    if (p != null) {
        outState.putParcelable(FRAGMENTS_TAG, p);
    }
    //主动填充相关
    if (mAutoFillResetNeeded) {
        outState.putBoolean(AUTOFILL_RESET_NEEDED, true);
        getAutofillManager().onSaveInstanceState(outState);
    }
    //分发SaveInstanceState事情，履行一切注册的ActivityLifecycleCallbacks的onActivitySaveInstanceState回调
    dispatchActivitySaveInstanceState(outState);
}

保存状况的流程就基本完结了，咱们再回过头来看onPause的触发

在上面performPauseActivityIfNeeded办法中有一行代码调用了Instrumentation.callActivityOnPause办法，
经过Instrumentation调用了Activity.performPause办法

final void performPause() {
    //分发PrePaused事情，履行一切注册的ActivityLifecycleCallbacks的onActivityPrePaused回调
    dispatchActivityPrePaused();
    mDoReportFullyDrawn = false;
    //FragmentManager分发pause状况
    mFragments.dispatchPause();
    mCalled = false;
    //回调onPause
    onPause();
    mResumed = false;
    //Target Sdk 9以上（Android 2.3）需求保证在onPause中调用super.onPause办法
    if (!mCalled && getApplicationInfo().targetSdkVersion
            >= android.os.Build.VERSION_CODES.GINGERBREAD) {
        throw new SuperNotCalledException(
                "Activity " + mComponent.toShortString() +
                " did not call through to super.onPause()");
    }
    //分发PostPaused事情，履行一切注册的ActivityLifecycleCallbacks的onActivityPostPaused回调
    dispatchActivityPostPaused();
}

履行onPause回调

protected void onPause() {
    //分发Paused事情，履行一切注册的ActivityLifecycleCallbacks的onActivityPaused回调
    dispatchActivityPaused();
    //主动填充相关
    if (mAutoFillResetNeeded) {
        if (!mAutoFillIgnoreFirstResumePause) {
            View focus = getCurrentFocus();
            if (focus != null && focus.canNotifyAutofillEnterExitEvent()) {
                getAutofillManager().notifyViewExited(focus);
            }
        } else {
            // reset after first pause()
            mAutoFillIgnoreFirstResumePause = false;
        }
    }
    //内容捕获服务
    notifyContentCaptureManagerIfNeeded(CONTENT_CAPTURE_PAUSE);
    //super.onPause标示为已被履行
    mCalled = true;
}

到此停止，Activity的onPause生命周期现已基本走完了，此刻咱们再回到PauseActivityItem.postExecute办法中做一些善后处理

public void postExecute(ClientTransactionHandler client, IBinder token,
        PendingTransactionActions pendingActions) {
    //mDontReport为咱们之前obtain办法中传入的pauseImmediately参数，一直为false
    if (mDontReport) {
        return;
    }
    try {
        // TODO(lifecycler): Use interface callback instead of AMS.
        //调用ATMS.activityPaused办法
        ActivityTaskManager.getService().activityPaused(token);
    } catch (RemoteException ex) {
        throw ex.rethrowFromSystemServer();
    }
}

这儿调用ATMS.activityPaused办法回到system_server进程处理Activity暂停后的事项

public final void activityPaused(IBinder token) {
    final long origId = Binder.clearCallingIdentity();
    synchronized (mGlobalLock) {
        //经过ActivityRecord.Token获取ActivityRecord
        final ActivityRecord r = ActivityRecord.forTokenLocked(token);
        if (r != null) {
            r.activityPaused(false);
        }
    }
    Binder.restoreCallingIdentity(origId);
}

调用ActivityRecord.activityPaused办法持续处理

void activityPaused(boolean timeout) {
    final ActivityStack stack = getStack();
    if (stack != null) {
        //移除超时监听
        removePauseTimeout();
        if (stack.mPausingActivity == this) {
            //暂停布局作业
            mAtmService.deferWindowLayout();
            try {
                stack.completePauseLocked(true /* resumeNext */, null /* resumingActivity */);
            } finally {
                //康复布局作业
                mAtmService.continueWindowLayout();
            }
            return;
        } else { //暂停Activity失利
            if (isState(PAUSING)) {
                setState(PAUSED, "activityPausedLocked");
                if (finishing) {
                    completeFinishing("activityPausedLocked");
                }
            }
        }
    }
    //更新Activity可见性
    mRootWindowContainer.ensureActivitiesVisible(null, 0, !PRESERVE_WINDOWS);
}

正常情况下会进入到ActivityStack.completePauseLocked办法中，但在暂停Activity失利的情况下，假如当时状况为PAUSING，则直接将其状况置为PAUSED已暂停，假如被标记为finishing，则会调用ActivityRecord.completeFinishing持续finish流程，这其实和正常情况下的调用链路差不多，详细咱们往下就能看到

void completePauseLocked(boolean resumeNext, ActivityRecord resuming) {
    ActivityRecord prev = mPausingActivity;
    if (prev != null) {
        prev.setWillCloseOrEnterPip(false);
        //之前的状况是否为正在中止
        final boolean wasStopping = prev.isState(STOPPING);
        //设置状况为已暂停
        prev.setState(PAUSED, "completePausedLocked");
        if (prev.finishing) {
            //持续finish流程
            prev = prev.completeFinishing("completePausedLocked");
        } else if (prev.hasProcess()) {
            //Configuration发生改变时可能会设置这个flag
            if (prev.deferRelaunchUntilPaused) {
                // Complete the deferred relaunch that was waiting for pause to complete.
                //等候暂停完结后relaunch Activity
                prev.relaunchActivityLocked(prev.preserveWindowOnDeferredRelaunch);
            } else if (wasStopping) {
                // We are also stopping, the stop request must have gone soon after the pause.
                // We can't clobber it, because the stop confirmation will not be handled.
                // We don't need to schedule another stop, we only need to let it happen.
                //之前的状况为正在中止，将状况置回即可
                prev.setState(STOPPING, "completePausedLocked");
            } else if (!prev.mVisibleRequested || shouldSleepOrShutDownActivities()) {
                // Clear out any deferred client hide we might currently have.
                prev.setDeferHidingClient(false);
                // If we were visible then resumeTopActivities will release resources before
                // stopping.
                //增加到stop列表中等候闲暇时履行stop
                prev.addToStopping(true /* scheduleIdle */, false /* idleDelayed */,
                        "completePauseLocked");
            }
        } else {
            //App在pause进程中逝世
            prev = null;
        }
        // It is possible the activity was freezing the screen before it was paused.
        // In that case go ahead and remove the freeze this activity has on the screen
        // since it is no longer visible.
        if (prev != null) {
            //中止屏幕冻住
            prev.stopFreezingScreenLocked(true /*force*/);
        }
        //Activity暂停完毕
        mPausingActivity = null;
    }
    //康复前一个顶层Activity
    if (resumeNext) {
        final ActivityStack topStack = mRootWindowContainer.getTopDisplayFocusedStack();
        if (topStack != null && !topStack.shouldSleepOrShutDownActivities()) {
            mRootWindowContainer.resumeFocusedStacksTopActivities(topStack, prev, null);
        } else {
            checkReadyForSleep();
            final ActivityRecord top = topStack != null ? topStack.topRunningActivity() : null;
            if (top == null || (prev != null && top != prev)) {
                // If there are no more activities available to run, do resume anyway to start
                // something. Also if the top activity on the stack is not the just paused
                // activity, we need to go ahead and resume it to ensure we complete an
                // in-flight app switch.
                mRootWindowContainer.resumeFocusedStacksTopActivities();
            }
        }
    }
    if (prev != null) {
        //康复按键分发
        prev.resumeKeyDispatchingLocked();
        ... //更新计算信息
    }
    //更新Activity可见性
    mRootWindowContainer.ensureActivitiesVisible(resuming, 0, !PRESERVE_WINDOWS);
    // Notify when the task stack has changed, but only if visibilities changed (not just
    // focus). Also if there is an active pinned stack - we always want to notify it about
    // task stack changes, because its positioning may depend on it.
    //告诉Task状况发生改变
    if (mStackSupervisor.mAppVisibilitiesChangedSinceLastPause
            || (getDisplayArea() != null && getDisplayArea().hasPinnedTask())) {
        mAtmService.getTaskChangeNotificationController().notifyTaskStackChanged();
        mStackSupervisor.mAppVisibilitiesChangedSinceLastPause = false;
    }
}

能够看到，无论暂停成功与否，终究都会走到ActivityRecord.completeFinishing办法中

/**
 * Complete activity finish request that was initiated earlier. If the activity is still
 * pausing we will wait for it to complete its transition. If the activity that should appear in
 * place of this one is not visible yet - we'll wait for it first. Otherwise - activity can be
 * destroyed right away.
 * @param reason Reason for finishing the activity.
 * @return Flag indicating whether the activity was removed from history.
 */
ActivityRecord completeFinishing(String reason) {
    ... //状况检查
    final boolean isCurrentVisible = mVisibleRequested || isState(PAUSED);
    if (isCurrentVisible) {
        ... //更新Activity可见性
    }
    boolean activityRemoved = false;
    // If this activity is currently visible, and the resumed activity is not yet visible, then
    // hold off on finishing until the resumed one becomes visible.
    // The activity that we are finishing may be over the lock screen. In this case, we do not
    // want to consider activities that cannot be shown on the lock screen as running and should
    // proceed with finishing the activity if there is no valid next top running activity.
    // Note that if this finishing activity is floating task, we don't need to wait the
    // next activity resume and can destroy it directly.
    // TODO(b/137329632): find the next activity directly underneath this one, not just anywhere
    final ActivityRecord next = getDisplayArea().topRunningActivity(
            true /* considerKeyguardState */);
    // isNextNotYetVisible is to check if the next activity is invisible, or it has been
    // requested to be invisible but its windows haven't reported as invisible.  If so, it
    // implied that the current finishing activity should be added into stopping list rather
    // than destroy immediately.
    final boolean isNextNotYetVisible = next != null
            && (!next.nowVisible || !next.mVisibleRequested);
    //假如此Activity当时可见，而要康复的Activity还不可见，则推延finish，直到要康复的Activity可见停止
    if (isCurrentVisible && isNextNotYetVisible) {
        // Add this activity to the list of stopping activities. It will be processed and
        // destroyed when the next activity reports idle.
        //增加到stop列表中等候闲暇时履行stop
        addToStopping(false /* scheduleIdle */, false /* idleDelayed */,
                "completeFinishing");
        //设置状况为stop中
        setState(STOPPING, "completeFinishing");
    } else if (addToFinishingAndWaitForIdle()) {
        // We added this activity to the finishing list and something else is becoming resumed.
        // The activity will complete finishing when the next activity reports idle. No need to
        // do anything else here.
        //将此Activity增加到待finish列表中，等候闲暇时履行finish
    } else {
        // Not waiting for the next one to become visible, and nothing else will be resumed in
        // place of this activity - requesting destruction right away.
        //马上毁掉此Activity
        activityRemoved = destroyIfPossible(reason);
    }
    return activityRemoved ? null : this;
}

关于非锁屏状况且当时要毁掉的Activity在前台的情况下，该Activity可见而待康复的Activity尚不可见，此刻优先完结待康复Activity的resume生命周期，等到之后闲暇再去处理待毁掉Activity的destroy生命周期

所以在面试中常问的Activity从B回来到A的生命周期次序咱们从这儿就能够看出来，理解后咱们就不用去死记硬背了：

B.onPause -> A.onRestart -> A.onResume -> B.onStop -> B.onDestory

关于锁屏状况或者要毁掉的Activity不在前台的情况下，由于不需求马上康复Activity，所以可能会直接处理待毁掉Activity的destroy生命周期

咱们以第一种当时要毁掉的Activity在前台的情况剖析，此刻会将这个Activity增加到stop列表中，并将状况设置为STOPPING，之后回来到ActivityStack.completePauseLocked办法中，持续履行resumeNext作业

在resumeNext中会调用RootWindowContainer.resumeFocusedStacksTopActivities办法康复栈顶Activity，由于这个办法之前现已在
Android源码剖析 – Activity发动流程（上） 中剖析过了，这儿就不再赘述了，咱们仍是将目光放在毁掉流程上

经过之前的文章，咱们知道康复Activity会调用到ActivityThread.handleResumeActivity办法，而当Activity康复完毕后，此办法终究一行会向MessageQueue增加一个IdleHandler，关于IdleHandler这儿就不再介绍了，这是每位Android开发都应该了解的东西

public void handleResumeActivity(IBinder token, boolean finalStateRequest, boolean isForward,
        String reason) {
    ...
    r.nextIdle = mNewActivities;
    mNewActivities = r;
    Looper.myQueue().addIdleHandler(new Idler());
}

这儿的Idler是ActivityThread的一个内部类

private class Idler implements MessageQueue.IdleHandler {
    @Override
    public final boolean queueIdle() {
        ActivityClientRecord a = mNewActivities;
        ...
        if (a != null) {
            mNewActivities = null;
            IActivityTaskManager am = ActivityTaskManager.getService();
            ActivityClientRecord prev;
            //遍历整条ActivityClientRecord.nextIdle链，顺次调用ATMS.activityIdle
            do {
                if (a.activity != null && !a.activity.mFinished) {
                    try {
                        am.activityIdle(a.token, a.createdConfig, stopProfiling);
                        a.createdConfig = null;
                    } catch (RemoteException ex) {
                        throw ex.rethrowFromSystemServer();
                    }
                }
                prev = a;
                a = a.nextIdle;
                prev.nextIdle = null;
            } while (a != null);
        }
        ...
        return false;
    }
}

这儿会遍历整个进程内一切的ActivityClientRecord，并顺次调用ATMS.activityIdle办法

public final void activityIdle(IBinder token, Configuration config, boolean stopProfiling) {
    ...
    final ActivityRecord r = ActivityRecord.forTokenLocked(token);
    if (r == null) {
        return;
    }
    mStackSupervisor.activityIdleInternal(r, false /* fromTimeout */,
            false /* processPausingActivities */, config);
    ...
}

从ActivityRecord.Token获取到ActivityRecord，接着调用ActivityStackSupervisor.activityIdleInternal办法

void activityIdleInternal(ActivityRecord r, boolean fromTimeout,
        boolean processPausingActivities, Configuration config) {
    ...
    // Atomically retrieve all of the other things to do.
    processStoppingAndFinishingActivities(r, processPausingActivities, "idle");
    ...
}

这儿咱们只需求要点重视processStoppingAndFinishingActivities这一个办法，从办法名咱们也能看出来，它是用来处理Activity stop或destroy的

/**
 * Processes the activities to be stopped or destroyed. This should be called when the resumed
 * activities are idle or drawn.
 */
private void processStoppingAndFinishingActivities(ActivityRecord launchedActivity,
        boolean processPausingActivities, String reason) {
    // Stop any activities that are scheduled to do so but have been waiting for the transition
    // animation to finish.
    ArrayList<ActivityRecord> readyToStopActivities = null;
    for (int i = mStoppingActivities.size() - 1; i >= 0; --i) {
        final ActivityRecord s = mStoppingActivities.get(i);
        final boolean animating = s.isAnimating(TRANSITION | PARENTS,
                ANIMATION_TYPE_APP_TRANSITION | ANIMATION_TYPE_RECENTS);
        //不在动画中或者ATMS服务正在封闭
        if (!animating || mService.mShuttingDown) {
            //跳过正在pause的Activitiy
            if (!processPausingActivities && s.isState(PAUSING)) {
                // Defer processing pausing activities in this iteration and reschedule
                // a delayed idle to reprocess it again
                removeIdleTimeoutForActivity(launchedActivity);
                scheduleIdleTimeout(launchedActivity);
                continue;
            }
            if (readyToStopActivities == null) {
                readyToStopActivities = new ArrayList<>();
            }
            //将预备好stop的Activitiy参加列表中
            readyToStopActivities.add(s);
            mStoppingActivities.remove(i);
        }
    }
    final int numReadyStops = readyToStopActivities == null ? 0 : readyToStopActivities.size();
    for (int i = 0; i < numReadyStops; i++) {
        final ActivityRecord r = readyToStopActivities.get(i);
        //Activity是否在使命栈中
        if (r.isInHistory()) {
            if (r.finishing) {
                // TODO(b/137329632): Wait for idle of the right activity, not just any.
                //被标记为finishing，尝试毁掉Activity
                r.destroyIfPossible(reason);
            } else {
                //不然仅仅只是stop Activity
                r.stopIfPossible();
            }
        }
    }
    final int numFinishingActivities = mFinishingActivities.size();
    if (numFinishingActivities == 0) {
        return;
    }
    // Finish any activities that are scheduled to do so but have been waiting for the next one
    // to start.
    final ArrayList<ActivityRecord> finishingActivities = new ArrayList<>(mFinishingActivities);
    mFinishingActivities.clear();
    for (int i = 0; i < numFinishingActivities; i++) {
        final ActivityRecord r = finishingActivities.get(i);
        if (r.isInHistory()) {
            //马上履行Activity的毁掉流程
            r.destroyImmediately(true /* removeFromApp */, "finish-" + reason);
        }
    }
}

关于被标记为finishing的Activity，调用destroyIfPossible办法毁掉

/**
 * Destroy and cleanup the activity both on client and server if possible. If activity is the
 * last one left on display with home stack and there is no other running activity - delay
 * destroying it until the next one starts.
 */
boolean destroyIfPossible(String reason) {
    //设置状况
    setState(FINISHING, "destroyIfPossible");
    // Make sure the record is cleaned out of other places.
    //保证此Activity已从待stop列表中移除
    mStackSupervisor.mStoppingActivities.remove(this);
    final ActivityStack stack = getRootTask();
    final TaskDisplayArea taskDisplayArea = getDisplayArea();
    final ActivityRecord next = taskDisplayArea.topRunningActivity();
    final boolean isLastStackOverEmptyHome =
            next == null && stack.isFocusedStackOnDisplay()
                    && taskDisplayArea.getOrCreateRootHomeTask() != null;
    if (isLastStackOverEmptyHome) {
        // Don't destroy activity immediately if this is the last activity on the display and
        // the display contains home stack. Although there is no next activity at the moment,
        // another home activity should be started later. Keep this activity alive until next
        // home activity is resumed. This way the user won't see a temporary black screen.
        //假如Home栈存在且这是当时焦点栈中终究一个Activity，则不要立即毁掉它
        //将此Activity增加到待finish列表中，等候闲暇时履行finish
        addToFinishingAndWaitForIdle();
        return false;
    }
    //设置finishing标记（之前设过了，这儿是重复设置）
    makeFinishingLocked();
    //马上履行Activity的毁掉流程
    final boolean activityRemoved = destroyImmediately(true /* removeFromApp */,
            "finish-imm:" + reason);
    // If the display does not have running activity, the configuration may need to be
    // updated for restoring original orientation of the display.
    //更新可见性和屏幕显现方向
    if (next == null) {
        mRootWindowContainer.ensureVisibilityAndConfig(next, getDisplayId(),
                false /* markFrozenIfConfigChanged */, true /* deferResume */);
    }
    //更新康复栈顶Activity
    if (activityRemoved) {
        mRootWindowContainer.resumeFocusedStacksTopActivities();
    }
    return activityRemoved;
}

这儿做了终究的一些判别，然后调用destroyImmediately办法，马上履行Activity的毁掉流程（这儿和上一个办法processStoppingAndFinishingActivities中，待finish列表的处理是相同的）

/**
 * Destroy the current CLIENT SIDE instance of an activity. This may be called both when
 * actually finishing an activity, or when performing a configuration switch where we destroy
 * the current client-side object but then create a new client-side object for this same
 * HistoryRecord.
 * Normally the server-side record will be removed when the client reports back after
 * destruction. If, however, at this point there is no client process attached, the record will
 * be removed immediately.
 *
 * @return {@code true} if activity was immediately removed from history, {@code false}
 * otherwise.
 */
boolean destroyImmediately(boolean removeFromApp, String reason) {
    //现已被毁掉或正在被毁掉，直接回来
    if (isState(DESTROYING, DESTROYED)) {
        return false;
    }
    boolean removedFromHistory = false;
    //整理作业
    cleanUp(false /* cleanServices */, false /* setState */);
    if (hasProcess()) {
        //整理更新作业
        if (removeFromApp) {
            app.removeActivity(this);
            if (!app.hasActivities()) {
                mAtmService.clearHeavyWeightProcessIfEquals(app);
                // Update any services we are bound to that might care about whether
                // their client may have activities.
                // No longer have activities, so update LRU list and oom adj.
                //更新进程信息
                app.updateProcessInfo(true /* updateServiceConnectionActivities */,
                        false /* activityChange */, true /* updateOomAdj */,
                        false /* addPendingTopUid */);
            }
        }
        boolean skipDestroy = false;
        try {
            //调度毁掉生命周期业务
            mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(), appToken,
                    DestroyActivityItem.obtain(finishing, configChangeFlags));
        } catch (Exception e) {
            // We can just ignore exceptions here...  if the process has crashed, our death
            // notification will clean things up.
            if (finishing) {
                //从历史使命中移除
                removeFromHistory(reason + " exceptionInScheduleDestroy");
                removedFromHistory = true;
                skipDestroy = true;
            }
        }
        nowVisible = false;
        // If the activity is finishing, we need to wait on removing it from the list to give it
        // a chance to do its cleanup.  During that time it may make calls back with its token
        // so we need to be able to find it on the list and so we don't want to remove it from
        // the list yet.  Otherwise, we can just immediately put it in the destroyed state since
        // we are not removing it from the list.
        if (finishing && !skipDestroy) {
            //设置状况
            setState(DESTROYING,
                    "destroyActivityLocked. finishing and not skipping destroy");
            //设置毁掉超时回调
            mAtmService.mH.postDelayed(mDestroyTimeoutRunnable, DESTROY_TIMEOUT);
        } else {
            //设置状况
            setState(DESTROYED,
                    "destroyActivityLocked. not finishing or skipping destroy");
            app = null;
        }
    } else {
        // Remove this record from the history.
        if (finishing) {
            //没有绑定进程，从历史使命中移除
            removeFromHistory(reason + " hadNoApp");
            removedFromHistory = true;
        } else {
            //没有绑定进程且不在finishing中，直接设置状况为已被毁掉
            setState(DESTROYED, "destroyActivityLocked. not finishing and had no app");
        }
    }
    configChangeFlags = 0;
    return removedFromHistory;
}

scheduleTransaction

这个办法做了一些整理作业，重头戏在于调用了ClientLifecycleManager.scheduleTransaction办法调度毁掉生命周期业务，接下来咱们就要点剖析这个业务的履行途径

scheduleTransaction的调用链路咱们在 Android源码剖析 – Activity发动流程（下） 中现已剖析过了，这儿我就简单的标示一下流程：

ClientLifecycleManager.scheduleTransaction ->
ClientTransaction.schedule ->
ActivityThread.scheduleTransaction ->
ClientTransaction.preExecute ->
ActivityLifecycleItem.preExecute->
ActivityThread.sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction) ->
TransactionExecutor.execute ->
TransactionExecutor.executeCallbacks ->
TransactionExecutor.executeLifecycleState ->
TransactionExecutor.cycleToPath ->
ActivityLifecycleItem.execute ->
ActivityLifecycleItem.postExecute

这儿的链路基本上和Activity发动业务链路相差无几，甚至更短了（Activity毁掉业务没有增加callback），所以没看过我上篇文章的强烈推荐去看一下，这儿我就不再做剖析了

咱们从TransactionExecutor.cycleToPath开端，之前咱们剖析过，咱们在业务中设置的ActivityLifecycleItem代表了Activity终究需求抵达履行的生命周期，而中心的那些过渡生命周期就由cycleToPath办法推动履行，咱们现在的生命周期状况为ON_PAUSE，而咱们的方针生命周期为ON_DESTROY，中心还夹着一个ON_STOP，所以这个办法会帮咱们履行ClientTransactionHandler.handleStopActivity办法，也便是ActivityThread.handleStopActivity办法

handleStopActivity

public void handleStopActivity(IBinder token, int configChanges,
        PendingTransactionActions pendingActions, boolean finalStateRequest /* false */, String reason) {
    final ActivityClientRecord r = mActivities.get(token);
    r.activity.mConfigChangeFlags |= configChanges;
    final StopInfo stopInfo = new StopInfo();
    //履行onStop生命周期
    performStopActivityInner(r, stopInfo, true /* saveState */, finalStateRequest,
            reason);
    //更新可见性
    updateVisibility(r, false);
    // Make sure any pending writes are now committed.
    //保证一切大局使命都被处理完结
    if (!r.isPreHoneycomb()) {
        QueuedWork.waitToFinish();
    }
    //记录Stop信息（不过在后续毁掉链路中好像并没有被用到）
    stopInfo.setActivity(r);
    stopInfo.setState(r.state);
    stopInfo.setPersistentState(r.persistentState);
    pendingActions.setStopInfo(stopInfo);
    mSomeActivitiesChanged = true;
}

接下来的途径就和其他生命周期差不多了，大部分内容我都用注释标示了，我们顺着往下看就行了

/**
 * Core implementation of stopping an activity.
 * @param r Target activity client record.
 * @param info Action that will report activity stop to server.
 * @param saveState Flag indicating whether the activity state should be saved.
 * @param finalStateRequest Flag indicating if this call is handling final lifecycle state
 *                          request for a transaction.
 * @param reason Reason for performing this operation.
 */
private void performStopActivityInner(ActivityClientRecord r, StopInfo info,
        boolean saveState, boolean finalStateRequest /* false */, String reason) {
    if (r != null) {
        ... //反常状况处理
        // One must first be paused before stopped...
        //假如没有被暂停则先履行pause生命周期
        performPauseActivityIfNeeded(r, reason);
        ... //设置描述（Activity.onCreateDescription）
        //回调Activity的onStop办法
        callActivityOnStop(r, saveState, reason);
    }
}

/**
 * Calls {@link Activity#onStop()} and {@link Activity#onSaveInstanceState(Bundle)}, and updates
 * the client record's state.
 * All calls to stop an activity must be done through this method to make sure that
 * {@link Activity#onSaveInstanceState(Bundle)} is also executed in the same call.
 */
private void callActivityOnStop(ActivityClientRecord r, boolean saveState, String reason) {
    // Before P onSaveInstanceState was called before onStop, starting with P it's
    // called after. Before Honeycomb state was always saved before onPause.
    //这儿shouldSaveState为true，由于activity.mFinished早在performPauseActivity的时分就被设为了true
    final boolean shouldSaveState = saveState && !r.activity.mFinished && r.state == null
            && !r.isPreHoneycomb();
    //targetSdkVersion为Android P (Android 9)之前
    final boolean isPreP = r.isPreP();
    if (shouldSaveState && isPreP) {
        callActivityOnSaveInstanceState(r);
    }
    try {
        //履行stop生命周期
        r.activity.performStop(r.mPreserveWindow, reason);
    } catch (SuperNotCalledException e) {
        throw e;
    } catch (Exception e) {
        ...
    }
    //设置生命周期状况
    r.setState(ON_STOP);
    if (shouldSaveState && !isPreP) {
        callActivityOnSaveInstanceState(r);
    }
}

final void performStop(boolean preserveWindow, String reason) {
    mDoReportFullyDrawn = false;
    //Loader相关，详见https://developer.android.com/guide/components/loaders
    mFragments.doLoaderStop(mChangingConfigurations /*retain*/);
    // Disallow entering picture-in-picture after the activity has been stopped
    //stop后禁用画中画
    mCanEnterPictureInPicture = false;
    if (!mStopped) {
        //分发PreStopped事情，履行一切注册的ActivityLifecycleCallbacks的onActivityPreStopped回调
        dispatchActivityPreStopped();
        //封闭一切子窗口
        if (mWindow != null) {
            mWindow.closeAllPanels();
        }
        // If we're preserving the window, don't setStoppedState to true, since we
        // need the window started immediately again. Stopping the window will
        // destroys hardware resources and causes flicker.
        if (!preserveWindow && mToken != null && mParent == null) {
            //设置中止状况，释放硬件资源，毁掉Surface
            WindowManagerGlobal.getInstance().setStoppedState(mToken, true);
        }
        //FragmentManager分发stop状况
        mFragments.dispatchStop();
        mCalled = false;
        //履行onStop回调
        mInstrumentation.callActivityOnStop(this);
        EventLogTags.writeWmOnStopCalled(mIdent, getComponentName().getClassName(), reason);
        if (!mCalled) {
            //必需要调用super.onStop办法
            throw new SuperNotCalledException(
                "Activity " + mComponent.toShortString() +
                " did not call through to super.onStop()");
        }
        //释放Cursors
        synchronized (mManagedCursors) {
            final int N = mManagedCursors.size();
            for (int i=0; i<N; i++) {
                ManagedCursor mc = mManagedCursors.get(i);
                if (!mc.mReleased) {
                    mc.mCursor.deactivate();
                    mc.mReleased = true;
                }
            }
        }
        mStopped = true;
        //分发PostStopped事情，履行一切注册的ActivityLifecycleCallbacks的onActivityPostStopped回调
        dispatchActivityPostStopped();
    }
    mResumed = false;
}

经过Instrumentation履行onStop回调

protected void onStop() {
    //ActionBar动画
    if (mActionBar != null) mActionBar.setShowHideAnimationEnabled(false);
    //同享元素动画
    mActivityTransitionState.onStop();
    //分发PostStopped事情，履行一切注册的ActivityLifecycleCallbacks的onActivityPostStopped回调
    dispatchActivityStopped();
    mTranslucentCallback = null;
    //super.onStop标示为已被履行
    mCalled = true;
    ... //主动填充相关
    mEnterAnimationComplete = false;
}

这样，一整个onStop生命周期就履行完结了，终究还剩下个onDestroy，根据之前写的业务调度链路，现在应该走到了DestroyActivityItem.execute办法

public void execute(ClientTransactionHandler client, IBinder token,
        PendingTransactionActions pendingActions) {
    client.handleDestroyActivity(token, mFinished, mConfigChanges,
            false /* getNonConfigInstance */, "DestroyActivityItem");
}

能够看到，实际上就直接调用了ActivityThread.handleDestroyActivity办法

handleDestroyActivity

public void handleDestroyActivity(IBinder token, boolean finishing, int configChanges,
        boolean getNonConfigInstance, String reason) {
    //履行onDestroy生命周期
    ActivityClientRecord r = performDestroyActivity(token, finishing,
            configChanges, getNonConfigInstance, reason);
    if (r != null) {
        //整理之前设置的延时移除的window
        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) {
                    // Hold off on removing this until the new activity's
                    // window is being added.
                    r.mPendingRemoveWindow = r.window;
                    r.mPendingRemoveWindowManager = wm;
                    // We can only keep the part of the view hierarchy that we control,
                    // everything else must be removed, because it might not be able to
                    // behave properly when activity is relaunching.
                    //从DecorView中移除ContentView
                    r.window.clearContentView();
                } else {
                    //马上履行View的移除操作，释放硬件资源，毁掉Surface，回调View.onDetachedFromWindow
                    wm.removeViewImmediate(v);
                }
            }
            if (wtoken != null && r.mPendingRemoveWindow == null) {
                //移除指定Window下的一切rootView
                WindowManagerGlobal.getInstance().closeAll(wtoken,
                        r.activity.getClass().getName(), "Activity");
            } else if (r.mPendingRemoveWindow != null) {
                // We're preserving only one window, others should be closed so app views
                // will be detached before the final tear down. It should be done now because
                // some components (e.g. WebView) rely on detach callbacks to perform receiver
                // unregister and other cleanup.
                //移除指定Window下除了当时DecorView以外的一切rootView
                WindowManagerGlobal.getInstance().closeAllExceptView(token, v,
                        r.activity.getClass().getName(), "Activity");
            }
            r.activity.mDecor = null;
        }
        if (r.mPendingRemoveWindow == null) {
            // If we are delaying the removal of the activity window, then
            // we can't clean up all windows here.  Note that we can't do
            // so later either, which means any windows that aren't closed
            // by the app will leak.  Well we try to warning them a lot
            // about leaking windows, because that is a bug, so if they are
            // using this recreate facility then they get to live with leaks.
            WindowManagerGlobal.getInstance().closeAll(token,
                    r.activity.getClass().getName(), "Activity");
        }
        // Mocked out contexts won't be participating in the normal
        // process lifecycle, but if we're running with a proper
        // ApplicationContext we need to have it tear down things
        // cleanly.
        //整理Context
        Context c = r.activity.getBaseContext();
        if (c instanceof ContextImpl) {
            ((ContextImpl) c).scheduleFinalCleanup(
                    r.activity.getClass().getName(), "Activity");
        }
    }
    if (finishing) {
        try {
            //处理一些毁掉后的事项，移除超时回调等
            ActivityTaskManager.getService().activityDestroyed(token);
        } catch (RemoteException ex) {
            throw ex.rethrowFromSystemServer();
        }
    }
    mSomeActivitiesChanged = true;
}

Window这块的处理我现在也不太了解，等以后我学习了WMS那块再补吧

其他的和之前的套路相同，调用performDestroyActivity办法履行毁掉Activity

/** Core implementation of activity destroy call. */
ActivityClientRecord performDestroyActivity(IBinder token, boolean finishing,
        int configChanges, boolean getNonConfigInstance, String reason) {
    ActivityClientRecord r = mActivities.get(token);
    Class<? extends Activity> activityClass = null;
    if (r != null) {
        activityClass = r.activity.getClass();
        r.activity.mConfigChangeFlags |= configChanges;
        if (finishing) {
            r.activity.mFinished = true;
        }
        //假如没有被暂停则先履行pause生命周期
        performPauseActivityIfNeeded(r, "destroy");
        //假如没有被停职则先履行stop生命周期
        if (!r.stopped) {
            callActivityOnStop(r, false /* saveState */, "destroy");
        }
        if (getNonConfigInstance) {
            ... //getNonConfigInstance为false，这儿不履行
        }
        try {
            r.activity.mCalled = false;
            //履行onDestroy回调
            mInstrumentation.callActivityOnDestroy(r.activity);
            //必需要调用super.onDestroy办法
            if (!r.activity.mCalled) {
                throw new SuperNotCalledException(
                    "Activity " + safeToComponentShortString(r.intent) +
                    " did not call through to super.onDestroy()");
            }
            //封闭一切子窗口
            if (r.window != null) {
                r.window.closeAllPanels();
            }
        } catch (SuperNotCalledException e) {
            throw e;
        } catch (Exception e) {
            ...
        }
        //设置生命周期状况
        r.setState(ON_DESTROY);
    }
    //闲暇时整理资源
    schedulePurgeIdler();
    // updatePendingActivityConfiguration() reads from mActivities to update
    // ActivityClientRecord which runs in a different thread. Protect modifications to
    // mActivities to avoid race.
    synchronized (mResourcesManager) {
        mActivities.remove(token);
    }
    //严厉形式更新Activity计数器，与实际Activity数量对比，判别是否发生内存走漏
    StrictMode.decrementExpectedActivityCount(activityClass);
    return r;
}

经过Instrumentation调用Activity.performDestroy办法

final void performDestroy() {
    //分发PreDestroyed事情，履行一切注册的ActivityLifecycleCallbacks的onActivityPreDestroyed回调
    dispatchActivityPreDestroyed();
    mDestroyed = true;
    mWindow.destroy();
    mFragments.dispatchDestroy();
    onDestroy();
    EventLogTags.writeWmOnDestroyCalled(mIdent, getComponentName().getClassName(),
            "performDestroy");
    mFragments.doLoaderDestroy();
    if (mVoiceInteractor != null) {
        mVoiceInteractor.detachActivity();
    }
    //分发PostDestroyed事情，履行一切注册的ActivityLifecycleCallbacks的onActivityPostDestroyed回调
    dispatchActivityPostDestroyed();
}

protected void onDestroy() {
    //super.onDestroy标示为已被履行
    mCalled = true;
    ... //主动填充相关
    // dismiss any dialogs we are managing.
    //封闭一切被办理的Dialog
    if (mManagedDialogs != null) {
        final int numDialogs = mManagedDialogs.size();
        for (int i = 0; i < numDialogs; i++) {
            final ManagedDialog md = mManagedDialogs.valueAt(i);
            if (md.mDialog.isShowing()) {
                md.mDialog.dismiss();
            }
        }
        mManagedDialogs = null;
    }
    // close any cursors we are managing.
    //封闭一切被办理的Cursor
    synchronized (mManagedCursors) {
        int numCursors = mManagedCursors.size();
        for (int i = 0; i < numCursors; i++) {
            ManagedCursor c = mManagedCursors.get(i);
            if (c != null) {
                c.mCursor.close();
            }
        }
        mManagedCursors.clear();
    }
    // Close any open search dialog
    //封闭系统搜索服务的弹窗
    if (mSearchManager != null) {
        mSearchManager.stopSearch();
    }
    if (mActionBar != null) {
        mActionBar.onDestroy();
    }
    //分发Destroyed事情，履行一切注册的ActivityLifecycleCallbacks的onActivityDestroyed回调
    dispatchActivityDestroyed();
    //内容捕获服务
    notifyContentCaptureManagerIfNeeded(CONTENT_CAPTURE_STOP);
}

DestroyActivityItem没有重写postExecute办法，所以到此停止，Activity整个毁掉流程就完毕了

Tips

咱们经过本篇文章的剖析，能够发现，触发Activity毁掉后，onStop和onDestroy这两个生命周期回调的触发时机是不确认的，假如有需求需求在确认Activity要被毁掉后马上履行，咱们能够在onPause回调中调用Activity.isFinishing办法判别mFinished标志是否被置true，假如为true则能够判定这个Activity将被毁掉

结尾

至此，Activity的发动流程和毁掉流程咱们都剖析完了，后边应该暂时不会再写Activity相关的源码剖析了

之后的一段时间，我可能会将我的精力投入到AIGC的技能调研中，Android源码剖析这一系列的后续更新可能会放慢，希望我们多多体谅