根Activity的启动过程
基于Android U
Activity的启动过程分为两种，一种是根Activity的启动过程，另一种是普通Activity的启动过程。根Activity指的是应用程序启动的第一个Activity，因此根Activity的启动过程一般情况下也可以理解为应用程序的启动过程。
原本四大组件的通信都是 AMS 来处理，后期AMS过于臃肿，将Activity相关工作转移到了ATMS中。
Launcher请求ATMS过程
Launcher启动后会将已安装应用程序的快捷图标显示到桌面上，这些应用程序的快捷图标就是启动根Activity的入口，当我们点击某个应用程序的快捷图标时，就会通过Launcher请求ATMS来启动该应用程序。
当我们点击应用程序的快捷图标时，就会调用Launcher#startActivitySafely()。
1 | |
调用了super.startActivitySafely()。
1 | |
由继承关系可知，调用的是ActivityContext#startActivitySafely()。
1 | |
注释1处将Flag设置为Intent.FLAG_ACTIVITY_NEW_TASK，这样根Activity会在新的任务栈中启动；
注释2处会调用Context#startActivity()，Context是抽象类，其中定义了抽象方法startActivity()，在其子类Activity中实现。
1 | |
在startActivity()中调用startActivityForResult()，它的第二个参数为-1，表示Launcher不需要知道Activity启动的结果。
1 | |
注释1处的mParent是Activity类型的，表示当前Activity的父类。因为目前根Activity还没有创建出来，因此，mParent == null为true。接着调用Instrumentation#execStartActivity()。Instrumentation主要用来监控应用程序和系统的交互。
1 | |
首先调用ActivityTaskManager#getService()来获取ATMS的代理对象，接着调用startActivity()。
先来看一下ActivityTaskManager#getService()做了什么：
1 | |
getService()调用了IActivityTaskManagerSingleton#get()。IActivityTaskManagerSingleton是一个Singleton类。在注释1处得到名为”activity_task”的Service引用，也就是IBinder类型的ATMS引用。接着在注释2处将它转换为IActivityTaskManager类型的对象。这段代码采用的是AIDL，IActivityTaskManager.java类是由AIDL工具在编译时自动生成的，IActivityTaskManager.aidl的文件路径是frameworks/base/core/java/android/app/IActivityTaskManager.aidl。要实现进程间通信，服务器端也就是ATMS只需要继承IActivityTaskManager.Stub类并实现相应的方法就可以了。
回到Instrumentation类的execStartActivity()方法中，从上面得知execStartActivity()最终调用的是ATMS的startActivity()方法。
ATMS到ApplicationThread的调用过程
Launcher请求ATMS之后，代码逻辑已经进入ATMS中，接着是ATMS到ApplicationThread的调用流程。
1 | |
在ATMS#startActivity()中返回了startActivityAsUser()方法，startActivityAsUser()比startActivity()多了一个参数UserHandle.getCallingUserId()，这个方法会获得调用者的UserId。ATMS根据这个UserId来确定调用者的权限。
1 | |
注释1处判断调用者进程是否被隔离，如果被隔离则抛出SecurityException异常；
注释2处检查调用者是否有权限，如果没有权限也会抛出SecurityException异常；
注释3处通过ActivityStartController来获取一个ActivityStarter，并且配置了一些参数。
ActivityStarter是加载Activity的控制类，会收集所有的逻辑来决定如何将Intent和Flags转换为Activity，并将Activity和Task相关联。execute()根据请求参数解析信息，executeRequest()执行一系列权限检查，对于合法的请求才继续。
1 | |
该方法中会执行一些初步的检查。
注释1处判断IApplicationThread类型的caller是否为null，caller指向的是Launcher所在的应用程序进程的ApplicationThread对象；
注释2处ActivityTaskManagerService#getProcessController()得到WindowProcessController对象，进一步获取Launcher进程的pid和uid；
接下来创建ActivityRecord，用于描述将要启动的Activity，然后注释3处调用startActivityUnchecked()。
1 | |
调用startActivityUnchecked()时表示大部分初步的权限检查已经完成，执行Trace，以及异常处理。
接着调用startActivityInner()启动Activity，并更新全局的Task栈帧信息。
1 | |
startActivityInner()用于启动 Activity，并更新全局的task栈帧信息，如处理singleTop、singleInstance问题，计算Intent Flag，以及栈顶复用问题等。接着调用RootWindowContainer#resumeFocusedTasksTopActivities()。
1 | |
resumeFocusedTasksTopActivities()将所有聚焦的Task的所有Activity恢复运行，因为有些刚加入的Activity是处于暂停状态的。resumeFocusedTasksTopActivities()中主要是判断传入的targetRootTask是否等于当前栈顶的 Task，不管是否相等，后续都是调用栈顶Task的resumeTopActivityUncheckedLocked()方法，启动栈顶Activity。
1 | |
resumeTopActivityUncheckedLocked()对 Task 进行了一次判断，如果是非叶子结点，则对所有子结点递归调用本方法，递归结束（即到达叶子结点）后才继续实际流程，然后进入到 resumeTopActivityInnerLocked()。
1 | |
调用TaskFragment#resumeTopActivity()。该方法主要是寻找合适的 ActivityRecord、设置 resume 条件、准备启动目标 Activity。
1 | |
调用 ActivityTaskSupervisor#startSpecificActivity()启动新进程。
1 | |
进程已存在时执行realStartActivityLocked()，进程不存在时执行ActivityTaskManagerService#startProcessAsync()。
1 | |
注释1处创建一个启动Activity事务；
注释2处添加Callback，这里创建的是LaunchActivityItem；
注释3处设置此次事务应该执行的最终状态，此次流程会设置为resume，表示Activity应该执行到onResume状态。设置ResumeActivityItem到clientTransaction中。
注释4处执行事务。
Activity的启动会通过事务来完成，事务通过目标App的IApplicationThread远程发送到目标App中，然后通过ClientLifecycleManager来执行。至此ATMS中执行的逻辑就结束了，剩下的就是目标App的ApplicationThread来执行目标Activity的各个生命周期方法了。
ApplicationThread启动Activity的过程
1 | |
执行ClientTransaction#schedule()。
1 | |
执行ApplicationThread#scheduleTransaction()。
1 | |
调用ActivityThread的scheduleTransaction()方法，ActivityThread继承自ClientTransactionHandler，实际调用的是ClientTransactionHandler的scheduleTransaction()方法，传入了创建好的transaction对象。
1 | |
调用sendMessage()方法，这里通过Handler发送了一个EXECUTE_TRANSACTION消息，会交给ActivityThread的H类来处理。
1 | |
在handleMessage()回调方法中执行EXECUTE_TRANSACTION对应的case。首先取出ClientTransaction对象，然后调用mTransactionExecutor的execute()方法，mTransactionExecutor是一个TransactionExecutor对象，是用来处理Transaction的。
1 | |
顺序执行executeCallbacks()和executeLifecycleState()方法。
executeCallbacks()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15frameworks/base/core/java/android/app/servertransaction/TransactionExecutor.java
public void executeCallbacks(ClientTransaction transaction) {
final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
...
final int size = callbacks.size();
for (int i = 0; i < size; ++i) {
final ClientTransactionItem item = callbacks.get(i);
...
item.execute(mTransactionHandler, token, mPendingActions);
item.postExecute(mTransactionHandler, token, mPendingActions);
...
}
}首先从系统进程传来的ClientTransaction中得到mActivityCallbacks列表，里面保存了一个LaunchActivityItem。接着通过遍历取出这个LaunchActivityItem，接着调用它的execute()方法，传入的第一个参数是持有的ActivityThread对象，第二个参数token是从系统进程传来的activityToken。
1
2
3
4
5
6
7
8
9
10
11
12frameworks/base/core/java/android/app/servertransaction/LaunchActivityItem.java
public void execute(ClientTransactionHandler client, IBinder token,
PendingTransactionActions pendingActions) {
...
ActivityClientRecord r = new ActivityClientRecord(token, mIntent, mIdent, mInfo,
mOverrideConfig, mReferrer, mVoiceInteractor, mState, mPersistentState,
mPendingResults, mPendingNewIntents, mActivityOptions, mIsForward, mProfilerInfo,
client, mAssistToken, mShareableActivityToken, mLaunchedFromBubble,
mTaskFragmentToken);
client.handleLaunchActivity(r, pendingActions, mDeviceId, null /* customIntent */);
...
}调用了ActivityThread类的handleLaunchActivity()方法。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20frameworks/base/core/java/android/app/ActivityThread.java
public Activity handleLaunchActivity(ActivityClientRecord r,
PendingTransactionActions pendingActions, int deviceId, Intent customIntent) {
...
final Activity a = performLaunchActivity(r, customIntent);
if (a != null) {
r.createdConfig = new Configuration(mConfigurationController.getConfiguration());
reportSizeConfigurations(r);
if (!r.activity.mFinished && pendingActions != null) {
pendingActions.setOldState(r.state);
pendingActions.setRestoreInstanceState(true);
pendingActions.setCallOnPostCreate(true);
}
} else {
...
}
return a;
}继续调用performLaunchActivity()。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49frameworks/base/core/java/android/app/ActivityThread.java
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
...
ContextImpl appContext = createBaseContextForActivity(r);
Activity activity = null;
try {
java.lang.ClassLoader cl = appContext.getClassLoader();
activity = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent); // 1
StrictMode.incrementExpectedActivityCount(activity.getClass());
r.intent.setExtrasClassLoader(cl);
r.intent.prepareToEnterProcess(isProtectedComponent(r.activityInfo),
appContext.getAttributionSource());
if (r.state != null) {
r.state.setClassLoader(cl);
}
} catch (Exception e) {
...
}
try {
Application app = r.packageInfo.makeApplicationInner(false, mInstrumentation); // 2
...
if (activity != null) {
...
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.activityConfigCallback,
r.assistToken, r.shareableActivityToken); // 3
...
// 4
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
...
}
...
} catch (SuperNotCalledException e) {
...
} catch (Exception e) {
...
}
return activity;
}注释1处创建Activity实例，这里的Activity指的是我们要启动的新的XXXActivity。调用了Instrumentation类的newActivity()方法；
注释2处尝试创建Application，r.packageInfo返回的是LoadedApk对象，调用了LoadApk的makeApplicationInner()方法。如果之前在bindApplication的时候已经创建了Application，这里直接返回之前创建的Application。
注释3处创建Activity的PhoneWindow，并将当前线程设置成主线程。我们在这个fork出来的新进程中还没有创建其他线程，这个Activity也是该App启动的第一个Activity，所以这个Activity就是在主线程中运行的。
注释4处调用了Instrumentation的callActivityOnCreate()，执行新Activity的onCreate生命周期。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26frameworks/base/core/java/android/app/Instrumentation.java
public void callActivityOnCreate(Activity activity, Bundle icicle) {
prePerformCreate(activity);
activity.performCreate(icicle);
postPerformCreate(activity);
}
frameworks/base/core/java/android/app/Activity.java
final void performCreate(Bundle icicle) {
performCreate(icicle, null);
}
final void performCreate(Bundle icicle, PersistableBundle persistentState) {
...
dispatchActivityPreCreated(icicle);
mCanEnterPictureInPicture = true;
...
restoreHasCurrentPermissionRequest(icicle);
final long startTime = SystemClock.uptimeMillis();
if (persistentState != null) {
onCreate(icicle, persistentState);
} else {
onCreate(icicle);
}
...
}executeLifecycleState()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28frameworks/base/core/java/android/app/servertransaction/TransactionExecutor.java
private void executeLifecycleState(ClientTransaction transaction) {
final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest(); // 1
if (lifecycleItem == null) {
// No lifecycle request, return early.
return;
}
final IBinder token = transaction.getActivityToken();
final ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
if (DEBUG_RESOLVER) {
Slog.d(TAG, tId(transaction) + "Resolving lifecycle state: "
+ lifecycleItem + " for activity: "
+ getShortActivityName(token, mTransactionHandler));
}
if (r == null) {
// Ignore requests for non-existent client records for now.
return;
}
// Cycle to the state right before the final requested state.
cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */, transaction); // 2
// Execute the final transition with proper parameters.
lifecycleItem.execute(mTransactionHandler, token, mPendingActions); // 3
lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
}注释1处获取的是之前添加的ResumeActivityItem；
注释2处cycleToPath()非常重要，其中的lifecycleItem.getTargetState()返回值是ON_RESUME；
注释3处执行ResumeActivityItem的execute()。
1 onStart()阶段
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43frameworks/base/core/java/android/app/servertransaction/TransactionExecutor.java
private void cycleToPath(ActivityClientRecord r, int finish, boolean excludeLastState,
ClientTransaction transaction) {
final int start = r.getLifecycleState(); // 1
...
final IntArray path = mHelper.getLifecyclePath(start, finish, excludeLastState); // 2
performLifecycleSequence(r, path, transaction); // 3
}
frameworks/base/core/java/android/app/servertransaction/TransactionExecutorHelper.java
public IntArray getLifecyclePath(int start, int finish, boolean excludeLastState) {
if (start == UNDEFINED || finish == UNDEFINED) {
throw new IllegalArgumentException("Can't resolve lifecycle path for undefined state");
}
if (start == ON_RESTART || finish == ON_RESTART) {
throw new IllegalArgumentException(
"Can't start or finish in intermittent RESTART state");
}
if (finish == PRE_ON_CREATE && start != finish) {
throw new IllegalArgumentException("Can only start in pre-onCreate state");
}
mLifecycleSequence.clear();
if (finish >= start) {
if (start == ON_START && finish == ON_STOP) {
...
} else {
// just go there
for (int i = start + 1; i <= finish; i++) { // 4
mLifecycleSequence.add(i);
}
}
} else { // finish < start, can't just cycle down
...
}
// Remove last transition in case we want to perform it with some specific params.
if (excludeLastState && mLifecycleSequence.size() != 0) { // 5
mLifecycleSequence.remove(mLifecycleSequence.size() - 1);
}
return mLifecycleSequence;
}注释1处的start是ON_CREATE；
注释2处finish是ON_RESUME，path是ON_START，这里是Activity执行onStart()函数的关键所在；
注释3处执行path中的相关的生命周期函数；
注释4处把ON_START和ON_RESUME添加到mLifecycleSequence中；
注释5处因为excludeLastState为true，所以删除掉ON_RESUME状态，只保留了ON_START。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49frameworks/base/core/java/android/app/servertransaction/TransactionExecutor.java
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);
if (DEBUG_RESOLVER) {
Slog.d(TAG, tId(transaction) + "Transitioning activity: "
+ getShortActivityName(r.token, mTransactionHandler)
+ " to state: " + getStateName(state));
}
switch (state) {
case ON_CREATE:
mTransactionHandler.handleLaunchActivity(r, mPendingActions,
Context.DEVICE_ID_INVALID, null /* customIntent */);
break;
case ON_START:
mTransactionHandler.handleStartActivity(r, mPendingActions,
null /* activityOptions */);
break;
case ON_RESUME:
mTransactionHandler.handleResumeActivity(r, false /* finalStateRequest */,
r.isForward, false /* shouldSendCompatFakeFocus */,
"LIFECYCLER_RESUME_ACTIVITY");
break;
case ON_PAUSE:
mTransactionHandler.handlePauseActivity(r, false /* finished */,
false /* userLeaving */, 0 /* configChanges */,
false /* autoEnteringPip */, mPendingActions,
"LIFECYCLER_PAUSE_ACTIVITY");
break;
case ON_STOP:
mTransactionHandler.handleStopActivity(r, 0 /* configChanges */,
mPendingActions, false /* finalStateRequest */,
"LIFECYCLER_STOP_ACTIVITY");
break;
case ON_DESTROY:
mTransactionHandler.handleDestroyActivity(r, false /* finishing */,
0 /* configChanges */, false /* getNonConfigInstance */,
"performLifecycleSequence. cycling to:" + path.get(size - 1));
break;
case ON_RESTART:
mTransactionHandler.performRestartActivity(r, false /* start */);
break;
default:
throw new IllegalArgumentException("Unexpected lifecycle state: " + state);
}
}
}state为ON_START，执行ActivityThread#handleStartActivity()。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21frameworks/base/core/java/android/app/ActivityThread.java
public void handleStartActivity(ActivityClientRecord r,
PendingTransactionActions pendingActions, ActivityOptions activityOptions) {
...
// Start
activity.performStart("handleStartActivity");
r.setState(ON_START);
...
}
frameworks/base/core/java/android/app/Activity.java
final void performStart(String reason) {
...
mInstrumentation.callActivityOnStart(this);
...
}
frameworks/base/core/java/android/app/Instrumentation.java
public void callActivityOnStart(Activity activity) {
activity.onStart();
}最终调用了Acitvity#onStart()。
2 onResume()阶段
1
2
3
4
5
6
7
8frameworks/base/core/java/android/app/servertransaction/ResumeActivityItem.java
public void execute(ClientTransactionHandler client, ActivityClientRecord r,
PendingTransactionActions pendingActions) {
Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityResume");
client.handleResumeActivity(r, true /* finalStateRequest */, mIsForward,
mShouldSendCompatFakeFocus, "RESUME_ACTIVITY");
Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}执行ActivityThread#handleStartActivity()。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36frameworks/base/core/java/android/app/ActivityThread.java
public void handleResumeActivity(ActivityClientRecord r, boolean finalStateRequest,
boolean isForward, boolean shouldSendCompatFakeFocus, String reason) {
...
if (!performResumeActivity(r, finalStateRequest, reason)) {
return;
}
...
}
public boolean performResumeActivity(ActivityClientRecord r, boolean finalStateRequest,
String reason) {
...
try {
...
r.activity.performResume(r.startsNotResumed, reason);
...
} catch (Exception e) {
...
}
return true;
}
frameworks/base/core/java/android/app/Activity.java
final void performResume(boolean followedByPause, String reason) {
...
mInstrumentation.callActivityOnResume(this);
...
}
frameworks/base/core/java/android/app/Instrumentation.java
public void callActivityOnResume(Activity activity) {
activity.mResumed = true;
activity.onResume();
...
}最终调用了Acitvity#onResume()。
根Activity的启动过程
https://citrus-maxima.github.io/2024/03/10/根Activity的启动过程/