Activity启动源码解析(Android12)
theme: channing-cyan
四大组件系列
一概述
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。
```java [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
```java 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
```java 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 进程中运行了。
```java [frameworks/base/core/java/android/app/ActivityTaskManager.java]
public static IActivityTaskManager getService() { return IActivityTaskManagerSingleton.get(); }
@UnsupportedAppUsage(trackingBug = 129726065)
private static final Singleton
3.2 ActivityTaskManagerService.onStart
java
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
```java 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 是可以复用的。
java
[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
```java [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
```java
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 的逻辑。
```java 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 是如何显示到界面上的
```java [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
```java [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
```java
@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
```java 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
```java
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
```java 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
```java [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
java
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
ActivityThread.this.scheduleTransaction(transaction);
}
调用到了 ActivityThread 的 scheduleTransaction,然后 ActivityThread 里并没有 scheduleTransaction,仔细一看,原来它继承自 ClientTransactionHandler,真正的实现在它的父类。
java
public final class ActivityThread extends ClientTransactionHandler
implements ActivityThreadInternal {
十一 ClientTransactionHandler
11.1 scheduleTransaction
```java [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)。
java
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
```java [frameworks/base/core/java/android/app/servertransaction/TransactionExecutor.java]
public void execute(ClientTransaction transaction) {
...
executeCallbacks(transaction);
executeLifecycleState(transaction);
mPendingActions.clear();
} ```
12.2 executeCallbacks
```java @VisibleForTesting public void executeCallbacks(ClientTransaction transaction) { ... for (int i = 0; i < size; ++i) { ...
cycleToPath(r, postExecutionState, shouldExcludeLastTransition, transaction);
}
} ```
12.3 cycleToPath
java
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。
```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);
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 的启动的大致流程。
- Activity启动源码解析(Android12)
- 从MediaServer看Binder的使用方式(一)
- 从MediaServer看Binder的使用方式(二)
- [Android禅修之路] 解读Layer
- [Android禅修之路] Android图形系统,从Activity到Surface
- [Android禅修之路] 解读 GraphicBuffer 之 Framework 层
- [Android禅修之路] 解读SurfaceFlinger中的BufferQueue
- [Android禅修之路] SurfaceFlinger 合成中的工作
- [Android禅修之路] SurfaceFlinger 中的一些对象
- [Android禅修之路] SurfaceFlinger 合成前的预处理
- [Android禅修之路] SurfaceFlinger合成总览
- [Android禅修之路] SurfaceFlinger的启动过程
- [Android禅修之路] Android 图形系统开篇