美文网首页
Android Activity——启动过程探索（三）

Android Activity——启动过程探索（三）

作者: ITRenj | 来源:发表于2021-03-02 22:54 被阅读0次

Activity 系列博客

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

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

当前Activity调用 onStop()

Activity 启动流程-5. 当前Activity流程 onStop().png

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

当我们调用 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 启动流程-6. 当前Activity流程 onDestory().png

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

-> 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——启动过程探索（三）

      本文链接：https://www.haomeiwen.com/subject/lhrfqltx.html

      延伸阅读

      深度阅读

      • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

      栏目导航

      热点阅读

      关于我们|服务条款|联系我们|Android Activity——启动过程探索（三）|投稿指南|网站地图|RSS订阅|排版工具|手机版

      提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

      Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

      备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

      本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

      所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！