本文深入剖析了Android系统中Activity的启动流程，从Activity的startActivity开始，经过Instrumentation、ActivityManagerService、ActivityStackSupervisor等多个关键组件，详细阐述了Intent解析、ActivityRecord创建、任务栈管理、生命周期回调等核心步骤，揭示了系统如何保证应用的正确运行和UI的平滑切换。通过对源码的追踪，展示了Android系统内部复杂的交互机制。
这篇文章通过追踪AMS源码（api28），走一遍调用startActivity的代码执行流程，先来一张流程图：
从源码开始追踪（省略无关的代码）：
代码简要目录：
2.Activity#startActivityForResult
3、Instrumentation#execStartActivity
4、ActivityManagerService#startActivity
5、ActivityManagerService#startActivityAsUser（多个重载）
7、ActivityStarter#startActivityMayWait
8、ActivityStarter#startActivity（1）
9、ActivityStarter#startActivity（2）
10、ActivityStarter#startActivity（3）
11、ActivityStarter#startActivityUnchecked
11.1、ActivityStarter#setInitialState
11.1.1、ActivityStarter#adjustLaunchFlagsToDocumentMode
11.2、ActivityStack#startActivityLocked
12、ActivityStackSupervisor#resumeFocusedStackTopActivityLocked
13、ActivityStack#resumeTopActivityUncheckedLocked
14、ActivityStack#resumeTopActivityInnerLocked
14.1、ActivityStack#startPausingLocked
15、ActivityStackSupervisor#startSpecificActivityLocked
16、ActivityStackSupervisor#realStartActivityLocked
17、ClientTransaction#scheduleTransaction
18、ActivityThread#scheduleTransaction、H#handleMessage
19、TransactionExecutor#execute
19.1、TransactionExecutor#executeCallbacks
19.1.1、ActivityThread#handleLaunchActivity（1）
19.1.2、ActivityThread#handleLaunchActivity（2）
19.1.3、Instrumentation#callActivityOnCreate
19.2、TransactionExecutor#executeLifecycleState
19.2.1、TransactionExecutor#cycleToPath
19.2.1.1、TransactionExecutorHelper#getLifecyclePath
19.2.1.2、TransactionExecutor#performLifecycleSequence
19.2.2、ActivityThread#handleResumeActivity
1.Activity#startActivity
2.Activity#startActivityForResult
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
@Nullable Bundle options) {
...
Instrumentation.ActivityResult ar =
mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, this,
intent, requestCode, options);
// 正常的启动ar一定等于null，仅在自动化测试时，下面这段代码才有作用
if (ar != null) {
mMainThread.sendActivityResult(
mToken, mEmbeddedID, requestCode, ar.getResultCode(),
ar.getResultData());
}
if (requestCode >= 0) {
// 如果此开始要求结果，我们可以避免在收到结果之前使活动可见。
// 在onCreate（BundlesavedInstanceState）或onResume（）
// 期间设置此代码将在此期间保持活动隐藏，以避免闪烁。 只能在请求结
// 果时执行此操作，因为这样可以确保无论活动发生什么，我们都将在活动结束时取回信息。
mStartedActivity = true;
}
cancelInputsAndStartExitTransition(options);
...
}3、Instrumentation#execStartActivity
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);
}
...
try {
intent.migrateExtraStreamToClipData();
intent.prepareToLeaveProcess(who);
// 这里通过IPC调用AMS的startActivity的方法
int result = ActivityManager.getService()
.startActivity(whoThread, who.getBasePackageName(), intent,
intent.resolveTypeIfNeeded(who.getContentResolver()),
token, target != null ? target.mEmbeddedID : null,
requestCode, 0, null, options);
// activity启动错误，返回到这里抛出，里面就是我们常见的启动错误的日志了
checkStartActivityResult(result, intent);
} catch (RemoteException e) {
throw new RuntimeException("Failure from system", e);
}
return null;
}4、ActivityManagerService#startActivity
5、ActivityManagerService#startActivityAsUser（多个重载）
获得进程的相关信息，作为参数传入
public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId,
boolean validateIncomingUser) {
...
userId = mActivityStartController.checkTargetUser(userId, validateIncomingUser,
Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");
// 通过ActivityStartControler获得ActivityStarter并配置参数，开始执行activity启动工作
return mActivityStartController.obtainStarter(intent, "startActivityAsUser")
.setCaller(caller)
.setCallingPackage(callingPackage)
.setResolvedType(resolvedType)
.setResultTo(resultTo)
.setResultWho(resultWho)
.setRequestCode(requestCode)
.setStartFlags(startFlags)
.setProfilerInfo(profilerInfo)
.setActivityOptions(bOptions)
.setMayWait(userId)
.execute();
}6.ActivityStarter#execute
int execute() {
try {
// 因为配置对应的userId，说明是应用调起，需要保持同步性
if (mRequest.mayWait) {
// 在该方法内有同步代码块，在同步代码块内调用就是startActivity方法（就是下面那个方
// 法）
return startActivityMayWait(mRequest.caller, mRequest.callingUid,
mRequest.callingPackage, mRequest.intent, mRequest.resolvedType,
mRequest.voiceSession, mRequest.voiceInteractor, mRequest.resultTo,
mRequest.resultWho, mRequest.requestCode, mRequest.startFlags,
mRequest.profilerInfo, mRequest.waitResult, mRequest.globalConfig,
mRequest.activityOptions, mRequest.ignoreTargetSecurity, mRequest.userId,
mRequest.inTask, mRequest.reason,
mRequest.allowPendingRemoteAnimationRegistryLookup);
} else {
return startActivity(mRequest.caller, mRequest.intent, mRequest.ephemeralIntent,
mRequest.resolvedType, mRequest.activityInfo, mRequest.resolveInfo,
mRequest.voiceSession, mRequest.voiceInteractor, mRequest.resultTo,
mRequest.resultWho, mRequest.requestCode, mRequest.callingPid,
mRequest.callingUid, mRequest.callingPackage, mRequest.realCallingPid,
mRequest.realCallingUid, mRequest.startFlags, mRequest.activityOptions,
mRequest.ignoreTargetSecurity, mRequest.componentSpecified,
mRequest.outActivity, mRequest.inTask, mRequest.reason,
mRequest.allowPendingRemoteAnimationRegistryLookup);
}
} finally {
onExecutionComplete();
}
}7、ActivityStarter#startActivityMayWait
private int startActivityMayWait(IApplicationThread caller, int callingUid,
String callingPackage, Intent intent, String resolvedType,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
IBinder resultTo, String resultWho, int requestCode, int startFlags,
ProfilerInfo profilerInfo, WaitResult outResult,
Configuration globalConfig, SafeActivityOptions options, boolean ignoreTargetSecurity,
int userId, TaskRecord inTask, String reason,
boolean allowPendingRemoteAnimationRegistryLookup) {
...
// 拦截直接针对临时安装程序的意图
boolean componentSpecified = intent.getComponent() != null;
final Intent ephemeralIntent = new Intent(intent);
intent = new Intent(intent);
if (componentSpecified
&& !(Intent.ACTION_VIEW.equals(intent.getAction()) && intent.getData() == null)
&& !Intent.ACTION_INSTALL_INSTANT_APP_PACKAGE.equals(intent.getAction())
&& !Intent.ACTION_RESOLVE_INSTANT_APP_PACKAGE.equals(intent.getAction())
&& mService.getPackageManagerInternalLocked()
.isInstantAppInstallerComponent(intent.getComponent())) {
intent.setComponent(null /*component*/);
componentSpecified = false;
}
// 在AndroidManifest中的注册信息
ResolveInfo rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId,
0 /* matchFlags */,
computeResolveFilterUid(
callingUid, realCallingUid, mRequest.filterCallingUid));
// 获得目标activity的信息
ActivityInfo aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags,
profilerInfo);
// 同步代码块
synchronized (mService) {
...
final ActivityRecord[] outRecord = new ActivityRecord[1];
int res = startActivity(caller, intent, ephemeralIntent, resolvedType, aInfo, rInfo,
voiceSession, voiceInteractor, resultTo, resultWho, requestCode,
callingPid,callingUid, callingPackage, realCallingPid, realCallingUid,
startFlags, options,ignoreTargetSecurity, componentSpecified, outRecord, inTask,
reason,allowPendingRemoteAnimationRegistryLookup);
...
}
}8、ActivityStarter#startActivity（1）
记录相关时间信息
9、ActivityStarter#startActivity（2）
private int startActivity(IApplicationThread caller, Intent intent, Intent ephemeralIntent,
String resolvedType, ActivityInfo aInfo, ResolveInfo rInfo,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
IBinder resultTo, String resultWho, int requestCode, int callingPid, int callingUid,
String callingPackage, int realCallingPid, int realCallingUid, int startFlags,
SafeActivityOptions options,
boolean ignoreTargetSecurity, boolean componentSpecified, ActivityRecord[] outActivity,
TaskRecord inTask, boolean allowPendingRemoteAnimationRegistryLookup) {
// 判断请求启动新的app进程是否存在，不存在就抛出没有启动权限
ProcessRecord callerApp = null;
if (caller != null) {
callerApp = mService.getRecordForAppLocked(caller);
if (callerApp != null) {
callingPid = callerApp.pid;
callingUid = callerApp.info.uid;
} else {
Slog.w(TAG, "Unable to find app for caller " + caller
+ " (pid=" + callingPid + ") when starting: "
+ intent.toString());
err = ActivityManager.START_PERMISSION_DENIED;
}
}
// 确定目标activity如果通过startActivityForResult返回的activity对象（即启动activity）
ActivityRecord sourceRecord = null;
ActivityRecord resultRecord = null;
if (resultTo != null) {
sourceRecord = mSupervisor.isInAnyStackLocked(resultTo);
if (DEBUG_RESULTS) Slog.v(TAG_RESULTS,
"Will send result to " + resultTo + " " + sourceRecord);
// finish时需要返回值给启动activity（requestCode > 0,说明通过startActivityForResult
// 启动的),且启动activity存在，并且未finish
if (sourceRecord != null) {
if (requestCode >= 0 && !sourceRecord.finishing) {
// 暂时设置为返回的目标activity，因为还受相关flag影响
resultRecord = sourceRecord;
}
}
}
// 如果使用了 Intent.FLAG_ACTIVITY_FORWARD_RESULT
// 应该返回的是启动activity的启动activity(例如 A->B B->C C返回的是A)
if ((launchFlags & Intent.FLAG_ACTIVITY_FORWARD_RESULT) != 0 && sourceRecord != null)
{
// 使用了Intent.FLAG_ACTIVITY_FORWARD_RESULT,不能使用startActivityForResult()
if (requestCode >= 0) {
SafeActivityOptions.abort(options);
return ActivityManager.START_FORWARD_AND_REQUEST_CONFLICT;
}
resultRecord = sourceRecord.resultTo;
if (resultRecord != null && !resultRecord.isInStackLocked()) {
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;
}
}
// intent的Component为空，错误
if (err == ActivityManager.START_SUCCESS && intent.getComponent() == null) {
err = ActivityManager.START_INTENT_NOT_RESOLVED;
}
// activity信息为空，错误
if (err == ActivityManager.START_SUCCESS && aInfo == null) {
err = ActivityManager.START_CLASS_NOT_FOUND;
}
...
// 如果前面存在错误，且是由startActivityForResult调起的，需要返回到onActivityResult()
final ActivityStack resultStack = resultRecord == null ? null :
resultRecord.getStack();
if (err != START_SUCCESS) {
if (resultRecord != null) {
// LifecycleManager和ActivityResultItem完成该操作（后面会有详细的调用说明）
resultStack.sendActivityResultLocked(
-1, resultRecord, resultWho, requestCode, RESULT_CANCELED, null);
}
SafeActivityOptions.abort(options);
return err;
}
...
// 构建新建activity的ActivityRecord
ActivityRecord r = new ActivityRecord(mService, callerApp, callingPid, callingUid,
callingPackage, intent, resolvedType, aInfo,
mService.getGlobalConfiguration(),resultRecord, resultWho, requestCode,
componentSpecified, voiceSession != null,
mSupervisor, checkedOptions, sourceRecord);
if (outActivity != null) {
outActivity[0] = r;
}
...
return startActivity(r, sourceRecord, voiceSession, voiceInteractor, startFlags,
true /* doResume */, checkedOptions, inTask, outActivity);
}10、ActivityStarter#startActivity（3）
windowManager停止刷新
11、ActivityStarter#startActivityUnchecked
private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
ActivityRecord[] outActivity) {
// 见11.1 初始化Intent相关的信息
setInitialState(r, options, inTask, doResume, startFlags, sourceRecord, voiceSession,
voiceInteractor);
// 通过activity启动另一个activity，不走下面这个方法，可以忽略
computeLaunchingTaskFlags();
// 找出启动activity的栈
computeSourceStack();
// 将调整好的flag更新到intent
mIntent.setFlags(mLaunchFlags);
...
// 1、如果flag为FLAG_ACTIVITY_CLEAR_TOP，找当前任务栈有没有可重用的activity
// 2、如果启动模式singleTask、singleInstance，找已经存在任务栈有没有可复用的activity
ActivityRecord reusedActivity = getReusableIntentActivity();
...
// 存在可重用的activity
if (reusedActivity != null) {
...
if ((mLaunchFlags & FLAG_ACTIVITY_CLEAR_TOP) != 0
|| isDocumentLaunchesIntoExisting(mLaunchFlags)
|| isLaunchModeOneOf(LAUNCH_SINGLE_INSTANCE, LAUNCH_SINGLE_TASK)) {
// 要重用已存在activity，就需要把它栈顶的activity都finish，把它推到栈顶
final TaskRecord task = reusedActivity.getTask();
final ActivityRecord top =task.performClearTaskForReuseLocked(mStartActivity,
mLaunchFlags);
...
if (top != null) {
if (top.frontOfTask) {
top.getTask().setIntent(mStartActivity);
}
// 回调到app进程，进行activity生命周期的切换
// 启动activity进onPause()，目标activity（即该复用的activity）
// 走onNewIntent() -> onResume()
// 具体调用流程后面会详细说明，可以通过NewIntentItem这个类追踪
deliverNewIntent(top);
}
// 把目标activity的任务栈，移动前台
reusedActivity = setTargetStackAndMoveToFrontIfNeeded(reusedActivity);
...
// 将启动完成的目标activity返回
if (outActivity != null && outActivity.length > 0) {
outActivity[0] = reusedActivity;
}
...
return mMovedToFront ? START_TASK_TO_FRONT : START_DELIVERED_TO_TOP;
}
}
// 找不到包名
if (mStartActivity.packageName == null) {
final ActivityStack sourceStack = mStartActivity.resultTo != null
? mStartActivity.resultTo.getStack() : null;
if (sourceStack != null) {
sourceStack.sendActivityResultLocked(-1 /* callingUid */,
mStartActivity.resultTo,mStartActivity.resultWho,
mStartActivity.requestCode, RESULT_CANCELED,null /* data */);
}
ActivityOptions.abort(mOptions);
return START_CLASS_NOT_FOUND;
}
// 如果当前任务栈栈顶的activity是目标activity，直接复用
final ActivityStack topStack = mSupervisor.mFocusedStack;
final ActivityRecord topFocused = topStack.getTopActivity();
final ActivityRecord top = topStack.topRunningNonDelayedActivityLocked(mNotTop);
final boolean dontStart = top != null && mStartActivity.resultTo == null
&& top.realActivity.equals(mStartActivity.realActivity)
&& top.userId == mStartActivity.userId
&& top.app != null && top.app.thread != null
&& ((mLaunchFlags & FLAG_ACTIVITY_SINGLE_TOP) != 0
|| isLaunchModeOneOf(LAUNCH_SINGLE_TOP, LAUNCH_SINGLE_TASK));
if (dontStart) {
topStack.mLastPausedActivity = null;
...
// 确保该activity处于onResume的状态
if (mDoResume) {
// 该方法后面会详细说明
mSupervisor.resumeFocusedStackTopActivityLocked();
}
...
deliverNewIntent(top);
...
return START_DELIVERED_TO_TOP;
}
// 为目标activity分配任务栈
int result = START_SUCCESS;
if (mStartActivity.resultTo == null && mInTask == null && !mAddingToTask
&& (mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0) {
newTask = true;
// 如果指定新的任务栈，就新建一个任务栈分配给目标activity
result = setTaskFromReuseOrCreateNewTask(taskToAffiliate, topStack);
} else if (mSourceRecord != null) {
// startActivityForResult()需要返回启动activity 和启动activity同个栈
result = setTaskFromSourceRecord();
} else if (mInTask != null) {
// 指定任务栈，分配该任务栈给目标activity
result = setTaskFromInTask();
} else {
// 其他分配当前栈给目标activity
setTaskToCurrentTopOrCreateNewTask();
}
if (result != START_SUCCESS) {
return result;
}
// 见11.2 初始化一个新activity的相关操作
mTargetStack.startActivityLocked(mStartActivity, topFocused, newTask,
mKeepCurTransition,mOptions);
// 处理启动activity和目标activity之间的切换，和相关生命周期回调
if (mDoResume) {
...
// 如果目标任务栈不是在最前面，将其移动到最前
if (mTargetStack.isFocusable() && !mSupervisor.isFocusedStack(mTargetStack)) {
mTargetStack.moveToFront("startActivityUnchecked");
}
// 将最前的任务栈顶部activity的状态设置为可见生命周期（即onResume）
mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity,
mOptions);
...
}
}11.1、ActivityStarter#setInitialState
private void setInitialState(ActivityRecord r, ActivityOptions options, TaskRecord inTask,
boolean doResume, int startFlags, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor) {
// 重置相关 ActivityStarter相关状态
reset(false /* clearRequest */);
...
mLaunchMode = r.launchMode;
// 见11.1.1 调整任务窗口的标志Intent.FLAG_ACTIVITY_NEW_DOCUMENT
mLaunchFlags = adjustLaunchFlagsToDocumentMode(
r, LAUNCH_SINGLE_INSTANCE == mLaunchMode,
LAUNCH_SINGLE_TASK == mLaunchMode, mIntent.getFlags());
// 如果目标activity在新栈上启动，onActivityResult()直接回调
sendNewTaskResultRequestIfNeeded();
...
// 通过FLAG_ACTIVITY_NO_USER_ACTION 判断是否相应onUserLeavingHint()
mSupervisor.mUserLeaving = (mLaunchFlags & FLAG_ACTIVITY_NO_USER_ACTION) == 0;
...
// 通过FLAG_ACTIVITY_NO_ANIMATION判断是否做动画
mNoAnimation = (mLaunchFlags & FLAG_ACTIVITY_NO_ANIMATION) != 0;
}11.1.1、ActivityStarter#adjustLaunchFlagsToDocumentMode
private int adjustLaunchFlagsToDocumentMode(ActivityRecord r, boolean launchSingleInstance,
boolean launchSingleTask, int launchFlags) {
if ((launchFlags & Intent.FLAG_ACTIVITY_NEW_DOCUMENT) != 0 &&
(launchSingleInstance || launchSingleTask)) {
// 如果设置launchSingleInstance和launchSingleTask
// 该Intent.FLAG_ACTIVITY_NEW_DOCUMENT无效(优先级较低)
launchFlags &=~(Intent.FLAG_ACTIVITY_NEW_DOCUMENT | FLAG_ACTIVITY_MULTIPLE_TASK);
} else {
// Manifest与Flag冲突，取Manifest中的值
switch (r.info.documentLaunchMode) {
case ActivityInfo.DOCUMENT_LAUNCH_NONE:
break;
case ActivityInfo.DOCUMENT_LAUNCH_INTO_EXISTING:
launchFlags |= Intent.FLAG_ACTIVITY_NEW_DOCUMENT;
break;
case ActivityInfo.DOCUMENT_LAUNCH_ALWAYS:
launchFlags |= Intent.FLAG_ACTIVITY_NEW_DOCUMENT;
break;
case ActivityInfo.DOCUMENT_LAUNCH_NEVER:
launchFlags &= ~FLAG_ACTIVITY_MULTIPLE_TASK;
break;
}
}
return launchFlags;
}11.2、ActivityStack#startActivityLocked
void startActivityLocked(ActivityRecord r, ActivityRecord focusedTopActivity,
boolean newTask, boolean keepCurTransition, ActivityOptions options) {
final int taskId = rTask.taskId;
if (!r.mLaunchTaskBehind && (taskForIdLocked(taskId) == null || newTask))
// 将目标activity的任务栈加入，并移动到最前面
insertTaskAtTop(rTask, r);
}
...
// 目标activity新建WindowContainerController实例，
// 并将目标activity加入任务栈
if (r.getWindowContainerController() == null) {
r.createWindowContainer();
}
...
}12、ActivityStackSupervisor#resumeFocusedStackTopActivityLocked
boolean resumeFocusedStackTopActivityLocked(ActivityStack targetStack,
ActivityRecord target, ActivityOptions targetOptions) {
// 对最顶部的activity的状态进行判断，如果已经可见，直接返回
if (!readyToResume()) {
return false;
}
if (targetStack != null && isFocusedStack(targetStack)) {
return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
}
...
return false;
}13、ActivityStack#resumeTopActivityUncheckedLocked
boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
// 保证同一时刻只能存在一次调用
if (mStackSupervisor.inResumeTopActivity) {
return false;
}
boolean result = false;
try {
mStackSupervisor.inResumeTopActivity = true;
result = resumeTopActivityInnerLocked(prev, options);
...
} finally {
mStackSupervisor.inResumeTopActivity = false;
}
return result;
}14、ActivityStack#resumeTopActivityInnerLocked
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options){
// 获得最顶部的activity
final ActivityRecord next = topRunningActivityLocked(true /* focusableOnly */);
final boolean hasRunningActivity = next != null;
// 如果在当前ActivityStack中没有存在符合的最顶部的activity，去其他的ActivityStack中寻找，并
// 恢复为可见状态
if (!hasRunningActivity) {
return resumeTopActivityInNextFocusableStack(prev, options,"noMoreActivities");
}
...
// 如果最顶部的activity是目标activity，且已经是可见状态
if (mResumedActivity == next && next.isState(RESUMED)
&& mStackSupervisor.allResumedActivitiesComplete()) {
executeAppTransition(options);
return false;
}
...
// 处于睡眠状态下，如果最顶部的activity是目标activity,且处于onPause状态
if (shouldSleepOrShutDownActivities()
&& mLastPausedActivity == next
&& mStackSupervisor.allPausedActivitiesComplete()) {
executeAppTransition(options);
return false;
}
// 处理当前可见activity的状态和生命周期
...
if (mResumedActivity != null) {
pausing |= startPausingLocked(userLeaving, false, next, false);
}
...
// 通过判断ActivityRecord是否设置进程消息，如果未设置，说明该activity还未存在，需要新建，
// 从走onCreate的生命周期到onResume的生命周期；如果该activity已经存在，只需要恢复到可见状态
// (即onResume的生命周期)
if (next.app != null && next.app.thread != null) {
// 目标activity已经存在
try {
final ClientTransaction transaction
= ClientTransaction.obtain(next.app.thread,next.appToken);
...
// 通知目标activity切换到可见生命周期onResume（） （后面会有详细的调用明）
transaction.setLifecycleStateRequest(
ResumeActivityItem.obtain(next.app.repProcState,
mService.isNextTransitionForward()));
mService.getLifecycleManager().scheduleTransaction(transaction);
} catch (Exception e) {
// 如果该activity异常状态，重新新建该activity
mStackSupervisor.startSpecificActivityLocked(next, true, false);
}else{
// 目标activity不存在，新建该activity
...
mStackSupervisor.startSpecificActivityLocked(next, true, true);
}
} 注意：ActivityRecord判断是否已经启动的标志位，是否有进程信息 ActivityRecord#app(该变量是否为空)
仅在真正启动activity时赋值，可以追踪该方法ActivityRecord#setProcess
14.1、ActivityStack#startPausingLocked
final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping,
ActivityRecord resuming, boolean pauseImmediately) {
// 获得当前可见的activity
ActivityRecord prev = mResumedActivity;
...
prev.setState(PAUSING, "startPausingLocked");
if (prev.app != null && prev.app.thread != null) {
try {
// 回调到应用进程切换activity的生命周期为onPause() （后面会有详细的调用明）
mService.getLifecycleManager().scheduleTransaction(prev.app.thread,
prev.appToken,PauseActivityItem.obtain(prev.finishing, userLeaving,
prev.configChangeFlags, pauseImmediately));
} catch (Exception e) {
mPausingActivity = null;
mLastPausedActivity = null;
mLastNoHistoryActivity = null;
}
} else {
mPausingActivity = null;
mLastPausedActivity = null;
mLastNoHistoryActivity = null;
}
...
}15、ActivityStackSupervisor#startSpecificActivityLocked
void startSpecificActivityLocked(ActivityRecord r,
boolean andResume, boolean checkConfig) {
ProcessRecord app = mService.getProcessRecordLocked(r.processName,
r.info.applicationInfo.uid, true);
// 如果新建目标activity的进程存在，直接在进程启动目标activity
if (app != null && app.thread != null) {
try {
...
realStartActivityLocked(r, app, andResume, checkConfig);
return;
} catch (RemoteException e) {
}
}
// 如果新建目标activity的进程不存在，先新建该进程，再启动目标activity
mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
"activity", r.intent.getComponent(), false, false, true);
}16、ActivityStackSupervisor#realStartActivityLocked
final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
boolean andResume, boolean checkConfig) throws RemoteException {
...
// 设置进程信息，这个标志是判断该actvitity是否已经启动的标志
r.setProcess(app);
...
// 通知app进程，新建目标activity实例，并回调onCreate()
final ClientTransaction clientTransaction = ClientTransaction.obtain(app.thread,
r.appToken);
clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
System.identityHashCode(r),r.info,
mergedConfiguration.getGlobalConfiguration(),
mergedConfiguration.getOverrideConfiguration(), r.compat,
r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle,
r.persistentState, results, newIntents,
mService.isNextTransitionForward(),profilerInfo));
// 确实目标最终应该处于的生命周期的状态
final ActivityLifecycleItem lifecycleItem;
if (andResume) {
lifecycleItem = ResumeActivityItem.obtain(mService.isNextTransitionForward());
} else {
lifecycleItem = PauseActivityItem.obtain();
}
clientTransaction.setLifecycleStateRequest(lifecycleItem);
// 开始通知app进程，执行生命周期的事件(到这个开始说，怎么回调到app进程，执行相关事务)
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
...
}17、ClientTransaction#scheduleTransaction
void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
final IApplicationThread client = transaction.getClient();
transaction.schedule();
if (!(client instanceof Binder)) {
transaction.recycle();
}
}activity的创建实例和相关生命周期的回调都是通过ClientTransaction类实现的，ClientTransaction通过持有的IApplicationThread（即对应app线程ActivityThread的内部类ApplicationThread的代理对象），调用ActivityThread的方法，实现从app进程跨进程到AMS进程，执行activity的申请和注册后，返回app进程，新建相关activity实例和执行生命周期的方法的整个完整流程。
ClientTransaction通过ClientTransactionItem，把返回app进程该做的事情包装成一个一个的事务，例如新建activity实例并执行onCreate、回调onPause方法等等，通过继承子类的命名就一目了然了
18、ActivityThread#scheduleTransaction、H#handleMessage
通过handler分发H类中去执行相应的事务，H类把事务放到TransactionExecutor中去执行。
ActivityThread的核心工作基本到交给H类去分发处理。
19、TransactionExecutor#execute
public void execute(ClientTransaction transaction) {
final IBinder token = transaction.getActivityToken();
// 见19.1 执行回调的事务
executeCallbacks(transaction);
// 见19.2 执行跟生命周期有关的事务回调
executeLifecycleState(transaction);
}19.1、TransactionExecutor#executeCallbacks
执行的是LaunchActivityItem的execute方法
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);
// 见19.1.1
client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
}19.1.1、ActivityThread#handleLaunchActivity（1）
public Activity handleLaunchActivity(ActivityClientRecord r,
PendingTransactionActions pendingActions, Intent customIntent){
...
// 创建activity实例，执行onCreate方法
final Activity a = performLaunchActivity(r, customIntent);
...
}19.1.2、ActivityThread#handleLaunchActivity（2）
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
...
// 新建目标activity实例
ContextImpl appContext = createBaseContextForActivity(r);
Activity activity = null;
try {
java.lang.ClassLoader cl = appContext.getClassLoader();
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);
}
}
...
// 初始化目标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);
// 设置相应的主题信息
if (theme != 0) {
activity.setTheme(theme);
}
// 回调onCreate方法，并将目标activity的状态设置为CREATE
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
r.setState(ON_CREATE);
}19.1.3、Instrumentation#callActivityOnCreate
public void callActivityOnCreate(Activity activity, Bundle icicle) {
// 里面就调用到onCreate（）
activity.performCreate(icicle);
}从onCreate()的调用过程就可以明白，为什么onCreate方法只有回调一次，就在目标activity实例被创建的时候
19.2、TransactionExecutor#executeLifecycleState
private void executeLifecycleState(ClientTransaction transaction) {
// 见19.2.1 补全在最终状态之前的生命周期回调。例如在最终状态onResume()之前还有onStart()
cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */);
// 见19.2.2 执行最终状态生命回调onResume()
lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
}19.2.1、TransactionExecutor#cycleToPath
private void cycleToPath(ActivityClientRecord r, int finish,
boolean excludeLastState) {
final int start = r.getLifecycleState();
// 见19.2.1.1
// 计算当前目标activity处于生命周期，到最终生命周期之间的过渡生命周期
// 当前目标activity处于ONCREATE，最终应处于ONRESUME
final IntArray path = mHelper.getLifecyclePath(start, finish, excludeLastState);
// 见 19.2.1.2 执行相关生命周期回调
performLifecycleSequence(r, path);
}19.2.1.1、TransactionExecutorHelper#getLifecyclePath
public IntArray getLifecyclePath(int start, int finish, boolean excludeLastState) {
...
// start（ON_CREATE 1） finish（ON_RESUME 3）
for (int i = start + 1; i <= finish; i++) {
// 补上（ON_START 2）（ON_RESUME 3）
mLifecycleSequence.add(i);
}
...
// 最后一个生命周期跳过，有专门的事务执行了
if (excludeLastState && mLifecycleSequence.size() != 0) {
// 移除（ON_RESUME 3）
mLifecycleSequence.remove(mLifecycleSequence.size() - 1);
}
// 返回（ON_START 2）
return mLifecycleSequence
}19.2.1.2、TransactionExecutor#performLifecycleSequence
private void performLifecycleSequence(ActivityClientRecord r, IntArray path) {
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);
break;
case ON_RESUME:
mTransactionHandler.handleResumeActivity(r.token, false /*
finalStateRequest */,
r.isForward, "LIFECYCLER_RESUME_ACTIVITY");
break;
case ON_PAUSE:
mTransactionHandler.handlePauseActivity(r.token, false /* finished */,
false /* userLeaving */, 0 /* configChanges */,
mPendingActions,
"LIFECYCLER_PAUSE_ACTIVITY");
break;
case ON_STOP:
mTransactionHandler.handleStopActivity(r.token, false /* show */,
0 /* configChanges */, mPendingActions, false /*
finalStateRequest */,
"LIFECYCLER_STOP_ACTIVITY");
break;
case ON_DESTROY:
mTransactionHandler.handleDestroyActivity(r.token, false /* finishing */,
0 /* configChanges */, false /* getNonConfigInstance */,
"performLifecycleSequence. cycling to:" + path.get(size -
1));
break;
case ON_RESTART:
mTransactionHandler.performRestartActivity(r.token, false /* start
*/);
break;
default:
throw new IllegalArgumentException("Unexpected lifecycle state: " +
state);
}
}
}19.2.2、ActivityThread#handleResumeActivity
public void handleResumeActivity(IBinder token, boolean finalStateRequest, boolean
isForward,String reason) {
...
// 在里面执行activity#performResume -> Instrumentation#callActivityOnResume(this)
// -> activity#OnResume
final ActivityClientRecord r = performResumeActivity(token, finalStateRequest, reason);
...
// 在目标ON_RESUME状态之后，才新建对应的window和DecorView
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;
ViewRootImpl impl = decor.getViewRootImpl();
if (impl != null) {
impl.notifyChildRebuilt();
}
}
if (a.mVisibleFromClient) {
if (!a.mWindowAdded) {
a.mWindowAdded = true;
wm.addView(decor, l);
} else {
a.onWindowAttributesChanged(l);
}
}
}
...
}总结
一个完整的startActivity()的调用流程就这样结束了，代码追踪从Activity -> ActivityThread -> AMS -> ActivityThread -> Activity一条完整的流程链。不同进程间通过IBinder进行通信，每个acivity在AMS都存在一个对应ActivityRecord，AMS通过数据结构进行管理。AMS通过ClientLifecycleManager回调具体Activity实例执行对应的生命切换。AMS管理着不同app所有activity状态，保证不同app间的activity不会错乱，屏幕能够正确显示相应的界面。整体的代码框架设计的很明朗，谷歌爸爸真的厉害。
写在最后
该文章主要通过代码追踪的形式，代码的篇幅较多，相关说明都放在注释里面了。不同API，AMS代码结构可能会存在不一样，如果以本文章作为参考，建议用API28，这样追踪起来不会迷路。文章中对AMS部分代码具体作用可能存在理解错误，表达可能有问题，希望有大神指出，不胜感激。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
