Activity生命周期

24K
281 阅读2分钟

1.概述

之前的文章App启动流程分析了点击Launcher上的app图标启动app，并创建Application和启动第一个Activity的流程。既然提到Activity自然就涉及到Activity的生命周期，都知道Activity的生命周期包括onCreate、onStart、onResume等等，那么在成功创建Activity之后这些生命周期是如何驱动起来的呢？

2.onCreate

之前的文章App启动流程中详细分析了Activity启动之后如何执行到onCreate方法的流程，这里只进行简单的总结性描述。首先来到ActivityThread中的Handler内部类H，在相对高版本的安卓系统上各种组件的创建等流程都是向这个Handler发送消息来完成的。Activity的onCreate方法执行的来源则是EXECUTE_TRANSACTION

class H extends Handler {
    ....
    public static final int EXECUTE_TRANSACTION = 159;
    ....
    public void handleMessage(Message msg) {
        switch (msg.what) {
            ....
            case EXECUTE_TRANSACTION:
                final ClientTransaction transaction = (ClientTransaction) msg.obj;
                //执行事务
                mTransactionExecutor.execute(transaction);
                ....
                break;
        }
        ....
    }
}
TransactionExecutor#execute
public void execute(ClientTransaction transaction) {
    final IBinder token = transaction.getActivityToken();
    // 该方法中通过遍历 transaction#callbacks 获取到LaunchActivityItem，然后调用onCreate方法
    executeCallbacks(transaction);
    // onStart方法的执行入口
    executeLifecycleState(transaction);
}
TransactionExecutor#executeCallbacks
public void executeCallbacks(ClientTransaction transaction) {
        final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
        ....
        //此处的item是LaunchActivityItem
        item.execute(mTransactionHandler, token, mPendingActions);
        item.postExecute(mTransactionHandler, token, mPendingActions);
        ....
    }
}
LaunchActivityItem#execute
public void execute(ClientTransactionHandler client, IBinder token,
        PendingTransactionActions pendingActions) {
        ....
        //这里的client就是ActivityThread，最终是调用ActivityThread的handleLaunchActivity方法
        client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
}
ActivityThread#handleLaunchActivity
public Activity handleLaunchActivity(ActivityClientRecord r,
        PendingTransactionActions pendingActions, Intent customIntent) {
    ....
    //performLaunchActivity方法会执行Activity的onCreate
    final Activity a = performLaunchActivity(r, customIntent);
    ....
}

从上述流程可以看出H接收到EXECUTE_TRANSACTION消息后通过TransactionExecutor执行事务来到LaunchActivityItem的execute方法，在execute方法中会执行到ActivityThread的handleLaunchActivity方法进而执行到performLaunchActivity，再往下一步其实就是通过Instrumentation来真正调用到OnCreate方法了，这里就不进行再下一步的分析了。其实在ActivityThread中存在多套handleXXXActivity与performXXXActivity的对应方法来处理Activity的生命周期的执行。

3.onStart

上文注释中标注了TransactionExecutor的executeLifecycleState方法是onStart的执行入口，这里就从这个方法开始分析。

TransactionExecutor#executeLifecycleState
private void executeLifecycleState(ClientTransaction transaction) {
    //此处获取到的是ResumeActivityItem
   final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest(); 
    ....
    //关键方法cycleToPath
    cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */);
    ....
    //由于此处是ResumeActivityItem，所以此处是onResume方法的执行入口
    lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
    lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
}
TransactionExecutor#cycleToPath
private void cycleToPath(ActivityClientRecord r, int finish,
        boolean excludeLastState) {
    //获取开始状态    
    final int start = r.getLifecycleState();
    //计算最终状态
    final IntArray path = mHelper.getLifecyclePath(start, finish, excludeLastState);
    performLifecycleSequence(r, path);
}
TransactionExecutor#performLifecycleSequence
private void performLifecycleSequence(ActivityClientRecord r, IntArray path) {
    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:
                //当前状态是onStart，所以会执行到这里，mTransactionHandler就是ActivityThread
                mTransactionHandler.handleStartActivity(r, mPendingActions);
                break;
            case ON_RESUME:
                mTransactionHandler.handleResumeActivity(r.token, false /* finalStateRequest */,
                        r.isForward, "LIFECYCLER_RESUME_ACTIVITY");
                break;
            case ON_PAUSE:
                mTransactionHandler.handlePauseActivity(r.token, false /* finished */,
                        false /* userLeaving */, 0 /* configChanges */, mPendingActions,
                        "LIFECYCLER_PAUSE_ACTIVITY");
                break;
            case ON_STOP:
                mTransactionHandler.handleStopActivity(r.token, false /* show */,
                        0 /* configChanges */, mPendingActions, false /* finalStateRequest */,
                        "LIFECYCLER_STOP_ACTIVITY");
                break;
            case ON_DESTROY:
                mTransactionHandler.handleDestroyActivity(r.token, false /* finishing */,
                        0 /* configChanges */, false /* getNonConfigInstance */,
                        "performLifecycleSequence. cycling to:" + path.get(size - 1));
                break;
            case ON_RESTART:
                mTransactionHandler.performRestartActivity(r.token, false /* start */);
                break;
            default:
                throw new IllegalArgumentException("Unexpected lifecycle state: " + state);
        }
    }
}

可以看到在onCreate方法执行之后通过执行TransactionExecutor的executeLifecycleState方法与cycleToPath方法计算出下一个状态的state，最后通过performLifecycleSequence方法执行到相应的生命周期处理方法。在此处当前的state是ON_START（具体计算的方式不分析了，读者可以通过调试的方式来查看），最后执行到了ActivityThread的handleStartActivity方法进而执行Activity的onStart方法。

4.onResume

上文注释中提到executeLifecycleState方法中transaction.getLifecycleStateRequest()这行代码获取到的是ResumeActivityItem。那么为什么获取到的是ResumeActivityItem呢？这里其实是在更早的时候构造ClientTransaction的时候就已经通过setLifecycleStateRequest方法设置好了。

final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
        boolean andResume, boolean checkConfig) throws RemoteException {
        ....
        final ActivityLifecycleItem lifecycleItem;
        if (andResume) {
            //这里进行获取ResumeActivityItem
           lifecycleItem =   ResumeActivityItem.obtain(mService.isNextTransitionForward());
        } else {
           lifecycleItem = PauseActivityItem.obtain();
        }
           //给Transaction设置lifecycleItem为ResumeActivityItem
           clientTransaction.setLifecycleStateRequest(lifecycleItem);
           // Schedule transaction.
           mService.getLifecycleManager().scheduleTransaction(clientTransaction);
        ....
}

接下来就需要分析ResumeActivityItem的execute方法了。

ResumeActivityItem#execute
public void execute(ClientTransactionHandler client, IBinder token,
        PendingTransactionActions pendingActions) {
    //client仍然是ActivityThread
    client.handleResumeActivity(token, true /* finalStateRequest */, mIsForward,
            "RESUME_ACTIVITY");
}

可以看到方法调用到了ActivityThread的handleResumeActivity方法了，最终也就会执行到onResume方法了。

5.onPause

通过上面的分析可以发现LaunchActivityItem对应Activity的onCreate方法，ResumeActivityItem对应Activity的onResume方法。通过源码可以发现 ClientTransactionItem有多个子类，除了以上两个之外还包括PauseActivityItem、StopActivityItem、DestroyActivityItem，这三种ActivityLifecycleItem是如何添加到ClientTransaction来执行的这里就不详细分析了。

public class PauseActivityItem extends ActivityLifecycleItem {
    ....
    @Override
    public void execute(ClientTransactionHandler client, IBinder token,
            PendingTransactionActions pendingActions) {
        //执行ActivityThread的handlePauseActivity方法 
        client.handlePauseActivity(token, mFinished, mUserLeaving, mConfigChanges, pendingActions,
                "PAUSE_ACTIVITY_ITEM");
    }
    @Override
    public int getTargetState() {
        return ON_PAUSE; //最终的state是ON_PAUSE
    }
    ....
}

PauseActivityItem的execute方法会调用到ActivityThread的handlePauseActivity方法，进而执行到performPauseActivity方法，最后就会执行到onPause方法。

6.onStop

同理onStop方法自然对应StopActivityItem

public class StopActivityItem extends ActivityLifecycleItem {
    ....
    @Override
    public void execute(ClientTransactionHandler client, IBinder token,
            PendingTransactionActions pendingActions) {
        //执行ActivityThread的handleStopActivity方法 
        client.handleStopActivity(token, mShowWindow, mConfigChanges, pendingActions,
                true /* finalStateRequest */, "STOP_ACTIVITY_ITEM");
    }

    @Override
    public int getTargetState() {
        return ON_STOP; //最终的state是ON_STOP
    }
    ....
}

StopActivityItem的execute方法会调用到ActivityThread的handleStopActivity方法，最后就会执行到onStop方法。

7.onDestory

onDestory方法的执行对应DestroyActivityItem

public class DestroyActivityItem extends ActivityLifecycleItem {
    ....
    @Override
    public void execute(ClientTransactionHandler client, IBinder token,
            PendingTransactionActions pendingActions) {
        //执行ActivityThread的handleDestroyActivity方法    
        client.handleDestroyActivity(token, mFinished, mConfigChanges,
                false /* getNonConfigInstance */, "DestroyActivityItem");
    }

    @Override
    public int getTargetState() {
        return ON_DESTROY; //最终的state是ON_DESTROY
    }
    ....
}

DestroyActivityItem的execute方法会调用到ActivityThread的handleDestroyActivity方法，最后就会执行到onDestory方法。

注：以上分析基于API Level 28

8.总结

Activity的生命周期的执行逻辑其实都依赖ActivityThread来处理，生命周期的逻辑调度上通过ClientTransaction的execute方法来执行对应生命周期的ClientTransactionItem来完成。

参考文章
Activity生命周期

avatar
文章
阅读
粉丝