Launcher应用Activity启动流程(生命周期篇)

1,196 阅读4分钟

「这是我参与2022首次更文挑战的第29天,活动详情查看:2022首次更文挑战」。

Launcher应用Activity启动流程(生命周期篇)

在前篇 Launcher应用Activity启动流程分析(启动篇)中,分析到Activity的启动流程中,最终会进入到Activity的生命周期流程中,在这个流程中,主要有一些的几个步骤(标识)

  1. a 调用ClientTransaction对象的preExecute函数
  2. b 调用LaunchActivityItem对象的execute函数
  3. c 调用LaunchActivityItem对象的postExecute函数
  4. d 调用TransactionExecutor的cycleToPath函数
  5. e 调用ResumeActivityItem对象的execute函数
  6. f 调用ResumeActivityItem对象的postExecute函数 接下来,我们一一来分析下这几个步骤

调用ClientTransaction对象的preExecute函数

在分析该函数的具体代码前,先要了解这个函数的传入参数是什么?

这个函数的调用是通过ActivityThread对象的scheduleTransaction函数调用,而ActivityThread没有重写其父类ClientTransactionHandler的scheduleTransaction函数,直接调用其父类函数,因此在传入参数显示this的时候,其实传递的是ActivityThread对象

了解了其传入参数后,我们继续查看ClientTransaction对象的preExecute函数

public void preExecute(android.app.ClientTransactionHandler clientTransactionHandler) {
    if (mActivityCallbacks != null) {
        // mActivityCallbacks的初始化时在其addCallback函数第一次调用的时候
        // 我们此前通过addCallback添加过一个LaunchActivityItem对象,此处调用其preExecute函数
        final int size = mActivityCallbacks.size();
        for (int i = 0; i < size; ++i) {
            mActivityCallbacks.get(i).preExecute(clientTransactionHandler, mActivityToken);
        }
    }
    if (mLifecycleStateRequest != null) {
        // 这个Lifecycle Request,设置的是一个ResumeActivityItem对象
        mLifecycleStateRequest.preExecute(clientTransactionHandler, mActivityToken);
    }
}

因此,在这个函数中,先调用了此前初始化的LaunchActivityItem对象的preExecute函数,再调用了ResumeActivityItem对象的preExecute函数

LaunchActivityItem.java
public void preExecute(ClientTransactionHandler client, IBinder token) {
    // 为ActivityThread的mNumLaunchingActivities增加1,表明Activity的Launch开始
    client.countLaunchingActivities(1);
    client.updateProcessState(mProcState, false);
    client.updatePendingConfiguration(mCurConfig);
}

ResumeActivityItem.java
public void preExecute(ClientTransactionHandler client, IBinder token) {
    if (mUpdateProcState) {
        client.updateProcessState(mProcState, false);
    }
}

可以看到,此处主要在ActivityThread中做一些预加载流程,此处不做详细分析

LaunchActivityItem对象的execute函数

public void execute(ClientTransactionHandler client, IBinder token,
        PendingTransactionActions pendingActions) {
    ActivityClientRecord r = new ActivityClientRecord(token, mIntent, mIdent, mInfo,
            mOverrideConfig, mCompatInfo, mReferrer, mVoiceInteractor, mState, mPersistentState,
            mPendingResults, mPendingNewIntents, mIsForward,
            mProfilerInfo, client, mAssistToken, mFixedRotationAdjustments);
    client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
}

根据此前的分析此处传入参数client实质为一个ActivityThread对象,因此

ActivityThread.java
public Activity handleLaunchActivity(ActivityClientRecord r,
        PendingTransactionActions pendingActions, Intent customIntent) {
    // ......
    final Activity a = performLaunchActivity(r, customIntent);
    // ......
    return a;
}

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    ActivityInfo aInfo = r.activityInfo;
    // ......
    ContextImpl appContext = createBaseContextForActivity(r);
    Activity activity = null;
    try {
        // 获取ClassLoader对象
        java.lang.ClassLoader cl = appContext.getClassLoader();
        // 调用Instrumentation的newActivity初始化Activity对象
        // 此处会根据第二个参数获取其对应的Class,然后初始化它,此处就会直接得到一个Activity子类的实例
        // 也是应用中的main activity的实例
        activity = mInstrumentation.newActivity(
                cl, component.getClassName(), r.intent);
        // ......
    }
    // ......

    try {
        // 获取Application对象
        Application app = r.packageInfo.makeApplication(false, mInstrumentation);
        // ......
        if (activity != null) {
            // ......
            // 调用Activity对象的attach函数,此处会初始化Activity对象所必须的一些信息
            // 如PhoneWindow的初始化等
            appContext.setOuterContext(activity);
            activity.attach(appContext, this, getInstrumentation(), r.token,
                    r.ident, app, r.intent, r.activityInfo, title, r.parent,
                    r.embeddedID, r.lastNonConfigurationInstances, config,
                    r.referrer, r.voiceInteractor, window, r.configCallback,
                    r.assistToken);

            // .......
            // 设置Activity的主题
            int theme = r.activityInfo.getThemeResource();
            if (theme != 0) {
                activity.setTheme(theme);
            }

            // 调用Instrumentation的callActivityOnCreate函数,
            // 在这个函数中,会调用Activity的onCreate函数
            activity.mCalled = false;
            if (r.isPersistable()) {
                mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
            } else {
                mInstrumentation.callActivityOnCreate(activity, r.state);
            }
            // ......
        }
        // 注意:此处会设置当前ActivityClientRecord的状态为ON_CREATE
        r.setState(ON_CREATE);
        // ......
    }

    return activity;
}

可以看到,在这个函数中,

  1. 首先会调用Activity的attach函数,这个函数定义在Activity.java中,是final的,因此无法被子类重写,在此函数中会对Activity做一些基本的操作,如PhoneWindow的初始化和设置等
  2. 其次,调用Instrumentation的callActivityOnCreate函数,这个函数最终会调用Actiivty.onCreate函数,这也是Activity生命周期的第一个函数

LaunchActivityItem对象的postExecute函数

public void postExecute(ClientTransactionHandler client, IBinder token,
        PendingTransactionActions pendingActions) {
    client.countLaunchingActivities(-1);
}

这个函数主要在ActivityThread对象中将mNumLaunchingActivities数值减去1,表明当前Activity已经启动成功

TransactionExecutor的cycleToPath函数

// lifecycleItem参数是一个ResumeActivityItem对象,其getTargetState函数返回的是ON_RESUME
cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */, transaction);

public static final int PRE_ON_CREATE = 0;
public static final int ON_CREATE = 1;
public static final int ON_START = 2;
public static final int ON_RESUME = 3;

private void cycleToPath(ActivityClientRecord r, int finish, boolean excludeLastState,
        ClientTransaction transaction) {
    // 记得在Activity的onCreate函数调用完成后,会将ActivityClientRecord的状态设置为ON_CREATE
    final int start = r.getLifecycleState();
    // ......
    // start 和 finish 之间只有一个ON_START
    final IntArray path = mHelper.getLifecyclePath(start, finish, excludeLastState);
    performLifecycleSequence(r, path, transaction);
}

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_START:
                // 此处会直接调用ActivityThread的handleStartActivity函数
                mTransactionHandler.handleStartActivity(r.token, mPendingActions);
                break;
    }
}

public void handleStartActivity(IBinder token, PendingTransactionActions pendingActions) {
    final ActivityClientRecord r = mActivities.get(token);
    final Activity activity = r.activity;
    // ......
    // Start
    // 调用Activity的performStart函数,最终会调用到Activity的onStart函数
    activity.performStart("handleStartActivity");
    r.setState(ON_START);
    // ......
    // Restore instance state
    // 最终调用到Activity的onRestoreInstanceState函数
    if (pendingActions.shouldRestoreInstanceState()) {
        if (r.isPersistable()) {
            if (r.state != null || r.persistentState != null) {
                mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state,
                        r.persistentState);
            }
        } else if (r.state != null) {
            mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
        }
    }

    // Call postOnCreate()
    // 最终调用Activity的onPostCreate函数
    if (pendingActions.shouldCallOnPostCreate()) {
        activity.mCalled = false;
        if (r.isPersistable()) {
            mInstrumentation.callActivityOnPostCreate(activity, r.state,
                    r.persistentState);
        } else {
            mInstrumentation.callActivityOnPostCreate(activity, r.state);
        }
        // ......
    }
}

如上代码和备注,此处会依次调用函数的onStart、onRestoreInstanceState 和 onPostCreate函数

ResumeActivityItem对象的execute函数

public void execute(ClientTransactionHandler client, IBinder token,
        PendingTransactionActions pendingActions) {
    Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityResume");
    client.handleResumeActivity(token, true /* finalStateRequest */, mIsForward,
            "RESUME_ACTIVITY");
    Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}

根据前述的分析,此处的ActivityThread的handleResumeActivity函数,最终会调用Activity的onResume函数,此处不做详细分析

ResumeActivityItem对象的postExecute函数

public void postExecute(ClientTransactionHandler client, IBinder token,
        PendingTransactionActions pendingActions) {
    // ......
    // TODO(lifecycler): Use interface callback instead of AMS.
    ActivityTaskManager.getService().activityResumed(token);
    // ......
}

可以看到,此处会向ATMS报告Activity onResume函数已经完成

总结

基于前面的三篇文章,Launcher应用Activity启动的大致流程,就已经梳理完成了,整个流程的代码时序图如下

图片.png