前言
在面试中经常会被问到，让面试者简述一下 Activity 的启动流程，这个问题是考察面试者对源码的理解程度的，熟悉源码对于解决日常开发过程中遇到的许多问题都有帮助，下面我们就通过源码来分析 Activity 的启动流程。
Activity 启动流程分为两种：
- 根 Activity 的启动流程：即第一次点击桌面上某个应用图标到该应用的第一个 Activity 显示出来的流程。这种情况下，刚开始这个应用的进程还不存在，所以会涉及到应用的进程的创建过程。
- 普通 Activity 的启动流程：这种情况下应用的进程已经存在了。相当于点击该应用的第一个 Activity 的某个按钮后，跳转到第二个 Activity 的流程。
根 Activity 的启动流程更加复杂，根 Activity 的启动流程包含了普通 Activity 的启动流程。下面我们就先通过源码来分析普通 Activity 的启动流程，源码基于 Android R（11.0）。
应用调起ATMS
一般我们使用如下代码来实现普通 Activity 的启动:
Intent intent = new Intent(this, SecondActivity.class);
this.startActivity(intent);
用起来很方便，但是里面究竟做了什么？下面我们就来一探究竟。
所有的 startActivity() 方法最终都会调用 startActivityForResult() 方法，代码如下:
public class Activity{
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
@Nullable Bundle options) {
if (mParent == null) {
...
Instrumentation.ActivityResult ar =
mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, this,
intent, requestCode, options);
...
} else {
...
}
}
// mMainThread 是 ActivityThread 的实例
ActivityThread mMainThread;
final void attach(Context context, ActivityThread aThread,
Instrumentation instr, ...) {
mMainThread = aThread;
mInstrumentation = instr;
...
}
}
mParent 表示当前 Activity 的父 Activity，一般情况下 mParent 为 null，此时会调用 mInstrumentation 的 execStartActivity() 方法。
execStartActivity() 方法的第 2 个参数是 mMainThread.getApplicationThread()，给 mMainThread 赋值是在 Activity 的 attach() 方法中，mMainThread 是 ActivityThread 的实例，其 getApplicationThread() 方法如下：
public final class ActivityThread extends ClientTransactionHandler {
final ApplicationThread mAppThread = new ApplicationThread();
public ApplicationThread getApplicationThread()
{
return mAppThread;
}
}
可以看到返回的是 ApplicationThread 的示例，ApplicationThread 是 ActivityThread 的内部类，继承自 IApplicationThread.Stub，是个 Binder 对象，在 Activity 的启动流程中有重要作用。
在 Android 中，Instrumentation （插桩）是一个用于监控和控制应用程序与系统交互的机制，它允许你在 Application 和 Activity 启动之前插入自定义代码，从而“监听”或“干预”应用的生命周期。这里的 Instrumentation 在应用代码之前实例化（在 attach() 方法中赋的值），可以用它来启动 Application 和 Activity。
跟进去看看 execStartActivity() 方法，代码如下：
public class Instrumentation {
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Activity target,
Intent intent, int requestCode, Bundle options) {
...
try {
...
// 使用 ActivityTaskManager.getService() 来获取 ATMS 的代理对象
int result = ActivityTaskManager.getService().startActivity(whoThread,
who.getBasePackageName(), who.getAttributionTag(), intent,
intent.resolveTypeIfNeeded(who.getContentResolver()), token,
target != null ? target.mEmbeddedID : null, requestCode, 0, null, options);
checkStartActivityResult(result, intent);
} catch (RemoteException e) {
throw new RuntimeException("Failure from system", e);
}
return null;
}
}
execStartActivity() 方法会调用 ActivityTaskManager 的 getService() 方法来获取ActivityTaskManagerService的代理对象，然后调用这个代理对象的 startActivity() 方法。
public class ActivityTaskManager {
public static IActivityTaskManager getService() {
return IActivityTaskManagerSingleton.get();
}
@UnsupportedAppUsage(trackingBug = 129726065)
private static final Singleton<IActivityTaskManager> IActivityTaskManagerSingleton =
new Singleton<IActivityTaskManager>() {
@Override
protected IActivityTaskManager create() {
final IBinder b = ServiceManager.getService(Context.ACTIVITY_TASK_SERVICE);
return IActivityTaskManager.Stub.asInterface(b);
}
};
}
这里是一个单例模式，通过 ServiceManager的getService()方法获得系统服务，然后通过 IActivityTaskManager.Stub.asInterface将其转换为具体的代理端对象，通过这个代理端对象我们就可以发起 RPC 调用了。
接下来发起远程调用 startActivity()，该远程调用在 aidl 文件中，定义如下：
// frameworks/base/core/java/android/app/IActivityTaskManager.aidl
interface IActivityTaskManager {
int startActivity(in IApplicationThread caller, in String callingPackage,
in String callingFeatureId, in Intent intent, in String resolvedType,
in IBinder resultTo, in String resultWho, int requestCode,
int flags, in ProfilerInfo profilerInfo, in Bundle options);
...
}
ActivityTaskManagerService（ATMS）继承自 IActivityTaskManager.Stub，ATMS 是 Android 10.0 中新增的，分担了之前 ActivityManagerService（AMS）的一部分功能，是用于管理 Activity 及其容器（task, stacks, displays,...）的系统服务，运行在 SystemServer 进程之中，与当前作为客户端的应用进程不在同一个进程。
ActivityTaskManager.getService().startActivity() 有个返回值 result，且调用了checkStartActivityResult(result, intent) 对 result 进行检查：
public class Instrumentation {
public static void checkStartActivityResult(int res, Object intent) {
if (!ActivityManager.isStartResultFatalError(res)) {
return;
}
switch (res) {
case ActivityManager.START_INTENT_NOT_RESOLVED:
case ActivityManager.START_CLASS_NOT_FOUND:
if (intent instanceof Intent && ((Intent)intent).getComponent() != null)
throw new ActivityNotFoundException(
"Unable to find explicit activity class "
+ ((Intent)intent).getComponent().toShortString()
+ "; have you declared this activity in your AndroidManifest.xml?");
throw new ActivityNotFoundException(
"No Activity found to handle " + intent);
case ActivityManager.START_PERMISSION_DENIED:
throw new SecurityException("Not allowed to start activity "
+ intent);
...
default:
throw new AndroidRuntimeException("Unknown error code "
+ res + " when starting " + intent);
}
}
}
这是用来检查 Activity 启动的结果的，看到第一个 case 中就抛出了 ActivityNotFoundException("have you declared this activity in your AndroidManifest.xml?"），如果 Activity 没有在 Manifest 中注册就会出现这个错误。
使用ATMS来管理Activity
通过上面的分析，启动流程跨进程进入到了 ATMS 中，调用了 ATMS 的 startActivity() 方法：
public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
private ActivityStartController mActivityStartController;
public void initialize(IntentFirewall intentFirewall, PendingIntentController intentController,
Looper looper) {
...
mActivityStartController = new ActivityStartController(this);
...
}
@Override
public final int startActivity(IApplicationThread caller, String callingPackage,
String callingFeatureId, Intent intent, String resolvedType, IBinder resultTo,
String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo,
Bundle bOptions) {
return startActivityAsUser(caller, callingPackage, callingFeatureId, intent, resolvedType,
resultTo, resultWho, requestCode, startFlags, profilerInfo, bOptions,
UserHandle.getCallingUserId());
}
@Override
public int startActivityAsUser(IApplicationThread caller, String callingPackage,
String callingFeatureId, Intent intent, String resolvedType, IBinder resultTo,
String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo,
Bundle bOptions, int userId) {
return startActivityAsUser(caller, callingPackage, callingFeatureId, intent, resolvedType,
resultTo, resultWho, requestCode, startFlags, profilerInfo, bOptions, userId,
true /*validateIncomingUser*/);
}
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");
// TODO: Switch to user app stacks here.
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();
}
ActivityStartController getActivityStartController() {
return mActivityStartController;
}
}
startActivity() 方法调用了 startActivityAsUser() 方法，最终通过 getActivityStartController().obtainStarter(intent, "startActivityAsUser") 来获取 ActivityStarter 实例：
public class ActivityStartController {
ActivityStartController(ActivityTaskManagerService service) {
this(service, service.mStackSupervisor,
new DefaultFactory(service, service.mStackSupervisor,
new ActivityStartInterceptor(service, service.mStackSupervisor)));
}
ActivityStartController(ActivityTaskManagerService service, ActivityStackSupervisor supervisor,
Factory factory) {
mService = service;
mSupervisor = supervisor;
mHandler = new StartHandler(mService.mH.getLooper());
mFactory = factory;
mFactory.setController(this);
mPendingRemoteAnimationRegistry = new PendingRemoteAnimationRegistry(service.mGlobalLock,
service.mH);
}
ActivityStarter obtainStarter(Intent intent, String reason) {
return mFactory.obtain().setIntent(intent).setReason(reason);
}
}
这里 mFactory.obtain() 是通过 ActivityStarter 的内部类 DefaultFactory 的 obtain() 方法来获取 ActivityStarter 实例的：
class ActivityStarter {
interface Factory {
void setController(ActivityStartController controller);
ActivityStarter obtain();
void recycle(ActivityStarter starter);
}
static class DefaultFactory implements Factory {
private final int MAX_STARTER_COUNT = 3;
private ActivityStartController mController;
private ActivityTaskManagerService mService;
private ActivityStackSupervisor mSupervisor;
private ActivityStartInterceptor mInterceptor;
private SynchronizedPool<ActivityStarter> mStarterPool =
new SynchronizedPool<>(MAX_STARTER_COUNT);
DefaultFactory(ActivityTaskManagerService service,
ActivityStackSupervisor supervisor, ActivityStartInterceptor interceptor) {
mService = service;
mSupervisor = supervisor;
mInterceptor = interceptor;
}
@Override
public void setController(ActivityStartController controller) {
mController = controller;
}
@Override
public ActivityStarter obtain() {
ActivityStarter starter = mStarterPool.acquire();
if (starter == null) {
starter = new ActivityStarter(mController, mService, mSupervisor, mInterceptor);
}
return starter;
}
@Override
public void recycle(ActivityStarter starter) {
starter.reset(true /* clearRequest*/);
mStarterPool.release(starter);
}
}
}
其中 mStarterPool 是一个同步缓存池，先去同步缓存池中获取，没有获取到就 new 一个。然后通过 Builder 模式（建造者模式）把启动所需的各种参数赋值给 mRequest：
class ActivityStarter {
Request mRequest = new Request();
ActivityStarter setIntent(Intent intent) {
mRequest.intent = intent;
return this;
}
ActivityStarter setReason(String reason) {
mRequest.reason = reason;
return this;
}
ActivityStarter setCaller(IApplicationThread caller) {
mRequest.caller = caller;
return this;
}
ActivityStarter setCallingPackage(String callingPackage) {
mRequest.callingPackage = callingPackage;
return this;
}
ActivityStarter setCallingFeatureId(String callingFeatureId) {
mRequest.callingFeatureId = callingFeatureId;
return this;
}
...
}
最后调用 ActivityStarter 实例的 execute() 方法：
class ActivityStarter {
// 根据 mRequest 里面的参数解析出必要的信息，执行 Activity 的启动流程的请求
int execute() {
try {
...
// Activity的启动流程的请求
res = executeRequest(mRequest);
...
} finally {
// 启动 Activity 后的回调
onExecutionComplete();
}
}
// 执行 Activity 的启动请求并开始 Activity 的启动流程，
// 这里将开始执行几个初步的检查，一般 Activity 的启动流程
// 需要依次经过 startActivityUnchecked() 和 startActivityInner()
private int executeRequest(Request request) {
...
// 传入 request 中的参数
final IApplicationThread caller = request.caller;
Intent intent = request.intent;
NeededUriGrants intentGrants = request.intentGrants;
String resolvedType = request.resolvedType;
ActivityInfo aInfo = request.activityInfo;
ResolveInfo rInfo = request.resolveInfo;
final IVoiceInteractionSession voiceSession = request.voiceSession;
final IBinder resultTo = request.resultTo;
String resultWho = request.resultWho;
int requestCode = request.requestCode;
int callingPid = request.callingPid;
int callingUid = request.callingUid;
String callingPackage = request.callingPackage;
String callingFeatureId = request.callingFeatureId;
final int realCallingPid = request.realCallingPid;
final int realCallingUid = request.realCallingUid;
final int startFlags = request.startFlags;
final SafeActivityOptions options = request.activityOptions;
Task inTask = request.inTask;
...
// 进行一些初步的检查，如果检查出错了，返回错误码 err
...
// 权限检查
boolean abort = !mSupervisor.checkStartAnyActivityPermission(intent, aInfo, resultWho,
requestCode, callingPid, callingUid, callingPackage, callingFeatureId,
request.ignoreTargetSecurity, inTask != null, callerApp, resultRecord, resultStack);
...
// 新建 ActivityRecord
final ActivityRecord r = new ActivityRecord(mService, callerApp, callingPid, callingUid,
callingPackage, callingFeatureId, intent, resolvedType, aInfo,
mService.getGlobalConfiguration(), resultRecord, resultWho, requestCode,
request.componentSpecified, voiceSession != null, mSupervisor, checkedOptions,
sourceRecord);
mLastStartActivityRecord = r;
...
// 接着调用 startActivityUnchecked()
mLastStartActivityResult = startActivityUnchecked(r, sourceRecord, voiceSession,
request.voiceInteractor, startFlags, true /* doResume */, checkedOptions, inTask,
restrictedBgActivity, intentGrants);
...
return mLastStartActivityResult;
}
}
execute() 方法又调用了 executeRequest() 方法，executeRequest() 方法会把 Request 的参数传入，进行初步的检查，然后在这里新建要启动的 Activity 对应的ActivityRecord，其包含了 Activity 的所有信息，然后继续调用 startActivityUnchecked() 方法：
class ActivityStarter {
private final ActivityTaskManagerService mService;
private final RootWindowContainer mRootWindowContainer;
ActivityStarter(ActivityStartController controller, ActivityTaskManagerService service,
ActivityStackSupervisor supervisor, ActivityStartInterceptor interceptor) {
...
mService = service;
mRootWindowContainer = service.mRootWindowContainer;
...
}
// 确保如果启动不成功，会移除启动的 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) {
int result = START_CANCELED;
...
result = startActivityInner(r, sourceRecord, voiceSession, voiceInteractor,
startFlags, doResume, options, inTask, restrictedBgActivity, intentGrants);
...
return result;
}
// 启动一个 activity，确认该 activity 是应该添加到现有的 task 的顶部，
// 还是把新的 intent 传给已存在的 activity。此外，还会将 activity task 放置到
// 指定的或有效的 stack 或 display 上
int startActivityInner(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
int startFlags, boolean doResume, ActivityOptions options, Task inTask,
boolean restrictedBgActivity, NeededUriGrants intentGrants) {
// 根据启动模式和 Intent 中的 flag 来计算 mLaunchFlags
computeLaunchingTaskFlags();
...
// 把 mLaunchFlags 传给 mIntent
mIntent.setFlags(mLaunchFlags);
// 尝试复用已有 Task
final Task reusedTask = getReusableTask();
...
// 如果 reusedTask 不为 null ，使用 reusedTask；否则使用 computeTargetTask()
final Task targetTask = reusedTask != null ? reusedTask : computeTargetTask();
// 如果 targetTask 为 null ，newTask 为 true
final boolean newTask = targetTask == null;
// targetTask 赋值给 mTargetTask
mTargetTask = targetTask;
// 计算启动参数，结果保存在 mLaunchParams 中
computeLaunchParams(r, sourceRecord, targetTask);
// Check if starting activity on given task or on a new task is allowed.
int startResult = isAllowedToStart(r, newTask, targetTask);
if (startResult != START_SUCCESS) {
// 不允许启动，返回错误码
return startResult;
}
...
// If the activity being launched is the same as the one currently at the top, then
// we need to check if it should only be launched once.
// 检查是否重复启动栈顶 Activity（SingleTop）
final ActivityStack topStack = mRootWindowContainer.getTopDisplayFocusedStack();
if (topStack != null) {
startResult = deliverToCurrentTopIfNeeded(topStack, intentGrants);
if (startResult != START_SUCCESS) {
return startResult;
}
}
// 决定 Activity 应该放入哪个显示栈（主屏、画中画、分屏等）
if (mTargetStack == null) {
mTargetStack = getLaunchStack(mStartActivity, mLaunchFlags, targetTask, mOptions);
}
if (newTask) {
final Task taskToAffiliate = (mLaunchTaskBehind && mSourceRecord != null)
? mSourceRecord.getTask() : null;
// 把目标 ActivityRecord 添加到新的 Task
setNewTask(taskToAffiliate);
...
} else if (mAddingToTask) {
// 把目标 ActivityRecord 添加到已有的 targetTask
addOrReparentStartingActivity(targetTask, "adding to task");
}
if (!mAvoidMoveToFront && mDoResume) {
// 如果需要 resume（即显示给用户），就把目标 Task 移动到前台
mTargetStack.getStack().moveToFront("reuseOrNewTask", targetTask);
if (mOptions != null) {
if (mOptions.getTaskAlwaysOnTop()) {
mTargetStack.setAlwaysOnTop(true);
}
}
if (!mTargetStack.isTopStackInDisplayArea() && 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;
}
}
// 给目标 Activity 添加 Uri 权限
mService.mUgmInternal.grantUriPermissionUncheckedFromIntent(intentGrants, mStartActivity.getUriPermissionsLocked());
...
// 将 Activity 加入 Stack
mTargetStack.startActivityLocked(mStartActivity, topStack.getTopNonFinishingActivity(),
newTask, mKeepCurTransition, mOptions);
// Resume 处理
if (mDoResume) {
final ActivityRecord topTaskActivity =
mStartActivity.getTask().topRunningActivityLocked();
if (!mTargetStack.isTopActivityFocusable()
|| (topTaskActivity != null && topTaskActivity.isTaskOverlay()
&& mStartActivity != topTaskActivity)) {
// 只保证可见，不获取焦点
// 如果该 activity 无法获取到焦点，我们不能执行 resume ，但是启动它的时候
// 还是要让它可见（这将会触发入场动画），RIP activities 就是其中一个例子
mTargetStack.ensureActivitiesVisible(null /* starting */,
0 /* configChanges */, !PRESERVE_WINDOWS);
mTargetStack.getDisplay().mDisplayContent.executeAppTransition();
} else {
...
// 正常 resume
mRootWindowContainer.resumeFocusedStacksTopActivities(
mTargetStack, mStartActivity, mOptions);
}
}
mRootWindowContainer.updateUserStack(mStartActivity.mUserId, mTargetStack);
// Update the recent tasks list immediately when the activity starts
mSupervisor.mRecentTasks.add(mStartActivity.getTask());
mSupervisor.handleNonResizableTaskIfNeeded(mStartActivity.getTask(),
mPreferredWindowingMode, mPreferredTaskDisplayArea, mTargetStack);
return START_SUCCESS;
}
}
startActivityUnchecked() 又调用了 startActivityInner() 方法，startActivityInner() 中根据启动参数（Intent、Flags、Task 等）决定如何将目标 Activity 放入系统任务栈（Task/Stack），处理复用、新建、权限授予、可见性、焦点恢复等逻辑，并最终调用 startActivityLocked() 和 resumeFocusedStacksTopActivities() 完成启动。
接下来分析 RootWindowContainer 的 resumeFocusedStacksTopActivities() 方法：
class RootWindowContainer extends WindowContainer<DisplayContent>
implements DisplayManager.DisplayListener {
boolean resumeFocusedStacksTopActivities(ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
...
for (int displayNdx = getChildCount() - 1; displayNdx >= 0; --displayNdx) {
...
if (!resumedOnDisplay) {
// In cases when there are no valid activities (e.g. device just booted or launcher
// crashed) it's possible that nothing was resumed on a display. Requesting resume
// of top activity in focused stack explicitly will make sure that at least home
// activity is started and resumed, and no recursion occurs.
final ActivityStack focusedStack = display.getFocusedStack();
if (focusedStack != null) {
result |= focusedStack.resumeTopActivityUncheckedLocked(target, targetOptions);
} else if (targetStack == null) {
result |= resumeHomeActivity(null /* prev */, "no-focusable-task",
display.getDefaultTaskDisplayArea());
}
}
}
return result;
}
}
RootWindowContainer是设备窗口容器（WindowContainer）的根容器，管理所有的窗口容器，设备上所有的窗口（Window）、显示（Display）都是由它来管理的。
RootWindowContainer 的 resumeFocusedStacksTopActivities() 方法转交给 ActivityStack 的 resumeTopActivityUncheckedLocked() 方法来继续启动流程：
class ActivityStack extends Task {
boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
if (mInResumeTopActivity) {
// Don't even start recursing.
return false;
}
boolean result = false;
try {
mInResumeTopActivity = true;
result = resumeTopActivityInnerLocked(prev, options);
final ActivityRecord next = topRunningActivity(true /* focusableOnly */);
if (next == null || !next.canTurnScreenOn()) {
checkReadyForSleep();
}
} finally {
mInResumeTopActivity = false;
}
return result;
}
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
...
// next 就是当前要启动的 Activity
ActivityRecord next = topRunningActivity(true /* focusableOnly */);
...
// 暂停所有栈里面的 Activity ，不包括可见的栈
boolean pausing = taskDisplayArea.pauseBackStacks(userLeaving, next);
if (mResumedActivity != null) {
if (DEBUG_STATES) Slog.d(TAG_STATES,
"resumeTopActivityLocked: Pausing " + mResumedActivity);
// pause 上一个 Activity ，上一个 Activity 处于 resume 状态
pausing |= startPausingLocked(userLeaving, false /* uiSleeping */, next);
}
...
// 判断 next 是否已经启动了
if (next.attachedToProcess()) {
...
final ClientTransaction transaction =
ClientTransaction.obtain(next.app.getThread(), next.appToken);
...
// 启动了的 Activity 就发送 ResumeActivityItem 事务给客户端，后面会讲到
transaction.setLifecycleStateRequest(
ResumeActivityItem.obtain(next.app.getReportedProcState(),
dc.isNextTransitionForward()));
mAtmService.getLifecycleManager().scheduleTransaction(transaction);
...
} else {
...
if (SHOW_APP_STARTING_PREVIEW) {
// 这里就是冷启动出现白屏的原因，取根 activity 的主题背景展示 StartingWindow
next.showStartingWindow(null /* prev */, false /* newTask */,
false /* taskSwich */);
}
// 继续启动当前 Activity
mStackSupervisor.startSpecificActivity(next, true, true);
}
return true;
}
}
从 resumeTopActivityUncheckedLocked() 方法继续跟进到 resumeTopActivityInnerLocked() 方法，resumeTopActivityInnerLocked() 中先对上一个 Activity 执行了 Pause 操作，然后判断当前要启动的 Activity 是否已经启动了，如果已经启动了，发送 ResumeActivityItem 事务给客户端，执行 resume 流程，如果没有启动，继续调用ActivityStackSupervisor的 startSpecificActivity() 方法。这里注意下，调用 startSpecificActivity() 方法前调用了 next.showStartingWindow() 来展示一个 window，这就是冷启动时出现白屏的原因。我们继续来看 ActivityStackSupervisor 的 startSpecificActivity() 方法：
public class ActivityStackSupervisor{
void startSpecificActivity(ActivityRecord r, boolean andResume, boolean checkConfig) {
final WindowProcessController wpc =
mService.getProcessController(r.processName, r.info.applicationInfo.uid);
boolean knownToBeDead = false;
// wpc.hasThread() 通过判断 IApplicationThread 是否被赋值，如果已赋值，即应用已运行
// 应用已运行，则是普通 Activity 的启动流程，走 realStartActivityLocked() 方法
if (wpc != null && wpc.hasThread()) {
try {
realStartActivityLocked(r, wpc, andResume, checkConfig);
return;
} catch (RemoteException e) {
Slog.w(TAG, "Exception when starting activity "
+ r.intent.getComponent().flattenToShortString(), e);
}
// If a dead object exception was thrown -- fall through to
// restart the application.
knownToBeDead = true;
}
r.notifyUnknownVisibilityLaunchedForKeyguardTransition();
final boolean isTop = andResume && r.isTopRunningActivity();
// 否则需要 ATMS 的 startProcessAsync() 方法请求创建进程
mService.startProcessAsync(r, knownToBeDead, isTop, isTop ? "top-activity" : "activity");
}
}
startSpecificActivity() 方法中通过 wpc.hasThread() 来判断 activity 所在的应用是否已经在运行，其内部是通过 IApplicationThread 是否已经被赋值来判断的，如果为 true ，走 ActivityStackSupervisor 的realStartActivityLocked() 方法，即普通 Activity 的启动流程；否则需要调用 ATMS 的 startProcessAsync() 来创建应用进程。
这里走 ActivityStackSupervisor 的 realStartActivityLocked() 方法：
public class ActivityStackSupervisor implements RecentTasks.Callbacks {
boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
boolean andResume, boolean checkConfig) throws RemoteException {
...
// 创建启动 activity 的 transaction
final ClientTransaction clientTransaction = ClientTransaction.obtain(
proc.getThread(), r.appToken);
final DisplayContent dc = r.getDisplay().mDisplayContent;
// 给 ClientTransaction 实例添加 LaunchActivityItem
clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
System.identityHashCode(r), r.info,
// TODO: Have this take the merged configuration instead of separate global
// and override configs.
mergedConfiguration.getGlobalConfiguration(),
mergedConfiguration.getOverrideConfiguration(), r.compat,
r.launchedFromPackage, task.voiceInteractor, proc.getReportedProcState(),
r.getSavedState(), r.getPersistentSavedState(), results, newIntents,
dc.isNextTransitionForward(), proc.createProfilerInfoIfNeeded(),
r.assistToken, r.createFixedRotationAdjustmentsIfNeeded()));
//Set desired final state.
final ActivityLifecycleItem lifecycleItem;
// 前面传入的参数 andResume 为 true
if (andResume) {
lifecycleItem = ResumeActivityItem.obtain(dc.isNextTransitionForward());
} else {
lifecycleItem = PauseActivityItem.obtain();
}
// 设置执行 transaction 后客户端的下一个生命周期状态
clientTransaction.setLifecycleStateRequest(lifecycleItem);
// Schedule transaction.
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
...
return true;
}
}
该方法执行流程如下：
- 使用 ClientTransaction.obtain(proc.getThread(), r.appToken) 获取 ClientTransaction 实例，proc 就是 WindowProcessController，参数 proc.getThread() 是 IApplicationThread 类型，它是 ApplicationThread 在系统进程的代理。
- 给 ClientTransaction 实例添加的
LaunchActivityItem实例，LaunchActivityItem 继承自 ClientTransactionItem，ClientTransactionItem 是一个抽象类。ClientTransaction是包含一系列的待客户端处理的事务的容器，客户端接收后取出事务并执行。 - 通过 mService.getLifecycleManager() 获取 ClientLifecycleManager 实例，调用其 scheduleTransaction() 方法，并把 clientTransaction 传入。
先来看看 ClientTransaction 的 addCallback() 方法：
public class ClientTransaction implements Parcelable, ObjectPoolItem {
// 都是用来发送到客户端的
private List<ClientTransactionItem> mActivityCallbacks;
// 在列表中添加 ClientTransactionItem 类型的消息
public void addCallback(ClientTransactionItem activityCallback) {
if (mActivityCallbacks == null) {
mActivityCallbacks = new ArrayList<>();
}
mActivityCallbacks.add(activityCallback);
}
}
addCallback() 方法把 ClientTransactionItem 类型的消息添加到 mActivityCallbacks 这个列表中。
看下 LaunchActivityItem 实例怎么获取的：
public class LaunchActivityItem extends ClientTransactionItem {
/** Obtain an instance initialized with provided params. */
public static LaunchActivityItem obtain(Intent intent, int ident, ActivityInfo info,
Configuration curConfig, Configuration overrideConfig, CompatibilityInfo compatInfo,
String referrer, IVoiceInteractor voiceInteractor, int procState, Bundle state,
PersistableBundle persistentState, List<ResultInfo> pendingResults,
List<ReferrerIntent> pendingNewIntents, boolean isForward, ProfilerInfo profilerInfo,
IBinder assistToken, FixedRotationAdjustments fixedRotationAdjustments) {
LaunchActivityItem instance = ObjectPool.obtain(LaunchActivityItem.class);
if (instance == null) {
instance = new LaunchActivityItem();
}
setValues(instance, intent, ident, info, curConfig, overrideConfig, compatInfo, referrer,
voiceInteractor, procState, state, persistentState, pendingResults,
pendingNewIntents, isForward, profilerInfo, assistToken, fixedRotationAdjustments);
return instance;
}
}
obtain() 方法里面 new 了一个 LaunchActivityItem，然后把各种配置信息传给了它。从名字来看，它就是用来启动 Activity 的。它是怎么发挥作用的呢？
前面的 mService.getLifecycleManager() 拿到的是 ClientLifecycleManager，然后调用其 scheduleTransaction() 方法：
class ClientLifecycleManager {
// 安排调度一个事务（启动、暂停等 Activity 事务），可能包含多个回调和一个生命周期请求
void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
final IApplicationThread client = transaction.getClient();
transaction.schedule();
if (!(client instanceof Binder)) {
// If client is not an instance of Binder - it's a remote call and at this point it is
// safe to recycle the object. All objects used for local calls will be recycled after
// the transaction is executed on client in ActivityThread.
transaction.recycle();
}
}
}
里面调用了 ClientTransaction 的 schedule() 方法：
public class ClientTransaction implements Parcelable, ObjectPoolItem {
public void schedule() throws RemoteException {
mClient.scheduleTransaction(this);
}
}
mClient 是 IApplicationThread 类型，是 ApplicationThread 在系统进程的代理，所以真正执行的地方就是客户端的 ApplicationThread 中了。也就是说，Activity 启动的操作又通过跨进程还给了客户端。
这一步总结起来就是 ATMS 经过 ActivityStarter、RootWindowContainer、ActivityStack、ActivityStackSupervisor 对 Activity 任务、Activity 栈进行管理后，拿到启动 Activity 的事务通过跨进程给到了客户端。
线程切换及消息处理
接着上面的分析，我们找到 ApplicationThread，ApplicationThread 是 ActivityThread 的内部类：
public final class ActivityThread extends ClientTransactionHandler {
private class ApplicationThread extends IApplicationThread.Stub {
@Override
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
ActivityThread.this.scheduleTransaction(transaction);
}
}
}
ApplicationThread 的 scheduleTransaction() 方法又调用了 ActivityThread 的 scheduleTransaction() 方法， ActivityThread 的 scheduleTransaction() 方法实际在其父类 ClientTransactionHandler 中
public abstract class ClientTransactionHandler {
void scheduleTransaction(ClientTransaction transaction) {
transaction.preExecute(this);
// 发送 ActivityThread.H.EXECUTE_TRANSACTION 消息
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
}
使用 sendMessage 发送消息，参数是 ActivityThread.H.EXECUTE_TRANSACTION 和 transaction，接着看 ActivityThread 的 sendMessage() 方法：
public final class ActivityThread extends ClientTransactionHandler {
final H mH = new H();
void sendMessage(int what, Object obj) {
sendMessage(what, obj, 0, 0, false);
}
private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) {
...
Message msg = Message.obtain();
msg.what = what;
msg.obj = obj;
msg.arg1 = arg1;
msg.arg2 = arg2;
if (async) {
msg.setAsynchronous(true);
}
mH.sendMessage(msg);
}
}
最后调用了 mH.sendMessage(msg)，mH 是一个 Handler 对象，mH 是在主线程创建的，所以通过 mH.sendMessage(msg) 把消息发送到了主线程。
那么前面 ApplicationThread 的 scheduleTransaction() 方法执行在哪个线程呢？根据 IPC 知识，服务器的 Binder 方法运行在 Binder 线程池中，也就是说系统进行跨进程调用 ApplicationThread 的 scheduleTransaction() 方法运行在 Binder 的线程池中，这样就把子线程中的消息通过 Handler 发送到了主线程。继续看 ActivityThread.H 的 handleMessage() 方法：
public final class ActivityThread extends ClientTransactionHandler {
class H extends Handler {
public static final int BIND_APPLICATION = 110;
@UnsupportedAppUsage
public static final int EXIT_APPLICATION = 111;
@UnsupportedAppUsage
public static final int RECEIVER = 113;
@UnsupportedAppUsage
public static final int CREATE_SERVICE = 114;
@UnsupportedAppUsage
public static final int SERVICE_ARGS = 115;
...
public static final int EXECUTE_TRANSACTION = 159;
public static final int RELAUNCH_ACTIVITY = 160;
...
public void handleMessage(Message msg) {
if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
switch (msg.what) {
case BIND_APPLICATION:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "bindApplication");
AppBindData data = (AppBindData)msg.obj;
handleBindApplication(data);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
case EXIT_APPLICATION:
if (mInitialApplication != null) {
mInitialApplication.onTerminate();
}
Looper.myLooper().quit();
break;
case RECEIVER:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "broadcastReceiveComp");
handleReceiver((ReceiverData)msg.obj);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
case CREATE_SERVICE:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, ("serviceCreate: " + String.valueOf(msg.obj)));
handleCreateService((CreateServiceData)msg.obj);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
case BIND_SERVICE:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "serviceBind");
handleBindService((BindServiceData)msg.obj);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
...
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();
}
break;
case RELAUNCH_ACTIVITY:
handleRelaunchActivityLocally((IBinder) msg.obj);
break;
...
}
Object obj = msg.obj;
if (obj instanceof SomeArgs) {
((SomeArgs) obj).recycle();
}
if (DEBUG_MESSAGES) Slog.v(TAG, "<<< done: " + codeToString(msg.what));
}
}
}
代码第 50 行获取传递过来的 ClientTransaction，然后执行 TransactionExecutor 的 execute() 方法：
public class TransactionExecutor {
public void execute(ClientTransaction transaction) {
...
final IBinder token = transaction.getActivityToken();
...
executeCallbacks(transaction);
executeLifecycleState(transaction);
...
}
}
继续跟进 executeCallbacks() 方法：
public class TransactionExecutor {
public TransactionExecutor(ClientTransactionHandler clientTransactionHandler) {
mTransactionHandler = clientTransactionHandler;
}
@VisibleForTesting
public void executeCallbacks(ClientTransaction transaction) {
final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
if (callbacks == null || callbacks.isEmpty()) {
// No callbacks to execute, return early.
return;
}
if (DEBUG_RESOLVER) Slog.d(TAG, tId(transaction) + "Resolving callbacks in transaction");
final IBinder token = transaction.getActivityToken();
ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
// In case when post-execution state of the last callback matches the final state requested
// for the activity in this transaction, we won't do the last transition here and do it when
// moving to final state instead (because it may contain additional parameters from server).
final ActivityLifecycleItem finalStateRequest = transaction.getLifecycleStateRequest();
final int finalState = finalStateRequest != null ? finalStateRequest.getTargetState()
: UNDEFINED;
// Index of the last callback that requests some post-execution state.
final int lastCallbackRequestingState = lastCallbackRequestingState(transaction);
final int size = callbacks.size();
// 遍历 callbacks
for (int i = 0; i < size; ++i) {
final ClientTransactionItem item = callbacks.get(i);
...
item.execute(mTransactionHandler, token, mPendingActions);
item.postExecute(mTransactionHandler, token, mPendingActions);
...
}
}
}
在 executeCallbacks() 方法里遍历 callbacks ，调用 ClientTransactionItem 的 execute() 方法，这里的 ClientTransactionItem 就是 LaunchActivityItem ，我们来看看它的 execute() 方法：
public class LaunchActivityItem extends ClientTransactionItem {
@Override
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.handleLaunchActivity() 方法，client 是 ClientTransactionHandler 的实例，是在 TransactionExecutor 的构造方法传入的，TransactionExecutor 创建是在 ActivityThread 中：
public final class ActivityThread extends ClientTransactionHandler {
private final TransactionExecutor mTransactionExecutor = new TransactionExecutor(this);
}
所以这里的 client 实际上是 ActivityThread，接下来执行 ActivityThread 的 handleLaunchActivity() 方法。
好了，这一步总结起来就是ApplicationThread 通过给 ActivityThead 里面的 Handler 发消息，切换到了主线程，走到了 ActivityThead 的 handleLaunchActivity() 方法。
Activity初始化及生命周期处理
接着看 ActivityThead 的 handleLaunchActivity() 方法：
public final class ActivityThread extends ClientTransactionHandler {
@Override
public Activity handleLaunchActivity(ActivityClientRecord r,
PendingTransactionActions pendingActions, Intent customIntent) {
...
final Activity a = performLaunchActivity(r, customIntent);
...
return a;
}
}
继续跟进performLaunchActivity() 方法，这里就是 Activity 启动的核心实现了：
public final class ActivityThread extends ClientTransactionHandler {
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
// 1、从 ActivityClientRecord 中获取待启动的 Activity 的组件信息
ActivityInfo aInfo = r.activityInfo;
if (r.packageInfo == null) {
r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
Context.CONTEXT_INCLUDE_CODE);
}
ComponentName component = r.intent.getComponent();
if (component == null) {
component = r.intent.resolveActivity(
mInitialApplication.getPackageManager());
r.intent.setComponent(component);
}
if (r.activityInfo.targetActivity != null) {
component = new ComponentName(r.activityInfo.packageName,
r.activityInfo.targetActivity);
}
// 创建 ContextImpl 对象
ContextImpl appContext = createBaseContextForActivity(r);
Activity activity = null;
try {
java.lang.ClassLoader cl = appContext.getClassLoader();
// 2、创建 Activity 实例
activity = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent);
StrictMode.incrementExpectedActivityCount(activity.getClass());
r.intent.setExtrasClassLoader(cl);
r.intent.prepareToEnterProcess();
if (r.state != null) {
r.state.setClassLoader(cl);
}
} catch (Exception e) {
if (!mInstrumentation.onException(activity, e)) {
throw new RuntimeException(
"Unable to instantiate activity " + component
+ ": " + e.toString(), e);
}
}
try {
// 3、创建 Application 对象（如果没有的话）
Application app = r.packageInfo.makeApplication(false, mInstrumentation);
if (localLOGV) Slog.v(TAG, "Performing launch of " + r);
if (localLOGV) Slog.v(
TAG, r + ": app=" + app
+ ", appName=" + app.getPackageName()
+ ", pkg=" + r.packageInfo.getPackageName()
+ ", comp=" + r.intent.getComponent().toShortString()
+ ", dir=" + r.packageInfo.getAppDir());
if (activity != null) {
CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
Configuration config = new Configuration(mCompatConfiguration);
if (r.overrideConfig != null) {
config.updateFrom(r.overrideConfig);
}
if (DEBUG_CONFIGURATION) Slog.v(TAG, "Launching activity "
+ r.activityInfo.name + " with config " + config);
Window window = null;
if (r.mPendingRemoveWindow != null && r.mPreserveWindow) {
window = r.mPendingRemoveWindow;
r.mPendingRemoveWindow = null;
r.mPendingRemoveWindowManager = null;
}
// Activity resources must be initialized with the same loaders as the
// application context.
appContext.getResources().addLoaders(
app.getResources().getLoaders().toArray(new ResourcesLoader[0]));
appContext.setOuterContext(activity);
// 4、attach() 方法为 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);
if (customIntent != null) {
activity.mIntent = customIntent;
}
r.lastNonConfigurationInstances = null;
checkAndBlockForNetworkAccess();
activity.mStartedActivity = false;
int theme = r.activityInfo.getThemeResource();
if (theme != 0) {
activity.setTheme(theme);
}
activity.mCalled = false;
// 5、调用生命周期 onCreate() 方法
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
if (!activity.mCalled) {
throw new SuperNotCalledException(
"Activity " + r.intent.getComponent().toShortString() +
" did not call through to super.onCreate()");
}
r.activity = activity;
mLastReportedWindowingMode.put(activity.getActivityToken(),
config.windowConfiguration.getWindowingMode());
}
r.setState(ON_CREATE);
// updatePendingActivityConfiguration() reads from mActivities to update
// ActivityClientRecord which runs in a different thread. Protect modifications to
// mActivities to avoid race.
synchronized (mResourcesManager) {
mActivities.put(r.token, r);
}
} catch (SuperNotCalledException e) {
throw e;
} catch (Exception e) {
if (!mInstrumentation.onException(activity, e)) {
throw new RuntimeException(
"Unable to start activity " + component
+ ": " + e.toString(), e);
}
}
return activity;
}
}
performLaunchActivity() 主要完成以下事情：
- 从 ActivityClientRecord 中获取待启动的 Activity 的组件信息。
- 通过 mInstrumentation.newActivity() 方法使用类加载器创建 Activity 实例。
- 通过 LoadedApk 的 makeApplication() 方法创建 Application 对象（如果之前没有的话），内部也是通过 mInstrumentation 使用类加载器来创建的，然后调用了 instrumentation.callApplicationOnCreate()，也就是 Application 的 onCreate() 方法。
- 创建 ContextImpl 对象并通过 activity.attach() 方法对重要数据初始化，关联了 Context 的具体实现 ContextImpl ， attach 方法内部还完成了 Window 创建，这样 Window 接收到外部事件后就能传递给 Activity 了。
- 调用 Activity 的 onCreate() 方法，是通过 mInstrumentation.callActivityOnCreate() 来完成的。
到这里 Activity 的 onCreate() 方法就执行完了，那么 onStart()、onResume() 呢？
回头看看 TransactionExecutor 的 execute() 方法，执行完 executeCallbacks(transaction) 之后会执行 executeLifecycleState(transaction):
public class TransactionExecutor {
private void executeLifecycleState(ClientTransaction transaction) {
// 获取执行 transaction 后，客户端应处于的生命周期状态
final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
if (lifecycleItem == null) {
// No lifecycle request, return early.
return;
}
final IBinder token = transaction.getActivityToken();
final ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
...
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);
// Execute the final transition with proper parameters.
lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
}
}
clientTransaction.setLifecycleStateRequest(lifecycleItem) 是在 AcivityStackSupervisor 的realStartActivityLocked() 方法中执行的，这里拿到的 lifecycleItem 就是 ResumeActivityItem，接下来执行 ResumeActivityItem 的 execute() 方法：
public class ResumeActivityItem extends ActivityLifecycleItem {
@Override
public void execute(ClientTransactionHandler client, IBinder token,
PendingTransactionActions pendingActions) {
...
client.handleResumeActivity(token, true /* finalStateRequest */, mIsForward,
"RESUME_ACTIVITY");
...
}
}
通过上面的分析，后面会执行 ActivityThread 的 handleResumeActivity() 方法：
public final class ActivityThread extends ClientTransactionHandler {
@Override
public void handleResumeActivity(IBinder token, boolean finalStateRequest, boolean isForward,
String reason) {
...
// performResumeActivity() 方法内部会走 onStart、onResume
final ActivityClientRecord r = performResumeActivity(token, finalStateRequest, reason);
if (r == null) {
// We didn't actually resume the activity, so skipping any follow-up actions.
return;
}
...
if (r.window == null && !a.mFinished && willBeVisible) {
r.window = r.activity.getWindow();
View decor = r.window.getDecorView();
decor.setVisibility(View.INVISIBLE);
ViewManager wm = a.getWindowManager();
WindowManager.LayoutParams l = r.window.getAttributes();
a.mDecor = decor;
l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
l.softInputMode |= forwardBit;
if (r.mPreserveWindow) {
a.mWindowAdded = true;
r.mPreserveWindow = false;
// Normally the ViewRoot sets up callbacks with the Activity
// in addView->ViewRootImpl#setView. If we are instead reusing
// the decor view we have to notify the view root that the
// callbacks may have changed.
ViewRootImpl impl = decor.getViewRootImpl();
if (impl != null) {
impl.notifyChildRebuilt();
}
}
if (a.mVisibleFromClient) {
if (!a.mWindowAdded) {
a.mWindowAdded = true;
// 执行 WindowManagerImpl 的 addView() 方法，里面执行了绘制流程
wm.addView(decor, l);
} else {
// The activity will get a callback for this {@link LayoutParams} change
// earlier. However, at that time the decor will not be set (this is set
// in this method), so no action will be taken. This call ensures the
// callback occurs with the decor set.
a.onWindowAttributesChanged(l);
}
}
// If the window has already been added, but during resume
// we started another activity, then don't yet make the
// window visible.
} else if (!willBeVisible) {
if (localLOGV) Slog.v(TAG, "Launch " + r + " mStartedActivity set");
r.hideForNow = true;
}
// Get rid of anything left hanging around.
cleanUpPendingRemoveWindows(r, false /* force */);
// The window is now visible if it has been added, we are not
// simply finishing, and we are not starting another activity.
if (!r.activity.mFinished && willBeVisible && r.activity.mDecor != null && !r.hideForNow) {
if (r.newConfig != null) {
performConfigurationChangedForActivity(r, r.newConfig);
if (DEBUG_CONFIGURATION) {
Slog.v(TAG, "Resuming activity " + r.activityInfo.name + " with newConfig "
+ r.activity.mCurrentConfig);
}
r.newConfig = null;
}
if (localLOGV) Slog.v(TAG, "Resuming " + r + " with isForward=" + isForward);
ViewRootImpl impl = r.window.getDecorView().getViewRootImpl();
WindowManager.LayoutParams l = impl != null
? impl.mWindowAttributes : r.window.getAttributes();
if ((l.softInputMode
& WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION)
!= forwardBit) {
l.softInputMode = (l.softInputMode
& (~WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION))
| forwardBit;
if (r.activity.mVisibleFromClient) {
ViewManager wm = a.getWindowManager();
View decor = r.window.getDecorView();
wm.updateViewLayout(decor, l);
}
}
r.activity.mVisibleFromServer = true;
mNumVisibleActivities++;
if (r.activity.mVisibleFromClient) {
// 里面设置了 DecorView 可见
r.activity.makeVisible();
}
}
r.nextIdle = mNewActivities;
mNewActivities = r;
if (localLOGV) Slog.v(TAG, "Scheduling idle handler for " + r);
Looper.myQueue().addIdleHandler(new Idler());
}
}
handleResumeActivity() 中主要做了这些事情：
- 调用 performResumeActivity() 方法，内部会调用 onStart()、onResume() 方法。
- 执行 wm.addView(decor, l)，里面执行了布局、测量与绘制三大流程，并完成了窗口的添加。这就是为什么在 onResume() 方法中无法获取到 View 的宽高的原因，因为在 onResume() 方法中宽高还没有被赋值。
- 执行 r.activity.makeVisible()，让 DecorView 可见。
来看看 performResumeActivity() 方法：
public final class ActivityThread extends ClientTransactionHandler {
public ActivityClientRecord performResumeActivity(IBinder token, boolean finalStateRequest,
String reason) {
final ActivityClientRecord r = mActivities.get(token);
...
r.activity.performResume(r.startsNotResumed, reason);
...
return r;
}
}
里面调用了 Activity 的 performResume() 方法：
public class Activity extends ContextThemeWrapper {
final void performResume(boolean followedByPause, String reason) {
dispatchActivityPreResumed();
// 里面执行了 Activity 的 onStart() 方法
performRestart(true /* start */, reason);
...
// 里面执行了 Activity 的 onResume() 方法
mInstrumentation.callActivityOnResume(this);
...
// 里面执行了 Fragment 的 onResume() 方法
mFragments.dispatchResume();
mFragments.execPendingActions();
...
}
}
先执行了 performRestart() 方法， performRestart() 方法里面执行了 onStart() 方法。然后执行了 mInstrumentation.callActivityOnResume(this)，里面执行了 onResume() 方法。
到这里，启动 Activity 的生命周期方法就走完了。
整个流程梳理成流程图如下所示：
