【Framework】Activity 生命周期调用原理

原创

已于 2023-07-01 17:17:36 修改 · 1.2k 阅读

8 ·

CC 4.0 BY-SA版权

文章标签：

#android #java #开发语言

于 2021-07-04 17:10:00 首次发布

本文深入剖析了Android应用中Activity的生命周期，从启动到销毁的每个阶段，包括onCreate、onStart、onResume、onPause、onStop和onDestroy。重点分析了TransactionExecutor在处理Activity生命周期调用中的作用，以及AMS如何通过ClientTransactionItem触发客户端的生命周期方法。此外，还探讨了不同Android版本中OnSaveInstanceState的调用时机变化。

这一篇会重点分析客户端调用activity的生命周期流程

原文链接【framework】Activity 生命周期调用原理

引言

上一篇讲了Activity的创建过程（没看过的小伙伴移步点我前往）。由于篇幅的问题，只分析到OnCreate周期，那这一篇就接着讲余下部分的周期。

在高版本上，activity的周期都是以事务的方式调用，activityThread里面H类的EXECUTE_TRANSACTION 消息正是接收、处理事务的入口，实际最终由TransactionExecutor 处理该事务。（PS：ATMS即ActivityTaskManagerService的简写）

public final class ActivityThread extends ClientTransactionHandler {
   
   
    private final TransactionExecutor mTransactionExecutor = new TransactionExecutor(this);
    class H extends Handler {
   
         
             public void handleMessage(Message msg) {
   
   
                  case EXECUTE_TRANSACTION:
                        final ClientTransaction transaction = (ClientTransaction) msg.obj;
                        mTransactionExecutor.execute(transaction);
                        if (isSystem()) {
   
   
                            transaction.recycle();
                        }
                   .....
             }
        }
}

我们来看看整个activity启动过程会走哪些周期，请记住下面的周期和顺序，接下来就会讲讲这些周期是如何调用的

06-20 13:58:04.476 17073 17073 D MainActivity: onCreate:
06-20 13:58:04.481 17073 17073 D MainActivity: onStart:
06-20 13:58:04.483 17073 17073 D MainActivity: onPostCreate:
06-20 13:58:04.483 17073 17073 D MainActivity: onResume:
06-20 13:58:04.494 17073 17073 D MainActivity: onPostResume:
06-20 13:58:08.690 17073 17073 D MainActivity: onPause:
06-20 13:58:10.207 17073 17073 D MainActivity: onStop:
06-20 13:58:10.210 17073 17073 D MainActivity: onDestroy:

1. onCreate

framework之Activity启动流程，里面已经很详细描述了onCreate的调用流程，对应的流程如下

在这里插入图片描述
简单来讲，通过LaunchActivityItem调用了ActivityThread的handleLaunchActivity方法。ActivityThread在创建activity实例后，会设置config、window、resource、theme相关资源，在调用activity的attach方法后，会接着调用onCreate方法。

2. onStart

onCreate之后，onStart又是如何调用的呢？这里我们回顾一下TransactionExecutor#executeLifecycleState()

2.1 TransactionExecutor

代码路径：rameworks\base\core\java\android\app\servertransaction\TransactionExecutor.java

 // 将请求的事务转为最终的生命周期
 private void executeLifecycleState(ClientTransaction transaction) {
   
   
     ....
     final IBinder token = transaction.getActivityToken();
     // 通过token获取到对应的activityRecord
     final ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
     // 循环到最终请求状态之前的状态。
     cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */, transaction);
     // 使用适当的参数执行最终转换。
     lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
     // 处理后续的执行
     lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
 }

cycleToPath() 在拿到lifeCyclePath后就交给了performLifecycleSequence

// 循环到最终请求状态之前的状态。
private void cycleToPath(ActivityClientRecord r, int finish, boolean excludeLastState,
            ClientTransaction transaction) {
   
   
        final int start = r.getLifecycleState();
        // 计算活动的主要生命周期状态的路径，并使用从初始状态之后的状态开始的值填充
        // 比如onStart,onStop周期就是在这里额外加入的
        final IntArray path = mHelper.getLifecyclePath(start, finish, excludeLastState);
        performLifecycleSequence(r, path, transaction);
}

performLifecycleSequence()看起来是处理全部周期的地方，问题来了，我们怎么知道走到哪个case？

    private PendingTransactionActions mPendingActions = new PendingTransactionActions();
    private ClientTransactionHandler mTransactionHandler;
    ...
    // 通过之前的序列状态过渡为客户端的状态
    private void performLifecycleSequence(ActivityClientRecord r, IntArray path,
            ClientTransaction transaction) {
   
   
        final int size = path.size();
        for (int i = 0, state; i < size; i++) {
   
   
              state = path.get(i);
              switch (state) {
   
   
                case ON_CREATE:
                    mTransactionHandler.handleLaunchActivity(r, mPendingActions,
                            null /* customIntent */);
                    break;
                case ON_START:
                    mTransactionHandler.handleStartActivity(r.token, mPendingActions);
                    break;
                case ON_RESUME:
                    mTransactionHandler.handleResumeActivity(r.token, false /* finalStateRequest */,
                            r.isForward, "LIFECYCLER_RESUME_ACTIVITY");
                    break;
                   ....
            }
        }
    }

public abstract class ActivityLifecycleItem extends ClientTransactionItem {
   
   
    ....
    // 将周期状态映射到具体值
    public static final int ON_CREATE = 1;
    public static final int ON_START = 2;
    public static final int ON_RESUME = 3;
    public static final int ON_PAUSE = 4;
    public static final int ON_STOP = 5;
    public static final int ON_DESTROY = 6;
    public static final int ON_RESTART = 7;
}

通过debug发现，path的size是1，mValues的第一个值是2，即state为2，显然走到ON_START case，调用mTransactionHandler#handleStartActivity方法。
在这里插入图片描述
ClientTransactionHandler其实是一个抽象类，ActivityThread才是具体实现类

2.2 ActivityThread

代码路径： frameworks\base\core\java\android\app\ActivityThread.java

handleStartActivity 实现如下

 public void handleStartActivity(IBinder token, PendingTransactionActions pendingActions) {
   
   
     final ActivityClientRecord r = mActivities.get(token);
     final Activity activity = r.activity;
     // Start，即调用start周期
     activity.performStart("handleStartActivity");
     // 更新当前的状态
     r.setState(ON_START);
     // 恢复实例的状态，即调用OnRestoreInstanceState周期
     if (pendingActions.shouldRestoreInstanceState()) {
   
   
         if (r.isPersistable()) {
   
   
            mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state,
                         r.persistentState);
         } else if (r.state != null) {
   
   
             mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
         }
     }
     // 调用 postOnCreate() 周期
     if (pendingActions.shouldCallOnPostCreate()) {
   
   
         if (r.isPersistable()) {
   
   
             mInstrumentation.callActivityOnPostCreate(activity, r.state,
                     r.persistentState);
         } else {
   
   
             mInstrumentation.callActivityOnPostCreate(activity, r.state);
         }
     }
     // 将activity设置为可见
     updateVisibility(r, true /* show */);
 }

从上面可以看到，handleStartActivity 方法主要调用onStart、OnRestoreInstanceState和 postOnCreate 周期。并在最后将activity设置为可见

2.3 Activity

 // start 周期的入口
 final void performStart(String reason) {
   
   
     // 将onStart周期开始事件分发给监听器ActivityLifecycleCallbacks
     dispatchActivityPreStarted();
     // 将onStart的逻辑交给mInstrumentation
     mInstrumentation.callActivityOnStart(this);
     // 将周期分发给fragment
     mFragments.dispatchStart();
     ...
     // 将onSart周期结束事件分发给监听器ActivityLifecycleCallbacks
     dispatchActivityPostStarted();
 }

Instrumentation 也只是调用activity的onStart方法，这样做的好处是，可以将周期调用的时机暴露出去。

public class Instrumentation {
   
   
    public void callActivityOnStart(Activity activity) {
   
   
        activity.onStart();
    }
}

3. onRestart

这里也贴一下onRestart周期对应的path值
在这里插入图片描述
其实就是在onStart的前面插入了onStart 下标值，对应的case调用的是performRestartActivity方法

3.1 ActivityThread

代码路径： frameworks\base\core\java\android\app\ActivityThread.java

 @Override
 public void performRestartActivity(IBinder token, boolean start) {
   
   
     ActivityClientRecord r = mActivities.get(token);
     if (r.stopped) {
   
   
         r.activity.performRestart(start, "performRestartActivity");
         if (start) {
   
   
             r.setState(ON_START);
         }
     }
 }

3.2 Activity

Activity对应的方法是

 final void performRestart(boolean start, String reason) {
   
   
       ....
       // 直接调用onRestart周期
       mInstrumentation.callActivityOnRestart(this