「这是我参与2022首次更文挑战的第29天,活动详情查看:2022首次更文挑战」。
Launcher应用Activity启动流程(生命周期篇)
在前篇 Launcher应用Activity启动流程分析(启动篇)中,分析到Activity的启动流程中,最终会进入到Activity的生命周期流程中,在这个流程中,主要有一些的几个步骤(标识)
- a 调用ClientTransaction对象的preExecute函数
- b 调用LaunchActivityItem对象的execute函数
- c 调用LaunchActivityItem对象的postExecute函数
- d 调用TransactionExecutor的cycleToPath函数
- e 调用ResumeActivityItem对象的execute函数
- 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;
}
复制代码
可以看到,在这个函数中,
- 首先会调用Activity的attach函数,这个函数定义在Activity.java中,是final的,因此无法被子类重写,在此函数中会对Activity做一些基本的操作,如PhoneWindow的初始化和设置等
- 其次,调用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启动的大致流程,就已经梳理完成了,整个流程的代码时序图如下