ActivityManagerService Activity的启动流程
简述
提到ActivityManagerService，最重要的流程之一就是启动Activity了。
这个流程比较复杂：
- 启动activity的调用链很长。
- 业务逻辑很多，activity启动有很多flag，例如FLAG_ACTIVITY_NEW_TASK，FLAG_ACTIVITY_CLEAR_TOP等等。
- 需要在app进程和systemserver之间来回binder调用。
同时activity启动还有两种不同的情况，一种是要启动的Activity进程已经存在了，只是新启动一个Activity，例如在app内部页面跳转。而另一种是要启动的Activity进程不存在，需要新启动一个进程，比如从桌面启动一个进程。
app启动Activity
1.1 Activity.startActivityForResult
Activity.startActivity最终也会走到Activity.startActivityForResult,只不过requestCode会传-1,我们就从这里开始.
这里的mParent是历史版本的遗留产物，应该是被Fragment替代了，这里可以不用管。
调用了Instrumentation.execStartActivity
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,@Nullable Bundle options) {if (mParent == null) { options = transferSpringboardActivityOptions(options);// 调用Instrumentation.execStartActivity,详见1.2Instrumentation.ActivityResult ar =mInstrumentation.execStartActivity(this, mMainThread.getApplicationThread(), mToken, this,intent, requestCode, options);if (ar != null) {mMainThread.sendActivityResult(mToken, mEmbeddedID, requestCode, ar.getResultCode(),ar.getResultData());}if (requestCode >= 0) {mStartedActivity = true;}cancelInputsAndStartExitTransition(options);} else {// ...}
}
1.2 Instrumentation.execStartActivity
mActivityMonitors一般用于CTS测试，除了mActivityMonitors插桩的逻辑，主要逻辑是调用ATMS服务，启动Activity
public ActivityResult execStartActivity(Context who, IBinder contextThread, IBinder token, Activity target,Intent intent, int requestCode, Bundle options) {IApplicationThread whoThread = (IApplicationThread) contextThread;Uri referrer = target != null ? target.onProvideReferrer() : null;if (referrer != null) {intent.putExtra(Intent.EXTRA_REFERRER, referrer);}// ...mActivityMonitors,一般用于CTS测试try {intent.migrateExtraStreamToClipData(who);intent.prepareToLeaveProcess(who);// 调用ATMS启动activity，详见1.3int result = ActivityTaskManager.getService().startActivity(whoThread,who.getOpPackageName(), who.getAttributionTag(), intent,intent.resolveTypeIfNeeded(who.getContentResolver()), token,target != null ? target.mEmbeddedID : null, requestCode, 0, null, options);// 通知mActivityMonitors返回结果notifyStartActivityResult(result, options);// 处理返回值，如果没有启动成功抛出对应异常checkStartActivityResult(result, intent);} catch (RemoteException e) {throw new RuntimeException("Failure from system", e);}return null;
}
1.3 ActivityTaskManagerService.startActivity
直接调用了startActivityAsUser
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) {// 详见1.4return startActivityAsUser(caller, callingPackage, callingFeatureId, intent, resolvedType,resultTo, resultWho, requestCode, startFlags, profilerInfo, bOptions,UserHandle.getCallingUserId());
}
1.4 ActivityTaskManagerService.startActivityAsUser
调用了重载函数startActivityAsUser
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*/);
}
1.5 ActivityTaskManagerService.startActivityAsUser
使用所有参数构造一个ActivityStarter，然后调用ActivityStarter.execute
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) {final SafeActivityOptions opts = SafeActivityOptions.fromBundle(bOptions);assertPackageMatchesCallingUid(callingPackage);enforceNotIsolatedCaller("startActivityAsUser");// ...userId = getActivityStartController().checkTargetUser(userId, validateIncomingUser,Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");// 详见1.6return getActivityStartController().obtainStarter(intent, "startActivityAsUser").setCaller(caller) // 调用者对应的binder token.setCallingPackage(callingPackage) // 调用者包名.setCallingFeatureId(callingFeatureId).setResolvedType(resolvedType) // MIME类型.setResultTo(resultTo) // startActivityForResult里接受返回结果的Activity.setResultWho(resultWho).setRequestCode(requestCode) // startActivityForResult里面的requestCode.setStartFlags(startFlags) // 启动的flag.setProfilerInfo(profilerInfo) .setActivityOptions(opts) // 启动Activity的option.setUserId(userId) // 设置userId.execute(); // 详见1.6}
1.6 ActivityStarter.execute
主要是判断activityInfo是否为空来判断之前Intent是否解析，如果没有解析则需要在这里解析出需要启动的Activity信息，然后调用executeRequest进行实际的启动。
除此之外还记录了一些信息以便重启后可以恢复一些数据。判断是否改变了Configuration，如果需要则通知Configuraion改变，进行Configuraion计算以及通知。
int execute() {try {// ...// 如果activityInfo为空，则说明之前没有解析Intent，就在这里解析，将action等解析为需要启动的Activity信息。if (mRequest.activityInfo == null) {mRequest.resolveActivity(mSupervisor);}if (mRequest.intent != null) {String intentAction = mRequest.intent.getAction();String callingPackage = mRequest.callingPackage;if (intentAction != null && callingPackage != null&& (Intent.ACTION_REQUEST_SHUTDOWN.equals(intentAction)|| Intent.ACTION_SHUTDOWN.equals(intentAction)|| Intent.ACTION_REBOOT.equals(intentAction))) {// 记录关机检测点，以便重启后可以恢复一些状态。ShutdownCheckPoints.recordCheckPoint(intentAction, callingPackage, null);}}int res;synchronized (mService.mGlobalLock) {// 检测Configuration是否需要变化final boolean globalConfigWillChange = mRequest.globalConfig != null&& mService.getGlobalConfiguration().diff(mRequest.globalConfig) != 0;final Task rootTask = mRootWindowContainer.getTopDisplayFocusedRootTask();if (rootTask != null) {rootTask.mConfigWillChange = globalConfigWillChange;}// ...try {// 具体启动的逻辑，详见1.7res = executeRequest(mRequest);} finally {mRequest.logMessage.append(" result code=").append(res);Slog.i(TAG, mRequest.logMessage.toString());mRequest.logMessage.setLength(0);}Binder.restoreCallingIdentity(origId);if (globalConfigWillChange) {// ...// 通知Configuration变化mService.updateConfigurationLocked(mRequest.globalConfig, null, false);}// ... 记录启动消耗时间等信息// 等待启动结果if (mRequest.waitResult != null) {mRequest.waitResult.result = res;res = waitResultIfNeeded(mRequest.waitResult, mLastStartActivityRecord,launchingState);}return getExternalResult(res);}} finally {onExecutionComplete();}
}
1.7 executeRequest
这里主要是一些预处理，resultRecord的判定，然后是对Intent中的信息进行解析，解析结果主要是ResolveInfo,里面有一个ActivityInfo。
ResolveInfo里面有用于Intent筛选的信息，如IntentFilter.还有一些图标，labels等信息。
ResolveInfo持有一个ActivityInfo，里面是Activity的一些信息，如launchMode，taskAffinity（acitivity启动的Task），启动activity所需的permission等。
这些信息几乎都是来源于AndroidManifest.xml，所以这里解析其实是通过PackageManagerService，我们这里就不细看了。
此外还有一些特殊场景的处理，如语音会话的启动，启动需要先启动用户确认授权Activity等。
然后就是构建ActivityRecord，这个在WMS章节提过，Activity在system_server侧就是一个ActivityRecord，会在WMS等窗口树上，就是这里创建的。
最后调用了startActivityUnchecked，进一步做启动Activity的操作。
private int executeRequest(Request request) {// ... 一些局部变量声明// ...ActivityRecord sourceRecord = null;ActivityRecord resultRecord = null;// 如果requestCode大于0，且SourceRecord没有finish，则说明这次启动activity结束后是需要给resultRecord返回结果的。if (resultTo != null) {sourceRecord = ActivityRecord.isInAnyTask(resultTo);if (sourceRecord != null) {if (requestCode >= 0 && !sourceRecord.finishing) {resultRecord = sourceRecord;}}}final int launchFlags = intent.getFlags();// FLAG_ACTIVITY_FORWARD_RESULT作用：假如A启动B，B使用FLAG_ACTIVITY_FORWARD_RESULT启动C，则C返回的结果给A。if ((launchFlags & Intent.FLAG_ACTIVITY_FORWARD_RESULT) != 0 && sourceRecord != null) {if (requestCode >= 0) {SafeActivityOptions.abort(options);return ActivityManager.START_FORWARD_AND_REQUEST_CONFLICT;}resultRecord = sourceRecord.resultTo;if (resultRecord != null && !resultRecord.isInRootTaskLocked()) {resultRecord = null;}resultWho = sourceRecord.resultWho;requestCode = sourceRecord.requestCode;sourceRecord.resultTo = null;if (resultRecord != null) {resultRecord.removeResultsLocked(sourceRecord, resultWho, requestCode);}if (sourceRecord.launchedFromUid == callingUid) {callingPackage = sourceRecord.launchedFromPackage;callingFeatureId = sourceRecord.launchedFromFeatureId;}}// 找不到处理Intent的类if (err == ActivityManager.START_SUCCESS && intent.getComponent() == null) {err = ActivityManager.START_INTENT_NOT_RESOLVED;}// 找不到Intent对应的Activity类if (err == ActivityManager.START_SUCCESS && aInfo == null) {err = ActivityManager.START_CLASS_NOT_FOUND;}// ... 语音会话启动，需要鉴权，处理兼容性问题// ... Intent权限检查if (request.allowPendingRemoteAnimationRegistryLookup) {checkedOptions = mService.getActivityStartController().getPendingRemoteAnimationRegistry().overrideOptionsIfNeeded(callingPackage, checkedOptions);}if (mService.mController != null) {try {Intent watchIntent = intent.cloneFilter();abort |= !mService.mController.activityStarting(watchIntent,aInfo.applicationInfo.packageName);} catch (RemoteException e) {mService.mController = null;}}mInterceptor.setStates(userId, realCallingPid, realCallingUid, startFlags, callingPackage,callingFeatureId);// ...// 这个ACTION_REVIEW_PERMISSIONS是给用户确认是否授于XXX权限if (aInfo != null) {if (mService.getPackageManagerInternalLocked().isPermissionsReviewRequired(aInfo.packageName, userId)) {final IIntentSender target = mService.getIntentSenderLocked(ActivityManager.INTENT_SENDER_ACTIVITY, callingPackage, callingFeatureId,callingUid, userId, null, null, 0, new Intent[]{intent},new String[]{resolvedType}, PendingIntent.FLAG_CANCEL_CURRENT| PendingIntent.FLAG_ONE_SHOT, null);Intent newIntent = new Intent(Intent.ACTION_REVIEW_PERMISSIONS);// ...}}// 处理临时应用程序，安装成功或者安装失败提示。if (rInfo != null && rInfo.auxiliaryInfo != null) {intent = createLaunchIntent(rInfo.auxiliaryInfo, request.ephemeralIntent,callingPackage, callingFeatureId, verificationBundle, resolvedType, userId);resolvedType = null;callingUid = realCallingUid;callingPid = realCallingPid;// The ephemeral installer shouldn't get any permission grants// intended for the original destinationintentGrants = null;aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, null /*profilerInfo*/);}if (callerApp == null && realCallingPid > 0) {final WindowProcessController wpc = mService.mProcessMap.getProcess(realCallingPid);if (wpc != null) {callerApp = wpc;}}// 构建ActivityRecordfinal 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;WindowProcessController homeProcess = mService.mHomeProcess;boolean isHomeProcess = homeProcess != null&& aInfo.applicationInfo.uid == homeProcess.mUid;if (balCode != BAL_BLOCK && !isHomeProcess) {mService.resumeAppSwitches();}// 调用startActivityUnchecked，详见1.8mLastStartActivityResult = startActivityUnchecked(r, sourceRecord, voiceSession,request.voiceInteractor, startFlags, checkedOptions,inTask, inTaskFragment, balCode, intentGrants, realCallingUid);if (request.outActivity != null) {request.outActivity[0] = mLastStartActivityRecord;}return mLastStartActivityResult;
}
1.8 startActivityUnchecked
处理启动动画相关的逻辑。调用startActivityInner
private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,int startFlags, ActivityOptions options, Task inTask,TaskFragment inTaskFragment, @BalCode int balCode,NeededUriGrants intentGrants, int realCallingUid) {int result = START_CANCELED;final Task startedActivityRootTask;// 创建Activity启动动画的Transactionfinal TransitionController transitionController = r.mTransitionController;Transition newTransition = transitionController.isShellTransitionsEnabled()? transitionController.createAndStartCollecting(TRANSIT_OPEN) : null;RemoteTransition remoteTransition = r.takeRemoteTransition();try {mService.deferWindowLayout();transitionController.collect(r);try {Trace.traceBegin(Trace.TRACE_TAG_WINDOW_MANAGER, "startActivityInner");// 详见1.9result = startActivityInner(r, sourceRecord, voiceSession, voiceInteractor,startFlags, options, inTask, inTaskFragment, balCode,intentGrants, realCallingUid);} finally {Trace.traceEnd(Trace.TRACE_TAG_WINDOW_MANAGER);// 处理result，同时会触发启动动画。startedActivityRootTask = handleStartResult(r, options, result, newTransition,remoteTransition);}} finally {mService.continueWindowLayout();}postStartActivityProcessing(r, result, startedActivityRootTask);return result;
}
1.9 startActivityInner
这里会处理Activity启动的flag等参数，处理新启动的Activity和WMS相关的逻辑（即调整WMS树），具体有以下的操作：
-
选择启动的Activity的DisplayContent
-
判断是否有可以复用的Task，如果没有则新增Task
-
调整Task位置，比如移动到最上层。
-
如果需要，则将ActivityRecord添加到对应的Task上
最后调用resumeFocusedTasksTopActivities，尝试唤醒Focus的Activity。（后面就是Activity声明周期相关的逻辑了）int startActivityInner(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
int startFlags, ActivityOptions options, Task inTask,
TaskFragment inTaskFragment, @BalCode int balCode,
NeededUriGrants intentGrants, int realCallingUid) {
// 设置初始化状态。主要是计算activity需要启动在哪个屏幕上，如果启动的时候没有指定display，就是这里计算的结果一般是sourceActivity所在的屏幕或者主屏
// 这里计算的diplay不一定是最终的display，如果后续发现有复用Task之类的情况，可能会更新这个display
// 除此之外还有一些option里面的参数处理（如指定了taskId），以及根据Activity launch mode更新launch flag等等。
setInitialState(r, options, inTask, inTaskFragment, startFlags, sourceRecord,
voiceSession, voiceInteractor, balCode, realCallingUid);
// 计算launch flag，会影响到后面是否需要new task或者敷用task等等。
computeLaunchingTaskFlags();
mIntent.setFlags(mLaunchFlags);// ...// 根据Activity的LaunchMode以及mLaunchFlags等信息，计算是否有可以复用的Taskfinal Task reusedTask = getReusableTask();// ...// computeTargetTask根据mLaunchFlags和sourceRecord等信息，计算是否已经有存在的Task用来启动目标的Activity// （比如mLaunchFlags有FLAG_ACTIVITY_NEW_TASK，表示要新增Task，computeTargetTask一般就会返回null）final Task targetTask = reusedTask != null ? reusedTask : computeTargetTask();final boolean newTask = targetTask == null;mTargetTask = targetTask;// 会根据计算出来的targetTask重新计算需要将Activity启动到哪个屏幕computeLaunchParams(r, sourceRecord, targetTask);// 合法性检查int startResult = isAllowedToStart(r, newTask, targetTask);if (startResult != START_SUCCESS) {// ...return startResult;}if (targetTask != null) {// 数量检查，由于每个Activity都有Surface，是系统资源，所以要约束app，每个Task有数量限制if (targetTask.getTreeWeight() > MAX_TASK_WEIGHT_FOR_ADDING_ACTIVITY) {// ...targetTask.removeImmediately("bulky-task");return START_ABORTED;}// ...}final ActivityRecord targetTaskTop = newTask? null : targetTask.getTopNonFinishingActivity();if (targetTaskTop != null) {// 如果Activity的LaunchMode是SingleInstance，检查一下其他的Task有没有这个activity，有就需要销毁if (LAUNCH_SINGLE_INSTANCE == mLaunchMode && mSourceRecord != null&& targetTask == mSourceRecord.getTask()) {final ActivityRecord activity = mRootWindowContainer.findActivity(mIntent,mStartActivity.info, false);if (activity != null && activity.getTask() != targetTask) {activity.destroyIfPossible("Removes redundant singleInstance");}}// 判断是否需要加入ActivityRecord（可能是复用原来存在的），还会把targetTask放到目标屏幕最上面。startResult = recycleTask(targetTask, targetTaskTop, reusedTask, intentGrants);if (startResult != START_SUCCESS) {return startResult;}} else {mAddingToTask = true;}if (mTargetRootTask == null) {mTargetRootTask = getOrCreateRootTask(mStartActivity, mLaunchFlags, targetTask,mOptions);}// 如果需要newTask，根据Affiliate新建一个Taskif (newTask) {final Task taskToAffiliate = (mLaunchTaskBehind && mSourceRecord != null)? mSourceRecord.getTask() : null;setNewTask(taskToAffiliate);} else if (mAddingToTask) {// 否则直接将启动activity添加addOrReparentStartingActivity(targetTask, "adding to task");}// ...final Task startedTask = mStartActivity.getTask();// ...mRootWindowContainer.startPowerModeLaunchIfNeeded(false /* forceSend */, mStartActivity);final boolean isTaskSwitch = startedTask != prevTopTask;mTargetRootTask.startActivityLocked(mStartActivity, topRootTask, newTask, isTaskSwitch,mOptions, sourceRecord);if (mDoResume) {final ActivityRecord topTaskActivity = startedTask.topRunningActivityLocked();if (!mTargetRootTask.isTopActivityFocusable()|| (topTaskActivity != null && topTaskActivity.isTaskOverlay()&& mStartActivity != topTaskActivity)) {// 如果activity不是focusable，不能设置为focus，但是仍然要设置可见性。mTargetRootTask.ensureActivitiesVisible(null /* starting */,0 /* configChanges */, !PRESERVE_WINDOWS);mTargetRootTask.mDisplayContent.executeAppTransition();} else {// 需要将Task移动到最上面if (!mAvoidMoveToFront && mTargetRootTask.isTopActivityFocusable()&& !mRootWindowContainer.isTopDisplayFocusedRootTask(mTargetRootTask)) {mTargetRootTask.moveToFront("startActivityInner");}// 这里resume，详见1.10mRootWindowContainer.resumeFocusedTasksTopActivities(mTargetRootTask, mStartActivity, mOptions, mTransientLaunch);}}mRootWindowContainer.updateUserRootTask(mStartActivity.mUserId, mTargetRootTask);// Update the recent tasks list immediately when the activity startsmSupervisor.mRecentTasks.add(startedTask);mSupervisor.handleNonResizableTaskIfNeeded(startedTask,mPreferredWindowingMode, mPreferredTaskDisplayArea, mTargetRootTask);// ...画中画相关逻辑return START_SUCCESS;}
1.10 RootWindowContainer.resumeFocusedTasksTopActivities
这里需要resume Activity。最终都会调用需要resume的Activity所在的rootTask的resumeTopActivityUncheckedLocked。
boolean resumeFocusedTasksTopActivities(Task targetRootTask, ActivityRecord target, ActivityOptions targetOptions,boolean deferPause) {// 如果有其他activity还在resume，直接returnif (!mTaskSupervisor.readyToResume()) {return false;}boolean result = false;// 如果focus的task就是targetRootTask，就调用resumeTopActivityUncheckedLockedif (targetRootTask != null && (targetRootTask.isTopRootTaskInDisplayArea()|| getTopDisplayFocusedRootTask() == targetRootTask)) {// 详见1.11result = targetRootTask.resumeTopActivityUncheckedLocked(target, targetOptions,deferPause);}// 遍历每个DisplayContentfor (int displayNdx = getChildCount() - 1; displayNdx >= 0; --displayNdx) {final DisplayContent display = getChildAt(displayNdx);final boolean curResult = result;boolean[] resumedOnDisplay = new boolean[1];// 遍历所有Taskdisplay.forAllRootTasks(rootTask -> {final ActivityRecord topRunningActivity = rootTask.topRunningActivity();if (!rootTask.isFocusableAndVisible() || topRunningActivity == null) {return;}if (rootTask == targetRootTask) {// 如果是targetRootTaskresumedOnDisplay[0] |= curResult;return;}if (topRunningActivity.isState(RESUMED)&& topRunningActivity == rootTask.getDisplayArea().topRunningActivity()) {rootTask.executeAppTransition(targetOptions);} else {// 这里会对每个Activity进行判断，如果是target则代表需要resume，会调用Activity对应Task的resumeTopActivityUncheckedLocked，详见1.11// 如果activity需要pause，调用scheduleTransaction通知端侧resumedOnDisplay[0] |= topRunningActivity.makeActiveIfNeeded(target);}});result |= resumedOnDisplay[0];// 前面都没有resume成功if (!resumedOnDisplay[0]) {final Task focusedRoot = display.getFocusedRootTask();// 调用focus task的resumeTopActivityUncheckedLockedif (focusedRoot != null) {// 详见1.11result |= focusedRoot.resumeTopActivityUncheckedLocked(target, targetOptions);} else if (targetRootTask == null) {// 如果没有focus task，就resume home activityresult |= resumeHomeActivity(null /* prev */, "no-focusable-task",display.getDefaultTaskDisplayArea());}}}return result;
}
1.11 Task.resumeTopActivityUncheckedLocked
如果是leafTask，直接调用resumeTopActivityInnerLocked，否则递归调用resumeTopActivityUncheckedLocked，遍历子节点，最终会调用可以focus并且有RunningActivity的leafTask的resumeTopActivityInnerLocked。
boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options,boolean deferPause) {// 防止重入if (mInResumeTopActivity) {return false;}boolean someActivityResumed = false;try {mInResumeTopActivity = true;// 如果是leafTask，直接调用Task的resumeTopActivityInnerLockedif (isLeafTask()) {if (isFocusableAndVisible()) {// 详见1.12someActivityResumed = resumeTopActivityInnerLocked(prev, options, deferPause);}} else {// 否则递归调用resumeTopActivityUncheckedLockedint idx = mChildren.size() - 1;while (idx >= 0) {final Task child = (Task) getChildAt(idx--);if (!child.isTopActivityFocusable()) {continue;}if (child.getVisibility(null /* starting */)!= TASK_FRAGMENT_VISIBILITY_VISIBLE) {if (child.topRunningActivity() == null) {continue;}break;}someActivityResumed |= child.resumeTopActivityUncheckedLocked(prev, options,deferPause);if (idx >= mChildren.size()) {idx = mChildren.size() - 1;}}}final ActivityRecord next = topRunningActivity(true /* focusableOnly */);if (next == null || !next.canTurnScreenOn()) {checkReadyForSleep();}} finally {mInResumeTopActivity = false;}return someActivityResumed;
}
1.12 Task.resumeTopActivityInnerLocked
遍历当前Task的所有的TaskFragment，调用Top且可resume的TaskFragment的resumeTopActivity
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options,boolean deferPause) {if (!mAtmService.isBooting() && !mAtmService.isBooted()) {return false;}final ActivityRecord topActivity = topRunningActivity(true /* focusableOnly */);if (topActivity == null) {return resumeNextFocusableActivityWhenRootTaskIsEmpty(prev, options);}final boolean[] resumed = new boolean[1];final TaskFragment topFragment = topActivity.getTaskFragment();// 调用TaskFragment的resumeTopActivity，详见1.13resumed[0] = topFragment.resumeTopActivity(prev, options, deferPause);forAllLeafTaskFragments(f -> {if (topFragment == f) {return;}if (!f.canBeResumed(null /* starting */)) {return;}resumed[0] |= f.resumeTopActivity(prev, options, deferPause);}, true);return resumed[0];
}
1.13 TaskFragment.resumeTopActivity
首先会检查是否有activity正在pause，如果有就直接返回，等待pause完成再继续操作。
然后需要检查是否需要pause activity，我们知道如果activity A跳转activity B，会先执行A的pause，再resume B，所以这里如果发现之前的activity没有pause，就先执行pause操作。（如果发生了pause操作，就会顺带检查一下ativity B所在的进程是否启动，如果没有启动就会在这里触发启动，并行进行节约时间，关于启动进程的逻辑我们下一个章节再介绍）
如果发现顶部的activity已经pause了（往往是第二次进这个方法，app pause完成后通知systemserver，systemserver重新执行resumeTopActivity），这个时候就可以进行resume操作。
如果要启动的Activity是复用之前已经创建过的，next.attachedToProcess()为true，这时候主要做的事是修改ActivityRecord的状态到RESUMED，更新Activity可见效以及config，然后通知app侧执行对应的声明周期。
而如果没有复用的Activity，这里是刚刚新建的Activity，则会调用startSpecificActivity来启动Activity。
关于通知App更新生命周期LifecycleManager的逻辑我们会单独有一篇文章来介绍。
final boolean resumeTopActivity(ActivityRecord prev, ActivityOptions options,boolean deferPause) {ActivityRecord next = topRunningActivity(true /* focusableOnly */);if (next == null || !next.canResumeByCompat()) {return false;}next.delayedResume = false;// ...如果没有正在pause的activty，继续流程final TaskDisplayArea taskDisplayArea = getDisplayArea();// 如果top activity已经resume，不做什么操作if (mResumedActivity == next && next.isState(RESUMED)&& taskDisplayArea.allResumedActivitiesComplete()) {// 确保topactivity visibletaskDisplayArea.ensureActivitiesVisible(null /* starting */, 0 /* configChanges */,false /* preserveWindows */, true /* notifyClients */);// 确保切换已经执行executeAppTransition(options);// ...return false;}// 如果topactivity是paused，并且在sleep，那什么都不用做if (mLastPausedActivity == next && shouldSleepOrShutDownActivities()) {executeAppTransition(options);return false;}// ...处理多用户情况// 从mStoppingActivities remove现在要换新的ActivityRecordmTaskSupervisor.mStoppingActivities.remove(next);mTaskSupervisor.setLaunchSource(next.info.applicationInfo.uid);ActivityRecord lastResumed = null;final Task lastFocusedRootTask = taskDisplayArea.getLastFocusedRootTask();if (lastFocusedRootTask != null && lastFocusedRootTask != getRootTaskFragment().asTask()) {lastResumed = lastFocusedRootTask.getTopResumedActivity();}boolean pausing = !deferPause && taskDisplayArea.pauseBackTasks(next);if (mResumedActivity != null) {// 如果之前的ResumeActivity还没有resume，现在触发pause，详见1.13.1pausing |= startPausing(mTaskSupervisor.mUserLeaving, false /* uiSleeping */,next, "resumeTopActivity");}// 如果已经触发pause，进这个分支直接return了，要等pausing完了activity，app回调回来才会进行resumeif (pausing) {if (next.attachedToProcess()) {// 更新进程信息，例如adj，启动组件可能需要更新adjnext.app.updateProcessInfo(false /* updateServiceConnectionActivities */,true /* activityChange */, false /* updateOomAdj */,false /* addPendingTopUid */);} else if (!next.isProcessRunning()) {// 如果没有绑定进程。那么就需要新启动进程。// 这个流程我们下一章再介绍。final boolean isTop = this == taskDisplayArea.getFocusedRootTask();mAtmService.startProcessAsync(next, false /* knownToBeDead */, isTop,isTop ? HostingRecord.HOSTING_TYPE_NEXT_TOP_ACTIVITY: HostingRecord.HOSTING_TYPE_NEXT_ACTIVITY);}if (lastResumed != null) {lastResumed.setWillCloseOrEnterPip(true);}return true;} else if (mResumedActivity == next && next.isState(RESUMED)&& taskDisplayArea.allResumedActivitiesComplete()) {// 确保AppTrasnsition。executeAppTransition(options);return true;}// ...// ... 处理动画mTaskSupervisor.mNoAnimActivities.clear();// 如果需要启动ActivityRecord的app已经绑定进程，这里需要做resume操作了// 如果activity没有复用，是新启动的这里一般是false。if (next.attachedToProcess()) {// mLastPausedActivityfinal boolean lastActivityTranslucent = inMultiWindowMode()|| mLastPausedActivity != null && !mLastPausedActivity.occludesParent();// 设置Activity可见性if (!next.isVisibleRequested() || next.mAppStopped || lastActivityTranslucent) {next.app.addToPendingTop();next.setVisibility(true);}// 收集app启动速度next.startLaunchTickingLocked();ActivityRecord lastResumedActivity =lastFocusedRootTask == null ? null: lastFocusedRootTask.getTopResumedActivity();final ActivityRecord.State lastState = next.getState();mAtmService.updateCpuStats();// 设置activity状态resumenext.setState(RESUMED, "resumeTopActivity");boolean notUpdated = true;if (shouldBeVisible(next)) {// 更新activity visible以及配置notUpdated = !mRootWindowContainer.ensureVisibilityAndConfig(next, getDisplayId(),true /* markFrozenIfConfigChanged */, false /* deferResume */);}if (notUpdated) {ActivityRecord nextNext = topRunningActivity();if (nextNext != next) {mTaskSupervisor.scheduleResumeTopActivities();}if (!next.isVisibleRequested() || next.mAppStopped) {next.setVisibility(true);}next.completeResumeLocked();return true;}try {// 回调app侧，通知app activity需要到resume状态。final ClientTransaction transaction =ClientTransaction.obtain(next.app.getThread(), next.token);// ...transaction.setLifecycleStateRequest(ResumeActivityItem.obtain(next.app.getReportedProcState(),dc.isNextTransitionForward(), next.shouldSendCompatFakeFocus()));mAtmService.getLifecycleManager().scheduleTransaction(transaction);} catch (Exception e) {// Whoops, need to restart this activity!ProtoLog.v(WM_DEBUG_STATES, "Resume failed; resetting state to %s: "+ "%s", lastState, next);next.setState(lastState, "resumeTopActivityInnerLocked");// lastResumedActivity being non-null implies there is a lastStack present.if (lastResumedActivity != null) {lastResumedActivity.setState(RESUMED, "resumeTopActivityInnerLocked");}Slog.i(TAG, "Restarting because process died: " + next);if (!next.hasBeenLaunched) {next.hasBeenLaunched = true;} else if (SHOW_APP_STARTING_PREVIEW && lastFocusedRootTask != null&& lastFocusedRootTask.isTopRootTaskInDisplayArea()) {next.showStartingWindow(false /* taskSwitch */);}mTaskSupervisor.startSpecificActivity(next, true, false);return true;}try {next.completeResumeLocked();} catch (Exception e) {// If any exception gets thrown, toss away this// activity and try the next one.Slog.w(TAG, "Exception thrown during resume of " + next, e);next.finishIfPossible("resume-exception", true /* oomAdj */);return true;}} else {if (!next.hasBeenLaunched) {next.hasBeenLaunched = true;} else {if (SHOW_APP_STARTING_PREVIEW) {next.showStartingWindow(false /* taskSwich */);}}// 正常新启动Activity而不是复用会走这里，详见1.14mTaskSupervisor.startSpecificActivity(next, true, true);}return true;
}
1.13.1 TaskFragment.startPausing
更新需要pause的ActivityRecord状态到PAUSING，通知app侧进行对应的生命周期操作。
如果pause到Activity对应的进程已经不在了，就直接调用resumeFocusedTasksTopActivities继续唤醒topActivity的流程。
否则等待app pause流程完成后，app会回调system_server,最终也会走到completePause，里面会将ActivityRecord状态改为PAUSED，并且重新调用resumeFocusedTasksTopActivities。（关于通知app的生命周期以及app回调流程，我们会单独有一篇文章来介绍）
boolean startPausing(boolean userLeaving, boolean uiSleeping, ActivityRecord resuming,String reason) {// ...// ... 合理性检查，如正在暂停的activity不能是我们正在唤醒的activity resumingProtoLog.v(WM_DEBUG_STATES, "Moving to PAUSING: %s", prev);mPausingActivity = prev;mLastPausedActivity = prev;if (!prev.finishing && prev.isNoHistory()&& !mTaskSupervisor.mNoHistoryActivities.contains(prev)) {mTaskSupervisor.mNoHistoryActivities.add(prev);}// 修改状态为PAUSINGprev.setState(PAUSING, "startPausingLocked");prev.getTask().touchActiveTime();mAtmService.updateCpuStats();boolean pauseImmediately = false;boolean shouldAutoPip = false;if (resuming != null) {// ...画中画相关逻辑 }if (prev.attachedToProcess()) {if (shouldAutoPip) {prev.mPauseSchedulePendingForPip = true;boolean didAutoPip = mAtmService.enterPictureInPictureMode(prev, prev.pictureInPictureArgs, false /* fromClient */);} else {// 通过getLifecycleManager().scheduleTransaction通知app进行pause到生命周期schedulePauseActivity(prev, userLeaving, pauseImmediately,false /* autoEnteringPip */, reason);}} else {mPausingActivity = null;mLastPausedActivity = null;mTaskSupervisor.mNoHistoryActivities.remove(prev);}// ...// If already entered PIP mode, no need to keep pausing.if (mPausingActivity != null) {// ... if (pauseImmediately) {// 如果需要立刻完成pause，不等待app侧完成pause再进行回调，这里直接执行completePause继续唤醒流程// completePause会将ActivityRecord状态改为PAUSED，并且重新调用resumeFocusedTasksTopActivities，completePause(false, resuming);return false;} else {prev.schedulePauseTimeout();if (!uiSleeping) {mTransitionController.setReady(this, false /* ready */);}return true;}} else {// ... 直接调用resumeFocusedTasksTopActivities继续唤醒流程if (resuming == null) {mRootWindowContainer.resumeFocusedTasksTopActivities();}return false;}
}
1.14 ActivityTaskSupervisor.startSpecificActivity
如果app进程已经启动，则会调用realStartActivityLocked进行Activity的启动，否则会调用startProcessAsync启动对应进程，启动进程的流程我们下一篇文章再介绍。
void startSpecificActivity(ActivityRecord r, boolean andResume, boolean checkConfig) {final WindowProcessController wpc =mService.getProcessController(r.processName, r.info.applicationInfo.uid);boolean knownToBeDead = false;// 如果app进程已经启动，则会调用realStartActivityLocked来启动activity，详见1.15if (wpc != null && wpc.hasThread()) {// ...realStartActivityLocked(r, wpc, andResume, checkConfig);return;// ...}// ...final boolean isTop = andResume && r.isTopRunningActivity();// 否则会触发启动进程的流程。mService.startProcessAsync(r, knownToBeDead, isTop,isTop ? HostingRecord.HOSTING_TYPE_TOP_ACTIVITY: HostingRecord.HOSTING_TYPE_ACTIVITY);
}
1.15 ActivityTaskSupervisor.realStartActivityLocked
主要通过getLifecycleManager通知app启动activity。最后还会调用rootTask.minimalResumeActivityLocked来设置Activity的可见性。
boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,boolean andResume, boolean checkConfig) throws RemoteException {// ...检测所有Activity pause完成final Task task = r.getTask();final Task rootTask = task.getRootTask();try {r.startFreezingScreenLocked(proc, 0);// schedule launch ticks to collect information about slow apps.r.startLaunchTickingLocked();r.lastLaunchTime = SystemClock.uptimeMillis();r.setProcess(proc);if (andResume && !r.canResumeByCompat()) {andResume = false;}r.notifyUnknownVisibilityLaunchedForKeyguardTransition();// ...if (checkConfig) {// 更新Activity visible以及configurationmRootWindowContainer.ensureVisibilityAndConfig(r, r.getDisplayId(),false /* markFrozenIfConfigChanged */, true /* deferResume */);}// ...try {// ...// 通知app侧创建启动activity。 final ClientTransaction clientTransaction = ClientTransaction.obtain(proc.getThread(), r.token);final boolean isTransitionForward = r.isTransitionForward();final IBinder fragmentToken = r.getTaskFragment().getFragmentToken();final int deviceId = getDeviceIdForDisplayId(r.getDisplayId());clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),System.identityHashCode(r), r.info, mergedConfiguration.getGlobalConfiguration(),mergedConfiguration.getOverrideConfiguration(), deviceId,r.getFilteredReferrer(r.launchedFromPackage), task.voiceInteractor,proc.getReportedProcState(), r.getSavedState(), r.getPersistentSavedState(),results, newIntents, r.takeOptions(), isTransitionForward,proc.createProfilerInfoIfNeeded(), r.assistToken, activityClientController,r.shareableActivityToken, r.getLaunchedFromBubble(), fragmentToken));final ActivityLifecycleItem lifecycleItem;if (andResume) {lifecycleItem = ResumeActivityItem.obtain(isTransitionForward,r.shouldSendCompatFakeFocus());} else {lifecycleItem = PauseActivityItem.obtain();}clientTransaction.setLifecycleStateRequest(lifecycleItem);mService.getLifecycleManager().scheduleTransaction(clientTransaction);// ... }// ...if (andResume && readyToResume()) {// 详见1.16rootTask.minimalResumeActivityLocked(r);}
}
1.16 Task.minimalResumeActivityLocked
void minimalResumeActivityLocked(ActivityRecord r) {ProtoLog.v(WM_DEBUG_STATES, "Moving to RESUMED: %s (starting new instance) "+ "callers=%s", r, Debug.getCallers(5));r.setState(RESUMED, "minimalResumeActivityLocked");// 详见1.17r.completeResumeLocked();
}
1.17 ActivityRecord.completeResumeLocked
这个方法其实只要resume了Activity的路径都会走到。
我们的主要关注更新可见性相关逻辑，其余的逻辑就忽略了。我们知道Activity可见状态是resume的时候，所以在这里会更新可见性。
通过setVisibility设置ActivityRecord可见，然后调用reportResumedActivityLocked。
void completeResumeLocked() {final boolean wasVisible = mVisibleRequested;setVisibility(true);// ...// 详见1.18mTaskSupervisor.reportResumedActivityLocked(this);// ...
}
1.18 ActivityTaskSupervisor.reportResumedActivityLocked
boolean reportResumedActivityLocked(ActivityRecord r) {// resumed的Activity不能在StoppingActivities集合里mStoppingActivities.remove(r);final Task rootTask = r.getRootTask();if (rootTask.getDisplayArea().allResumedActivitiesComplete()) {// 这个方法用来更新Activity的可见性，详见1.19mRootWindowContainer.ensureActivitiesVisible(null, 0, !PRESERVE_WINDOWS);mRootWindowContainer.executeAppTransitionForAllDisplay();return true;}return false;
}
1.19 Task.ensureActivitiesVisible
RootWindowContainer.ensureActivitiesVisible会递归遍历DisplayContent,调用DisplayContent.ensureActivitiesVisible
同样DisplayContent会调用RootTask的ensureActivitiesVisible
我们直接看Task.ensureActivitiesVisible
遍历LeafTask，调用updateActivityVisibilities方法。
void ensureActivitiesVisible(@Nullable ActivityRecord starting, int configChanges,boolean preserveWindows, boolean notifyClients) {mTaskSupervisor.beginActivityVisibilityUpdate();try {forAllLeafTasks(task -> {// 详见1.20task.updateActivityVisibilities(starting, configChanges, preserveWindows,notifyClients);}, true /* traverseTopToBottom */);if (mTranslucentActivityWaiting != null &&mUndrawnActivitiesBelowTopTranslucent.isEmpty()) {notifyActivityDrawnLocked(null);}} finally {mTaskSupervisor.endActivityVisibilityUpdate();}
}
1.20 TaskFragment.updateActivityVisibilities
只是调用了mEnsureActivitiesVisibleHelper.process
final void updateActivityVisibilities(@Nullable ActivityRecord starting, int configChanges,boolean preserveWindows, boolean notifyClients) {mTaskSupervisor.beginActivityVisibilityUpdate();try {// 详见1.21mEnsureActivitiesVisibleHelper.process(starting, configChanges, preserveWindows, notifyClients);} finally {mTaskSupervisor.endActivityVisibilityUpdate();}
}
1.21 EnsureActivitiesVisibleHelper.process
递归遍历所有TaskFragment.updateActivityVisibilities，如果TaskFragment有activity，则更新activity可见性状态。
void process(@Nullable ActivityRecord starting, int configChanges, boolean preserveWindows,boolean notifyClients) {reset(starting, configChanges, preserveWindows, notifyClients);if (mTopRunningActivity != null && mTaskFragment.asTask() != null) {// TODO(14709632): Check if this needed to be implemented in TaskFragment.mTaskFragment.asTask().checkTranslucentActivityWaiting(mTopRunningActivity);}// 判断一些不应resumeActivity的情况。 // 我们不应该恢复在后面启动的Activity，因为这些活动实际上在其他全屏的Activity后面，但仍然需要可见（例如执行Recents动画）。final boolean resumeTopActivity = mTopRunningActivity != null&& !mTopRunningActivity.mLaunchTaskBehind&& mTaskFragment.canBeResumed(starting)&& (starting == null || !starting.isDescendantOf(mTaskFragment));ArrayList<TaskFragment> adjacentTaskFragments = null;for (int i = mTaskFragment.mChildren.size() - 1; i >= 0; --i) {final WindowContainer child = mTaskFragment.mChildren.get(i);final TaskFragment childTaskFragment = child.asTaskFragment();if (childTaskFragment != null&& childTaskFragment.getTopNonFinishingActivity() != null) {// 递归遍历调用子TaskFragment.updateActivityVisibilitieschildTaskFragment.updateActivityVisibilities(starting, configChanges,preserveWindows, notifyClients);// 判断当前Task边界是否和父Task边界相同，如果相同，且不透明，则他完全遮盖了下面的兄弟TaskmBehindFullyOccludedContainer |=(childTaskFragment.getBounds().equals(mTaskFragment.getBounds())&& !childTaskFragment.isTranslucent(starting));if (mAboveTop && mTopRunningActivity.getTaskFragment() == childTaskFragment) {mAboveTop = false;}// 如果之前的Task已经全部遮盖了，就直接continueif (mBehindFullyOccludedContainer) {continue;}if (adjacentTaskFragments != null && adjacentTaskFragments.contains(childTaskFragment)) {if (!childTaskFragment.isTranslucent(starting)&& !childTaskFragment.getAdjacentTaskFragment().isTranslucent(starting)) {// Everything behind two adjacent TaskFragments are occluded.mBehindFullyOccludedContainer = true;}continue;}final TaskFragment adjacentTaskFrag = childTaskFragment.getAdjacentTaskFragment();if (adjacentTaskFrag != null) {if (adjacentTaskFragments == null) {adjacentTaskFragments = new ArrayList<>();}adjacentTaskFragments.add(adjacentTaskFrag);}} else if (child.asActivityRecord() != null) {// 设置activity visible state，详见1.22setActivityVisibilityState(child.asActivityRecord(), starting, resumeTopActivity);}}
}
1.22 EnsureActivitiesVisibleHelper.setActivityVisibilityState
判断activity是否可见，如果是可见的，则需要设置他的可见状态。
针对不同情况有不同的处理，如果可见的activity还没有attachedToProcess，则调用makeVisibleAndRestartIfNeeded，会设置Activity可见，且如果正在starting的Activity不是当前正在设置可见的Activity，还会重新调用startSpecificActivity来启动Activity。
而其他情况则调用makeActiveIfNeeded或者makeVisibleIfNeeded设置Activity可见，makeVisibleIfNeeded最终也会调用到makeActiveIfNeeded，而makeActiveIfNeeded我们前面已经介绍过了。1.10里也调用这个方法。会重新走上面的流程，而在1.13里如果Activity已经创建过，则会走另一个分支，直接设置Activity可见，通知app侧activity resume的生命周期。
private void setActivityVisibilityState(ActivityRecord r, ActivityRecord starting,final boolean resumeTopActivity) {final boolean isTop = r == mTopRunningActivity;if (mAboveTop && !isTop) {// 如果不是最上层的activity，设置不可见r.makeInvisible();return;}mAboveTop = false;r.updateVisibilityIgnoringKeyguard(mBehindFullyOccludedContainer);// 计算Activity是否可见final boolean reallyVisible = r.shouldBeVisibleUnchecked();// Check whether activity should be visible without Keyguard influenceif (r.visibleIgnoringKeyguard) {if (r.occludesParent()) {mBehindFullyOccludedContainer = true;} else {mBehindFullyOccludedContainer = false;}} else if (r.isState(INITIALIZING)) {r.cancelInitializing();}if (reallyVisible) {if (r.finishing) {return;}if (r != mStarting && mNotifyClients) {r.ensureActivityConfiguration(0 /* globalChanges */, mPreserveWindows,true /* ignoreVisibility */);}// 如果ActivityRecord还没有attch到进程上if (!r.attachedToProcess()) {// 设置activity visible// 且如果当前需要设置可见的activity不是正在starting的activity，就会调用startSpecificActivity去启动当前设置可见的activitymakeVisibleAndRestartIfNeeded(mStarting, mConfigChanges,resumeTopActivity && isTop, r);} else if (r.isVisibleRequested()) {if (r.mClientVisibilityDeferred && mNotifyClients) {// 这个方法之前提过，在1.10的方法中也调用了该方法。// 如果需要走会resumeTopActivity的流程，相当于重新走了上面的流程，只是如果activity已经构建，在1.13中，会走另一条分支，直接通知app侧resume activity，同时会通知client。而不是走startSpecificActivity流程了。r.makeActiveIfNeeded(r.mClientVisibilityDeferred ? null : starting);r.mClientVisibilityDeferred = false;}r.handleAlreadyVisible();if (mNotifyClients) {r.makeActiveIfNeeded(mStarting);}} else {// mNotifyClients为true，则也会调用到makeActiveIfNeeded，否则设置mClientVisibilityDeferred为true，推迟操作。r.makeVisibleIfNeeded(mStarting, mNotifyClients);}// Aggregate current change flags.mConfigChanges |= r.configChangeFlags;} else {// 否者设置不可见r.makeInvisible();}if (!mBehindFullyOccludedContainer && mTaskFragment.isActivityTypeHome()&& r.isRootOfTask()) {mBehindFullyOccludedContainer = true;}
}
小结
Activity的启动流程非常长，核心思想主要是两个，一个是处理WMS的窗口层次结构，在WMS树上加上新增的ActivityRecord（如需要可能还有Task），或者是找到复用的ActivityRecord；另一个则是需要处理AMS侧activity生命周期以及可见性相关的逻辑。
一个未启动的应用首次创建Activity是会走启动进程流程的，与当前的逻辑略有不同，我们下一篇文章来介绍。
还有app侧对生命周期的控制，我们在下下篇文章中介绍。
