Android Activity——启动过程探索

Posted ITRenj

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Android Activity——启动过程探索相关的知识，希望对你有一定的参考价值。

在《Android Activity——启动过程探索（一） 和 《Android Activity——启动过程探索（二） 中我们知道了Activity启动的生命周期回调，并且分析了其中当前Activity的 onPause() 和新打开的Activity的 onCreate() 、 onStart()和onResume()回调执行过程，也就是新的Activity已经完成了 “创建->用户可见->用户可操作” 的过程。那么当前的Activity就变为不可见了，需要执行 onstop() 回调，如果调用了 finish() 方法，还要执行 onDestory() 回调，这篇文章我们就来分析一下这两个回调的执行过程。

注意：以下分析过程，源码版本为 android 10（Api 29），不同Android版本可能有一些差别。

当前Activity调用 onStop()


根据上图查看对应的方法：

当我们调用 startActivity() 之后，系统按如下步骤执行:

-> Activity#startActivity()
-> Activity#startActivityForResult()
-> Instrumentation#execStartActivity(activity, mMainThread.getApplicationThread(), mToken, this,intent, requestCode, options)

说明：

  1. mMainThread.getApplicationThread() 返回 ApplicationThread
  2. ApplicationThread 的声明为 ActivityThread.ApplicationThread extends IApplicationThread.Stub

-> ActivityTaskManagerService#startActivity()

说明：

  1. ActivityTaskManagerService 通过 ActivityTaskManager.getService() 获取
  2. ActivityTaskManager.getService() 返回 IActivityTaskManager
  3. ActivityTaskManagerService 的声明为 ActivityTaskManagerService extends IActivityTaskManager.Stub，所以上一步是： ActivityTaskManagerService#startActivity()

-> ActivityTaskManagerService#startActivityAsUser()

说明：

  1. 会多次调用重载方法，这里就看做一步了，最终走到 下一步

-> ActivityStartController#obtainStarter()

说明：

  1. ActivityStartController 通过 getActivityStartController() 方法获取
  2. ActivityStartController.obtainStarter() 方法返回的是ActivityStarter对象
  3. 然后设置数据，实际调用的都是 ActivityStarter 中的设置数据方法，最终调用 ActivityStarter 的 execute() 方法

具体代码如下：

	getActivityStartController().obtainStarter(intent, "startActivityAsUser")
                .setCaller(caller)
                .setCallingPackage(callingPackage)
                .setResolvedType(resolvedType)
                .setResultTo(resultTo)
                .setResultWho(resultWho)
                .setRequestCode(requestCode)
                .setStartFlags(startFlags)
                .setProfilerInfo(profilerInfo)
                .setActivityOptions(bOptions)
                .setMayWait(userId) // 注意该方法，会将ActivityStarter mRequest.mayWait = true;
                .execute();

-> ActivityStarter#execute()

说明：

  1. 上一步的 setMayWait() 方法 会将 ActivityStarter 中的 mRequest.mayWait 标识置为 true，在 execute() 方法中会通过该标记判断下一步执行的方法

-> ActivityStarter#startActivityMayWait()
-> ActivityStarter#startActivity()

说明：

  1. 会多次调用重载 startActivity() 方法，这里就看做一步了，最终走到 下一步

-> ActivityStarter#startActivityUnchecked()
-> RootActivityContainer#resumeFocusedStacksTopActivities()

说明：

  1. 调用重载无参数方法，由无参数方法调用有参数方法，参数都为null，看做一步，走到下一步

-> ActivityStack#resumeTopActivityUncheckedLocked()
-> ActivityStack#resumeTopActivityInnerLocked()
-> ActivityStackSupervisor#startSpecificActivityLocked()
-> ActivityStackSupervisor#realStartActivityLocked()

realStartActivityLocked() 方法中有如下代码：

// Create activity launch transaction.
final ClientTransaction clientTransaction = ClientTransaction.obtain(
        proc.getThread(), r.appToken);

final DisplayContent dc = r.getDisplay().mDisplayContent;
clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
        System.identityHashCode(r), r.info,
        mergedConfiguration.getGlobalConfiguration(),
        mergedConfiguration.getOverrideConfiguration(), r.compat,
        r.launchedFromPackage, task.voiceInteractor, proc.getReportedProcState(),
        r.icicle, r.persistentState, results, newIntents,
        dc.isNextTransitionForward(), proc.createProfilerInfoIfNeeded(),r.assistToken));

mService.getLifecycleManager().scheduleTransaction(clientTransaction);

说明：

  1. mService.getLifecycleManager() 方法返回的对象是 ClientLifecycleManager，（其中mService 是 ActivityTaskManagerService）
  2. 创建 ClientTransaction 对象后，调用了它的 addCallback() 方法，增加了 LaunchActivityItem 对象（LaunchActivityItem extends ClientTransactionItem）

-> ClientLifecycleManager#scheduleTransaction(ClientTransaction transaction)
-> ClientTransaction#schedule()
-> IApplicationThread#scheduleTransaction()

说明：

  1. IApplicationThread就是ActivityThread.ApplicationThread
  2. 在 ActivityThread.ApplicationThread 中直接调用了 ActivityThread.this.scheduleTransaction(transaction)，所以最终调用的是 ActivityThread#scheduleTransaction()，但是 ActivityThread 中并没有这个方法，是在其父类 ClientTransactionHandler 中的方法（ ActivityThread extends ClientTransactionHandler）

-> ClientTransactionHandler#sendMessage()

说明：

  1. sendMessage() 方法在 ClientTransactionHandler中定义，由子类 ActivityThread 实现

  2. 在sendMessage()方法中传递的 what 是 ActivityThread.H.EXECUTE_TRANSACTION

  3. 在ActivityThread中的handler消息都是由 ActivityThread 内部类 H 负责处理，所以查看 H 类中 handleMessage() 方法对应的处理逻辑

     case EXECUTE_TRANSACTION:
     final ClientTransaction transaction = (ClientTransaction) msg.obj;
     mTransactionExecutor.execute(transaction);
     if (isSystem()) 
         transaction.recycle();
     
     break;

  4. mTransactionExecutor 对象是 TransactionExecutor

-> TransactionExecutor#execute(transaction)
-> TransactionExecutor#executeCallbacks(transaction)
-> ActivityLifecycleItem#execute()

final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
lifecycleItem.execute(mTransactionHandler, token, mPendingActions);

说明：

  1. transaction.getLifecycleStateRequest() 获取到的实际是：ResumeActivityItem。具体原因如下：

    在 ActivityStackSupervisor#realStartActivityLocked()方法中有如下代码：

     		if (andResume) 
             lifecycleItem = ResumeActivityItem.obtain(dc.isNextTransitionForward());
          else 
             lifecycleItem = PauseActivityItem.obtain();
         
 		// 设置了 lifecycleItem 
 		clientTransaction.setLifecycleStateRequest(lifecycleItem);

    往前走能知道 andResume 参数为 true，所以这里的 lifecycleItem 为 ResumeActivityItem

-> ClientTransactionHandler#handleResumeActivity()

说明：

  1. handleResumeActivity() 方法在 ClientTransactionHandler中定义，由子类 ActivityThread 实现，所以查看 ActivityThread 的 handleResumeActivity()

==== 标记 =============================== 以上部分和上一步的是一样的 ==================================== 标记 ====

-> Looper.myQueue().addIdleHandler(new Idler())

说明：

  1. Idler 为 ActivityThread内部类，定义为： class Idler implements MessageQueue.IdleHandler

  2. 将Idler对象增加到消息队列中，然后通过 MessageQueue 的 next() 方法获取并执行。这里的Looper线程就是是主线程

  3. 在MessageQueue类中的 next() 方法内有如下代码：

     final IdleHandler idler = mPendingIdleHandlers[i];
 mPendingIdleHandlers[i] = null; // release the reference to the handler

 boolean keep = false;
 try 
     keep = idler.queueIdle();
  catch (Throwable t) 
     Log.wtf(TAG, "IdleHandler threw exception", t);
 

 if (!keep) 
     synchronized (this) 
         mIdleHandlers.remove(idler);

根据上面代码，可以看到调用了 Idler类的 queueIdle() 方法

-> Idler#queueIdle()

说明：queueIdle() 核心代码如下：

IActivityTaskManager am = ActivityTaskManager.getService();
ActivityClientRecord prev;
do 
    if (localLOGV) Slog.v(
        TAG, "Reporting idle of " + a +
        " finished=" +
        (a.activity != null && a.activity.mFinished));
    if (a.activity != null && !a.activity.mFinished) 
        try 
			// 调用 ActivityTaskManagerService#activityIdle()
            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);

-> ActivityTaskManagerService#activityIdle()
-> ActivityStackSupervisor#activityIdleInternalLocked()

说明：

  1. activityIdleInternalLocked() 中线获取需要调用 onStop() 的 ActivityRecord，然后调用 ActivityStack.stopActivityLocked()

     final ArrayList<ActivityRecord> stops = processStoppingActivitiesLocked(r, true ,processPausingActivities);
 NS = stops != null ? stops.size() : 0;
 
 for (int i = 0; i < NS; i++) 
     r = stops.get(i);
     final ActivityStack stack = r.getActivityStack();
     if (stack != null) 
 		// 这里 r.finishing 是false
         if (r.finishing) 
             stack.finishCurrentActivityLocked(r, ActivityStack.FINISH_IMMEDIATELY, false,"activityIdleInternalLocked");
          else 
             stack.stopActivityLocked(r);

  2. processStoppingActivitiesLocked() 方法获取到的 ActivityRecord 是在哪里添加的呢？

    查看方法详情，我们发现这个方法是从 ActivityStackSupervisor 类中的 mStoppingActivities（定义：ArrayList<ActivityRecord> mStoppingActivities） 变量获取的数据，那么当前需要调用 onStop() 回调的这个Activity是在什么时候添加到这个变量中的呢？

    我们回过头看一下在《Android Activity——启动过程探索（一）》中 的 “当前Activity调用 onPause() 过程” 这一步有调用 ActivityStack.startPausingLocked() 方法的过程，在方法内有如下代码：

     if (mPausingActivity != null) 
 	// 查看方法参数，可知 pauseImmediately 参数为 false
     if (pauseImmediately) 
         completePauseLocked(false, resuming);
         return false;
      else 
 		// 所以调用schedulePauseTimeout()方法
         schedulePauseTimeout(prev);
         return true;
     
 

 // schedulePauseTimeout()方法，发送一个消息
 private void schedulePauseTimeout(ActivityRecord r) 
     final Message msg = mHandler.obtainMessage(PAUSE_TIMEOUT_MSG);
     msg.obj = r;
     r.pauseTime = SystemClock.uptimeMillis();
     mHandler.sendMessageDelayed(msg, PAUSE_TIMEOUT);
 

 // 消息处理代码
 case PAUSE_TIMEOUT_MSG: 
     ActivityRecord r = (ActivityRecord)msg.obj;
     synchronized (mService.mGlobalLock) 
         if (r.hasProcess()) 
             mService.logAppTooSlow(r.app, r.pauseTime, "pausing " + r);
         
 		// 调用方法
         activityPausedLocked(r.appToken, true);

    在 activityPausedLocked() 方法内部调用 completePauseLocked(true, null )，接着调用 addToStopping(prev, true, false,"completePauseLocked")，在 addToStopping() 方法中有如下代码：

     	if (!mStackSupervisor.mStoppingActivities.contains(r)) 
         EventLog.writeEvent(EventLogTags.AM_ADD_TO_STOPPING, r.mUserId,
                 System.identityHashCode(r), r.shortComponentName, reason);
         mStackSupervisor.mStoppingActivities.add(r);

    将当前的Activity添加到了 mStackSupervisor.mStoppingActivities 中。

-> ActivityStack#stopActivityLocked()

stopActivityLocked() 方法中有如下代码：

mService.getLifecycleManager().scheduleTransaction(r.app.getThread(), r.appToken,
                    StopActivityItem.obtain(r.visible, r.configChangeFlags));

说明：

  1. mService.getLifecycleManager() 方法返回的对象是 ClientLifecycleManager，（其中mService 是 ActivityTaskManagerService）
  2. 重点注意方法中的几个参数：
    1. 第一个参数 prev.app.getThread() 获取到的是 IApplicationThread（IApplicationThread 的声明在上面已经说明了）
    2. 第三个参数 StopActivityItem.obtain()，注意StopActivityItem类： StopActivityItem extends ActivityLifecycleItem

-> ClientLifecycleManager#scheduleTransaction(IApplicationThread client, IBinder activityToken, ActivityLifecycleItem stateRequest)

注意 scheduleTransaction() 方法的代码：

final ClientTransaction clientTransaction = transactionWithState(client, activityToken,stateRequest);
scheduleTransaction(clientTransaction);

// 调用方法创建 ClientTransaction 对象
private static ClientTransaction transactionWithState(@NonNull IApplicationThread client,
        @NonNull IBinder activityToken, @NonNull ActivityLifecycleItem stateRequest) 
    final ClientTransaction clientTransaction = ClientTransaction.obtain(client, activityToken);
	// 注意调用的是 setLifecycleStateRequest() 方法
    clientTransaction.setLifecycleStateRequest(stateRequest);
    return clientTransaction;

构建了一个 ClientTransaction 对象 clientTransaction 进行传递，调用重载方法。其中 stateRequest 就是 StopActivityItem。

-> ClientLifecycleManager#scheduleTransaction(ClientTransaction transaction)
-> ClientTransaction#schedule()
-> IApplicationThread#scheduleTransaction()

说明：

  1. IApplicationThread就是ActivityThread.ApplicationThread
  2. 在 ActivityThread.ApplicationThread 中直接调用了 ActivityThread.this.scheduleTransaction(transaction)，所以最终调用的是 ActivityThread#scheduleTransaction()，但是 ActivityThread 中并没有这个方法，是在其父类 ClientTransactionHandler 中的方法（ ActivityThread extends ClientTransactionHandler）

-> ClientTransactionHandler#sendMessage()

说明：

  1. sendMessage() 方法在 ClientTransactionHandler中定义，由子类 ActivityThread 实现

  2. 在sendMessage()方法中传递的 what 是 ActivityThread.H.EXECUTE_TRANSACTION

  3. 在ActivityThread中的handler消息都是由 ActivityThread 内部类 H 负责处理，所以查看 H 类中 handleMessage() 方法对应的处理逻辑

     case EXECUTE_TRANSACTION:
     final ClientTransaction transaction = (ClientTransaction) msg.obj;
     mTransactionExecutor.execute(transaction);
     if (isSystem()) 
         transaction.recycle();
     
     break;

  4. mTransactionExecutor 对象是 TransactionExecutor

-> TransactionExecutor#execute(transaction)

说明：

  1. 参数 transaction 就是上面 scheduleTransaction() 方法中构建的对象

-> TransactionExecutor#executeLifecycleState(transaction)

final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
lifecycleItem.execute(mTransactionHandler, token, mPendingActions);

说明：

  1. 参数 transaction 就是上面构建的 ClientTransaction 对象
  2. transaction.getLifecycleStateRequest() 获取到 ActivityLifecycleItem 对象，，在这里实际上获取到的就是 StopActivityItem 对象，是在 ClientLifecycleManager#scheduleTransaction(IApplicationThread client, IBinder activityToken, ActivityLifecycleItem stateRequest) 这一步中构建 ClientTransactionItem 对象时通过 transactionWithState() 方法设置的。

-> StopActivityItem#execute()
-> ClientTransactionHandler#handleStopActivity()

说明：

  1. handleStopActivity() 方法在 ClientTransactionHandler中定义，由子类 ActivityThread 实现，所以查看 ActivityThread 的 handleStopActivity()

-> ActivityThread#performStopActivityInner()
-> ActivityThread#callActivityOnStop()
-> Activity#performStop()
-> Instrumentation#callActivityOnStop()
-> Activity#onStop()

通过以上步骤，当前不可见的Activity的onStop()方法已经被回调了，那么正常打开Activity的过程通过 《Android Activity——启动过程探索（一） 和 《Android Activity——启动过程探索（二） 及以上代码的说明已经算是基本完成了，但是在打开新的Activity的同时，需要关闭当前的Activity，那么调用 finish() 方法的过程是怎样的呢？请继续往下看。

当前Activity调用 onDestory()

调用了 finish() 方法时，关闭当前Activity，最终会调用 onDestory() 回调。

根据上图查看对应的方法：

-> Activity#finish()

if (ActivityTaskManager.getService().finishActivity(mToken, resultCode, resultData, finishTask)) 
    mFinished = true;

ActivityTaskManager.getService() 获取的对象为：ActivityTaskManagerService

-> ActivityTaskManagerService#finishActivity()
-> ActivityStack#requestFinishActivityLocked()
-> ActivityStack#finishActivityLocked()

 r.makeFinishingLocked();
 ...

 // 当前Activity是否为顶层Activity，是的话，走onPause()的流程
 if (mResumedActivity == r) 
    if (endTask) 
        mService.getTaskChangeNotificationController().notifyTaskRemovalStarted(
                task.getTaskInfo());
    
    getDisplay().mDisplayContent.prepareAppTransition(transit, false);
    r.setVisibility(false);

    if (mPausingActivity == null) 
        startPausingLocked(false, false, null, pauseImmediately);
    

    if (endTask) 
        mService.getLockTaskController().clearLockedTask(task);
    
 else if (!r.isState(PAUSING))  // 状态已经是 STOPPING 了
    if (r.visible) 
        prepareActivityHideTransitionAnimation(r, transit);
    

    final int finishMode = (r.visible || r.nowVisible) ? FINISH_AFTER_VISIBLE
            : FINISH_AFTER_PAUSE;
    final boolean removedActivity = finishCurrentActivityLocked(r, finishMode, oomAdj,
            "finishActivityLocked") == null;
    if (task.onlyHasTaskOverlayActivities(true /* excludeFinishing */)) 
        for (ActivityRecord taskOverlay : task.mActivities) 
            if (!taskOverlay.mTaskOverlay) 
                continue;
            
            prepareActivityHideTransitionAnimation(taskOverlay, transit);
        
    
    return removedActivity;

首先判断当前Activity是不是顶层Activity，也就是没有打开新的Activity，直接关闭的情况，就调用 ActivityStack.startPausingLocked()，走onPause()回调。这里我们不考虑了，所以调用 finishCurrentActivityLocked() 方法

-> ActivityStack#finishCurrentActivityLocked()
-> ActivityStack#destroyActivityLocked()

mService.getLifecycleManager().scheduleTransaction(r.app.getThread(), 
					r.appToken,DestroyActivityItem.obtain(r.finishing, r.configChangeFlags));

说明：

  1. mService.getLifecycleManager() 方法返回的对象是 ClientLifecycleManager，（其中mService 是 ActivityTaskManagerService）
  2. 重点注意方法中的几个参数：
    1. 第一个参数 prev.app.getThread() 获取到的是 IApplicationThread（IApplicationThread 的声明在上面已经说明了）
    2. 第三个参数 DestroyActivityItem.obtain()，注意StopActivityItem类： DestroyActivityItem extends ActivityLifecycleItem

-> ClientLifecycleManager#scheduleTransaction(IApplicationThread client, IBinder activityToken, ActivityLifecycleItem stateRequest)

注意 scheduleTransaction() 方法的代码：

final ClientTransaction clientTransaction = transactionWithState(client, activityToken,stateRequest);
scheduleTransaction(clientTransaction);

// 调用方法创建 ClientTransaction 对象
private static ClientTransaction transactionWithState(@NonNull IApplicationThread client,
        @NonNull IBinder activityToken, @NonNull ActivityLifecycleItem stateRequest) 
    final ClientTransaction clientTransaction = ClientTransaction.obtain(client, activityToken);
	// 注意调用的是 setLifecycleStateRequest() 方法
    clientTransaction.setLifecycleStateRequest(stateRequest);
    return clientTransaction;

构建了一个 ClientTransaction 对象 clientTransaction 进行传递，调用重载方法。其中 stateRequest 就是 StopActivityItem。

-> ClientLifecycleManager#scheduleTransaction(ClientTransaction transaction)
-> ClientTransaction#schedule()
-> IApplicationThread#scheduleTransaction()

说明：

  1. IApplicationThread就是ActivityThread.ApplicationThread
  2. 在 ActivityThread.ApplicationThread 中直接调用了 ActivityThread.this.scheduleTransaction(transaction)，所以最终调用的是 ActivityThread#scheduleTransaction()，但是 ActivityThread 中并没有这个方法，是在其父类 ClientTransactionHandler 中的方法（ ActivityThread extends ClientTransactionHandler）

-> ClientTransactionHandler#sendMessage()

说明：

  1. sendMessage() 方法在 ClientTransactionHandler中定义，由子类 ActivityThread 实现

  2. 在sendMessage()方法中传递的 what 是 ActivityThread.H.EXECUTE_TRANSACTION

  3. 在ActivityThread中的handler消息都是由 ActivityThread 内部类 H 负责处理，所以查看 H 类中 handleMessage() 方法对应的处理逻辑

     case EXECUTE_TRANSACTION:
     final ClientTransaction transaction = (ClientTransaction) msg.obj;
     mTransactionExecutor.execute(transaction);
     if (isSystem()) 
         transaction.recycle();
     
     break;

  4. mTransactionExecutor 对象是 TransactionExecutor

-> TransactionExecutor#execute(transaction)

说明：

  1. 参数 transaction 就是上面 scheduleTransaction() 方法中构建的对象

-> TransactionExecutor#executeLifecycleState(transaction)

final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
lifecycleItem.execute(mTransactionHandler, token, mPendingActions);

说明：

  1. 参数 transaction 就是上面构建的 ClientTransaction 对象
  2. transaction.getLifecycleStateRequest() 获取到 ActivityLifecycleItem 对象，，在这里实际上获取到的就是 DestroyActivityItem 对象，是在 ClientLifecycleManager#scheduleTransaction(IApplicationThread client, IBinder activityToken, ActivityLifecycleItem stateRequest) 这一步中构建 ClientTransactionItem 对象时通过 transactionWithState() 方法设置的。

-> DestroyActivityItem#execute()
-> ClientTransactionHandler#handleDestroyActivity()

说明：

  1. handleDestroyActivity() 方法在 ClientTransactionHandler中定义，由子类 ActivityThread 实现，所以查看 ActivityThread 的 handleDestroyActivity()

-> ActivityThread#handleDestroyActivity()
-> ActivityThread#performDestroyActivity()

// 是否需要调用 onStop() 方法
if (!r.stopped) 
    callActivityOnStop(r, false /* saveState */, "destroy");

try 
    r.activity.mCalled = false;
    mInstrumentation.callActivityOnDestroy(r.activity);
    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 (Exception e)

说明：

  1. 在这里会对Activity状态进行判断，看对否已经是 stopped，如果不是，会先调用 callActivityOnStop() 方法，然后走 onStop() 回调

-> Instrumentation#callActivityOnDestroy()
-> Activity#performDestroy()
-> Activity#onDestroy()

以上就是调用 finish() 时，Activity的关闭（回调 onDestory() 方法）过程。

通过《Android Activity——启动过程探索（一） 和 《Android Activity——启动过程探索（二） 以及以上分析，我们已经知道了在我们启动一个新的Activity同时关闭当前Activity时的整个流程了，当然，其中还有很多的细节问题没有分析，如：启动模式（任务栈）、参数的传递与处理等需要我们继续探讨与学习。

扩展

在 **“当前Activity调用 onDestory()”**一节中， 对于 ActivityStack#finishActivityLocked()部分有个说明

 r.makeFinishingLocked();
	 ...

 // 当前Activity是否为顶层Activity，是的话，走onPause()的流程
 if (mResumedActivity == r) 
    if (endTask) 
        mService.getTaskChangeNotificationController().notifyTaskRemovalStarted(
                task.getTaskInfo());
    
    getDisplay().mDisplayContent.prepareAppTransition(transit, false);
    r.setVisibility(false);

    if (mPausingActivity == null) 
        startPausingLocked(false, false, null, pauseImmediately);
    

    if (endTask) 
        mService.getLockTaskController().clearLockedTask(task);

我们在分析上面时是直接跳过了，在这里继续来看一下，先调用了 ActivityRecord 的 makeFinishingLocked() 方法：

void makeFinishingLocked() 
    if (finishing) 
        return;
    
    finishing = true;
    if (stopped) 
        clearOptionsLocked();
    

    if (mAtmService != null) 
        mAtmService.getTaskChangeNotificationController().notifyTaskStackChanged();

将 finishing 变量设置为 true了。接着调用 ActivityStackSupervisor.startPausingLocked() 方法，之后流程就是和 《Android Activity——启动过程探索（一）中**“当前Activity调用 onPause()”**一样了，只把需要注意的地方提取出来说明:

在上文中对 ActivityStackSupervisor#activityIdleInternalLocked() 这一步的说明中有一个这样的过程:

ActivityStack.startPausingLocked() -> ActivityStack.schedulePauseTimeout() -> mHandler.sendMessageDelayed(msg, PAUSE_TIMEOUT) -> ActivityStack.activityPausedLocked() -> ActivityStack.completePauseLocked()

最终会调用 ActivityStack.completePauseLocked() 方法，在这个方法中有如下代码：

ActivityRecord prev = mPausingActivity;
if (prev != null) 
    final boolean wasStopping = prev.isState(STOPPING);
    prev.setState(PAUSED, "completePausedLocked");
    if (prev.finishing) 
        prev = finishCurrentActivityLocked(prev, FINISH_AFTER_VISIBLE, false,
                "completePausedLocked");
    
    mPausingActivity = null;

此时 mPausingActivity 即是要销毁的 activity !=null，所以 prev != null，并且上面我们已经在 makeFinishingLocked() 方法中将变量 finishing 这是为 true 了，所以这里会调用 finishCurrentActivityLocked() 方法，接下来的执行过程和 “当前Activity调用 onDestory()” 部分一样了，只是这里我们只是调用了 onPuse() 回调，离 onDestory() 回调中间还有一步，执行 onStop() 回调，这一步是在**ActivityThread#performDestroyActivity()**中操作的：

// 我们已经执行了 pause()过程，所以这里不需要了
performPauseActivityIfNeeded(r, "destroy");

// 是否需要调用 onStop() 方法，这里需要，所以先调用 Activity的 onStop()
if (!r.stopped) 
    callActivityOnStop(r, false /* saveState */, "destroy");

try 
    r.activity.mCalled = false;
    mInstrumentation.callActivityOnDestroy(r.activity);
    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 (Exception e)

说明：

  1. 先判断是否需要执行 onPause() 过程，这里已经不需要了，因为我们已经执行了 ActivityStackSupervisor.startPausingLocked() 方法了
  2. 接着对Activity状态进行判断，看对否已经是 stopped，这里不是 STOPPING 状态，所以会先调用 callActivityOnStop() 方法，走 onStop() 回调。

以上的说明，其实就是当我们在顶层Activity直接调用 finish() 的执行过程，因为不打开新的Activity，所以 onPause()和onStop()都不会在之前执行，都是在调用 finish() 方法后执行。

以上是关于Android Activity——启动过程探索的主要内容，如果未能解决你的问题，请参考以下文章

Android Activity——启动过程探索

Android Activity——启动过程探索

Android开发艺术探索——第一章：Activity的生命周期和启动模式

Activity常见问题

Activity常见问题

Android： Activity启动模式 FLAG_ACTIVITY_NEW_TASK 详细探索