四大组件系列
一概述
Activity 的启动非常复杂，其中涉及到多个进程参与工作。Activity 所在的进程，系统进程（Zygote），AMS 进程，还有点击桌面图标所在的 Launch 进程。由于这个原因，所以很难在一篇文章中，将它们所有的工作内容梳理清楚。并且由于其中大部分逻辑，都是在 AMS 中完成的，所以我打算本篇仅描述 Activity 的启动流程，关于进程的启动，Activity 的栈管理，都放在 AMS 的篇章中。
本篇先梳理整个启动流程。关于启动流程，本篇只梳理出大致脉络即可，关于其中的进程启动，进程管理，任务栈管理，后续会单独列举出来介绍。
二 startActivity
首先是我们熟悉的 startActivity，需要注意的是，startActivity 需要区分 Activity 中的 startActivity 和 Context 中的 startActivity，这一点在后面有不同的逻辑。
2.1 Context 的 startActivity
startActivity 前面这些流程大家应该都比较熟悉，所以我就简单跳过了。Context 中的 startActivity 会调用到 ContextImpl.startActivity。
[frameworks/base/core/java/android/app/ContextImpl.java]
public void startActivity(Intent intent, Bundle options) {
warnIfCallingFromSystemProcess();
// 一些异常判断
...
// 调用 Instrumentation 的 execStartActivity
mMainThread.getInstrumentation().execStartActivity(
getOuterContext(), mMainThread.getApplicationThread(), null,
(Activity) null, intent, -1, options);
}
2.2 Activity 的 startActivity
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
@Nullable Bundle options) {
if (mParent == null) {
options = transferSpringboardActivityOptions(options);
// 调用 Instrumentation 的 execStartActivity
Instrumentation.ActivityResult ar =
mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, this,
intent, requestCode, options);
} else {
if (options != null) {
mParent.startActivityFromChild(this, intent, requestCode, options);
} else {
mParent.startActivityFromChild(this, intent, requestCode);
}
}
}
对比两个两个 startActivity，我们发现 Activity 中的 startActivity 多了几个参数，分别是 mToken 和 this。这两个值决定了之后 Activity 启动中的栈管理逻辑，它们一个是后续的 token，一个则是 resultTo。
Activity 的栈管理是 Activity 启动的重要内容，后面在 AMS 中会详细讲述。
mMainThread 的类似是 ActivityThread，这里其实就是获取 ActivityThread 中的 Instrumentation，调用 Instrumentation.execStartActivity。
三 Instrumentation.execStartActivity
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Activity target,
Intent intent, int requestCode, Bundle options) {
...
try {
intent.migrateExtraStreamToClipData(who);
intent.prepareToLeaveProcess(who);
// 启动 Activity
int result = ActivityTaskManager.getService().startActivity(whoThread,
who.getOpPackageName(), who.getAttributionTag(), intent,
intent.resolveTypeIfNeeded(who.getContentResolver()), token,
target != null ? target.mEmbeddedID : null, requestCode, 0, null, options);
notifyStartActivityResult(result, options);
checkStartActivityResult(result, intent);
} catch (RemoteException e) {
throw new RuntimeException("Failure from system", e);
}
return null;
}
在 execStartActivity 中，会通过 ActivityTaskManager（后面检查 ATM） 的 getService 来启动 Activity。这里 getService 拿到的就是 ActivityTaskManagerService（后面简称为 ATMS）。
注意，我们需要关注mToken 和 this这两个参数的变化，这里它们变成了token和target，最后token会变成resultTo
3.1 ActivityTaskManager.getService
获取 ATMS 服务的 IBinder 对象，这个服务在之前 AMS 服务启动的时候会发布。到这里，就会通过 IBinder 调用到对应的 AMS 进程，后续的逻辑就是在 AMS 进程中运行了。
[frameworks/base/core/java/android/app/ActivityTaskManager.java]
public static IActivityTaskManager getService() {
return IActivityTaskManagerSingleton.get();
}
@UnsupportedAppUsage(trackingBug = 129726065)
private static final Singleton<IActivityTaskManager> IActivityTaskManagerSingleton =
new Singleton<IActivityTaskManager>() {
@Override
protected IActivityTaskManager create() {
// 从 ServiceManager 获取 Context.ACTIVITY_TASK_SERVICE
final IBinder b = ServiceManager.getService(Context.ACTIVITY_TASK_SERVICE);
return IActivityTaskManager.Stub.asInterface(b);
}
};
3.2 ActivityTaskManagerService.onStart
public void onStart() {
publishBinderService(Context.ACTIVITY_TASK_SERVICE, mService);
mService.start();
}
Context.ACTIVITY_TASK_SERVICE 服务其实就是 ATMS，在 ATMS 的 onStart 中，会将自己发布到 ServiceManager。所以启动 Activitiy 最终会调用到 ATMS 的 startActivity。
然后在 ATMS 的 startActivity 内部，会调用到 startActivityAsUser，所以我们直接看 startActivityAsUser。
3.3 ActivityTaskManagerService.startActivityAsUser
private int startActivityAsUser(IApplicationThread caller, String callingPackage,
@Nullable String callingFeatureId, Intent intent, String resolvedType,
IBinder resultTo, String resultWho, int requestCode, int startFlags,
ProfilerInfo profilerInfo, Bundle bOptions, int userId, boolean validateIncomingUser) {
assertPackageMatchesCallingUid(callingPackage);
enforceNotIsolatedCaller("startActivityAsUser");
userId = getActivityStartController().checkTargetUser(userId, validateIncomingUser,
Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");
// 获取 一个 ActivityStartController，然后通过它获取一个 ActivityStarter
// 然后执行 execute
return getActivityStartController().obtainStarter(intent, "startActivityAsUser")
.setCaller(caller)
.setCallingPackage(callingPackage)
.setCallingFeatureId(callingFeatureId)
.setResolvedType(resolvedType)
.setResultTo(resultTo)
.setResultWho(resultWho)
.setRequestCode(requestCode)
.setStartFlags(startFlags)
.setProfilerInfo(profilerInfo)
.setActivityOptions(bOptions)
.setUserId(userId)
.execute();
}
startActivityAsUser 这个函数更简单，就是获取一个 ActivityStarter，然后设置一堆的参数之后，调用 execute。这里的参数很多，但是我们只需要关注其中重要的几个即可
- intent：启动 Activity 传入的参数
- caller：这次调用的 ApplicationThread。（传入的是 IApplicationThread，ApplicationThread 是 ActivityThread 的内部类，它继承自 IApplicationThread，IApplicationThread 又继承自 IInterface，ApplicationThread 是用于应用进程和系统进程通信使用的）
- resultTo：这次启动的动作来自哪个 Activity（可以是同一个进程，也可以是不同的进程，例如桌面的 Launch 进程。或者可以为空，例如从 Service 或其他非 Activity 的 Context 中启动），传入的是当前 Activity 的 Token（Token 是每个 Activity 的唯一标识）。
四 ActivityStarter
ActivityStarter 看名字也就知道，它这个类的任务就是用来启动 Activity 的。
4.1 ActivityStarter.obtainStarter
首先会通过一个工厂来获得 ActivityStarter，工厂中有一个 ActivityStarter 池，ActivityStarter 是可以复用的。
[frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java]
ActivityStarter obtainStarter(Intent intent, String reason) {
// Factory 其实就是 ActivityStarter 的一个内部类。
// 这里获取 ActivityStarter 其实就是从 Factory 中的一个 ActivityStarter 池获取
return mFactory.obtain().setIntent(intent).setReason(reason);
}
obtainStarter 其实就是从 ActivityStarter.Factory 的池子中，取出一个 ActivityStarter。因为 ActivityStarter 是可以复用的，所以有些参数并不需要每次都设置，它会使用之前的参数。
4.2 ActivityStarter.execute
[frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java]
int execute() {
try {
...
int res;
synchronized (mService.mGlobalLock) {
// 前面做了很多关于 Intent 参数的判断和参数解析相关的操作
...
// 执行启动流程
res = executeRequest(mRequest);
...
}
} finally {
onExecutionComplete();
}
}
4.3 ActivityStarter.executeRequest
executeRequest 开始就准备启动 Activity 了。这个函数很长，有 400 多行，根据 Google 官方的注释解释。这个函数主要做了这么两件事
- 首先执行初步的检查
- 调用 startActivityUnchecked 到 startActivityInner
private int executeRequest(Request request) {
...
// 前面会通过 Supervisor.resolveActivity 做一些 Activity 和 Intent 的解析，
// 判断是否有匹配要启动的 Activity
// 如果存在多个，则会调用到 ActivityTaskSupervisor.resolveIntent 中
// 最后通过 PMS 让用户选择
// 前面做了好多检查，最后会把这些参数封装到一个 ActivityRecord 中
final ActivityRecord r = new ActivityRecord.Builder(mService)
.setCaller(callerApp)
.setLaunchedFromPid(callingPid)
.setLaunchedFromUid(callingUid)
.setLaunchedFromPackage(callingPackage)
.setLaunchedFromFeature(callingFeatureId)
.setIntent(intent)
.setResolvedType(resolvedType)
.setActivityInfo(aInfo)
.setConfiguration(mService.getGlobalConfiguration())
.setResultTo(resultRecord)
.setResultWho(resultWho)
.setRequestCode(requestCode)
.setComponentSpecified(request.componentSpecified)
.setRootVoiceInteraction(voiceSession != null)
.setActivityOptions(checkedOptions)
.setSourceRecord(sourceRecord)
.build();
mLastStartActivityRecord = r;
...
mLastStartActivityResult = startActivityUnchecked(r, sourceRecord, voiceSession,
request.voiceInteractor, startFlags, true /* doResume */, checkedOptions, inTask,
restrictedBgActivity, intentGrants);
...
return mLastStartActivityResult;
}
在 executeRequest 中，会将请求的参数封装到一个 ActivityRecord 中，然后调用 startActivityUnchecked。
4.4 ActivityStarter.startActivityUnchecked
startActivityUnchecked 主要就是调用了 startActivityInner，它才是真正执行启动 Activity 的逻辑。
private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
int startFlags, boolean doResume, ActivityOptions options, Task inTask,
boolean restrictedBgActivity, NeededUriGrants intentGrants) {
...
try {
...
// 真正执行启动 Activity 的逻辑
result = startActivityInner(r, sourceRecord, voiceSession, voiceInteractor,
startFlags, doResume, options, inTask, restrictedBgActivity, intentGrants);
} finally {
Trace.traceEnd(Trace.TRACE_TAG_WINDOW_MANAGER);
...
}
postStartActivityProcessing(r, result, startedActivityRootTask);
return result;
}
4.5 ActivityStarter.startActivityInner
从这一步开始，就是正式的启动 Activity 了，当然，启动 Activity 的过程中有三个重点
- 不同启动模式的 Activity 的启动原理
- 冷启动和热启动的原理
- Activity 是如何显示到界面上的
[frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java]
int startActivityInner(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
int startFlags, boolean doResume, ActivityOptions options, Task inTask,
boolean restrictedBgActivity, NeededUriGrants intentGrants) {
// 设置初始状态
setInitialState(r, options, inTask, doResume, startFlags, sourceRecord, voiceSession,
voiceInteractor, restrictedBgActivity);
// 首先就是计算 Activity 的启动模式
// 获得一个的 Flag，这玩意就是我们设置给 Intent 的。
computeLaunchingTaskFlags();
// 处理源 Activity 的任务栈
// 如果源 Activity 正在 finish 则需要开启一个新的栈
computeSourceRootTask();
// mLaunchFlags 就是前面计算的，这里设置给 mIntent
// 其实和我们启动 Activity 时自定义 Flag 很像
mIntent.setFlags(mLaunchFlags);
// Reusable 复用，这里是获取可以复用的 Task
final Task reusedTask = getReusableTask();
//是否需要冻结 Task 列表
if (mOptions != null && mOptions.freezeRecentTasksReordering()
&& mSupervisor.mRecentTasks.isCallerRecents(r.launchedFromUid)
&& !mSupervisor.mRecentTasks.isFreezeTaskListReorderingSet()) {
mFrozeTaskList = true;
mSupervisor.mRecentTasks.setFreezeTaskListReordering();
}
// 是否存在一个可以现在使用的 Task
// 是否有复用，如果没有，是否可以计算获取一个
final Task targetTask = reusedTask != null ? reusedTask : computeTargetTask();
// 如果没有可以现在使用的 Task，那么就创建一个新 Task
final boolean newTask = targetTask == null;
mTargetTask = targetTask;
// 计算启动参数
computeLaunchParams(r, sourceRecord, targetTask);
// 判断是否可以通过 targetTask 或者新建 Task 启动的 Activity
int startResult = isAllowedToStart(r, newTask, targetTask);
if (startResult != START_SUCCESS) {
return startResult;
}
// 获取栈顶没有 finish 的 activity
final ActivityRecord targetTaskTop = newTask
? null : targetTask.getTopNonFinishingActivity();
if (targetTaskTop != null) {
// 看一下栈顶的 Task targetTaskTop 是否可以回收复用
startResult = recycleTask(targetTask, targetTaskTop, reusedTask, intentGrants);
if (startResult != START_SUCCESS) {
return startResult;
}
} else {
mAddingToTask = true;
}
// 如果要启动的 Activity 与当前在顶部的 Activity 相同，那么我们需要检查它是否应该只被启动一次。
final Task topRootTask = mPreferredTaskDisplayArea.getFocusedRootTask();
if (topRootTask != null) {
startResult = deliverToCurrentTopIfNeeded(topRootTask, intentGrants);
if (startResult != START_SUCCESS) {
return startResult;
}
}
if (mTargetRootTask == null) {
// 获得一个栈 Task
mTargetRootTask = getLaunchRootTask(mStartActivity, mLaunchFlags, targetTask, mOptions);
}
if (newTask) {
// 如果是新建 Task
final Task taskToAffiliate = (mLaunchTaskBehind && mSourceRecord != null)
? mSourceRecord.getTask() : null;
// 关联 Task 与 ActivityRecord
// 这个函数也会调用 addOrReparentStartingActivity
setNewTask(taskToAffiliate);
} else if (mAddingToTask) {
// 将要启动的 Activity 添加到 targetTask
// 并且会将此 Activity 添加到最近启动的 ActivityRecord 中，后续可以通过 findActivity 复用
addOrReparentStartingActivity(targetTask, "adding to task");
}
if (!mAvoidMoveToFront && mDoResume) {
mTargetRootTask.getRootTask().moveToFront("reuseOrNewTask", targetTask);
if (mOptions != null) {
if (mOptions.getTaskAlwaysOnTop()) {
mTargetRootTask.setAlwaysOnTop(true);
}
}
if (!mTargetRootTask.isTopRootTaskInDisplayArea() && mService.mInternal.isDreaming()) {
// Launching underneath dream activity (fullscreen, always-on-top). Run the launch-
// -behind transition so the Activity gets created and starts in visible state.
mLaunchTaskBehind = true;
r.mLaunchTaskBehind = true;
}
}
mService.mUgmInternal.grantUriPermissionUncheckedFromIntent(intentGrants,
mStartActivity.getUriPermissionsLocked());
if (mStartActivity.resultTo != null && mStartActivity.resultTo.info != null) {
// we need to resolve resultTo to a uid as grantImplicitAccess deals explicitly in UIDs
final PackageManagerInternal pmInternal =
mService.getPackageManagerInternalLocked();
final int resultToUid = pmInternal.getPackageUid(
mStartActivity.resultTo.info.packageName, 0 /* flags */,
mStartActivity.mUserId);
pmInternal.grantImplicitAccess(mStartActivity.mUserId, mIntent,
UserHandle.getAppId(mStartActivity.info.applicationInfo.uid) /*recipient*/,
resultToUid /*visible*/, true /*direct*/);
}
if (newTask) {
EventLogTags.writeWmCreateTask(mStartActivity.mUserId,
mStartActivity.getTask().mTaskId);
}
mStartActivity.logStartActivity(
EventLogTags.WM_CREATE_ACTIVITY, mStartActivity.getTask());
mTargetRootTask.mLastPausedActivity = null;
mRootWindowContainer.startPowerModeLaunchIfNeeded(
false /* forceSend */, mStartActivity);
mTargetRootTask.startActivityLocked(mStartActivity,
topRootTask != null ? topRootTask.getTopNonFinishingActivity() : null, newTask,
mKeepCurTransition, mOptions, sourceRecord);
if (mDoResume) {
final ActivityRecord topTaskActivity =
mStartActivity.getTask().topRunningActivityLocked();
// 要启动的 Activity 无法获取焦点
if (!mTargetRootTask.isTopActivityFocusable()
|| (topTaskActivity != null && topTaskActivity.isTaskOverlay()
&& mStartActivity != topTaskActivity)) {
// 如果 Activity 不可见就无法恢复
// 如有要确保可见，就会触发进入动画
// 并且，被覆盖的 Activity，直到覆盖物被移除前，都是不可见的
mTargetRootTask.ensureActivitiesVisible(null /* starting */,
0 /* configChanges */, !PRESERVE_WINDOWS);
// 告诉 WMS 继续执行，因为现在 Activity 还无法恢复。
mTargetRootTask.mDisplayContent.executeAppTransition();
} else {
//
if (mTargetRootTask.isTopActivityFocusable()
&& !mRootWindowContainer.isTopDisplayFocusedRootTask(mTargetRootTask)) {
mTargetRootTask.moveToFront("startActivityInner");
}
// 恢复栈顶的 Activity
mRootWindowContainer.resumeFocusedTasksTopActivities(
mTargetRootTask, mStartActivity, mOptions, mTransientLaunch);
}
}
mRootWindowContainer.updateUserRootTask(mStartActivity.mUserId, mTargetRootTask);
// Activity 启动时立即更新最近的任务列表
mSupervisor.mRecentTasks.add(mStartActivity.getTask());
mSupervisor.handleNonResizableTaskIfNeeded(mStartActivity.getTask(),
mPreferredWindowingMode, mPreferredTaskDisplayArea, mTargetRootTask);
return START_SUCCESS;
}
startActivityInner 这个函数做了很多事，但是这里就不展开了，后面在 Activity 的栈管理中还会详细说明这个函数。我们现在知道，它通过 RootWindowContainer 调用了 resumeFocusedTasksTopActivities。
五 RootWindowContainer
5.1 resumeFocusedTasksTopActivities
[frameworks/base/services/core/java/com/android/server/wm/RootWindowContainer.java]
boolean resumeFocusedTasksTopActivities(
Task targetRootTask, ActivityRecord target, ActivityOptions targetOptions,
boolean deferPause) {
// mTaskSupervisor 判断是否恢复状态
if (!mTaskSupervisor.readyToResume()) {
return false;
}
boolean result = false;
if (targetRootTask != null && (targetRootTask.isTopRootTaskInDisplayArea()
|| getTopDisplayFocusedRootTask() == targetRootTask)) {
// 恢复栈顶的 Activity
result = targetRootTask.resumeTopActivityUncheckedLocked(target, targetOptions,
deferPause);
}
for (int displayNdx = getChildCount() - 1; displayNdx >= 0; --displayNdx) {
...
if (!resumedOnDisplay[0]) {
...
if (focusedRoot != null) {
final Task focusedRoot = display.getFocusedRootTask();
// 恢复栈顶的 Activity
result |= focusedRoot.resumeTopActivityUncheckedLocked(target, targetOptions);
} else if (targetRootTask == null) {
result |= resumeHomeActivity(null /* prev */, "no-focusable-task",
display.getDefaultTaskDisplayArea());
}
}
}
return result;
}
然后在 resumeTopActivityUncheckedLocked 中，调用到了 Task.resumeTopActivityInnerLocked。
六 Task
Task 是系统对 ActivityRecord 的又一层封装。
Task.resumeTopActivityInnerLocked
@GuardedBy("mService")
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options,
boolean deferPause) {
...
if (next.attachedToProcess()) {
...
try {
final ClientTransaction transaction =
ClientTransaction.obtain(next.app.getThread(), next.appToken);
...
// 启动事务
mAtmService.getLifecycleManager().scheduleTransaction(transaction);
} catch (Exception e) {
// Whoops, need to restart this activity!
...
// 调用
mTaskSupervisor.startSpecificActivity(next, true, false);
return true;
}
...
} else {
// Whoops, need to restart this activity!
...
mTaskSupervisor.startSpecificActivity(next, true, true);
}
return true;
}
七 ActivityTaskSupervisor
ActivityTaskSupervisor 是 Activity 栈的超级管理者，所以它负责者 Activity 的栈的。
7.1 startSpecificActivity
void startSpecificActivity(ActivityRecord r, boolean andResume, boolean checkConfig) {
...
if (wpc != null && wpc.hasThread()) {
try {
// 真正启动 Activity
realStartActivityLocked(r, wpc, andResume, checkConfig);
return;
} catch (RemoteException e) {
Slog.w(TAG, "Exception when starting activity "
+ r.intent.getComponent().flattenToShortString(), e);
}
...
}
...
}
7.2 realStartActivityLocked
boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
boolean andResume, boolean checkConfig) throws RemoteException {
...
// 这里的 proc.getThread() 其实拿到的是 ActivityThread
final ClientTransaction clientTransaction = ClientTransaction.obtain(
proc.getThread(), r.appToken);
try {
...
// 启动事务，mService 是 ActivityTaskManagerService
// 拿到的 Manager 是 ClientLifecycleManager
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
...
} catch (RemoteException e) {
...
return true;
}
realStartActivityLocked 里首先会通过 proc.getThread 拿到一个 ActivityThread，然后通过 ActivityThread 拿到一个 ClientTransaction。
然后会有一个 mService，它就是 ATMS，然后通过 ATMS 的 getLifecycleManager 拿到 ClientLifecycleManager 并调用它的 scheduleTransaction。
八 ClientLifecycleManager
8.1 scheduleTransaction
void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
final IApplicationThread client = transaction.getClient();
// 执行 ClientTransaction 的 schedule
transaction.schedule();
if (!(client instanceof Binder)) {
// 如果客户端不是 Binder 的实例--即这是一个远程调用，
// 此时回收该对象是安全的。
// 所有用于本地调用的对象在 ActivityThread 中的客户端上执行完事务后将被回收
transaction.recycle();
}
}
九 ClientTransaction
9.1 schedule
[frameworks/base/core/java/android/app/servertransaction/ClientTransaction.java]
// 这个 mClient，其实就是之前创建的
private IApplicationThread mClient;
public void schedule() throws RemoteException {
mClient.scheduleTransaction(this);
}
这里有一个 mClient，其实就是之前 obtain 中传入的 proc.getThread。而这个 proc 其实就是 WindowProcessController。而获取到的 Thread 就是 IApplicationThread。
这里用到了跨进程通信，这个 IApplicationThread 真正的实现是 ActivityThread 的内部类 ApplicationThread。
所以前面调用的 transaction.schedule 其实就是 ApplicationThread.scheduleTransaction。而 ApplicationThread 其实是 ActivityThread 的内部类。
十 ActivityThread
10.1 scheduleTransaction
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
ActivityThread.this.scheduleTransaction(transaction);
}
调用到了 ActivityThread 的 scheduleTransaction，然后 ActivityThread 里并没有 scheduleTransaction，仔细一看，原来它继承自 ClientTransactionHandler，真正的实现在它的父类。
public final class ActivityThread extends ClientTransactionHandler
implements ActivityThreadInternal {
十一 ClientTransactionHandler
11.1 scheduleTransaction
[frameworks/base/core/java/android/app/ClientTransactionHandler.java]
void scheduleTransaction(ClientTransaction transaction) {
transaction.preExecute(this);
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
然后在父类 ClientTransactionHandler 中，会通过消息机制发送一条 EXECUTE_TRANSACTION 的消息，这个会调用到 ActivityThread 的 Handle 中。
在 ActivityThread 的消息处理中，首先会执行这个 ClientTransaction，然后再将它回收（调用 recycle）。
case EXECUTE_TRANSACTION:
final ClientTransaction transaction = (ClientTransaction) msg.obj;
mTransactionExecutor.execute(transaction);
if (isSystem()) {
// Client transactions inside system process are recycled on the client side
// instead of ClientLifecycleManager to avoid being cleared before this
// message is handled.
transaction.recycle();
}
// TODO(lifecycler): Recycle locally scheduled transactions.
break;
接下来的流程就比较简单了，通过消息机制，在 ActivityThread 的 handleMessage 中，调用了 execute 执行之前传递过来的 ClientTransaction。
十二 TransactionExecutor
12.1 execute
[frameworks/base/core/java/android/app/servertransaction/TransactionExecutor.java]
public void execute(ClientTransaction transaction) {
...
executeCallbacks(transaction);
executeLifecycleState(transaction);
mPendingActions.clear();
}
12.2 executeCallbacks
@VisibleForTesting
public void executeCallbacks(ClientTransaction transaction) {
...
for (int i = 0; i < size; ++i) {
...
cycleToPath(r, postExecutionState, shouldExcludeLastTransition, transaction);
}
}
12.3 cycleToPath
private void cycleToPath(ActivityClientRecord r, int finish, boolean excludeLastState,
ClientTransaction transaction) {
...
performLifecycleSequence(r, path, transaction);
}
12.4 performLifecycleSequence
TransactionExecutor 中有一个 mTransactionHandler，它的类型是 ClientTransactionHandler，这个变量其实就是在创建的时候初始化的，在 ActivityThread 中，ActivityThread 将自己作为参数传递了进来，所以这个 mTransactionHandler 其实就是 ActivityThread。
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, mPendingActions,
null /* activityOptions */);
break;
case ON_RESUME:
mTransactionHandler.handleResumeActivity(r, false /* finalStateRequest */,
r.isForward, "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);
}
}
}
最后就通过这里的 ActivityThread 调用到了对应的生命周期。
十三 总结
到这里，Activity 的启动流程我们算是梳理完了，但是，Activity 启动的复杂程度远不止如此，本篇博客中，我忽略了其中的很多细节。例如：
- 进程的启动（启动 Activity 时会判断进程的存在与否，应用的进程是如何启动的）
- 进程的管理（通过进程的启动，引申出进程是如何管理的，Activity 的前后台切换，优先级与系统杀进程）
- Activity 栈的管理（Activity 栈是如何复用的）
由于以上的逻辑涉及很多 AMS 的工作原理，所以我打算放 AMS 源码解析中说明。下面我们用一幅图来总结一下 Activity 的启动的大致流程。
