基于Android10 分析Activity启动过程
本文基于AOSP Android10的源码分析startActivity的启动流程。
相关源码文件如下：
frameworks/base/core/java/android/app/
Activity.java
Instrumentation.java
frameworks/base/services/core/java/com/android/server/wm/
ActivityTaskManagerService.java
ActivityStartController.java
ActivityStarter.java
ActivityRecord.java
RootActivityContainer.java
ActivityDisplay.java
ActivityStack.java
TaskRecord.java
Task.java
ActivityStackSupervisor.java
ActivityManagerService.java
ClientLifecycleManager.java
frameworks/base/services/core/java/com/android/server/wm/
ProcessList.java
frameworks/base/core/java/android/os/
Process.java
ZygoteProcess.java
frameworks/base/core/java/android/app/
ActivityThread.java
frameworks/base/core/java/android/app/servertransaction/
ClientTransaction.java
PauseActivityItem.java
LaunchActivityItem.java
ResumeActivityItem.java
TransactionExecutor.java
frameworks/base/core/java/com/android/internal/os/
ZygoteInit.java
ZygoteServer.java
ZygoteConnection.java
Zygote.java
RuntimeInit.java
一. 概述
本文主要介绍的是从Launcher应用中首次启动第三方App的的流程，非Launcher应用启动同样适用。
首先需要清楚启动的大致流程是：Launcher应用进程 》SystemServer进程》Zygote进程》被启动的三方App进程》SystemServer进程。
既然这么多进程之间需要通信，那么各个进程直接是如何通信的呢？
首先Launcher进程或其它被启动的三方App进程与SystemServer是通过Binder IPC通信。
SystemServer进程与Zygote是通过LocalSocket IPC通信。
大致了解了之后，接下来根据AOSP源码分析具体启动过程。
二. 启动流程
启动流程介绍可以分成两部分
第一部分介绍Launcher进程到SystemServer调用过程和SystemServer进程到Zygote进程调用过程。
第二部分介绍Zygote进程到第三方App进程和三方App到SystemServer进程调用过程。
第一部分
2.1.1 Activity.startActivity
frameworks/base/core/java/android/app/Activity.java
@Override
public void startActivity(Intent intent) {
this.startActivity(intent, null);
}
@Override
public void startActivity(Intent intent, @Nullable Bundle options) {
if (options != null) {
startActivityForResult(intent, -1, options);
} else {
// [2.1.2小节]
startActivityForResult(intent, -1);
}
}
2.1.2 Activity.startActivityForResult
frameworks/base/core/java/android/app/Activity.java
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode, @Nullable Bundle options) {
if (mParent == null) {
// ...
// [2.1.3小节]
Instrumentation.ActivityResult ar = mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, this,
intent, requestCode, options);
// ...
} else {
// ...
}
}
2.1.3 Instrumentation.execStartActivity
frameworks/base/core/java/android/app/Instrumentation.java
/**
* <p>如果没找到运行给定的Intent的Activity，则会抛出异常 {@link android.content.ActivityNotFoundException}
*
* @param who 调用方的Content
* @param contextThread 实际传递的是调用方的ApplicationThread.
* @param token 正在启动的系统内部令牌; 或许为空.
* @param target 调用方的Activity对象，以此来接收返回结果; 或许为空.
* @param intent Intent对象.
* @param requestCode 请求结果的标识符; 小于0,表示调用方不需要结果.
* @param options Addition options.
*/
@UnsupportedAppUsage
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);
// [2.1.4和2.1.5小节] Android10以前使用的是ActivityManager，Android10使用的是ActivityTaskManager
int result = ActivityTaskManager.getService()
.startActivity(whoThread, who.getBasePackageName(), intent,
intent.resolveTypeIfNeeded(who.getContentResolver()),
token, target != null ? target.mEmbeddedID : null,
requestCode, 0, null, options);
checkStartActivityResult(result, intent); // 检查返回结果，result在[-100,-1]之间则会抛出异常
} catch (RemoteException e) {
throw new RuntimeException("Failure from system", e);
}
return null;
}
2.1.4 ActivityTaskManager.getService
frameworks/base/core/java/android/app/ActivityTaskManager.java
通过ServiceManager获取IBinder对象进行跨进程调用ActivityTaskManagerService服务。
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);
}
};
2.1.5 ActivityTaskManagerService.startActivity
frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
/**
* @param caller Activity的IApplicationThread对象
* @param callingPackage 调用方的包名
* @param intent 启动意图
* @param resolvedType MIME type
* @param resultTo Activity的mToken对象
* @param resultWho Activity的mEmbeddedID
* @param requestCode -1
* @param startFlags 0
* @param profilerInfo null
* @param bOptions null Bundle
*/
@Override
public final int startActivity(IApplicationThread caller, String callingPackage,
Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {
// [2.1.6小节]
return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
resultWho, requestCode, startFlags, profilerInfo, bOptions,
UserHandle.getCallingUserId());
}
2.1.6 ActivityTaskmanagerService.startActivityAsUser
frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
@Override
public int startActivityAsUser(IApplicationThread caller, String callingPackage,
Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId) {
return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
resultWho, requestCode, startFlags, profilerInfo, bOptions, userId,
true /*validateIncomingUser*/);
}
// startActivityAsUser为重载方法，方法名相同，参数不同。
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) {
enforceNotIsolatedCaller("startActivityAsUser");
userId = getActivityStartController().checkTargetUser(userId, validateIncomingUser,
Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");
// obtainStarter的reason为startActivityAsUser
return getActivityStartController().obtainStarter(intent, "startActivityAsUser")
.setCaller(caller)
.setCallingPackage(callingPackage)
.setResolvedType(resolvedType)
.setResultTo(resultTo)
.setResultWho(resultWho)
.setRequestCode(requestCode)
.setStartFlags(startFlags)
.setProfilerInfo(profilerInfo)
.setActivityOptions(bOptions)
.setMayWait(userId) // 注意此方法 [2.1.7小节]
.execute(); // [2.1.8小节]
}
2.1.7 ActivityStarter.setMayWait
frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java
// 该方法设置了userId同时设置myWait为true
ActivityStarter setMayWait(int userId) {
mRequest.mayWait = true;
mRequest.userId = userId;
return this;
}
2.1.8 ActivityStarter.execute
int execute() {
try {
// 因为[2.1.7小节]设置了mayWait为true，所以最终调用startActivityMayWait [2.1.9小节]
if (mRequest.mayWait) {
return startActivityMayWait(mRequest.caller, mRequest.callingUid,
mRequest.callingPackage, mRequest.realCallingPid, mRequest.realCallingUid,
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,
mRequest.originatingPendingIntent, mRequest.allowBackgroundActivityStart);
} else {
// ...
}
} finally {
onExecutionComplete();
}
}
2.1.9 ActivityStarter.startActivityMayWait
frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java
private int startActivityMayWait(IApplicationThread caller, int callingUid,
String callingPackage, int requestRealCallingPid, int requestRealCallingUid,
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,
PendingIntentRecord originatingPendingIntent, boolean allowBackgroundActivityStart) {
// ..
boolean componentSpecified = intent.getComponent() != null;
// 处理pid和uid
final int realCallingPid = requestRealCallingPid != Request.DEFAULT_REAL_CALLING_PID
? requestRealCallingPid
: Binder.getCallingPid();
final int realCallingUid = requestRealCallingUid != Request.DEFAULT_REAL_CALLING_UID
? requestRealCallingUid
: Binder.getCallingUid();
int callingPid;
if (callingUid >= 0) {
callingPid = -1;
} else if (caller == null) {
callingPid = realCallingPid;
callingUid = realCallingUid;
} else {
callingPid = callingUid = -1;
}
// 给Intent做个备份
final Intent ephemeralIntent = new Intent(intent);
// 不需要修改客户端对象
intent = new Intent(intent);
// ...
// mSupervisor是ActivityStackSupervisor实例对象
// 调用ASS的resolveIntent方法获取到ResolveInfo实例
// 本文暂不剖析resolveIntent与resolveActivity具体实现，后续通过剖析PMS服务来理解
ResolveInfo rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId,
0 /* matchFlags */,computeResolveFilterUid(callingUid, realCallingUid, mRequest.filterCallingUid));
// ...
// 同样是调用ASS的resolveActivity方法获取到ActivityInfo实例，该实例对象记录了Activity相关信息。
ActivityInfo aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, profilerInfo);
synchronized (mService.mGlobalLock) {
// 获取目前焦点的ActivityStack
final ActivityStack stack = mRootActivityContainer.getTopDisplayFocusedStack();
// ...
// 在此处构建了ActivityRecord数组，此时数组元素为空
final ActivityRecord[] outRecord = new ActivityRecord[1];
// [2.1.10 小节]
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, originatingPendingIntent,
allowBackgroundActivityStart);
// ...
return res;
}
}
2.1.10 ActivityStarter.startActivity
frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java
2.1.10.1 startActivity
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, String reason,
boolean allowPendingRemoteAnimationRegistryLookup,
PendingIntentRecord originatingPendingIntent, boolean allowBackgroundActivityStart) {
// 必须要有reason，reason是在调用obtainStater赋值为startActivityAsUser，参考[2.1.6小节]
if (TextUtils.isEmpty(reason)) {
throw new IllegalArgumentException("Need to specify a reason.");
}
mLastStartReason = reason;
mLastStartActivityTimeMs = System.currentTimeMillis();
mLastStartActivityRecord[0] = null;
// [2.1.10.2] 注意此处调用的outActivity参数给的是mLastStartActivityRecord
mLastStartActivityResult = startActivity(caller, intent, ephemeralIntent, resolvedType,
aInfo, rInfo, voiceSession, voiceInteractor, resultTo, resultWho, requestCode,
callingPid, callingUid, callingPackage, realCallingPid, realCallingUid, startFlags,
options, ignoreTargetSecurity, componentSpecified, mLastStartActivityRecord,
inTask, allowPendingRemoteAnimationRegistryLookup, originatingPendingIntent,
allowBackgroundActivityStart);
if (outActivity != null) {
// 给调用方的outActivity参数数组下标0元素赋值
outActivity[0] = mLastStartActivityRecord[0];
}
return getExternalResult(mLastStartActivityResult);
}
2.1.10.2 startActivity
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,
PendingIntentRecord originatingPendingIntent, boolean allowBackgroundActivityStart) {
// ...
int err = ActivityManager.START_SUCCESS;
// ...
final int userId = aInfo != null && aInfo.applicationInfo != null
? UserHandle.getUserId(aInfo.applicationInfo.uid) : 0;
if (err == ActivityManager.START_SUCCESS) {
Slog.i(TAG, "START u" + userId + " {" + intent.toShortString(true, true, true, false)
+ "} from uid " + callingUid);
}
ActivityRecord sourceRecord = null;
ActivityRecord resultRecord = null;
if (resultTo != null) {
// resultTo为Activity的mToken属性，由于是首次启动，所以sourceRecord和resultRecord都为null
sourceRecord = mRootActivityContainer.isInAnyStack(resultTo);
if (sourceRecord != null) {
if (requestCode >= 0 && !sourceRecord.finishing) {
resultRecord = sourceRecord;
}
}
}
// intent 启动标志位
final int launchFlags = intent.getFlags();
// ...
// 未找到指定的Component
if (err == ActivityManager.START_SUCCESS && intent.getComponent() == null) {
err = ActivityManager.START_INTENT_NOT_RESOLVED;
}
// 未匹配到ActivityInfo
if (err == ActivityManager.START_SUCCESS && aInfo == null) {
err = ActivityManager.START_CLASS_NOT_FOUND;
}
// ...
// 返回错误码
if (err != START_SUCCESS) {
if (resultRecord != null) {
resultStack.sendActivityResultLocked(
-1, resultRecord, resultWho, requestCode, RESULT_CANCELED, null);
}
SafeActivityOptions.abort(options);
return err;
}
// abort标记是否中止启动，通过权限等判断
boolean abort = !mSupervisor.checkStartAnyActivityPermission(intent, aInfo, resultWho,
requestCode, callingPid, callingUid, callingPackage, ignoreTargetSecurity,
inTask != null, callerApp, resultRecord, resultStack);
abort |= !mService.mIntentFirewall.checkStartActivity(intent, callingUid,
callingPid, resolvedType, aInfo.applicationInfo);
abort |= !mService.getPermissionPolicyInternal().checkStartActivity(intent, callingUid,callingPackage);
boolean restrictedBgActivity = false;
if (!abort) {
try {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER,
"shouldAbortBackgroundActivityStart");
restrictedBgActivity = shouldAbortBackgroundActivityStart(callingUid,
callingPid, callingPackage, realCallingUid, realCallingPid, callerApp,
originatingPendingIntent, allowBackgroundActivityStart, intent);
} finally {
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
}
}
// ...
if (abort) {
// 中止启动，如果有resultRecord则给其发送取消通知。
if (resultRecord != null) {
resultStack.sendActivityResultLocked(-1, resultRecord, resultWho, requestCode,
RESULT_CANCELED, null);
}
ActivityOptions.abort(checkedOptions);
return START_ABORTED;
}
// ...
// 注意此处才真正的构建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;
}
// ...
// 获取焦点的ActivityStack
final ActivityStack stack = mRootActivityContainer.getTopDisplayFocusedStack();
// ...
// 再次调用startActivity[2.1.10.3] 传递的doResume为true
final int res = startActivity(r, sourceRecord, voiceSession, voiceInteractor, startFlags,
true /* doResume */, checkedOptions, inTask, outActivity, restrictedBgActivity);
mSupervisor.getActivityMetricsLogger().notifyActivityLaunched(res, outActivity[0]);
return res;
}
2.1.10.3 startActivity
private int startActivity(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
ActivityRecord[] outActivity, boolean restrictedBgActivity) {
int result = START_CANCELED;
final ActivityStack startedActivityStack;
try {
mService.mWindowManager.deferSurfaceLayout();
// 经过三次startActivity最终调用到startActivityUnchecked[2.1.11小节]
result = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor,
startFlags, doResume, options, inTask, outActivity, restrictedBgActivity);
} finally {
// ...
}
// ...
return result;
}
2.1.11 ActivityStarter.startActivityUnchecked
frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java
private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
ActivityRecord[] outActivity, boolean restrictedBgActivity) {
// 初始化状态属性
setInitialState(r, options, inTask, doResume, startFlags, sourceRecord, voiceSession,
voiceInteractor, restrictedBgActivity);
final int preferredWindowingMode = mLaunchParams.mWindowingMode;
computeLaunchingTaskFlags(); // 计算mLaunchFlags []
computeSourceStack(); // 计算mSourceStack
mIntent.setFlags(mLaunchFlags); // 设置Flags
ActivityRecord reusedActivity = getReusableIntentActivity(); // 返回null
// 计算启动参数 displayId等
mSupervisor.getLaunchParamsController().calculate(
reusedActivity != null ? reusedActivity.getTaskRecord() : mInTask,
r.info.windowLayout, r, sourceRecord, options, PHASE_BOUNDS, mLaunchParams);
mPreferredDisplayId =
mLaunchParams.hasPreferredDisplay() ? mLaunchParams.mPreferredDisplayId
: DEFAULT_DISPLAY;
// ...
// 如果启动的Activity的packageName为null，则中止当前启动任务.
if (mStartActivity.packageName == null) {
final ActivityStack sourceStack = mStartActivity.resultTo != null
? mStartActivity.resultTo.getActivityStack() : 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;
}
// 获取当前焦点的ActivityStack
final ActivityStack topStack = mRootActivityContainer.getTopDisplayFocusedStack();
// 获取当前焦点的ActivityRecord
final ActivityRecord topFocused = topStack.getTopActivity();
final ActivityRecord top = topStack.topRunningNonDelayedActivityLocked(mNotTop);
// dontStart 标记是否需要继续执行启动
final boolean dontStart = top != null && mStartActivity.resultTo == null
&& top.mActivityComponent.equals(mStartActivity.mActivityComponent)
&& top.mUserId == mStartActivity.mUserId
&& top.attachedToProcess()
&& ((mLaunchFlags & FLAG_ACTIVITY_SINGLE_TOP) != 0
|| isLaunchModeOneOf(LAUNCH_SINGLE_TOP, LAUNCH_SINGLE_TASK))
&& (!top.isActivityTypeHome() || top.getDisplayId() == mPreferredDisplayId);
if (DEBUG_STACK) {
Slog.d(TAG, "topStack: " + topStack + " topFocused:" + topFocused + " topRecord:" + top + " dontStart:" + dontStart);
}
if (dontStart) {
topStack.mLastPausedActivity = null;
if (mDoResume) {
// 执行resume动作
mRootActivityContainer.resumeFocusedStacksTopActivities();
}
ActivityOptions.abort(mOptions);
// ...
return START_DELIVERED_TO_TOP;
}
// 标记是否是新的task
boolean newTask = false;
final TaskRecord taskToAffiliate = (mLaunchTaskBehind && mSourceRecord != null)
? mSourceRecord.getTaskRecord() : null; // null
int result = START_SUCCESS;
// 我们主要关注从Launcher首次启动一个App的过程，所以会进入第一个if
if (mStartActivity.resultTo == null && mInTask == null && !mAddingToTask
&& (mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0) {
newTask = true; // 标记是新的task
result = setTaskFromReuseOrCreateNewTask(taskToAffiliate); // [2.1.12 小节]
// 经过一系列负责调用[2.1.12-2.1.30 小节]后,返回的结果是START_SUCCESS
} else if (mSourceRecord != null) {
result = setTaskFromSourceRecord();
} else if (mInTask != null) {
result = setTaskFromInTask();
} else {
result = setTaskToCurrentTopOrCreateNewTask();
}
if (result != START_SUCCESS) {
return result;
}
// ...
// mTargetStack在setTaskFromReuseOrCreateNewTask被赋值
mTargetStack.mLastPausedActivity = null;
// ...
// [2.1.31 小节] newTask为true
mTargetStack.startActivityLocked(mStartActivity, topFocused, newTask, mKeepCurTransition,
mOptions);
// 经过[2.1.31 - 2.1.33 小节]的调用返回到这里, mDoResume为true
if (mDoResume) {
final ActivityRecord topTaskActivity =
mStartActivity.getTaskRecord().topRunningActivityLocked();
// topTaskActivity与mStartActivity一致
// mTargetStack具备焦点,最终进入else
if (!mTargetStack.isFocusable()
|| (topTaskActivity != null && topTaskActivity.mTaskOverlay
&& mStartActivity != topTaskActivity)) {
// ...
} else {
// ...
// 调用了RootActivityContainer的方法 [2.1.34 小节]
mRootActivityContainer.resumeFocusedStacksTopActivities(
mTargetStack, mStartActivity, mOptions);
}
} else if (mStartActivity != null) {
mSupervisor.mRecentTasks.add(mStartActivity.getTaskRecord());
}
// ...
// 返回启动成功结果
return START_SUCCESS;
}
2.1.12 ActivityStarter.setTaskFromReuseOrCreateNewTask
frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java
private int setTaskFromReuseOrCreateNewTask(TaskRecord taskToAffiliate) {
// ...
// [2.1.13 小节]
mTargetStack = computeStackFocus(mStartActivity, true, mLaunchFlags, mOptions);
// 通过复杂的一系列调用后,最终获取到ActivityStack赋值给mTargetStack
// mReuseTask 为空
if (mReuseTask == null) {
// [2.1.23 小节] 创建TaskRecord
final TaskRecord task = mTargetStack.createTaskRecord(
mSupervisor.getNextTaskIdForUserLocked(mStartActivity.mUserId),
mNewTaskInfo != null ? mNewTaskInfo : mStartActivity.info,
mNewTaskIntent != null ? mNewTaskIntent : mIntent, mVoiceSession,
mVoiceInteractor, !mLaunchTaskBehind /* toTop */, mStartActivity, mSourceRecord,
mOptions);
// 又经过一系列复杂调用后获得到TaskRecord对象
// [2.1.29 小节]
addOrReparentStartingActivity(task, "setTaskFromReuseOrCreateNewTask - mReuseTask");
updateBounds(mStartActivity.getTaskRecord(), mLaunchParams.mBounds);
if (DEBUG_TASKS) Slog.v(TAG_TASKS, "Starting new activity " + mStartActivity
+ " in new task " + mStartActivity.getTaskRecord());
} else {
addOrReparentStartingActivity(mReuseTask, "setTaskFromReuseOrCreateNewTask");
}
// ...
return START_SUCCESS;
}
2.1.13 ActivityStarter.computeStackFocus
frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java
private ActivityStack computeStackFocus(ActivityRecord r, boolean newTask, int launchFlags,
ActivityOptions aOptions) {
final TaskRecord task = r.getTaskRecord(); // task为null
// [2.1.14 小节]
ActivityStack stack = getLaunchStack(r, launchFlags, task, aOptions);
if (stack != null) {
return stack;
}
// ...
return stack;
}
2.1.14 ActivityStarter.getLaunchStack
frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java
private ActivityStack getLaunchStack(ActivityRecord r, int launchFlags, TaskRecord task,
ActivityOptions aOptions) {
// mReuseTask为null
if (mReuseTask != null) {
return mReuseTask.getStack();
}
// FLAG_ACTIVITY_LAUNCH_ADJACENT 仅使用在分屏多窗口模式下,这里我们条件成立进入if
if (((launchFlags & FLAG_ACTIVITY_LAUNCH_ADJACENT) == 0)
|| mPreferredDisplayId != DEFAULT_DISPLAY) {
final boolean onTop = aOptions == null || !aOptions.getAvoidMoveToFront();
// [2.1.15 小节]
final ActivityStack stack =
mRootActivityContainer.getLaunchStack(r, aOptions, task, onTop, mLaunchParams);
return stack;
}
// ...
}
2.1.15 RootActivityContainer.getLaunchStack
frameworks/base/services/core/java/com/android/server/wm/RootActivityContainer.java
<T extends ActivityStack> T getLaunchStack(@Nullable ActivityRecord r,
@Nullable ActivityOptions options, @Nullable TaskRecord candidateTask, boolean onTop,
@Nullable LaunchParamsController.LaunchParams launchParams) {
int taskId = INVALID_TASK_ID;
int displayId = INVALID_DISPLAY;
// ... 省略一大部分
// 一般情况下使用的是defaultDisplay
if (display == null || !canLaunchOnDisplay(r, display.mDisplayId)) {
display = getDefaultDisplay();
}
// [2.1.16 小节]
return display.getOrCreateStack(r, options, candidateTask, activityType, onTop);
}
2.1.16 ActivityDisplay.getOrCreateStack
frameworks/base/services/core/java/com/android/server/wm/ActivityDisplay.java
// 重载方法
<T extends ActivityStack> T getOrCreateStack(@Nullable ActivityRecord r,
@Nullable ActivityOptions options, @Nullable TaskRecord candidateTask, int activityType,
boolean onTop) {
int windowingMode = (options != null)
? options.getLaunchWindowingMode() : WINDOWING_MODE_UNDEFINED;
windowingMode = validateWindowingMode(windowingMode, r, candidateTask, activityType);
return getOrCreateStack(windowingMode, activityType, onTop);
}
<T extends ActivityStack> T getOrCreateStack(int windowingMode, int activityType,
boolean onTop) {
// ...
// [2.1.17 小节]
return createStack(windowingMode, activityType, onTop);
}
2.1.17 ActivityDisplay.createStack
frameworks/base/services/core/java/com/android/server/wm/ActivityDisplay.java
// StackId递增
int getNextStackId() {
return sNextFreeStackId++;
}
<T extends ActivityStack> T createStack(int windowingMode, int activityType, boolean onTop) {
// ...
final int stackId = getNextStackId();
// [2.1.18 小节]
return createStackUnchecked(windowingMode, activityType, stackId, onTop);
}
2.1.18 ActivityDisplay.createStackUnchecked
frameworks/base/services/core/java/com/android/server/wm/ActivityDisplay.java
<T extends ActivityStack> T createStackUnchecked(int windowingMode, int activityType,
int stackId, boolean onTop) {
// 构建了ActivityStack [2.1.19]
return (T) new ActivityStack(this, stackId,
mRootActivityContainer.mStackSupervisor, windowingMode, activityType, onTop);
}
2.1.19 new ActivityStack
frameworks/base/services/core/java/com/android/server/wm/ActivityStack.java
ActivityStack(ActivityDisplay display, int stackId, ActivityStackSupervisor supervisor,
int windowingMode, int activityType, boolean onTop) {
mStackSupervisor = supervisor; // ActivityStackSupervisor
mService = supervisor.mService; // ActivityTaskManagerService
mRootActivityContainer = mService.mRootActivityContainer; // RootActivityContainer
mHandler = new ActivityStackHandler(supervisor.mLooper); // Handler
mWindowManager = mService.mWindowManager; // WindowManagerService
mStackId = stackId; // 赋值mStackId
mCurrentUser = mService.mAmInternal.getCurrentUserId(); // userId
mDisplayId = display.mDisplayId; // 赋值mDisplayId
setActivityType(activityType); // 设置ActivityType
createTaskStack(display.mDisplayId, onTop, mTmpRect2); // 注意 创建了TaskStack [2.1.20 小节]
setWindowingMode(windowingMode, false /* animate */, false /* showRecents */,
false /* enteringSplitScreenMode */, false /* deferEnsuringVisibility */,
true /* creating */); // 设置WindowingMode
display.addChild(this, onTop ? POSITION_TOP : POSITION_BOTTOM); // 注意 调用了ActivityDisplay的addChild方法 [2.1.21 小节]
}
2.1.20 ActivityStack.createTaskStack
frameworks/base/services/core/java/com/android/server/wm/ActivityStack.java
void createTaskStack(int displayId, boolean onTop, Rect outBounds) {
final DisplayContent dc = mWindowManager.mRoot.getDisplayContent(displayId);
if (dc == null) {
throw new IllegalArgumentException("Trying to add stackId=" + mStackId
+ " to unknown displayId=" + displayId);
}
// 构建TaskStack
mTaskStack = new TaskStack(mWindowManager, mStackId, this);
dc.setStackOnDisplay(mStackId, onTop, mTaskStack); // DisplayContent关联TaskStack
// ...
}
2.1.21 ActivityDisplay.addChild
frameworks/base/services/core/java/com/android/server/wm/ActivityDisplay.java
void addChild(ActivityStack stack, int position) {
// 此时position为 POSITION_TOP = Integer.MAX_VALUE
if (position == POSITION_BOTTOM) {
position = 0;
} else if (position == POSITION_TOP) {
position = mStacks.size(); // position修改为mStacks size 也就是栈顶
}
// 主要用来根据ActivityStack的activityType赋值给不同的mStack(mHomeStack/mRecenetsStack/mPinneedStack)
addStackReferenceIfNeeded(stack);
// [2.1.22 小节]
positionChildAt(stack, position);
mService.updateSleepIfNeededLocked();
}
2.1.22 ActivityDisplay.positionChildAt
frameworks/base/services/core/java/com/android/server/wm/ActivityDisplay.java
// 重载方法
private void positionChildAt(ActivityStack stack, int position) {
positionChildAt(stack, position, false /* includingParents */,
null /* updateLastFocusedStackReason */);
}
private void positionChildAt(ActivityStack stack, int position, boolean includingParents,
String updateLastFocusedStackReason) {
// ...
// 获取插入的position
final int insertPosition = getTopInsertPosition(stack, position);
// mStacks是ArrayList<ActivityStack>, 插入到列表中
mStacks.add(insertPosition, stack);
// ...
// 到此算是ActivityStack构建完成,现在返回去看[2.1.12小节]
}
2.1.23 ActivityStack.createTaskRecord
frameworks/base/services/core/java/com/android/server/wm/ActivityStack.java
TaskRecord createTaskRecord(int taskId, ActivityInfo info, Intent intent,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
boolean toTop, ActivityRecord activity, ActivityRecord source,
ActivityOptions options) {
// 调用TaskRecord静态方法create [2.1.24 小节]
final TaskRecord task = TaskRecord.create(
mService, taskId, info, intent, voiceSession, voiceInteractor);
// toTop为true [2.1.26]
addTask(task, toTop, "createTaskRecord");
// ...
// 调用TaskRecord的createTask方法 [2.1.27 小节]
task.createTask(toTop, (info.flags & FLAG_SHOW_FOR_ALL_USERS) != 0);
return task;
}
2.1.24 TaskRecord.create
frameworks/base/services/core/java/com/android/server/wm/TaskRecord.java
static TaskRecordFactory getTaskRecordFactory() {
if (sTaskRecordFactory == null) {
setTaskRecordFactory(new TaskRecordFactory());
}
return sTaskRecordFactory;
}
static void setTaskRecordFactory(TaskRecordFactory factory) {
sTaskRecordFactory = factory;
}
// 最终是通过静态内部类TaskRecordFactory创建的TaskRecord [2.1.25 小节]
static TaskRecord create(ActivityTaskManagerService service, int taskId, ActivityInfo info,
Intent intent, IVoiceInteractionSession voiceSession,
IVoiceInteractor voiceInteractor) {
return getTaskRecordFactory().create(
service, taskId, info, intent, voiceSession, voiceInteractor);
}
2.1.25 TaskRecordFactory.create
frameworks/base/services/core/java/com/android/server/wm/TaskRecord.java
static class TaskRecordFactory {
// 真正构建出TaskRecord,回到[2.1.23 小节]
TaskRecord create(ActivityTaskManagerService service, int taskId, ActivityInfo info,
Intent intent, IVoiceInteractionSession voiceSession,
IVoiceInteractor voiceInteractor) {
return new TaskRecord(
service, taskId, info, intent, voiceSession, voiceInteractor);
}
// ...
}
2.1.26 ActivityStack.addTask
frameworks/base/services/core/java/com/android/server/wm/ActivityStack.java
// 重载方法,添加任务
void addTask(final TaskRecord task, final boolean toTop, String reason) {
// toTop为true,所以传递的是Integer.MAX_VALUE
addTask(task, toTop ? MAX_VALUE : 0, true /* schedulePictureInPictureModeChange */, reason);
if (toTop) {
positionChildWindowContainerAtTop(task);
}
}
void addTask(final TaskRecord task, int position, boolean schedulePictureInPictureModeChange,
String reason) {
// 先从列表中移除,或许列表中没有该task
mTaskHistory.remove(task);
if (isSingleTaskInstance() && !mTaskHistory.isEmpty()) {
throw new IllegalStateException("Can only have one child on stack=" + this);
}
position = getAdjustedPositionForTask(task, position, null /* starting */);
final boolean toTop = position >= mTaskHistory.size();
final ActivityStack prevStack = preAddTask(task, reason, toTop);
mTaskHistory.add(position, task); // 添加到列表中,mTaskHistory是ArrayList
task.setStack(this); // 设置TaskRecord的mStack为当前ActivityStack
updateTaskMovement(task, toTop);
postAddTask(task, prevStack, schedulePictureInPictureModeChange);
}
2.1.27 TaskRecord.createTask
frameworks/base/services/core/java/com/android/server/wm/TaskRecord.java
void createTask(boolean onTop, boolean showForAllUsers) {
// TaskRecord 仅允许创建一个Task对象
if (mTask != null) {
throw new IllegalArgumentException("mTask=" + mTask
+ " already created for task=" + this);
}
final Rect bounds = updateOverrideConfigurationFromLaunchBounds();
final TaskStack stack = getStack().getTaskStack(); // 获取ActivityStack中的TaskStack
if (stack == null) {
throw new IllegalArgumentException("TaskRecord: invalid stack=" + mStack);
}
// 创建一个Task对象, TaskRecord和Task一对一关系
mTask = new Task(taskId, stack, userId, mService.mWindowManager, mResizeMode,
mSupportsPictureInPicture, lastTaskDescription, this);
final int position = onTop ? POSITION_TOP : POSITION_BOTTOM;
// ...
// 调用TaskStack添加Task对象 [2.1.28 小节]
stack.addTask(mTask, position, showForAllUsers, onTop /* moveParents */);
}
2.1.28 TaskStack.addTask
frameworks/base/services/core/java/com/android/server/wm/TaskStack.java
void addTask(Task task, int position, boolean showForAllUsers, boolean moveParents) {
final TaskStack currentStack = task.mStack;
// 检查ActivityStack的mStackId 是否匹配
if (currentStack != null && currentStack.mStackId != mStackId) {
throw new IllegalStateException("Trying to add taskId=" + task.mTaskId
+ " to stackId=" + mStackId
+ ", but it is already attached to stackId=" + task.mStack.mStackId);
}
// 设置Task对象的mStack为当前TaskStack,方便Task找到所属TaskStack
task.mStack = this;
// 由于TaskStack继承了WindowContainer,所以具有addChild方法,最终会添加到父类的mChildren的列表中.
addChild(task, null);
// 移动到指定的position位置中
positionChildAt(position, task, moveParents /* includingParents */, showForAllUsers);
// 最终返回到[2.1.12 小节]
}
2.1.29 ActivityStarter.addOrReparentStartingActivity
frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java
private void addOrReparentStartingActivity(TaskRecord parent, String reason) {
// 由于目前mStartActivity.getTaskRecord还为null,进入if
if (mStartActivity.getTaskRecord() == null || mStartActivity.getTaskRecord() == parent) {
parent.addActivityToTop(mStartActivity); // [2.1.30 小节]
} else {
mStartActivity.reparent(parent, parent.mActivities.size() /* top */, reason);
}
}
2.1.30 TaskRecord.addActivityToTop
frameworks/base/services/core/java/com/android/server/wm/TaskRecord.java
void addActivityToTop(ActivityRecord r) {
// 获取mActivities列表的长度当作index
addActivityAtIndex(mActivities.size(), r);
}
void addActivityAtIndex(int index, ActivityRecord r) {
TaskRecord task = r.getTaskRecord();
if (task != null && task != this) {
throw new IllegalArgumentException("Can not add r=" + " to task=" + this
+ " current parent=" + task);
}
// 设置ActivityRecord的task属性为当前TaskRecord
r.setTask(this);
// 首先删除列表中的r对象,并且它不在列表中且是全屏则计算它
if (!mActivities.remove(r) && r.fullscreen) {
numFullscreen++;
}
// ... 主要设置activityType
final int size = mActivities.size(); // 目前为0
if (index == size && size > 0) {
final ActivityRecord top = mActivities.get(size - 1);
if (top.mTaskOverlay) {
index--;
}
}
index = Math.min(size, index);
// 添加到mActivities列表中,mActivities同样是ArrayList
mActivities.add(index, r);
// ...
}
2.1.31 ActivityStack.startActivityLocked
frameworks/base/services/core/java/com/android/server/wm/ActivityStack.java
void startActivityLocked(ActivityRecord r, ActivityRecord focusedTopActivity,
boolean newTask, boolean keepCurTransition, ActivityOptions options) {
TaskRecord rTask = r.getTaskRecord(); //此处TaskRecord为先前创建的TaskRecord
final int taskId = rTask.taskId;
if (!r.mLaunchTaskBehind && (taskForIdLocked(taskId) == null || newTask)) {
// 把TaskRecord插入到当前mTaskHistory栈顶
insertTaskAtTop(rTask, r);
}
TaskRecord task = null;
// 由[2.1.11 小节]可知newTask为true
if (!newTask) {
// ..
}
final TaskRecord activityTask = r.getTaskRecord();
// ...
task = activityTask;
// 首次ActivityRecord.mAppWindowToken为null
if (r.mAppWindowToken == null) {
// [2.1.32 小节]
r.createAppWindowToken();
}
// ...
}
2.1.32 ActivityRecord.createAppWindowToken
frameworks/base/services/core/java/com/android/server/wm/ActivityRecord.java
void createAppWindowToken() {
// 如果存在则抛出异常
if (mAppWindowToken != null) {
throw new IllegalArgumentException("App Window Token=" + mAppWindowToken
+ " already created for r=" + this);
}
inHistory = true;
// ...
// appToken为ActivityRecord构造函数中创建的IBinder对象
mAppWindowToken = mAtmService.mWindowManager.mRoot.getAppWindowToken(appToken.asBinder());// 返回为null
if (mAppWindowToken != null) {
Slog.w(TAG, "Attempted to add existing app token: " + appToken);
} else {
// 确认是否有Task
final Task container = task.getTask();
if (container == null) {
throw new IllegalArgumentException("createAppWindowToken: invalid task =" + task);
}
// [2.1.33 小节]
mAppWindowToken = createAppWindow(mAtmService.mWindowManager, appToken,
task.voiceSession != null, container.getDisplayContent(),
ActivityTaskManagerService.getInputDispatchingTimeoutLocked(this)
* 1000000L, fullscreen,
(info.flags & FLAG_SHOW_FOR_ALL_USERS) != 0, appInfo.targetSdkVersion,
info.screenOrientation, mRotationAnimationHint,
mLaunchTaskBehind, isAlwaysFocusable());
// ...
// 由于Task继承WindowContainer,所以具备addChild,最终也是放入父类的mChildren列表中
container.addChild(mAppWindowToken, Integer.MAX_VALUE /* add on top */);
}
// 再一次调用TaskRecord的addActivityToTop [2.1.30 小节]
task.addActivityToTop(this);
// ...
// 返回[2.1.11 小节]
}
2.1.33 ActivityRecord.createAppWindow
frameworks/base/services/core/java/com/android/server/wm/ActivityRecord.java
AppWindowToken createAppWindow(WindowManagerService service, IApplicationToken token,
boolean voiceInteraction, DisplayContent dc, long inputDispatchingTimeoutNanos,
boolean fullscreen, boolean showForAllUsers, int targetSdk, int orientation,
int rotationAnimationHint, boolean launchTaskBehind,
boolean alwaysFocusable) {
// token为ActivityRecord中的appToken属性
return new AppWindowToken(service, token, mActivityComponent, voiceInteraction, dc,
inputDispatchingTimeoutNanos, fullscreen, showForAllUsers, targetSdk, orientation,
rotationAnimationHint, launchTaskBehind, alwaysFocusable,
this);
// 返回[2.1.32 小节]
}
2.1.34 RootActivityContainer.resumeFocusedStacksTopActivities
frameworks/base/services/core/java/com/android/server/wm/RootActivityContainer.java
boolean resumeFocusedStacksTopActivities(
ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
// ...
boolean result = false;
if (targetStack != null && (targetStack.isTopStackOnDisplay()
|| getTopDisplayFocusedStack() == targetStack)) {
// 调用ActivityStack方法 [2.1.35 小节]
result = targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
}
// ...
return result;
}
2.1.35 ActivityStack.resumeTopActivityUncheckedLocked
frameworks/base/services/core/java/com/android/server/wm/ActivityStack.java
boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
// 避免重复调用
if (mInResumeTopActivity) {
return false;
}
boolean result = false;
try {
mInResumeTopActivity = true;
// [2.1.36 小节]
result = resumeTopActivityInnerLocked(prev, options);
// ...
} finally {
mInResumeTopActivity = false;
}
return result;
}
2.1.36 ActivityStack.resumeTopActivityInnerLocked
frameworks/base/services/core/java/com/android/server/wm/ActivityStack.java
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
if (!mService.isBooting() && !mService.isBooted()) {
// AMS 未启动
return false;
}
// 参数prev是上一个ActivityRecord
// 找到栈顶可获得焦点的ActivityRecord,也就是目前准备启动的ActivityRecord
ActivityRecord next = topRunningActivityLocked(true /* focusableOnly */);
final boolean hasRunningActivity = next != null; // true
if (hasRunningActivity && !isAttached()) {
return false;
}
// ...
final ActivityDisplay display = getDisplay();
// ...
if (DEBUG_SWITCH) Slog.v(TAG_SWITCH, "Resuming " + next);
// ...
// 先把当前resumed状态的ActivityRecord设置为pause状态[2.1.37]
boolean pausing = getDisplay().pauseBackStacks(userLeaving, next, false);
// ...
当执行完Pause动作后[2.1.55 小节],再次调用了此函数,此时pausing为false
最终会调用startSpecificActivityLocked
if (pausing && !resumeWhilePausing) {
// 先执行上一个pause动作,中断这次resume动作
// ...
return true;
} else if (mResumedActivity == next && next.isState(RESUMED)
&& display.allResumedActivitiesComplete()) {
// ...
return true;
}
//...
if (next.attachedToProcess()) { // false
// ...
} else {
// 没有进程关联,创建新的进程 [2.1.56 小节]
mStackSupervisor.startSpecificActivityLocked(next, true, true);
}
return true;
}
2.1.37 ActivityDisplay.pauseBackStacks
frameworks/base/services/core/java/com/android/server/wm/ActivityDisplay.java
boolean pauseBackStacks(boolean userLeaving, ActivityRecord resuming, boolean dontWait) { // dontWait为false
boolean someActivityPaused = false;
for (int stackNdx = mStacks.size() - 1; stackNdx >= 0; --stackNdx) {
// 遍历所有ActivityStack
final ActivityStack stack = mStacks.get(stackNdx);
// 取出当前ActivityStack中为resumed状态的ActivityRecord
final ActivityRecord resumedActivity = stack.getResumedActivity();
if (resumedActivity != null
&& (stack.getVisibility(resuming) != STACK_VISIBILITY_VISIBLE
|| !stack.isFocusable())) {
// 执行pause [2.1.38 小节]
someActivityPaused |= stack.startPausingLocked(userLeaving, false, resuming,
dontWait);
}
}
return someActivityPaused;
}
2.1.38 ActivityStack.startPausingLocked
frameworks/base/services/core/java/com/android/server/wm/ActivityStack.java
final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping,
ActivityRecord resuming, boolean pauseImmediately) { // pauseImmediately为false
// 准备执行pause的Activity
ActivityRecord prev = mResumedActivity;
if (prev == null) {
if (resuming == null) {
// 当两个Activity都是null,则让RootActivityContainer获取焦点Activity执行resume操作
mRootActivityContainer.resumeFocusedStacksTopActivities();
}
// 如果执行pause的activity为空,不做处理并且返回false
return false;
}
// 准备执行pause的Activity和准备执行resume的Activity一致,直接返回false
if (prev == resuming) {
return false;
}
// 记录下被pause的Activity
mPausingActivity = prev;
mLastPausedActivity = prev;
mLastNoHistoryActivity = (prev.intent.getFlags() & Intent.FLAG_ACTIVITY_NO_HISTORY) != 0
|| (prev.info.flags & ActivityInfo.FLAG_NO_HISTORY) != 0 ? prev : null;
// 更改Activity状态为PAUSING
prev.setState(PAUSING, "startPausingLocked");
// ...
if (prev.attachedToProcess()) { // 进程存在
try {
// 获取ClientLifecycleManager对象后调用scheduleTransaction方法 [2.1.39 小节]
// 注意参数3为PauseActivityItem
mService.getLifecycleManager().scheduleTransaction(prev.app.getThread(),
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;
}
// ...
if (mPausingActivity != null) {
// ...
if (pauseImmediately) { // pauseImmediately为false
completePauseLocked(false, resuming); // 完成pause
return false;
} else {
// 当前执行的是这
schedulePauseTimeout(prev);
return true;
}
} else {
// mPausingActivity 为空说明为执行pause动作或者是执行异常了.
// 那么还是调用以下执行resume的方法
if (resuming == null) {
mRootActivityContainer.resumeFocusedStacksTopActivities();
}
return false;
}
}
2.1.39 ClientLifecycleManager.scheduleTransaction
frameworks/base/services/core/java/com/android/server/wm/ClientLifecycleManager.java
void scheduleTransaction(@NonNull IApplicationThread client, @NonNull IBinder activityToken,
@NonNull ActivityLifecycleItem stateRequest) throws RemoteException {
// 调用当前类中的静态方法 transactionWithState,当前类静态方法还有一个transactionWithCallback
final ClientTransaction clientTransaction = transactionWithState(client, activityToken,
stateRequest);
// 还是调用当前类的重载方法
scheduleTransaction(clientTransaction);
}
void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
final IApplicationThread client = transaction.getClient();
transaction.schedule(); // 执行 [2.1.40 小节]
if (!(client instanceof Binder)) { // 如果client不是Binder对象
transaction.recycle(); // ClientTransaction回收
}
}
private static ClientTransaction transactionWithState(@NonNull IApplicationThread client,
@NonNull IBinder activityToken, @NonNull ActivityLifecycleItem stateRequest) {
// 构造出ClientTransaction [2.1.40 小节]
final ClientTransaction clientTransaction = ClientTransaction.obtain(client, activityToken);
clientTransaction.setLifecycleStateRequest(stateRequest);
return clientTransaction;
}
2.1.40 ClientTransaction.schedule和obtain
frameworks/base/core/java/android/app/servertransaction/ClientTransaction.java
public static ClientTransaction obtain(IApplicationThread client, IBinder activityToken) {
ClientTransaction instance = ObjectPool.obtain(ClientTransaction.class); // 利用了对象复用机制
if (instance == null) {
instance = new ClientTransaction();
}
instance.mClient = client; // 把client赋值给mClient变量了
instance.mActivityToken = activityToken; // 把activityToken赋值给mActivityToken了
return instance;
}
public void schedule() throws RemoteException {
// 调用了IApplicationThread的scheduleTransaction,执行了HIDL Binder跨进程调用
// 具体实现在ActivityThread类的ApplicationThread内部类中 [2.1.41 小节]
mClient.scheduleTransaction(this);
}
2.1.41 IApplicationThread.scheduleTransaction
frameworks/base/core/java/android/app/ActivityThread.java
frameworks/base/core/java/android/app/ClientTransactionHandler.java
@Override
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
// 最终调用了外部类的ActivityThread的scheduleTransaction方法
// 由于ActivityThread继承了ClientTransactionHandler抽象类,该类实现了scheduleTransaction
ActivityThread.this.scheduleTransaction(transaction);
}
// ClientTransactionHandler.java
void scheduleTransaction(ClientTransaction transaction) {
transaction.preExecute(this); // 真正执行前的一次调用preExecute [2.1.42 小节]
// 给ActivityThread中的变量为mH的Handle发送消息 [2.1.43]
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
2.1.42 ClientTransaction.preExecute
frameworks/base/core/java/android/app/servertransaction/ClientTransaction.java
public void preExecute(android.app.ClientTransactionHandler clientTransactionHandler) {
// mActivityCallbacks是一个List,可以通知多个监听者执行preExecute,此次mActivityCallbacks为空,没有监听者
if (mActivityCallbacks != null) {
final int size = mActivityCallbacks.size();
for (int i = 0; i < size; ++i) {
mActivityCallbacks.get(i).preExecute(clientTransactionHandler, mActivityToken);
}
}
// mLifecycleStateRequest是ActivityLifecycleItem对象,当前该值是在[2.1.38 小节]构建的PauseActivityItem
// PauseActivityItem是ActivityLifecycleItem子类
// ActivityLifecycleItem是ClientTransactionItem的子类
// ClientTransactionItem是BaseClientRequest的子类
// BaseClientRequest是接口,定义了三个接口preExecute(执行前),execute(执行中),postExecute(执行后)
// 其中preExecute和postExecute声明了default子类可以不实现,execute未声明需要子类实现
// PauseActivityItem 未实现 preExecute
if (mLifecycleStateRequest != null) {
mLifecycleStateRequest.preExecute(clientTransactionHandler, mActivityToken);
}
}
2.1.43 ActivityThread$H.handleMessage
frameworks/base/core/java/android/app/ActivityThread.java
public void handleMessage(Message msg) {
switch (msg.what) {
// ...
case EXECUTE_TRANSACTION:
final ClientTransaction transaction = (ClientTransaction) msg.obj;
// mTransactionExecutor是TransactionExecutor的实例对象. [2.1.44 小节]
mTransactionExecutor.execute(transaction);
if (isSystem()) {
// 系统进程执行回收
transaction.recycle();
}
break;
// ...
}
}
2.1.44 TransactionExecutor.execute
frameworks/base/core/java/android/app/servertransaction/TransactionExecutor.java
public void execute(ClientTransaction transaction) {
final IBinder token = transaction.getActivityToken(); // ActivityRecord.appToken属性
// ...
executeCallbacks(transaction); // 从[2.1.38-2.1.40小节中可以看见没有添加callbacks], 后面再LaunchActivityItem中进行分析
executeLifecycleState(transaction); // 此次主要是关注这里 [2.1.45 小节]
// ...
}
2.1.45 TransactionExecutor.executeLifecycleState
frameworks/base/core/java/android/app/servertransaction/TransactionExecutor.java
private void executeLifecycleState(ClientTransaction transaction) {
final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
// 由前面分析可知,此处lifecycleItem为PauseActivityItem
if (lifecycleItem == null) {
return;
}
final IBinder token = transaction.getActivityToken();
// 等等ActivityClientRecord是从哪来的?
// 首先mTransactionHandler是ActivityThread, ActivityThread实现了getActivityClient
// 通过属性mActivities列表获取的,这里mActivities其实是在启动的时候添加进去的,后面具体分析
final ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
if (r == null) { // 此处不为null
return;
}
// 循环到最终请求状态之前的状态。
// 在此处由于excludeLastState为true,所以没有处理任何事情,后续会出现具体作用再进行分析
cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */, transaction);
// 在[2.1.41 小节]我们看见调用了preExecute,这里接着调用了PauseActivityItem的execute和postExecute
// 参数一传递了ActivityThread [2.1.46 小节]
lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
// 经过[2.1.46 - 2.1.51 小节]的调用后回到这里执行postExecute [2.1.52 小节]
lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
}
2.1.46 PauseActivityItem.execute
frameworks/base/core/java/android/app/servertransaction/PauseActivityItem.java
@Override
public void execute(ClientTransactionHandler client, IBinder token,
PendingTransactionActions pendingActions) {
// client为ActivityThread,所以调用的是ActivityThread的handlePauseActivity方法 [2.1.47 小节]
client.handlePauseActivity(token, mFinished, mUserLeaving, mConfigChanges, pendingActions,
"PAUSE_ACTIVITY_ITEM");
}
2.1.47 ActivityThread.handlePauseActivity
frameworks/base/core/java/android/app/ActivityThread.java
@Override
public void handlePauseActivity(IBinder token, boolean finished, boolean userLeaving,
int configChanges, PendingTransactionActions pendingActions, String reason) {
ActivityClientRecord r = mActivities.get(token); // mActivities具体是启动Activity中添加的,后续详细分析
if (r != null) {
// 目前还没搞清userLeaving具体起作用,先略过,不影响主线流程
if (userLeaving) {
performUserLeavingActivity(r);
}
// ...
// 主要关注这里, [2.1.48 小节]
performPauseActivity(r, finished, reason, pendingActions);
// ...
mSomeActivitiesChanged = true;
}
}
2.1.48 ActivityThread.performPauseActivity
frameworks/base/core/java/android/app/ActivityThread.java
private Bundle performPauseActivity(ActivityClientRecord r, boolean finished, String reason,
PendingTransactionActions pendingActions) {
if (r.paused) {
if (r.activity.mFinished) {
// 如果此前已经是paused和finish状态我们则不执行任何处理,直接返回
return null;
}
// 如果此前已经是paused,并没有finish,则输出异常信息
RuntimeException e = new RuntimeException(
"Performing pause of activity that is not resumed: "
+ r.intent.getComponent().toShortString());
Slog.e(TAG, e.getMessage(), e);
}
// finished为false
if (finished) {
r.activity.mFinished = true;
}
// 如果此前没有finish,并且targetSdkVersion小于11, 显然不成立
final boolean shouldSaveState = !r.activity.mFinished && r.isPreHoneycomb();
if (shouldSaveState) {
callActivityOnSaveInstanceState(r);
}
// [2.1.49 小节]
performPauseActivityIfNeeded(r, reason);
// 通知监听者
ArrayList<OnActivityPausedListener> listeners;
synchronized (mOnPauseListeners) {
listeners = mOnPauseListeners.remove(r.activity);
}
int size = (listeners != null ? listeners.size() : 0);
for (int i = 0; i < size; i++) {
listeners.get(i).onPaused(r.activity);
}
// ...
// 返回null
return shouldSaveState ? r.state : null;
}
2.1.49 ActivityThread.performPauseActivityIfNeeded
private void performPauseActivityIfNeeded(ActivityClientRecord r, String reason) {
if (r.paused) {
// 已经是paused状态,不需要任何处理了
return;
}
// ...
try {
r.activity.mCalled = false;
// mInstrumentation和[2.1.2小节]启动是相同的对象 [2.1.50 小节]
mInstrumentation.callActivityOnPause(r.activity);
if (!r.activity.mCalled) {
throw new SuperNotCalledException("Activity " + safeToComponentShortString(r.intent)
+ " did not call through to super.onPause()");
}
} catch (SuperNotCalledException e) {
throw e;
} catch (Exception e) {
if (!mInstrumentation.onException(r.activity, e)) {
throw new RuntimeException("Unable to pause activity "
+ safeToComponentShortString(r.intent) + ": " + e.toString(), e);
}
}
// 最后把Activity状态标记为ON_PAUSE
r.setState(ON_PAUSE);
}
2.1.50 Instrumentation.callActivityOnPause
frameworks/base/core/java/android/app/Instrumentation.java
public void callActivityOnPause(Activity activity) {
// 可以看见该函数比较简单,只是调用了activity的performPause [2.1.51]
activity.performPause();
}
2.1.51 Activity.performPause
frameworks/base/core/java/android/app/Activity.java
final void performPause() {
// 转发Activity的Paused之前的状态
dispatchActivityPrePaused();
mDoReportFullyDrawn = false;
mFragments.dispatchPause(); // 给对应Fragment转发pause事件
mCalled = false;
onPause(); // 执行当前Activity的onPause回调,也是我们熟知的Activity生命周期之一
mResumed = false;
// 可以看见mCalled被设置为false,且targetSdkVersion也大于9
// 那么是不是肯定会抛出异常呢? 答案是否定的,因为在mCalled赋值为false后,接着调用了onPause方法
// onPause会把mCalled赋值为true,也就是说默认是不会抛出异常的
// 但是如果你的Activity重写了onPause却没有调用super.onPause()是会抛出异常的
if (!mCalled && getApplicationInfo().targetSdkVersion
>= android.os.Build.VERSION_CODES.GINGERBREAD) {
throw new SuperNotCalledException(
"Activity " + mComponent.toShortString() +
" did not call through to super.onPause()");
}
dispatchActivityPostPaused(); // 转发Activity已经Paused的状态
// 自此我们PauseActivityItem的execute已经完成
// 接下来我们回到[2.1.45 小节]
}
2.1.52 PauseActivityItem.postExecute
frameworks/base/core/java/android/app/servertransaction/PauseActivityItem.java
@Override
public void postExecute(ClientTransactionHandler client, IBinder token,
PendingTransactionActions pendingActions) {
if (mDontReport) { // 此处mDontReport为false
return;
}
try {
// 目前所在进程是Launcher
// 通过AIDI跨进程调用了ATMS的activityPaused方法 [2.1.53 小节]
ActivityTaskManager.getService().activityPaused(token);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
2.1.53 ActivityTaskManagerService.activityPaused
frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
@Override
public final void activityPaused(IBinder token) {
final long origId = Binder.clearCallingIdentity();
synchronized (mGlobalLock) {
// 首先通过token获取当前的ActivityRecord再通过ActivityRecord获取所在ActivityStack
// 其实ActivityRecord在构造函数中创建了Token对象,并且Token通过弱引用持有了ActivityRecord
ActivityStack stack = ActivityRecord.getStackLocked(token);
if (stack != null) {
// 调用ActivityStack的activityPausedLocked [2.1.54 小节]
stack.activityPausedLocked(token, false);
}
}
Binder.restoreCallingIdentity(origId);
}
2.1.54 ActivityStack.activityPausedLocked
frameworks/base/services/core/java/com/android/server/wm/ActivityStack.java
final void activityPausedLocked(IBinder token, boolean timeout) {
// 通过Token取出ActivityRecord
final ActivityRecord r = isInStackLocked(token);
if (r != null) {
// 在[2.1.39小节]中发送了延长500ms的消息,如果执行pause动作超出500ms则会在/data/anr/app_slow记录下时间等关键信息
// 此时已经执行完onPause生命周期所以可以移除该Message
mHandler.removeMessages(PAUSE_TIMEOUT_MSG, r);
if (mPausingActivity == r) { // mPausingActivity是在[2.1.38小节]被赋值的,此处为true
mService.mWindowManager.deferSurfaceLayout();
try {
// [2.1.55 小节] resumeNext为true,resumingActivity为null
completePauseLocked(true /* resumeNext */, null /* resumingActivity */);
} finally {
mService.mWindowManager.continueSurfaceLayout();
}
return;
} else {
// ...
}
}
// ...
}
2.1.55 ActivityStack.completePauseLocked
frameworks/base/services/core/java/com/android/server/wm/ActivityStack.java
private void completePauseLocked(boolean resumeNext, ActivityRecord resuming) {
ActivityRecord prev = mPausingActivity;
if (prev != null) {
prev.setWillCloseOrEnterPip(false);
final boolean wasStopping = prev.isState(STOPPING);
prev.setState(PAUSED, "completePausedLocked"); // 设置ActivityRecord设置为PAUSED状态
// ...
// mPausingActivity 赋值为null
mPausingActivity = null;
}
if (resumeNext) { // true
final ActivityStack topStack = mRootActivityContainer.getTopDisplayFocusedStack();
// topStack.shouldSleepOrShutDownActivities 一般情况下是false, 执行if
if (!topStack.shouldSleepOrShutDownActivities()) {
// 继续执行resumeFocusedStacksTopActivities [2.1.34 - 2.1.36 小节]
mRootActivityContainer.resumeFocusedStacksTopActivities(topStack, prev, null);
} else {
// ...
}
}
// ...
}
2.1.56 ActivityStackSupervisor.startSpecificActivityLocked
frameworks/base/services/core/java/com/android/server/wm/ActivityStackSupervisor.java
void startSpecificActivityLocked(ActivityRecord r, boolean andResume, boolean checkConfig) {
// Is this activity's application already running?
final WindowProcessController wpc =
mService.getProcessController(r.processName, r.info.applicationInfo.uid);
if (DEBUG_STACK) {
Slog.d(TAG, "startSpecificActivityLocked wpc hasThread:" + (wpc != null
&& wpc.hasThread()));
}
boolean knownToBeDead = false;
if (wpc != null && wpc.hasThread()) { // 此时wpc为null
try {
realStartActivityLocked(r, wpc, andResume, checkConfig);
return;
} catch (RemoteException e) {
Slog.w(TAG, "Exception when starting activity "
+ r.intent.getComponent().flattenToShortString(), e);
}
knownToBeDead = true;
}
// ...
try {
// 此处利用了lambda表达式,再通过Handler发送消息处理
// 最终会调用ActivityManagerService的内部类中LocalService的startProcess方法 [2.1.57 小节]
// 具体包装的Lambda函数,可以参考aosp源码
final Message msg = PooledLambda.obtainMessage(
ActivityManagerInternal::startProcess, mService.mAmInternal, r.processName,
r.info.applicationInfo, knownToBeDead, "activity", r.intent.getComponent());
mService.mH.sendMessage(msg);
} finally {
Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}
}
2.1.57 ActivityManagerService$LocalService.startProcess
frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
@Override
public void startProcess(String processName, ApplicationInfo info,
boolean knownToBeDead, String hostingType, ComponentName hostingName) {
try {
// ... trace
synchronized (ActivityManagerService.this) {
// 内部类调用外部类方法 [2.1.58 小节]
startProcessLocked(processName, info, knownToBeDead, 0 /* intentFlags */,
new HostingRecord(hostingType, hostingName),
false /* allowWhileBooting */, false /* isolated */,
true /* keepIfLarge */);
}
} finally {
// ... trace
}
}
2.1.58 ActivityManagerService.startProcessLocked
frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
final ProcessRecord startProcessLocked(String processName,
ApplicationInfo info, boolean knownToBeDead, int intentFlags,
HostingRecord hostingRecord, boolean allowWhileBooting,
boolean isolated, boolean keepIfLarge) {
// mProcessList 为ProcessList实例对象 [2.1.59 小节]
return mProcessList.startProcessLocked(processName, info, knownToBeDead, intentFlags,
hostingRecord, allowWhileBooting, isolated, 0 /* isolatedUid */, keepIfLarge,
null /* ABI override */, null /* entryPoint */, null /* entryPointArgs */,
null /* crashHandler */);
}
2.1.59 ProcessList.startProcessLocked
frameworks/base/services/core/java/com/android/server/am/ProcessList.java
2.1.59.1 startProcessLocked
final ProcessRecord startProcessLocked(String processName, ApplicationInfo info,
boolean knownToBeDead, int intentFlags, HostingRecord hostingRecord,
boolean allowWhileBooting, boolean isolated, int isolatedUid, boolean keepIfLarge,
String abiOverride, String entryPoint, String[] entryPointArgs, Runnable crashHandler) {
long startTime = SystemClock.elapsedRealtime();
ProcessRecord app;
if (!isolated) { // isolated为false
app = getProcessRecordLocked(processName, info.uid, keepIfLarge);
// app 为null
} else {
app = null;
}
// ...
if (app == null) {
// [2.1.60 小节]
app = newProcessRecordLocked(info, processName, isolated, isolatedUid, hostingRecord);
// 经过[2.1.60 - 2.1.61 小节]后返回了ProcessRecord
if (app == null) {
Slog.w(TAG, "Failed making new process record for "
+ processName + "/" + info.uid + " isolated=" + isolated);
return null;
}
app.crashHandler = crashHandler;
app.isolatedEntryPoint = entryPoint;
app.isolatedEntryPointArgs = entryPointArgs;
} else {
// ...
}
// ...
// 最后调用startProcessLocked [2.1.59.2 小节]
final boolean success = startProcessLocked(app, hostingRecord, abiOverride);
// ...
return success ? app : null;
}
2.1.59.2 startProcessLocked
final boolean startProcessLocked(ProcessRecord app, HostingRecord hostingRecord,
String abiOverride) {
// [2.1.59.3 小节]
return startProcessLocked(app, hostingRecord,
false /* disableHiddenApiChecks */, false /* mountExtStorageFull */, abiOverride);
}
2.1.59.3 startProcessLocked
boolean startProcessLocked(ProcessRecord app, HostingRecord hostingRecord,
boolean disableHiddenApiChecks, boolean mountExtStorageFull,
String abiOverride) {
if (app.pendingStart) { // 默认为false
return true;
}
long startTime = SystemClock.elapsedRealtime();
// 此时pid默认为-1
if (app.pid > 0 && app.pid != ActivityManagerService.MY_PID) {
// ...
}
// ...
try {
// ...
int uid = app.uid; // uid
int[] gids = null; // groupid列表
int mountExternal = Zygote.MOUNT_EXTERNAL_NONE;
if (!app.isolated) { // false
int[] permGids = null;
try {
final IPackageManager pm = AppGlobals.getPackageManager();
// 通过PM获取权限所需要的GroupId类别
permGids = pm.getPackageGids(app.info.packageName,
MATCH_DIRECT_BOOT_AUTO, app.userId);
if (StorageManager.hasIsolatedStorage() && mountExtStorageFull) {
mountExternal = Zygote.MOUNT_EXTERNAL_FULL;
} else {
StorageManagerInternal storageManagerInternal = LocalServices.getService(
StorageManagerInternal.class);
mountExternal = storageManagerInternal.getExternalStorageMountMode(uid,
app.info.packageName);
}
} catch (RemoteException e) {
throw e.rethrowAsRuntimeException();
}
if (ArrayUtils.isEmpty(permGids)) {
gids = new int[3]; // 默认拥有共享权限,缓存权限,user权限
} else {
gids = new int[permGids.length + 3]; // 在应用其它权限基础上添加默认3中权限
System.arraycopy(permGids, 0, gids, 3, permGids.length);
}
gids[0] = UserHandle.getSharedAppGid(UserHandle.getAppId(uid)); // 共享权限
gids[1] = UserHandle.getCacheAppGid(UserHandle.getAppId(uid)); // 缓存权限
gids[2] = UserHandle.getUserGid(UserHandle.getUserId(uid)); // 用户权限
// 替换无效的GID
if (gids[0] == UserHandle.ERR_GID) gids[0] = gids[2];
if (gids[1] == UserHandle.ERR_GID) gids[1] = gids[2];
}
app.mountMode = mountExternal;
// ...
int runtimeFlags = 0; // 运行的Flags
if ((app.info.flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0) {
// 如果应用开启了DEBUGGABLE,则添加以下Flag
runtimeFlags |= Zygote.DEBUG_ENABLE_JDWP;
runtimeFlags |= Zygote.DEBUG_JAVA_DEBUGGABLE;
runtimeFlags |= Zygote.DEBUG_ENABLE_CHECKJNI;
// 检查是否进行开启ART
if (android.provider.Settings.Global.getInt(mService.mContext.getContentResolver(),
android.provider.Settings.Global.ART_VERIFIER_VERIFY_DEBUGGABLE, 1) == 0) {
runtimeFlags |= Zygote.DISABLE_VERIFIER;
}
}
// ... 根据系统属性或应用配置 添加一些runtimeFlags
String invokeWith = null; // 执行脚本命令 一般为null
if ((app.info.flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0) {
// 应用开启了DEBUG之后, 查看是否包含wrap.sh脚本文件
String wrapperFileName = app.info.nativeLibraryDir + "/wrap.sh";
StrictMode.ThreadPolicy oldPolicy = StrictMode.allowThreadDiskReads();
try {
if (new File(wrapperFileName).exists()) {
invokeWith = "/system/bin/logwrapper " + wrapperFileName;
}
} finally {
StrictMode.setThreadPolicy(oldPolicy);
}
}
// ...
final String entryPoint = "android.app.ActivityThread";
// 参数二为 "android.app.ActivityThread" [2.1.59.4 小节]
return startProcessLocked(hostingRecord, entryPoint, app, uid, gids,
runtimeFlags, mountExternal, seInfo, requiredAbi, instructionSet, invokeWith,
startTime);
} catch (RuntimeException e) {
// ...
return false;
}
}
2.1.59.4 startProcessLocked
boolean startProcessLocked(HostingRecord hostingRecord,
String entryPoint,
ProcessRecord app, int uid, int[] gids, int runtimeFlags, int mountExternal,
String seInfo, String requiredAbi, String instructionSet, String invokeWith,
long startTime) {
// 恢复一些ProcessRecord得属性值
app.pendingStart = true;
app.killedByAm = false;
app.removed = false;
app.killed = false;
final long startSeq = app.startSeq = ++mProcStartSeqCounter;
app.setStartParams(uid, hostingRecord, seInfo, startTime);
app.setUsingWrapper(invokeWith != null
|| SystemProperties.get("wrap." + app.processName) != null);
mPendingStarts.put(startSeq, app);
if (mService.mConstants.FLAG_PROCESS_START_ASYNC) {
// 异步启动, AMS配置是异步启动
mService.mProcStartHandler.post(() -> {
try {
// [2.1.62 小节]
final Process.ProcessStartResult startResult = startProcess(app.hostingRecord,
entryPoint, app, app.startUid, gids, runtimeFlags, mountExternal,
app.seInfo, requiredAbi, instructionSet, invokeWith, app.startTime);
// 经过[2.1.62 - 2.1.68 小节]的调用后取得启动结果包含pid
synchronized (mService) {
// [2.1.69 小节]
handleProcessStartedLocked(app, startResult, startSeq);
}
} catch (RuntimeException e) {
synchronized (mService) {
Slog.e(ActivityManagerService.TAG, "Failure starting process "
+ app.processName, e);
mPendingStarts.remove(startSeq);
app.pendingStart = false;
mService.forceStopPackageLocked(app.info.packageName,
UserHandle.getAppId(app.uid),
false, false, true, false, false, app.userId, "start failure");
}
}
});
return true;
} else {
// ...
return app.pid > 0;
}
}
2.1.60 ProcessList.newProcessRecordLocked
frameworks/base/services/core/java/com/android/server/am/ProcessList.java
final ProcessRecord newProcessRecordLocked(ApplicationInfo info, String customProcess,
boolean isolated, int isolatedUid, HostingRecord hostingRecord) {
String proc = customProcess != null ? customProcess : info.processName;
final int userId = UserHandle.getUserId(info.uid);
int uid = info.uid;
if (isolated) { // false
// ...
}
// 构建了ProcessRecord
final ProcessRecord r = new ProcessRecord(mService, info, proc, uid);
// ...
// [2.1.61 小节]
addProcessNameLocked(r);
return r;
}
2.1.61 ProcessList.addProcessNameLocked
frameworks/base/services/core/java/com/android/server/am/ProcessList.java
final void addProcessNameLocked(ProcessRecord proc) {
// ...
UidRecord uidRec = mActiveUids.get(proc.uid);
if (uidRec == null) { // true
// 构建了UidRecord
uidRec = new UidRecord(proc.uid);
// ...
// mActiveUids是ActiveUids实例对象,内部使用SparseArray记录
mActiveUids.put(proc.uid, uidRec);
// ...
}
// 设置proc的uidRecord
proc.uidRecord = uidRec;
// ...
// mProcessNames是MyProcessMap实例对象,继承ProcessMap,内部采用了ArrayMap+SparseArray数据结构记录
mProcessNames.put(proc.processName, proc.uid, proc);
// ...
// 回到[2.1.59 小节]
}
2.1.62 ProcessList.startProcess
frameworks/base/services/core/java/com/android/server/am/ProcessList.java
private Process.ProcessStartResult startProcess(HostingRecord hostingRecord, String entryPoint,
ProcessRecord app, int uid, int[] gids, int runtimeFlags, int mountExternal,
String seInfo, String requiredAbi, String instructionSet, String invokeWith,
long startTime) {
try {
// ...
final Process.ProcessStartResult startResult;
if (hostingRecord.usesWebviewZygote()) { // 使用WebviewZygote
startResult = startWebView(entryPoint,
app.processName, uid, uid, gids, runtimeFlags, mountExternal,
app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
app.info.dataDir, null, app.info.packageName,
new String[] {PROC_START_SEQ_IDENT + app.startSeq});
} else if (hostingRecord.usesAppZygote()) { // 使用AppZygote
final AppZygote appZygote = createAppZygoteForProcessIfNeeded(app);
startResult = appZygote.getProcess().start(entryPoint,
app.processName, uid, uid, gids, runtimeFlags, mountExternal,
app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
app.info.dataDir, null, app.info.packageName,
/*useUsapPool=*/ false,
new String[] {PROC_START_SEQ_IDENT + app.startSeq});
} else { // 使用默认Zygote
// 当前执行的是默认Zygote [2.1.63 小节]
startResult = Process.start(entryPoint,
app.processName, uid, uid, gids, runtimeFlags, mountExternal,
app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
app.info.dataDir, invokeWith, app.info.packageName,
new String[] {PROC_START_SEQ_IDENT + app.startSeq});
}
// ...
return startResult;
} finally {
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
}
}
2.1.63 Process.start
frameworks/base/core/java/android/os/Process.java
public static final ZygoteProcess ZYGOTE_PROCESS = new ZygoteProcess();
public static ProcessStartResult start(@NonNull final String processClass,
@Nullable final String niceName,
int uid, int gid, @Nullable int[] gids,
int runtimeFlags,
int mountExternal,
int targetSdkVersion,
@Nullable String seInfo,
@NonNull String abi,
@Nullable String instructionSet,
@Nullable String appDataDir,
@Nullable String invokeWith,
@Nullable String packageName,
@Nullable String[] zygoteArgs) {
// 调用ZygoteProcess.start [2.1.64 小节]
// processClasss为"android.app.ActivityThread"
return ZYGOTE_PROCESS.start(processClass, niceName, uid, gid, gids,
runtimeFlags, mountExternal, targetSdkVersion, seInfo,
abi, instructionSet, appDataDir, invokeWith, packageName,
/*useUsapPool=*/ true, zygoteArgs);
}
2.1.64 ZygoteProcess.start
public final Process.ProcessStartResult start(@NonNull final String processClass,
final String niceName,
int uid, int gid, @Nullable int[] gids,
int runtimeFlags, int mountExternal,
int targetSdkVersion,
@Nullable String seInfo,
@NonNull String abi,
@Nullable String instructionSet,
@Nullable String appDataDir,
@Nullable String invokeWith,
@Nullable String packageName,
boolean useUsapPool,
@Nullable String[] zygoteArgs) {
// ... uasp
try {
// 调用当前类startViaZygote方法 [2.1.65]
return startViaZygote(processClass, niceName, uid, gid, gids,
runtimeFlags, mountExternal, targetSdkVersion, seInfo,
abi, instructionSet, appDataDir, invokeWith, /*startChildZygote=*/ false,
packageName, useUsapPool, zygoteArgs);
} catch (ZygoteStartFailedEx ex) {
throw new RuntimeException(
"Starting VM process through Zygote failed", ex);
}
}
2.1.65 ZygoteProcess.startViaZygote
private Process.ProcessStartResult startViaZygote(@NonNull final String processClass,
@Nullable final String niceName,
final int uid, final int gid,
@Nullable final int[] gids,
int runtimeFlags, int mountExternal,
int targetSdkVersion,
@Nullable String seInfo,
@NonNull String abi,
@Nullable String instructionSet,
@Nullable String appDataDir,
@Nullable String invokeWith,
boolean startChildZygote,
@Nullable String packageName,
boolean useUsapPool,
@Nullable String[] extraArgs)
throws ZygoteStartFailedEx {
ArrayList<String> argsForZygote = new ArrayList<>(); // 存放启动参数
argsForZygote.add("--runtime-args");
argsForZygote.add("--setuid=" + uid);
argsForZygote.add("--setgid=" + gid);
argsForZygote.add("--runtime-flags=" + runtimeFlags);
if (mountExternal == Zygote.MOUNT_EXTERNAL_DEFAULT) {
argsForZygote.add("--mount-external-default");
} else if (mountExternal == Zygote.MOUNT_EXTERNAL_READ) {
argsForZygote.add("--mount-external-read");
} else if (mountExternal == Zygote.MOUNT_EXTERNAL_WRITE) {
argsForZygote.add("--mount-external-write");
} else if (mountExternal == Zygote.MOUNT_EXTERNAL_FULL) {
argsForZygote.add("--mount-external-full");
} else if (mountExternal == Zygote.MOUNT_EXTERNAL_INSTALLER) {
argsForZygote.add("--mount-external-installer");
} else if (mountExternal == Zygote.MOUNT_EXTERNAL_LEGACY) {
argsForZygote.add("--mount-external-legacy");
}
argsForZygote.add("--target-sdk-version=" + targetSdkVersion);
// 设置GroupIds
if (gids != null && gids.length > 0) {
StringBuilder sb = new StringBuilder();
sb.append("--setgroups=");
int sz = gids.length;
for (int i = 0; i < sz; i++) {
if (i != 0) {
sb.append(',');
}
sb.append(gids[i]);
}
argsForZygote.add(sb.toString());
}
// 设置进程名
if (niceName != null) {
argsForZygote.add("--nice-name=" + niceName);
}
if (seInfo != null) {
argsForZygote.add("--seinfo=" + seInfo);
}
if (instructionSet != null) {
argsForZygote.add("--instruction-set=" + instructionSet);
}
// 应用data目录
if (appDataDir != null) {
argsForZygote.add("--app-data-dir=" + appDataDir);
}
// 一般情况下为null /system/bin/logwrapper {wrap.sh path}
if (invokeWith != null) {
argsForZygote.add("--invoke-with");
argsForZygote.add(invokeWith);
}
// false
if (startChildZygote) {
argsForZygote.add("--start-child-zygote");
}
// 包名
if (packageName != null) {
argsForZygote.add("--package-name=" + packageName);
}
// android.app.ActivityThread
argsForZygote.add(processClass);
// 额外参数
if (extraArgs != null) {
Collections.addAll(argsForZygote, extraArgs);
}
synchronized(mLock) {
// [2.1.66小节] openZygoteSocketIfNeeded
// [2.1.67小节] zygoteSendArgsAndGetResult
return zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi),
useUsapPool,
argsForZygote);
}
}
2.1.66 ZygoteProcess.openZygoteSocketIfNeeded
frameworks/base/core/java/android/os/ZygoteProcess.java
private ZygoteState openZygoteSocketIfNeeded(String abi) throws ZygoteStartFailedEx {
try {
// zygote在系统中有两个,分别为主要zygote和次要zygote
// 两个zygote区别主要是针对不同的cpu架构
attemptConnectionToPrimaryZygote(); // 建立与主要Zygote服务的socket连接
if (primaryZygoteState.matches(abi)) { // abi是否匹配
return primaryZygoteState;
}
if (mZygoteSecondarySocketAddress != null) { // 如果主要zygote不匹配abi，则调用尝试次要zygote连接
attemptConnectionToSecondaryZygote(); // 建立与次要Zygote服务的socket连接
if (secondaryZygoteState.matches(abi)) {
return secondaryZygoteState;
}
}
} catch (IOException ioe) {
throw new ZygoteStartFailedEx("Error connecting to zygote", ioe);
}
throw new ZygoteStartFailedEx("Unsupported zygote ABI: " + abi);
}
// 建立与主要Zygote服务的socket连接
private void attemptConnectionToPrimaryZygote() throws IOException {
if (primaryZygoteState == null || primaryZygoteState.isClosed()) {
primaryZygoteState =
ZygoteState.connect(mZygoteSocketAddress, mUsapPoolSocketAddress);
// 连接建立成功后，发送一些信息给Zygote server
maybeSetApiBlacklistExemptions(primaryZygoteState, false); // 发送 --set-api-blacklist-exemptions
maybeSetHiddenApiAccessLogSampleRate(primaryZygoteState); // 发送 --hidden-api-log-sampling-rate=
maybeSetHiddenApiAccessStatslogSampleRate(primaryZygoteState); // 发送 --hidden-api-statslog-sampling-rate=
}
}
// ZygoteState为ZygoteProcess内部类
private static class ZygoteState implements AutoCloseable {
// ...
static ZygoteState connect(@NonNull LocalSocketAddress zygoteSocketAddress,
@Nullable LocalSocketAddress usapSocketAddress)
throws IOException {
DataInputStream zygoteInputStream; // 输入流
BufferedWriter zygoteOutputWriter; // 输出流
final LocalSocket zygoteSessionSocket = new LocalSocket();
if (zygoteSocketAddress == null) { // 检查连接地址
throw new IllegalArgumentException("zygoteSocketAddress can't be null");
}
try {
zygoteSessionSocket.connect(zygoteSocketAddress); // 建立连接
zygoteInputStream = new DataInputStream(zygoteSessionSocket.getInputStream()); // 获取输入流
zygoteOutputWriter = new BufferedWriter(new OutputStreamWriter(zygoteSessionSocket.getOutputStream()),
Zygote.SOCKET_BUFFER_SIZE); // 获取输出流
} catch (IOException ex) {
try { // 连接异常，关闭
zygoteSessionSocket.close();
} catch (IOException ignore) { }
throw ex;
}
return new ZygoteState(zygoteSocketAddress, usapSocketAddress,
zygoteSessionSocket, zygoteInputStream, zygoteOutputWriter,
getAbiList(zygoteOutputWriter, zygoteInputStream));
}
}
2.1.67 ZygoteProcess.zygoteSendArgsAndGetResult
frameworks/base/core/java/android/os/ZygoteProcess.java
private Process.ProcessStartResult zygoteSendArgsAndGetResult(
ZygoteState zygoteState, boolean useUsapPool, @NonNull ArrayList<String> args)
throws ZygoteStartFailedEx {
// 如果参数列表中包含\n或者\r则抛出异常
for (String arg : args) {
if (arg.indexOf('\n') >= 0) {
throw new ZygoteStartFailedEx("Embedded newlines not allowed");
} else if (arg.indexOf('\r') >= 0) {
throw new ZygoteStartFailedEx("Embedded carriage returns not allowed");
}
}
// 把列表转成字符串，且开头为参数列表个数，参数之间换行
String msgStr = args.size() + "\n" + String.join("\n", args) + "\n";
// ... uasp
// [2.1.68]
return attemptZygoteSendArgsAndGetResult(zygoteState, msgStr);
}
2.1.68 ZygoteProcess.attemptZygoteSendArgsAndGetResult
frameworks/base/core/java/android/os/ZygoteProcess.java
private Process.ProcessStartResult attemptZygoteSendArgsAndGetResult(
ZygoteState zygoteState, String msgStr) throws ZygoteStartFailedEx {
try {
final BufferedWriter zygoteWriter = zygoteState.mZygoteOutputWriter;
final DataInputStream zygoteInputStream = zygoteState.mZygoteInputStream;
zygoteWriter.write(msgStr); // 往输出流写入数据
zygoteWriter.flush();
Process.ProcessStartResult result = new Process.ProcessStartResult();
// 读取Zygote server发回的数据
result.pid = zygoteInputStream.readInt(); // 进程id
result.usingWrapper = zygoteInputStream.readBoolean();
if (result.pid < 0) {
throw new ZygoteStartFailedEx("fork() failed");
}
// 如果返回正确pid，则返回，此时我们直接回[2.1.59.4 小节]
return result;
} catch (IOException ex) {
zygoteState.close();
throw new ZygoteStartFailedEx(ex);
}
}
2.1.69 ProcessList.handleProcessStartedLocked
frameworks/base/services/core/java/com/android/server/am/ProcessList.java
2.1.69.1 handleProcessStartedLocked
private boolean handleProcessStartedLocked(ProcessRecord pending,
Process.ProcessStartResult startResult, long expectedStartSeq) {
if (mPendingStarts.get(expectedStartSeq) == null) { // false
if (pending.pid == startResult.pid) {
pending.setUsingWrapper(startResult.usingWrapper);
}
return false;
}
// [2.1.69.2 小节]
return handleProcessStartedLocked(pending, startResult.pid, startResult.usingWrapper,
expectedStartSeq, false);
}
2.1.69.2 handleProcessStartedLocked
boolean handleProcessStartedLocked(ProcessRecord app, int pid, boolean usingWrapper,
long expectedStartSeq, boolean procAttached) {
mPendingStarts.remove(expectedStartSeq);
final String reason = isProcStartValidLocked(app, expectedStartSeq);
if (reason != null) { // false，如果不为null说明发生错误
Slog.w(TAG_PROCESSES, app + " start not valid, killing pid=" +
pid
+ ", " + reason);
app.pendingStart = false;
killProcessQuiet(pid);
Process.killProcessGroup(app.uid, app.pid);
return false;
}
// ...
// 在ProcessRecord设置一些属性 pid等
app.setPid(pid);
// ...
return true;
}
至此第一部分Launcher进程到SystemServer进程(ATMS/AMS)再到Zygote调用流程已经介绍完毕。
第二部分介绍Zygote Server创建进程后的处理。
三. 总结
调用时序图
UML类图
数据结构图
461
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
