ActivityManagerService分析（二）——Activity管理
（注：源代码为android-8.1）
0. 前言
在文章《Android源码阅读分析：ActivityManagerService分析（一）——启动流程》中，分析了ActivityManagerService是如何被创建并启动的，以及启动后的初始化操作。前文提到了，ActivityManagerService是管理四大组件的核心。那么，本篇文章就先从ActivityManagerService管理Activity的逻辑开始分析。
1. 启动Activity
这个过程我在文章《Android源码阅读分析：ActivityManagerService分析（一）——启动流程》中已经做了一些简要的代码跟踪分析。这里再详细的分析一下执行启动Activity的操作的时候，ActivityManagerService到底做了什么。因为前文已经对方法调用流程做了跟踪，那么本篇文章就针对核心方法来做分析。
首先分析ActivityStarter.startActivity方法。
(frameworks/base/services/core/java/com/android/server/am/ActivityStarter.java)
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,
ActivityOptions options, boolean ignoreTargetSecurity, boolean componentSpecified,
ActivityRecord[] outActivity, TaskRecord inTask) {
int err = ActivityManager.START_SUCCESS;
...
ProcessRecord callerApp = null;
if (caller != null) {
callerApp = mService.getRecordForAppLocked(caller);
// 可能会出现因内存不足等原因，导致发起者的进程被杀死
if (callerApp != null) {
callingPid = callerApp.pid;
callingUid = callerApp.info.uid;
} else {
// 如果进程被杀死，那么不能启动新的Activity，返回权限拒绝
err = ActivityManager.START_PERMISSION_DENIED;
}
}
...
// 启动当前Activity的Activity
ActivityRecord sourceRecord = null;
// 接收返回结果的Activity
ActivityRecord resultRecord = null;
if (resultTo != null) {
sourceRecord = mSupervisor.isInAnyStackLocked(resultTo);
if (sourceRecord != null) {
if (requestCode >= 0 && !sourceRecord.finishing) {
// 需要返回结果，则resultRecord设置为sourceRecord
resultRecord = sourceRecord;
}
}
}
final int launchFlags = intent.getFlags();
if ((launchFlags & Intent.FLAG_ACTIVITY_FORWARD_RESULT) != 0 && sourceRecord != null) {
if (requestCode >= 0) {
// FLAG_ACTIVITY_FORWARD_RESULT和requestCode>=0不能同时设置
// 因为设置了FLAG_ACTIVITY_FORWARD_RESULT后，新启动的Activity会将result透传回操作发起的Activity的源Activity
ActivityOptions.abort(options);
return ActivityManager.START_FORWARD_AND_REQUEST_CONFLICT;
}
// 结果返回到发起者的源Activity
resultRecord = sourceRecord.resultTo;
if (resultRecord != null && !resultRecord.isInStackLocked()) {
resultRecord = null;
}
resultWho = sourceRecord.resultWho;
requestCode = sourceRecord.requestCode;
sourceRecord.resultTo = null;
if (resultRecord != null) {
// 设置FLAG_ACTIVITY_FORWARD_RESULT后，接收结果的Activity就不能再持有接收结果的Activity
resultRecord.removeResultsLocked(sourceRecord, resultWho, requestCode);
}
if (sourceRecord.launchedFromUid == callingUid) {
callingPackage = sourceRecord.launchedFromPackage;
}
}
if (err == ActivityManager.START_SUCCESS && intent.getComponent() == null) {
// 需要启动的Activity不存在，返回intent无法解析
err = ActivityManager.START_INTENT_NOT_RESOLVED;
}
if (err == ActivityManager.START_SUCCESS && aInfo == null) {
// 找不到类
err = ActivityManager.START_CLASS_NOT_FOUND;
}
...
final ActivityStack resultStack = resultRecord == null ? null : resultRecord.getStack();
if (err != START_SUCCESS) {
// 不能成功启动的情况，则放弃执行
if (resultRecord != null) {
resultStack.sendActivityResultLocked(-1, resultRecord, resultWho, requestCode, RESULT_CANCELED, null);
}
ActivityOptions.abort(options);
return err;
}
// 检查是否有启动Activity权限
boolean abort = !mSupervisor.checkStartAnyActivityPermission(intent, aInfo, resultWho,
requestCode, callingPid, callingUid, callingPackage, ignoreTargetSecurity, callerApp,
resultRecord, resultStack, options);
abort |= !mService.mIntentFirewall.checkStartActivity(intent, callingUid, callingPid, resolvedType, aInfo.applicationInfo);
...
if (abort) {
...
return START_ABORTED;
}
...
// 新建需要创建的Activity的对应ActivityRecord
ActivityRecord r = new ActivityRecord(mService, callerApp, callingPid, callingUid,
callingPackage, intent, resolvedType, aInfo, mService.getGlobalConfiguration(),
resultRecord, resultWho, requestCode, componentSpecified, voiceSession != null,
mSupervisor, options, sourceRecord);
if (outActivity != null) {
outActivity[0] = r;
}
...
// 获取当前接收输入或正在启动Activity的ActivityStack
final ActivityStack stack = mSupervisor.mFocusedStack;
if (voiceSession == null && (stack.mResumedActivity == null
|| stack.mResumedActivity.info.applicationInfo.uid != callingUid)) {
// 如果当前ActivityStack的处于resumed状态的Activity为空，处于resumed状态的Activity的userId与发起startActivity的userId不同
// 若是这时检查不能切换进程，则放弃执行创建Activity，返回。
if (!mService.checkAppSwitchAllowedLocked(callingPid, callingUid, realCallingPid, realCallingUid, "Activity start")) {
PendingActivityLaunch pal = new PendingActivityLaunch(r, sourceRecord, startFlags, stack, callerApp);
mPendingActivityLaunches.add(pal);
ActivityOptions.abort(options);
return ActivityManager.START_SWITCHES_CANCELED;
}
}
...
// 启动pending的Activity，但是doResume参数为false
doPendingActivityLaunchesLocked(false);
return startActivity(r, sourceRecord, voiceSession, voiceInteractor, startFlags, true, options, inTask, outActivity);
} 该方法主要做一些权限检查。
下面在详细分析一下ActivityStarter.startActivityUnchecked方法。
(frameworks/base/services/core/java/com/android/server/am/ActivityStarter.java)
private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
ActivityRecord[] outActivity) {
...
// 判断是否需要将新的Activity放入到已存在的Task内
// 如果返回null，则新的Acitivity需要方法新的Task内，否则返回要加入的Task内的Activity
ActivityRecord reusedActivity = getReusableIntentActivity();
...
if (reusedActivity != null) {
...
if (mStartActivity.getTask() == null) {
mStartActivity.setTask(reusedActivity.getTask());
}
if (reusedActivity.getTask().intent == null) {
reusedActivity.getTask().setIntent(mStartActivity);
}
if ((mLaunchFlags & FLAG_ACTIVITY_CLEAR_TOP) != 0
|| isDocumentLaunchesIntoExisting(mLaunchFlags)
|| mLaunchSingleInstance || mLaunchSingleTask) {
final TaskRecord task = reusedActivity.getTask();
// 这种情况下，需要将在栈内的正在启动的Activity之上的Activity移除掉
// 大部分情况下，这意味着将Task重置到初始状态。
final ActivityRecord top = task.performClearTaskForReuseLocked(mStartActivity, mLaunchFlags);
// 上步操作可能会将reusedActivity从Task中移除，会导致将其
if (reusedActivity.getTask() == null) {
reusedActivity.setTask(task);
}
if (top != null) {
if (top.frontOfTask) {
// 确保Task现在有新的intent
top.getTask().setIntent(mStartActivity);
}
deliverNewIntent(top);
}
}
...
reusedActivity = setTargetStackAndMoveToFrontIfNeeded(reusedActivity);
final ActivityRecord outResult = outActivity != null && outActivity.length > 0 ? outActivity[0] : null;
if (outResult != null && (outResult.finishing || outResult.noDisplay)) {
outActivity[0] = reusedActivity;
}
if ((mStartFlags & START_FLAG_ONLY_IF_NEEDED) != 0) {
// 不需要启动一个新的Activity，且客户端（即启动者）指定在这种情况下不需要做任何事
// 这种情况下，仅仅在必要的时候resume目标栈
resumeTargetStackIfNeeded();
return START_RETURN_INTENT_TO_CALLER;
}
setTaskFromIntentActivity(reusedActivity);
if (!mAddingToTask && mReuseTask == null) {
// 必要的时候resume目标栈
resumeTargetStackIfNeeded();
if (outActivity != null && outActivity.length > 0) {
outActivity[0] = reusedActivity;
}
return START_TASK_TO_FRONT;
}
}
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是同样的，那么需要检查该Activity是否只能启动一次
final ActivityStack topStack = mSupervisor.mFocusedStack;
final ActivityRecord topFocused = topStack.topActivity();
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
|| mLaunchSingleTop || mLaunchSingleTask);
if (dontStart) {
// 确保正确的resume栈顶的Activity
topStack.mLastPausedActivity = null;
if (mDoResume) {
mSupervisor.resumeFocusedStackTopActivityLocked();
}
...
return ...
}
boolean newTask = false;
final TaskRecord taskToAffiliate = (mLaunchTaskBehind && mSourceRecord != null) ? mSourceRecord.getTask() : null;
// 判断是否需要一个新的Task
int result = START_SUCCESS;
if (mStartActivity.resultTo == null && mInTask == null && !mAddingToTask && (mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0) {
newTask = true;
result = setTaskFromReuseOrCreateNewTask(taskToAffiliate, preferredLaunchStackId, topStack);
} else if (mSourceRecord != null) {
result = setTaskFromSourceRecord();
} else if (mInTask != null) {
result = setTaskFromInTask();
} else {
setTaskToCurrentTopOrCreateNewTask();
}
if (result != START_SUCCESS) {
return result;
}
...
// 启动新的Activity
mTargetStack.startActivityLocked(mStartActivity, topFocused, newTask, mKeepCurTransition, mOptions);
if (mDoResume) {
final ActivityRecord topTaskActivity = mStartActivity.getTask().topRunningActivityLocked();
if (!mTargetStack.isFocusable()
|| (topTaskActivity != null && topTaskActivity.mTaskOverlay
&& mStartActivity != topTaskActivity)) {
// 1.该Activity没有焦点，那么就不能resume，但是仍然要确认其可见
// 2.当前的Task若是有覆盖，那么启动的Activity需要处于可见暂停状态，直到覆盖被移除
mTargetStack.ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
mWindowManager.executeAppTransition();
} else {
// 如果目标Task之前不是有焦点的，那么则使该Task获取焦点
if (mTargetStack.isFocusable() && !mSupervisor.isFocusedStack(mTargetStack)) {
mTargetStack.moveToFront("startActivityUnchecked");
}
mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity, mOptions);
}
} else {
mTargetStack.addRecentActivityLocked(mStartActivity);
}
// 为非当前用户更新最新使用的栈的id
// 当前用户的最新使用栈就是焦点栈
mSupervisor.updateUserStackLocked(mStartActivity.userId, mTargetStack);
mSupervisor.handleNonResizableTaskIfNeeded(mStartActivity.getTask(), preferredLaunchStackId, preferredLaunchDisplayId, mTargetStack.mStackId);
return START_SUCCESS;
}该方法主要的作用是对活动栈和任务的管理。
再看一下ActivityStack.startActivityLocked方法。
(frameworks/base/services/core/java/com/android/server/am/ActivityStack.java)
final void startActivityLocked(ActivityRecord r, ActivityRecord focusedTopActivity,
boolean newTask, boolean keepCurTransition, ActivityOptions options) {
TaskRecord rTask = r.getTask();
final int taskId = rTask.taskId;
if (!r.mLaunchTaskBehind && (taskForIdLocked(taskId) == null || newTask)) {
// 最新的Activity已经被移除，或者ActivityManangerService正在重用Task，那么插入或者替换
insertTaskAtTop(rTask, r);
}
TaskRecord task = null;
if (!newTask) {
// 在已存在的Task内启动，先找到是哪个Task
boolean startIt = true;
for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
task = mTaskHistory.get(taskNdx);
if (task.getTopActivity() == null) {
// 该Task所有的Activity都处于finishing状态
continue;
}
if (task == rTask) {
// 该栈就是需要启动Activity的栈
// 如果当前不是可见的，那么只将该Activity加入栈中，但不start
// 当用户回到这个Activity的时候，会启动它
if (!startIt) {
r.createWindowContainer();
ActivityOptions.abort(options);
return;
}
break;
} else if (task.numFullscreen > 0) {
startIt = false;
}
}
}
// 将一个新的Activity置于栈顶，那么接下来就是与用户交互
// 如果我们不是将这个新的Activity放置于最前面，那么就不要调用实际在最前面的Activity的onUserLeaving回调
final TaskRecord activityTask = r.getTask();
if (task == activityTask && mTaskHistory.indexOf(task) != (mTaskHistory.size() - 1)) {
mStackSupervisor.mUserLeaving = false;
}
...
if (r.getWindowContainerController() == null) {
r.createWindowContainer();
}
// 确保frontOfTask设置正确
task.setFrontOfTask();
if (!isHomeOrRecentsStack() || numActivities() > 0) {
...
// 准备开启过渡动画
if ((r.intent.getFlags() & Intent.FLAG_ACTIVITY_NO_ANIMATION) != 0) {
mWindowManager.prepareAppTransition(TRANSIT_NONE, keepCurTransition);
mNoAnimActivities.add(r);
} else {
int transit = TRANSIT_ACTIVITY_OPEN;
if (newTask) {
if (r.mLaunchTaskBehind) {
transit = TRANSIT_TASK_OPEN_BEHIND;
} else {
if (canEnterPipOnTaskSwitch(focusedTopActivity, null /* toFrontTask */, r, options)) {
focusedTopActivity.supportsEnterPipOnTaskSwitch = true;
}
transit = TRANSIT_TASK_OPEN;
}
}
mWindowManager.prepareAppTransition(transit, keepCurTransition);
mNoAnimActivities.remove(r);
}
boolean doShow = true;
if (newTask) {
if ((r.intent.getFlags() & Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED) != 0) {
resetTaskIfNeededLocked(r, r);
doShow = topRunningNonDelayedActivityLocked(null) == r;
}
} else if (options != null && options.getAnimationType() == ActivityOptions.ANIM_SCENE_TRANSITION) {
doShow = false;
}
if (r.mLaunchTaskBehind) {
// 如果启动的Activity的mLauchTaskBehind，那么不启动window
// 要确保通知WindowManager启动的Activity是可见的，即使该Activity不在栈顶
r.setVisibility(true);
ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
} else if (SHOW_APP_STARTING_PREVIEW && doShow) {
TaskRecord prevTask = r.getTask();
ActivityRecord prev = prevTask.topRunningActivityWithStartingWindowLocked();
if (prev != null) {
if (prev.getTask() != prevTask) {
prev = null;
}
else if (prev.nowVisible) {
prev = null;
}
}
r.showStartingWindow(prev, newTask, isTaskSwitch(r, focusedTopActivity));
}
} else {
// 如果这是第一个Activity，不要做任何动画
ActivityOptions.abort(options);
}
}该方法主要作用是入栈操作以及过渡动画类别的确定。
2. 销毁Activity
当一个Activity完成使命后，我们通常会调用finish方法来销毁该Activity。
(frameworks/base/core/java/android/app/Activity.java)
public void finish() {
finish(DONT_FINISH_TASK_WITH_ACTIVITY);
}
private void finish(int finishTask) {
...
if (ActivityManager.getService().finishActivity(mToken, resultCode, resultData, finishTask)) {
mFinished = true;
}
...
} 调用finish销毁Activity会调用ActivityManagerService的finishActivity方法。
(frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java)
@Override
public final boolean finishActivity(IBinder token, int resultCode, Intent resultData, int finishTask) {
...
synchronized(this) {
ActivityRecord r = ActivityRecord.isInStackLocked(token);
...
TaskRecord tr = r.getTask();
ActivityRecord rootR = tr.getRootActivity();
...
try {
boolean res;
final boolean finishWithRootActivity = finishTask == Activity.FINISH_TASK_WITH_ROOT_ACTIVITY;
if (finishTask == Activity.FINISH_TASK_WITH_ACTIVITY || (finishWithRootActivity && r == rootR)) {
// 只有当要销毁的Activity是相应Task的根Activity时，才会移除该Task
// 忽略执行结果，因为不支持跨Task传递结果
res = mStackSupervisor.removeTaskByIdLocked(tr.taskId, false, finishWithRootActivity);
...
} else {
res = tr.getStack().requestFinishActivityLocked(token, resultCode, resultData, "app-request", true);
...
}
return res;
}
...
}
} 该方法首先判断是否需要结束Task。最终都会调用ActivityStack.finishActivityLocked方法。
(frameworks/base/services/core/java/com/android/server/am/ActivityStack.java)
final boolean finishActivityLocked(ActivityRecord r, int resultCode, Intent resultData, String reason, boolean oomAdj, boolean pauseImmediately) {
...
final TaskRecord task = r.getTask();
...
if (mResumedActivity == r) {
...
} else if (r.state != ActivityState.PAUSING) {
...
// 通知window manager准备移除该Activity
r.setVisibility(false);
if (mPausingActivity == null) {
...
// 先pause该Activity
startPausingLocked(false, false, null, pauseImmediately);
}
...
} else if (r.state != ActivityState.PAUSING) {
// 如果Activity处于PAUSING状态，那么需要在完成pause后完成finish
...
final int finishMode = (r.visible || r.nowVisible) ? FINISH_AFTER_VISIBLE : FINISH_AFTER_PAUSE;
final boolean removedActivity = finishCurrentActivityLocked(r, finishMode, oomAdj) == null;
...
}
...
}
final ActivityRecord finishCurrentActivityLocked(ActivityRecord r, int mode, boolean oomAdj) {
// 如果该Activity当前是可见的，而resumed的Activity还不可见，
// 那么暂缓finish直到resumed的Activity变成可见的
final ActivityRecord next = mStackSupervisor.topRunningActivityLocked();
if (mode == FINISH_AFTER_VISIBLE && (r.visible || r.nowVisible) && next != null && !next.nowVisible) {
if (!mStackSupervisor.mStoppingActivities.contains(r)) {
addToStopping(r, false /* scheduleIdle */, false /* idleDelayed */);
}
...
r.state = STOPPING;
if (oomAdj) {
mService.updateOomAdjLocked();
}
return r;
}
// 确保该Activit在其他地方被清除掉
mStackSupervisor.mStoppingActivities.remove(r);
mStackSupervisor.mGoingToSleepActivities.remove(r);
mStackSupervisor.mActivitiesWaitingForVisibleActivity.remove(r);
if (mResumedActivity == r) {
mResumedActivity = null;
}
final ActivityState prevState = r.state;
final boolean finishingActivityInNonFocusedStack
= r.getStack() != mStackSupervisor.getFocusedStack()
&& prevState == ActivityState.PAUSED && mode == FINISH_AFTER_VISIBLE;
if (mode == FINISH_IMMEDIATELY
|| (prevState == ActivityState.PAUSED
&& (mode == FINISH_AFTER_PAUSE || mStackId == PINNED_STACK_ID))
|| finishingActivityInNonFocusedStack
|| prevState == STOPPING
|| prevState == STOPPED
|| prevState == ActivityState.INITIALIZING) {
r.makeFinishingLocked();
// 销毁Activity
boolean activityRemoved = destroyActivityLocked(r, true, "finish-imm");
...
if (activityRemoved) {
mStackSupervisor.resumeFocusedStackTopActivityLocked();
}
...
return activityRemoved ? null : r;
}
...
mStackSupervisor.mFinishingActivities.add(r);
r.resumeKeyDispatchingLocked();
mStackSupervisor.resumeFocusedStackTopActivityLocked();
return r;
}
final boolean destroyActivityLocked(ActivityRecord r, boolean removeFromApp, String reason) {
...
final boolean hadApp = r.app != null;
if (hadApp) {
if (removeFromApp) {
// 将该Activity从进程中移除
...
}
boolean skipDestroy = false;
try {
// 在应用进程中处理销毁操作，该方法会在后续操作中陆续调用Activity的onPause、onStop和onDestroy方法
r.app.thread.scheduleDestroyActivity(r.appToken, r.finishing, r.configChangeFlags);
}
...
// 如果Activity正在finishing，需要暂缓将其从列表中移除，以便于cleanup。
// 否则直接标注为DESTROYING状态
if (r.finishing && !skipDestroy) {
r.state = ActivityState.DESTROYING;
Message msg = mHandler.obtainMessage(DESTROY_TIMEOUT_MSG, r);
mHandler.sendMessageDelayed(msg, DESTROY_TIMEOUT);
} else {
r.state = ActivityState.DESTROYED;
r.app = null;
}
}
...
} 先pause当前的Activity，然后在下一个Activity进入可见状态之后，执行销毁Activity。
3. 总结
ActivityManagerService对Activity的管理，基本都是通过ActivityStack来进行栈管理。大致的流程可以用下面两图总结。
启动Acitivity
销毁Activity
