一：背景
Activity作为Android四大组件之一，用途之广、作用之重要想必不需要多做赘述，下面将从Launcher点击Dialer图标这个流程来剖析Activity是如何启动的。
PS：点击事件在Launcher中的传递本篇文章不涉及，流程起始点是ContextImpl.startActivity
二：Activity启动流程
2.1 准备工作
2.1.1 ContextImpl.startActivity
最终会通过ActivityTaskManagerService调用到ActivityStarter，在ActivityStarter中做真正Activity启动工作。
//frameworks/base/core/java/android/app/ContextImpl.java
public void startActivity(Intent intent) {
warnIfCallingFromSystemProcess();
startActivity(intent, null);
}
//frameworks/base/core/java/android/app/ContextImpl.java
public void startActivity(Intent intent, Bundle options) {
...
mMainThread.getInstrumentation().execStartActivity(
getOuterContext(), mMainThread.getApplicationThread(), null,
(Activity) null, intent, -1, options);
}
//frameworks/base/core/java/android/app/Instrumentation.java
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Activity target,
Intent intent, int requestCode, Bundle options) {
...
try {
intent.migrateExtraStreamToClipData(who);
intent.prepareToLeaveProcess(who);
//启动Activity
int result = ActivityTaskManager.getService().startActivity(whoThread,
who.getOpPackageName(), who.getAttributionTag(), intent,
intent.resolveTypeIfNeeded(who.getContentResolver()), token,
target != null ? target.mEmbeddedID : null, requestCode, 0, null, options);
notifyStartActivityResult(result, options);
checkStartActivityResult(result, intent);
} catch (RemoteException e) {
throw new RuntimeException("Failure from system", e);
}
return null;
}
//frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
public final int startActivity(IApplicationThread caller, String callingPackage,
String callingFeatureId, Intent intent, String resolvedType, IBinder resultTo,
String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo,
Bundle bOptions) {
return startActivityAsUser(caller, callingPackage, callingFeatureId, intent, resolvedType,
resultTo, resultWho, requestCode, startFlags, profilerInfo, bOptions,
UserHandle.getCallingUserId());
}
//frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
private int startActivityAsUser(IApplicationThread caller, String callingPackage,
@Nullable String callingFeatureId, Intent intent, String resolvedType,
IBinder resultTo, String resultWho, int requestCode, int startFlags,
ProfilerInfo profilerInfo, Bundle bOptions, int userId, boolean validateIncomingUser) {
...
return getActivityStartController().obtainStarter(intent, "startActivityAsUser")
.setCaller(caller)
.setCallingPackage(callingPackage)
.setCallingFeatureId(callingFeatureId)
.setResolvedType(resolvedType)
.setResultTo(resultTo)
.setResultWho(resultWho)
.setRequestCode(requestCode)
.setStartFlags(startFlags)
.setProfilerInfo(profilerInfo)
.setActivityOptions(opts)
.setUserId(userId)
.execute();
}2.1.2 ActivityStarter.execute
这里主要完成以下工作
- 校验Activity启动合法性，判断是否需要拦截Activity启动
- 创建ActivityRecord对象
- 校准Activity启动的flag，并根据flag判断是否有可以复用的task，没有则创建新的任务栈
- 计算Activity的参数，如窗口区域、窗口模式等
- 开始播放Activity启动时startingWindow动画
//frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java
int execute() {
try {
//执行开始即开始启动Activity
onExecutionStarted();
...
int res = START_CANCELED;
synchronized (mService.mGlobalLock) {
...
try {
...
res = executeRequest(mRequest);
} finally {
...
}
...
}
...
} finally {
//执行结束即Activity启动结束
onExecutionComplete();
}
...
}
//frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java
private int executeRequest(Request request) {
...
//判断是否需要拦截Activity启动
if (mInterceptor.intercept(intent, rInfo, aInfo, resolvedType, inTask, inTaskFragment,
callingPid, callingUid, checkedOptions, suggestedLaunchDisplayArea)) {
...
intentGrants = null;
}
...
//创建ActivityRecord对象
final ActivityRecord r = new ActivityRecord.Builder(mService)
...
.build();
...
//启动Activity
mLastStartActivityResult = startActivityUnchecked(r, sourceRecord, voiceSession,
request.voiceInteractor, startFlags, checkedOptions,
inTask, inTaskFragment, balVerdict, intentGrants, realCallingUid);
...
}
//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, ActivityOptions options, Task inTask,
TaskFragment inTaskFragment,
BalVerdict balVerdict,
NeededUriGrants intentGrants, int realCallingUid) {
...
try {
mService.deferWindowLayout();
transitionController.collect(r);
try {
//开始"startActivityInner" trace的地方
Trace.traceBegin(Trace.TRACE_TAG_WINDOW_MANAGER, "startActivityInner");
//启动Activity
result = startActivityInner(r, sourceRecord, voiceSession, voiceInteractor,
startFlags, options, inTask, inTaskFragment, balVerdict,
intentGrants, realCallingUid);
} catch (Exception ex) {
Slog.e(TAG, "Exception on startActivityInner", ex);
} finally {
//结束"startActivityInner" trace的地方
Trace.traceEnd(Trace.TRACE_TAG_WINDOW_MANAGER);
startedActivityRootTask = handleStartResult(r, options, result, newTransition,
remoteTransition);
}
} finally {
mService.continueWindowLayout();
}
postStartActivityProcessing(r, result, startedActivityRootTask);
return result;
}
//frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java
int startActivityInner(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
int startFlags, ActivityOptions options, Task inTask,
TaskFragment inTaskFragment, BalVerdict balVerdict,
NeededUriGrants intentGrants, int realCallingUid) {
//初始化状态
setInitialState(r, options, inTask, inTaskFragment, startFlags, sourceRecord,
voiceSession, voiceInteractor, balVerdict.getCode(), realCallingUid);
//校准mLaunchFlags并更新到mIntent中
computeLaunchingTaskFlags();
mIntent.setFlags(mLaunchFlags);
...
//根据includeLaunchedFromBubble判断是否有task可以复用，并返回可以复用的task
final Task reusedTask = resolveReusableTask(includeLaunchedFromBubble);
...
//判断是否有可以使用的现成的task（例如在应用中通过Activity1启动Activity2，启动方式是standard，那么Activity1所在的task就可以给Activity2使用而不需要重新创建一个task）
final Task targetTask = reusedTask != null ? reusedTask : computeTargetTask();
final boolean newTask = targetTask == null;
...
//计算启动Activity时的参数，例如窗口区域、窗口模式等
computeLaunchParams(r, sourceRecord, targetTask);
//检查启动是否被允许
int startResult = isAllowedToStart(r, newTask, targetTask);
...
final ActivityRecord targetTaskTop = newTask
? null : targetTask.getTopNonFinishingActivity();
if (targetTaskTop != null) {
//Activity的启动模式是SINGLE_INSTANCE，移除所有有该Activity的任务栈
if (LAUNCH_SINGLE_INSTANCE == mLaunchMode && mSourceRecord != null
&& targetTask == mSourceRecord.getTask()) {
final ActivityRecord activity = mRootWindowContainer.findActivity(mIntent,
mStartActivity.info, false);
if (activity != null && activity.getTask() != targetTask) {
activity.destroyIfPossible("Removes redundant singleInstance");
}
}
...
}
//如果当前任务栈的最上层Activity是将要启动的Activity，判断是否需要再次启动Activity（standard模式会再次启动，singletop模式则不会再次启动）
final Task topRootTask = mPreferredTaskDisplayArea.getFocusedRootTask();
if (topRootTask != null) {
startResult = deliverToCurrentTopIfNeeded(topRootTask, intentGrants);
if (startResult != START_SUCCESS) {
return startResult;
}
}
...
//可用任务栈不存在，创建新的任务栈
if (mTargetRootTask == null) {
mTargetRootTask = getOrCreateRootTask(mStartActivity, mLaunchFlags, targetTask,
mOptions);
}
...
//在event log中记录有新的task创建了
if (newTask) {
EventLogTags.writeWmCreateTask(mStartActivity.mUserId, startedTask.mTaskId,
startedTask.getRootTaskId(), startedTask.getDisplayId());
}
//在event log中记录create Activity
mStartActivity.logStartActivity(EventLogTags.WM_CREATE_ACTIVITY, startedTask);
...
//开始Activity启动过渡动画
mTargetRootTask.startActivityLocked(mStartActivity, topRootTask, newTask, isTaskSwitch,
mOptions, sourceRecord);
//mDoResume为true
if (mDoResume) {
final ActivityRecord topTaskActivity = startedTask.topRunningActivityLocked();
if (!mTargetRootTask.isTopActivityFocusable()
|| (topTaskActivity != null && topTaskActivity.isTaskOverlay()
&& mStartActivity != topTaskActivity)) {
...
mTargetRootTask.ensureActivitiesVisible(null /* starting */);
mTargetRootTask.mDisplayContent.executeAppTransition();
} else {
...
mRootWindowContainer.resumeFocusedTasksTopActivities(
mTargetRootTask, mStartActivity, mOptions, mTransientLaunch);
}
}
...
//更新最近任务栈
mSupervisor.mRecentTasks.add(startedTask);
...
}
//frameworks/base/services/core/java/com/android/server/wm/Task.java
void startActivityLocked(ActivityRecord r, @Nullable Task topTask, boolean newTask,
boolean isTaskSwitch, ActivityOptions options, @Nullable ActivityRecord sourceRecord) {
...
final DisplayContent dc = mDisplayContent;
if ((r.intent.getFlags() & Intent.FLAG_ACTIVITY_NO_ANIMATION) != 0) {//不需要过渡动画
...
} else {
//准备过渡动画
dc.prepareAppTransition(TRANSIT_OPEN);
mTaskSupervisor.mNoAnimActivities.remove(r);
}
...
//后台启动
if (r.mLaunchTaskBehind) {
...
} else if (SHOW_APP_STARTING_PREVIEW && doShow) {//SHOW_APP_STARTING_PREVIEW为true
...
//开始StartingWindow动画
mWmService.mStartingSurfaceController.showStartingWindow(r, prev, newTask,
isTaskSwitch, sourceRecord);
}
}
//frameworks/base/services/core/java/com/android/server/wm/RootWindowContainer.java
boolean resumeFocusedTasksTopActivities(
Task targetRootTask, ActivityRecord target, ActivityOptions targetOptions,
boolean deferPause) {
...
if (targetRootTask != null && (targetRootTask.isTopRootTaskInDisplayArea()
|| getTopDisplayFocusedRootTask() == targetRootTask)) {
result = targetRootTask.resumeTopActivityUncheckedLocked(target, targetOptions,
deferPause);
}
...
}
//frameworks/base/services/core/java/com/android/server/wm/Task.java
boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options,
boolean deferPause) {
...
try {
...
if (isLeafTask()) {
if (isFocusableAndVisible()) {
someActivityResumed = resumeTopActivityInnerLocked(prev, options, deferPause);
}
}
...
}
...
}
//frameworks/base/services/core/java/com/android/server/wm/Task.java
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options,
boolean deferPause) {
...
final boolean[] resumed = new boolean[1];
final TaskFragment topFragment = topActivity.getTaskFragment();
resumed[0] = topFragment.resumeTopActivity(prev, options, deferPause);
forAllLeafTaskFragments(f -> {
if (topFragment == f) {
return;
}
if (!f.canBeResumed(null /* starting */)) {
return;
}
resumed[0] |= f.resumeTopActivity(prev, options, deferPause);
}, true);
return resumed[0];
}
//frameworks/base/services/core/java/com/android/server/wm/TaskFragment.java
final boolean resumeTopActivity(ActivityRecord prev, ActivityOptions options,
boolean skipPause) {
...
//暂停前一个Activity
boolean pausing = !skipPause && taskDisplayArea.pauseBackTasks(next);
...
if (pausing) {
...
if (next.attachedToProcess()) {//Activity所属进程已存在
...
} else if (!next.isProcessRunning()) {//Activity所属进程不存在
...
//启动Activity所属进程
mAtmService.startProcessAsync(next, false /* knownToBeDead */, isTop,
isTop ? HostingRecord.HOSTING_TYPE_NEXT_TOP_ACTIVITY
: HostingRecord.HOSTING_TYPE_NEXT_ACTIVITY);
}
...
}
...
boolean anim = true;
final DisplayContent dc = taskDisplayArea.mDisplayContent;
if (prev != null) {
if (prev.finishing) {
...
if (mTaskSupervisor.mNoAnimActivities.contains(prev)) {
...
} else {
//过渡动画准备完成
dc.prepareAppTransition(TRANSIT_CLOSE);
}
prev.setVisibility(false);
} else {
...
}
} else {
...
}
if (anim) {
//播放过渡动画
next.applyOptionsAnimation();
} else {
...
}
...
if (next.attachedToProcess()) {
...
//更新CPU统计信息
mAtmService.updateCpuStats();
//更新状态
next.setState(RESUMED, "resumeTopActivity");
...
try {
...
//标记Activity resume
next.notifyAppResumed();
...
}2.2 暂停前一个Activity
2.2.1 TaskFragment.startPausing
获取需要暂停的ActivityRecord（即当前处于resume状态的Activity对应的ActivityRecord），更新需要暂停Activity的状态为PAUSING，调用TaskFragment的schedulePauseActivity做真正暂停Activity的工作
//frameworks/base/services/core/java/com/android/server/wm/TaskDisplayArea.java
boolean pauseBackTasks(ActivityRecord resuming) {
final int[] someActivityPaused = {0};
forAllLeafTasks(leafTask -> {
//调用Task的pauseActivityIfNeeded来暂定Activity，暂停原因是"pauseBackTasks"
if (leafTask.pauseActivityIfNeeded(resuming, "pauseBackTasks")) {
someActivityPaused[0]++;
}
}, true /* traverseTopToBottom */);
return someActivityPaused[0] > 0;
}
//frameworks/base/services/core/java/com/android/server/wm/Task.java
boolean pauseActivityIfNeeded(@Nullable ActivityRecord resuming, @NonNull String reason) {
...
forAllLeafTaskFragments((taskFrag) -> {
final ActivityRecord resumedActivity = taskFrag.getResumedActivity();
if (resumedActivity != null && !taskFrag.canBeResumed(resuming)) {
//调用TaskFragment的startPausing继续暂停流程
if (taskFrag.startPausing(false /* uiSleeping*/, resuming, reason)) {
someActivityPaused[0]++;
}
}
}, true /* traverseTopToBottom */);
...
}
//frameworks/base/services/core/java/com/android/server/wm/TaskFragment.java
boolean startPausing(boolean userLeaving, boolean uiSleeping, ActivityRecord resuming,
String reason) {
...
//将要暂停的Activity对应的ActivityRecord赋值给prev
ActivityRecord prev = mResumedActivity;
...
mPausingActivity = prev;
...
//更新状态为PAUSING
prev.setState(PAUSING, "startPausingLocked");
prev.getTask().touchActiveTime();
...
if (prev.attachedToProcess()) {
if (shouldAutoPip && ActivityTaskManagerService.isPip2ExperimentEnabled()) {//画中画模式，不暂停Activity
...
} else if (shouldAutoPip) {//画中画模式，不暂停Activity
...
} else {
//真正暂停Activity的地方
schedulePauseActivity(prev, userLeaving, pauseImmediately,
false /* autoEnteringPip */, reason);
}
}
...
if (mPausingActivity != null) {
...
if (pauseImmediately) {
//暂停完成
completePause(false, resuming);
return false;
} else {
...
}
}
...
}2.2.2 ActivityThread.performPauseActivity
Activity的暂停是通过PauseActivityItem（Activity 的暂停transaction）来实现。PauseActivityItem会调用ActivityThread，更新Activity的状态为ON_PAUSE，最终通过Activity的performPause来调用到Launcher Activity的onPause函数
//frameworks/base/services/core/java/com/android/server/wm/TaskFragment.java
void schedulePauseActivity(ActivityRecord prev, boolean userLeaving,
boolean pauseImmediately, boolean autoEnteringPip, String reason) {
try {
...
//暂停Activity
mAtmService.getLifecycleManager().scheduleTransactionItem(prev.app.getThread(),
PauseActivityItem.obtain(prev.token, prev.finishing, userLeaving,
pauseImmediately, autoEnteringPip));
} catch (Exception e) {
...
}
}
//frameworks/base/core/java/android/app/servertransaction/PauseActivityItem.java
//先执行
public void execute(ClientTransactionHandler client, ActivityClientRecord r,
PendingTransactionActions pendingActions) {
Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityPause");
client.handlePauseActivity(r, mFinished, mUserLeaving, mConfigChanges, mAutoEnteringPip,
pendingActions, "PAUSE_ACTIVITY_ITEM");
Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}
//后执行
public void postExecute(ClientTransactionHandler client, IBinder token,
PendingTransactionActions pendingActions) {
...
ActivityClient.getInstance().activityPaused(token);
}
//frameworks/base/core/java/android/app/ActivityThread.java
public void handlePauseActivity(ActivityClientRecord r, boolean finished, boolean userLeaving,
boolean autoEnteringPip, PendingTransactionActions pendingActions,
String reason) {
...
performPauseActivity(r, finished, reason, pendingActions);
...
}
//frameworks/base/core/java/android/app/ActivityThread.java
private Bundle performPauseActivity(ActivityClientRecord r, boolean finished, String reason,
PendingTransactionActions pendingActions) {
...
performPauseActivityIfNeeded(r, reason);
...
}
//frameworks/base/core/java/android/app/Instrumentation.java
public void callActivityOnPause(Activity activity) {
activity.performPause();
}
//frameworks/base/core/java/android/app/Activity.java
final void performPause() {
...
dispatchActivityPrePaused();
...
//调用Launcher进程对应Activity的onPause函数
onPause();
...
dispatchActivityPostPaused();
}
//frameworks/base/services/core/java/com/android/server/wm/ActivityRecord.java
void activityPaused(boolean timeout) {
...
try {
//通知系统Activity已经pause完成，可以继续进程启动流程
taskFragment.completePause(true /* resumeNext */, null /* resumingActivity */);
}
...
}2.2.3 TaskFragment.completePause
更新Activity的状态为PAUSED
//frameworks/base/services/core/java/com/android/server/wm/ActivityRecord.java
void activityPaused(boolean timeout) {
...
try {
//通知系统Activity已经pause完成，可以继续进程启动流程
taskFragment.completePause(true /* resumeNext */, null /* resumingActivity */);
}
...
}
//frameworks/base/services/core/java/com/android/server/wm/TaskFragment.java
void completePause(boolean resumeNext, ActivityRecord resuming) {
...
ActivityRecord prev = mPausingActivity;
if (prev != null) {
...
//Activity当前状态是PAUSING，所以wasStopping为false
final boolean wasStopping = prev.isState(STOPPING);
//更新状态为PAUSED
prev.setState(PAUSED, "completePausedLocked");
mPausingActivity = null;
if (prev.finishing) {
...
prev = prev.completeFinishing(false /* updateVisibility */,
"completePausedLocked");
} else if (prev.attachedToProcess()) {
...
if (wasStopping) {
...
//更新状态为STOPPING
prev.setState(STOPPING, "completePausedLocked");
} else if (!prev.isVisibleRequested() || shouldSleepOrShutDownActivities()) {
...
prev.addToStopping(true /* scheduleIdle */, false /* idleDelayed */,
"completePauseLocked");
}
}
...
if (prev != null) {
//停止冻结屏幕
prev.stopFreezingScreen(true /* unfreezeNow */, true /* force */);
}
}
...
if (prev != null) {
//恢复按键分发
prev.resumeKeyDispatchingLocked();
}
mRootWindowContainer.ensureActivitiesVisible(resuming);
...
}2.3 新进程的创建
2.3.1 ProcessList.startProcessLocked
更新runtimeFlags，根据不同Zygote需求采用不用的Zygote方式，这里使用走的是默认创建进程方式。
//frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
void startProcessAsync(ActivityRecord activity, boolean knownToBeDead, boolean isTop,
String hostingType) {
...
try {
if (Trace.isTagEnabled(TRACE_TAG_WINDOW_MANAGER)) {
Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, "dispatchingStartProcess:"
+ activity.processName);
}
...
final Message m = PooledLambda.obtainMessage(ActivityManagerInternal::startProcess,
mAmInternal, activity.processName, activity.info.applicationInfo, knownToBeDead,
isTop, hostingType, activity.intent.getComponent());
mH.sendMessage(m);
} finally {
Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);
}
}
//frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
public void startProcess(String processName, ApplicationInfo info, boolean knownToBeDead,
boolean isTop, String hostingType, ComponentName hostingName) {
try {
if (Trace.isTagEnabled(Trace.TRACE_TAG_ACTIVITY_MANAGER)) {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "startProcess:"
+ processName);
}
synchronized (ActivityManagerService.this) {
...
ProcessRecord app = startProcessLocked(...);
}
} finally {
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
}
}
//frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
final ProcessRecord startProcessLocked(...) {
return mProcessList.startProcessLocked(processName, info, knownToBeDead, intentFlags,
hostingRecord, zygotePolicyFlags, allowWhileBooting, isolated, 0 /* isolatedUid */,
false /* isSdkSandbox */, 0 /* sdkSandboxClientAppUid */,
null /* sdkSandboxClientAppPackage */,
null /* ABI override */, null /* entryPoint */,
null /* entryPointArgs */, null /* crashHandler */);
}
//frameworks/base/services/core/java/com/android/server/am/ProcessList.java
ProcessRecord startProcessLocked(String processName, ApplicationInfo info,
boolean knownToBeDead, int intentFlags, HostingRecord hostingRecord,
int zygotePolicyFlags, boolean allowWhileBooting, boolean isolated, int isolatedUid,
boolean isSdkSandbox, int sdkSandboxUid, String sdkSandboxClientAppPackage,
String abiOverride, String entryPoint, String[] entryPointArgs, Runnable crashHandler) {
...
final boolean success =
startProcessLocked(app, hostingRecord, zygotePolicyFlags, abiOverride);
...
}
//frameworks/base/services/core/java/com/android/server/am/ProcessList.java
boolean startProcessLocked(ProcessRecord app, HostingRecord hostingRecord,
int zygotePolicyFlags, String abiOverride) {
return startProcessLocked(app, hostingRecord, zygotePolicyFlags,
false /* disableHiddenApiChecks */, false /* disableTestApiChecks */,
abiOverride);
}
//frameworks/base/services/core/java/com/android/server/am/ProcessList.java
boolean startProcessLocked(ProcessRecord app, HostingRecord hostingRecord,
int zygotePolicyFlags, boolean disableHiddenApiChecks, boolean disableTestApiChecks,
String abiOverride) {
...
//更新CPU统计信息
mService.updateCpuStats();
...
try {
...
int runtimeFlags = 0;
...
//更新runtimeFlags
if ((app.info.flags & ApplicationInfo.FLAG_VM_SAFE_MODE) != 0 || mService.mSafeMode) {
runtimeFlags |= Zygote.DEBUG_ENABLE_SAFEMODE;
}
if (isProfileableByShell) {
runtimeFlags |= Zygote.PROFILE_FROM_SHELL;
}
if (isProfileable) {
runtimeFlags |= Zygote.PROFILEABLE;
}
...
runtimeFlags |= Zygote.getMemorySafetyRuntimeFlags(
definingAppInfo, app.processInfo, instructionSet, mPlatformCompat);
...
return startProcessLocked(hostingRecord, entryPoint, app, uid, gids,
runtimeFlags, zygotePolicyFlags, mountExternal, seInfo, requiredAbi,
instructionSet, invokeWith, startUptime, startElapsedTime);
...
}
}
//frameworks/base/services/core/java/com/android/server/am/ProcessList.java
boolean startProcessLocked(HostingRecord hostingRecord, String entryPoint, ProcessRecord app,
int uid, int[] gids, int runtimeFlags, int zygotePolicyFlags, int mountExternal,
String seInfo, String requiredAbi, String instructionSet, String invokeWith,
long startUptime, long startElapsedTime) {
...
if (mService.mConstants.FLAG_PROCESS_START_ASYNC) {
mService.mProcStartHandler.post(() -> handleProcessStart(
app, entryPoint, gids, runtimeFlags, zygotePolicyFlags, mountExternal,
requiredAbi, instructionSet, invokeWith, startSeq));
return true;
}
...
}
//frameworks/base/services/core/java/com/android/server/am/ProcessList.java
private void handleProcessStart(final ProcessRecord app, final String entryPoint,
final int[] gids, final int runtimeFlags, int zygotePolicyFlags,
final int mountExternal, final String requiredAbi, final String instructionSet,
final String invokeWith, final long startSeq) {
final Runnable startRunnable = () -> {
try {
//启动进程
final Process.ProcessStartResult startResult = startProcess(app.getHostingRecord(),
entryPoint, app, app.getStartUid(), gids, runtimeFlags, zygotePolicyFlags,
mountExternal, app.getSeInfo(), requiredAbi, instructionSet, invokeWith,
app.getStartTime());
synchronized (mService) {
handleProcessStartedLocked(app, startResult, startSeq);
}
} catch (RuntimeException e) {
...
}
};
// Use local reference since we are not using locks here
final ProcessRecord predecessor = app.mPredecessor;
if (predecessor != null && predecessor.getDyingPid() > 0) {
handleProcessStartWithPredecessor(predecessor, startRunnable);
} else {
//开启一个单独的线程来进行进程启动工作
startRunnable.run();
}
}
//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 zygotePolicyFlags,
int mountExternal, String seInfo, String requiredAbi, String instructionSet,
String invokeWith, long startTime) {
try {
//开始"Start proc: "的systrace tag
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "Start proc: " +
app.processName);
...
if (hostingRecord.usesWebviewZygote()) {//Webview进程创建
startResult = startWebView(...);
} else if (hostingRecord.usesAppZygote()) {//使用AppZygote来创建进程
final AppZygote appZygote = createAppZygoteForProcessIfNeeded(app);
...
startResult = appZygote.getProcess().start(...);
} else {//默认创建进程方式
...
startResult = Process.start(...);
...
}
...
}
...
}
//frameworks/base/core/java/android/app/Process.java
public static ProcessStartResult start(...) {
return ZYGOTE_PROCESS.start(...);
}2.3.2 ZygoteProcess.startViaZygote
- 在fork进程之前，会先判断是否开启usap，这里是关闭usap的fork流程
- 设置fork参数
- 建立与zygote的socket连接
- 把fork参数传到zygote并接收fork成功后的pid
usap：在开机时初始化一个进程池，进程池数量可调，在zygote接收到需要fork进程时，会从进程池中取出一个进程并返回，节省fork时间
//frameworks/base/core/java/android/os/ZygoteProcess.java
public final Process.ProcessStartResult start(...) {
//判断是否开启usap
if (fetchUsapPoolEnabledPropWithMinInterval()) {
informZygotesOfUsapPoolStatus();
}
try {
return startViaZygote(...);
} catch (ZygoteStartFailedEx ex) {
...
}
}
//frameworks/base/core/java/android/os/ZygoteProcess.java
private Process.ProcessStartResult startViaZygote(...)
throws ZygoteStartFailedEx {
ArrayList<String> argsForZygote = new ArrayList<>();
//设置fork参数
argsForZygote.add("--runtime-args");
...
if (extraArgs != null) {
Collections.addAll(argsForZygote, extraArgs);
}
synchronized(mLock) {
if (ZygoteConfigExt.shouldAttemptApp32Boost(zygotePolicyFlags, runtimeFlags)) {//判断是否需要为32位应用做加速
ZygoteState state = openZygoteSocketIfNeeded(abi, packageName);
return zygoteSendArgsAndGetResult(state, zygotePolicyFlags, argsForZygote);
}
//通过socket进行zygote的fork流程
return zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi)/* 打开socket连接 */,
zygotePolicyFlags,
argsForZygote);
}
}
//frameworks/base/core/java/android/os/ZygoteProcess.java
private ZygoteState openZygoteSocketIfNeeded(String abi) throws ZygoteStartFailedEx {
try {
attemptConnectionToPrimaryZygote();
if (primaryZygoteState.matches(abi)) {//这里abi的值为arm64-v8a
return primaryZygoteState;
}
...
}
...
}
//frameworks/base/core/java/android/os/ZygoteProcess.java
private void attemptConnectionToPrimaryZygote() throws IOException {
if (primaryZygoteState == null || primaryZygoteState.isClosed()) {
primaryZygoteState =
ZygoteState.connect(mZygoteSocketAddress, mUsapPoolSocketAddress);
...
}
}
//frameworks/base/core/java/android/os/ZygoteProcess.java
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();
...
try {
//建立socket连接
zygoteSessionSocket.connect(zygoteSocketAddress);
zygoteInputStream = new DataInputStream(zygoteSessionSocket.getInputStream());
zygoteOutputWriter =
new BufferedWriter(
new OutputStreamWriter(zygoteSessionSocket.getOutputStream()),
Zygote.SOCKET_BUFFER_SIZE);
}
...
//创建ZygoteState对象
return new ZygoteState(zygoteSocketAddress, usapSocketAddress,
zygoteSessionSocket, zygoteInputStream, zygoteOutputWriter,
getAbiList(zygoteOutputWriter, zygoteInputStream));
}
}
//frameworks/base/core/java/android/os/ZygoteProcess.java
private Process.ProcessStartResult zygoteSendArgsAndGetResult(
ZygoteState zygoteState, int zygotePolicyFlags, @NonNull ArrayList<String> args)
throws ZygoteStartFailedEx {
...
return attemptZygoteSendArgsAndGetResult(zygoteState, msgStr);
}
//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;
//把fork参数传到zygote
zygoteWriter.write(msgStr);
zygoteWriter.flush();
Process.ProcessStartResult result = new Process.ProcessStartResult();
//zygote fork进程成功后，返回新进程的pid
result.pid = zygoteInputStream.readInt();
result.usingWrapper = zygoteInputStream.readBoolean();
...
return result;
}
...
}2.3.3 Zygote.forkSimpleApps
ZygoteServer会启动一个死循环，处理fork进程的socket请求，最终fork进程的地方是在jni中。
//frameworks/base/core/java/com/android/internal/os/ZygoteServer.java
Runnable runSelectLoop(String abiList) {
...
while (true) {
...
if (pollReturnValue == 0) {
...
} else {
...
while (--pollIndex >= 0) {
if (pollIndex == 0) {
...
} else if (pollIndex < usapPoolEventFDIndex) {
try {
//获取socket连接
ZygoteConnection connection = peers.get(pollIndex);
boolean multipleForksOK = !isUsapPoolEnabled()
&& ZygoteHooks.isIndefiniteThreadSuspensionSafe();
//处理socket请求
final Runnable command =
connection.processCommand(this, multipleForksOK);
}
...
}
}
...
}
...
}
}
//frameworks/base/core/java/com/android/internal/os/ZygoteConnection.java
Runnable processCommand(ZygoteServer zygoteServer, boolean multipleOK) {
ZygoteArguments parsedArgs;
try (ZygoteCommandBuffer argBuffer = new ZygoteCommandBuffer(mSocket)) {
while (true) {
...
int pid;
...
if (parsedArgs.mInvokeWith != null || parsedArgs.mStartChildZygote
|| !multipleOK || peer.getUid() != Process.SYSTEM_UID) {
...
} else {
ZygoteHooks.preFork();
Runnable result = Zygote.forkSimpleApps(argBuffer,
zygoteServer.getZygoteSocketFileDescriptor(),
peer.getUid(), Zygote.minChildUid(peer), parsedArgs.mNiceName);
...
}
...
}
}
...
}
//frameworks/base/core/java/com/android/internal/os/Zygote.java
static @Nullable Runnable forkSimpleApps(...) {
boolean in_child =
argBuffer.forkRepeatedly(zygoteSocket, expectedUid, minUid, firstNiceName);
if (in_child) {
return childMain(argBuffer, /*usapPoolSocket=*/null, /*writePipe=*/null);
} else {
return null;
}
}
//frameworks/base/core/java/com/android/internal/os/ZygoteCommandBuffer.java
boolean forkRepeatedly(FileDescriptor zygoteSocket, int expectedUid, int minUid,
String firstNiceName) {
try {
return nativeForkRepeatedly(mNativeBuffer, zygoteSocket.getInt$(),
expectedUid, minUid, firstNiceName);
}
...
}
//frameworks/base/core/jni/com_android_internal_os_ZygoteCommandBuffer.java
jboolean com_android_internal_os_ZygoteCommandBuffer_nativeForkRepeatedly(
JNIEnv* env,
jclass,
jlong j_buffer,
jint zygote_socket_fd,
jint expected_uid,
jint minUid,
jstring managed_nice_name) {
...
int pid = zygote::forkApp(env, /* no pipe FDs */ -1, -1, session_socket_fds,
/*args_known=*/ true, /*is_priority_fork=*/ true,
/*purge=*/ first_time);
...
}2.3.4 com_android_internal_os_Zygote.ForkCommon
调用Linux的fork函数来实现fork进程
//frameworks/base/core/jni/com_android_internal_os_Zygote.java
int zygote::forkApp(JNIEnv* env,
int read_pipe_fd,
int write_pipe_fd,
const std::vector<int>& session_socket_fds,
bool args_known,
bool is_priority_fork,
bool purge) {
...
return zygote::ForkCommon(env, /* is_system_server= */ false, fds_to_close,
fds_to_ignore, is_priority_fork == JNI_TRUE, purge);
}
//frameworks/base/core/jni/com_android_internal_os_Zygote.java
pid_t zygote::ForkCommon(JNIEnv* env, bool is_system_server,
const std::vector<int>& fds_to_close,
const std::vector<int>& fds_to_ignore,
bool is_priority_fork,
bool purge) {
ATRACE_CALL();
if (is_priority_fork) {//设置最大优先级
setpriority(PRIO_PROCESS, 0, PROCESS_PRIORITY_MAX);
}
//设置信号处理程序
SetSignalHandlers();
...
//阻断信号
BlockSignal(SIGCHLD, fail_fn);
...
//真正fork进程的地方，在父进程中，fork()返回新创建子进程的PID，而在子进程中，fork()返回0。
pid_t pid = fork();
...
//解除阻断信号
UnblockSignal(SIGCHLD, fail_fn);
if (is_priority_fork && pid != 0) {//设置优先级为PROCESS_PRIORITY_DEFAULT
setpriority(PRIO_PROCESS, 0, PROCESS_PRIORITY_DEFAULT);
}
return pid;
}2.3.5 ZygoteInit.zygoteInit
- 设置进程名称
- 设置应用进程默认的java异常处理机制，可以实现监听、拦截应用进程所有的Java crash的逻辑
- JNI调用启动进程的binder线程池，应用进程的binder线程池资源是自己创建的并非从zygote父进程继承的
- 反射创建ActivityThread对象并调用其"main"入口方法
//frameworks/base/core/java/com/android/internal/os/Zygote.java
private static Runnable childMain(@Nullable ZygoteCommandBuffer argBuffer,
@Nullable LocalServerSocket usapPoolSocket,
FileDescriptor writePipe) {
final int pid = Process.myPid();
...
if (argBuffer == null) {
...
} else {
...
try {
args = ZygoteArguments.getInstance(argBuffer);
}
...
}
...
try {
...
//设置线程名称和优先级
specializeAppProcess(args.mUid, args.mGid, args.mGids,
args.mRuntimeFlags, rlimits, args.mMountExternal,
args.mSeInfo, args.mNiceName, args.mStartChildZygote,
args.mInstructionSet, args.mAppDataDir, args.mIsTopApp,
args.mPkgDataInfoList, args.mAllowlistedDataInfoList,
args.mBindMountAppDataDirs, args.mBindMountAppStorageDirs,
args.mBindMountSyspropOverrides);
//设置进程名称
Zygote.setAppProcessName(args, TAG);
return ZygoteInit.zygoteInit(args.mTargetSdkVersion,
args.mDisabledCompatChanges,
args.mRemainingArgs,
null /* classLoader */);
}
...
}
//frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
public static Runnable zygoteInit(int targetSdkVersion, long[] disabledCompatChanges,
String[] argv, ClassLoader classLoader) {
...
//开始"ZygoteInit"的systrace tag
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ZygoteInit");
RuntimeInit.redirectLogStreams();
//设置应用进程默认的java异常处理机制，可以实现监听、拦截应用进程所有的Java crash的逻辑
RuntimeInit.commonInit();
//JNI调用启动进程的binder线程池，应用进程的binder线程池资源是自己创建的并非从zygote父进程继承的
ZygoteInit.nativeZygoteInit();
//反射创建ActivityThread对象并调用其“main”入口方法
return RuntimeInit.applicationInit(targetSdkVersion, disabledCompatChanges, argv,
classLoader);
}
//frameworks/base/core/java/com/android/internal/os/RuntimeInit.java
protected static Runnable applicationInit(int targetSdkVersion, long[] disabledCompatChanges,
String[] argv, ClassLoader classLoader) {
...
return findStaticMain(args.startClass, args.startArgs, classLoader);
}
//frameworks/base/core/java/com/android/internal/os/RuntimeInit.java
protected static Runnable findStaticMain(String className, String[] argv,
ClassLoader classLoader) {
Class<?> cl;
try {
//获取ActivityThread类
cl = Class.forName(className, true, classLoader);
}
...
Method m;
try {
//获取main函数
m = cl.getMethod("main", new Class[] { String[].class });
}
...
//调用ActivityThread的main函数，开始进程初始化
return new MethodAndArgsCaller(m, argv);
}2.4 新进程的初始化
2.4.1 ActivityManagerService.attachApplicationLocked
- 创建主线程的loop消息循环，并在应用初始化完成之后启动该消息循环
- 初始化数据库并设置超时检测
- 在应用初始化完成后更新应用状态、更新LRU列表、更新oom_adj
//frameworks/base/core/java/android/app/ActivityThread.java
public static void main(String[] args) {
//开始"ActivityThreadMain"的systrace tag
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
...
//创建主线程的loop消息循环
Looper.prepareMainLooper();
...
ActivityThread thread = new ActivityThread();
//执行attach继续进行应用初始化的工作
thread.attach(false, startSeq);
...
//结束"ActivityThreadMain"的systrace tag
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
...
//启动主线程的loop消息循环
Looper.loop();
}
//frameworks/base/core/java/android/app/ActivityThread.java
private void attach(boolean system, long startSeq) {
...
if (!system) {
...
final IActivityManager mgr = ActivityManager.getService();
try {
//初始化Application
mgr.attachApplication(mAppThread, startSeq);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
//如果堆大小接近限制，则释放一些Activity
BinderInternal.addGcWatcher(new Runnable() {
@Override public void run() {
...
Runtime runtime = Runtime.getRuntime();
long dalvikMax = runtime.maxMemory();
long dalvikUsed = runtime.totalMemory() - runtime.freeMemory();
if (dalvikUsed > ((3*dalvikMax)/4)) {
...
mSomeActivitiesChanged = false;
try {
ActivityTaskManager.getService().releaseSomeActivities(mAppThread);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
}
});
}
...
//系统配置改变的监听（例如语言切换）
ViewRootImpl.ConfigChangedCallback configChangedCallback = (Configuration globalConfig) -> {
synchronized (mResourcesManager) {
// We need to apply this change to the resources immediately, because upon returning
// the view hierarchy will be informed about it.
if (mResourcesManager.applyConfigurationToResources(globalConfig,
null /* compat */)) {
...
final Configuration updatedConfig =
mConfigurationController.updatePendingConfiguration(globalConfig);
if (updatedConfig != null) {//配置发生改变
sendMessage(H.CONFIGURATION_CHANGED, globalConfig);
mPendingConfiguration = updatedConfig;
}
}
}
};
ViewRootImpl.addConfigCallback(configChangedCallback);
}
//frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
private void attachApplicationLocked(@NonNull IApplicationThread thread,
int pid, int callingUid, long startSeq) {
...
synchronized (this) {
...
attachApplicationLocked(thread, callingPid, callingUid, startSeq);
...
}
}
//frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
private void attachApplicationLocked(@NonNull IApplicationThread thread,
int pid, int callingUid, long startSeq) {
...
//初始化应用数据库并设置超时检测
boolean normalMode = mProcessesReady || isAllowedWhileBooting(app.info);
List<ProviderInfo> providers = normalMode
? mCpHelper.generateApplicationProvidersLocked(app)
: null;
if (providers != null && mCpHelper.checkAppInLaunchingProvidersLocked(app)) {
Message msg = mHandler.obtainMessage(CONTENT_PROVIDER_PUBLISH_TIMEOUT_MSG);
msg.obj = app;
mHandler.sendMessageDelayed(msg,
ContentResolver.CONTENT_PROVIDER_PUBLISH_TIMEOUT_MILLIS);
}
...
try {
...
if (app.getIsolatedEntryPoint() != null) {
...
} else {
...
//调用应用进程ActivityThread.ApplicationThread.bindApplication接口
thread.bindApplication(...);
}
//设置应用启动超时检测，如果超时则报ANR
Message msg = mHandler.obtainMessage(BIND_APPLICATION_TIMEOUT_SOFT_MSG);
msg.obj = app;
msg.arg1 = BIND_APPLICATION_TIMEOUT;
mHandler.sendMessageDelayed(msg, msg.arg1 /* BIND_APPLICATION_TIMEOUT */);
mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app);
...
//在bindApplication之后，设置应用为Active状态
synchronized (mProcLock) {
app.makeActive(thread, mProcessStats);
}
...
//更新LRU列表
updateLruProcessLocked(app, false, null);
...
//更新oom_adj，更新原因是进程启动（OOM_ADJ_REASON_PROCESS_BEGIN）
updateOomAdjLocked(app, OOM_ADJ_REASON_PROCESS_BEGIN);
...
//当应用首次在私有空间启动时，需要向应用发送开机完成广播
maybeSendBootCompletedLocked(app);
}
...
}2.4.2 ActivityThread.handleBindApplication
- 把UI线程在Runtime中注册为敏感线程，不希望UI线程进行JIT编译
- 初始化mProfile，配置分析器参数
- 创建应用的LoadedApk对象
- 将应用数据目录路径传递给AndroidRuntime
- 创建应用Application的Context，触发Art虚拟机加载应用APK的Dex文件到内存中，并加载应用APK的Resource资源
//frameworks/base/core/java/android/app/ActivityThread.java
private class ApplicationThread extends IApplicationThread.Stub {
public final void bindApplication(...) {
if (services != null) {
...
//在ServiceManager中设置服务缓存
ServiceManager.initServiceCache(services);
}
...
//初始化AppBindData
AppBindData data = new AppBindData();
data.processName = processName;
...
data.startRequestedUptime = startRequestedUptime;
...
sendMessage(H.BIND_APPLICATION, data);
}
}
//frameworks/base/core/java/android/app/ActivityThread.java
class H extends Handler {
public void handleMessage(Message msg) {
switch (msg.what) {
case BIND_APPLICATION:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "bindApplication");
AppBindData data = (AppBindData)msg.obj;
handleBindApplication(data);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
}
}
}
//frameworks/base/core/java/android/app/ActivityThread.java
private void handleBindApplication(AppBindData data) {
...
//在Runtime中将UI线程注册为敏感线程。不希望UI线程进行JIT编译，确保线程执行具有可预测性和稳定性
VMRuntime.registerSensitiveThread();
...
//设置进程启动时间
Process.setStartTimes(SystemClock.elapsedRealtime(), SystemClock.uptimeMillis(),
data.startRequestedElapsedTime, data.startRequestedUptime);
...
//初始化mProfiler，配置分析器参数
mProfiler = new Profiler();
if (data.initProfilerInfo != null) {
mProfiler.profileFile = data.initProfilerInfo.profileFile;
...
}
...
//创建应用的LoadedApk对象
data.info = getPackageInfo(data.appInfo, mCompatibilityInfo, null /* baseLoader */,
false /* securityViolation */, true /* includeCode */,
false /* registerPackage */, isSdkSandbox);
...
//将数据目录路径传递给AndroidRuntime
VMRuntime.setProcessDataDirectory(data.appInfo.dataDir);
...
//开始收集应用信息，如正在运行的线程、内存使用情况、关键方法的执行时间等
if (mProfiler.profileFd != null) {
mProfiler.startProfiling();
}
...
//初始化线程严格模式的默认设置
StrictMode.initThreadDefaults(data.appInfo);
//初始化虚拟机严格模式的默认设置
StrictMode.initVmDefaults(data.appInfo);
...
//创建应用Application的Context，触发Art虚拟机加载应用APK的Dex文件到内存中，并加载应用APK的Resource资源
final ContextImpl appContext = ContextImpl.createAppContext(this, data.info);
...
try {
//调用LoadedApk的makeApplicationInner函数，创建应用的Application对象
app = data.info.makeApplicationInner(data.restrictedBackupMode, null);
...
}
...
try {
mgr.finishAttachApplication(mStartSeq, timestampApplicationOnCreateNs);
}
...
}2.4.3 ActivityThread.getPackageInfo
初始化LoadedApk对象。LoadedApk管理应用的资源和类加载器、维护应用的上下文环境、处理应用程序的初始化和启动过程
//frameworks/base/core/java/android/app/ActivityThread.java
private LoadedApk getPackageInfo(ApplicationInfo aInfo, CompatibilityInfo compatInfo,
ClassLoader baseLoader, boolean securityViolation, boolean includeCode,
boolean registerPackage, boolean isSdkSandbox) {
...
synchronized (mResourcesManager) {
...
//初始化LoadedApk对象。LoadedApk管理应用的资源和类加载器、维护应用的上下文环境、处理应用程序的初始化和启动过程
packageInfo =
new LoadedApk(this, aInfo, compatInfo, baseLoader,
securityViolation, includeCode
&& (aInfo.flags & ApplicationInfo.FLAG_HAS_CODE) != 0, registerPackage);
...
if (differentUser || isSdkSandbox) {
...
} else if (includeCode) {//如果应用包含code，把应用加到mPackages集合中
mPackages.put(aInfo.packageName,
new WeakReference<LoadedApk>(packageInfo));
} else {//如果应用不包含code，把应用加到mResourcePackages集合中
mResourcePackages.put(aInfo.packageName,
new WeakReference<LoadedApk>(packageInfo));
}
...
}2.4.4 LoadedApk.getResources
- 创建Context对象
- 调用LoadedApk的getClassLoader函数获取类加载器
- 调用ResourcesManager的getResources函数获取资源文件
//frameworks/base/core/java/android/app/ContextImpl.java
static ContextImpl createAppContext(ActivityThread mainThread, LoadedApk packageInfo,
String opPackageName) {
//创建Context对象
ContextImpl context = new ContextImpl(null, mainThread, packageInfo,
ContextParams.EMPTY, null, null, null, null, null, 0, null, opPackageName,
DEVICE_ID_DEFAULT, false);
//获取资源文件
context.setResources(packageInfo.getResources());
...
}
//frameworks/base/core/java/android/app/LoadedApk.java
public Resources getResources() {
if (mResources == null) {
...
//获取资源文件
mResources = ResourcesManager.getInstance().getResources(null, mResDir,
splitPaths, mLegacyOverlayDirs, mOverlayPaths,
mApplicationInfo.sharedLibraryFiles, null, null, getCompatibilityInfo(),
getClassLoader()/*获取类加载器*/, null);
}
return mResources;
}2.4.5 LoadedApk.createOrUpdateClassLoaderLocked
获取类加载器流程，主要完成以下工作
- 寻找apk的资源文件路径保存在zipPaths中，寻找apk的库文件路径保存在libPaths中
- 构造默认类加载器
- 创建PathClassLoader加载应用APK的Dex类
- 通过new的方式创建ClassLoader对象，最终会触发art虚拟机加载APK的dex文件
//frameworks/base/core/java/android/app/LoadedApk.java
public ClassLoader getClassLoader() {
synchronized (mLock) {
if (mClassLoader == null) {
createOrUpdateClassLoaderLocked(null /*addedPaths*/);
}
return mClassLoader;
}
}
//frameworks/base/core/java/android/app/LoadedApk.java
private void createOrUpdateClassLoaderLocked(List<String> addedPaths) {
...
//寻找apk的资源文件路径保存在zipPaths中，寻找apk的库文件路径保存在libPaths中
makePaths(mActivityThread, isBundledApp, mApplicationInfo, zipPaths, libPaths);
...
if (mDefaultClassLoader == null) {
...
//构造默认类加载器，触发art虚拟机加载dex文件
mDefaultClassLoader = ApplicationLoaders.getDefault().getClassLoaderWithSharedLibraries(
zip, mApplicationInfo.targetSdkVersion, isBundledApp, librarySearchPath,
libraryPermittedPath, mBaseClassLoader,
mApplicationInfo.classLoaderName, sharedLibraries.first, nativeSharedLibraries,
sharedLibraries.second);
}
...
//创建ClassLoader对象（这里相当于把mDefaultClassLoader赋值给mClassLoader）
if (mClassLoader == null) {
mClassLoader = mAppComponentFactory.instantiateClassLoader(mDefaultClassLoader,
new ApplicationInfo(mApplicationInfo));
}
}
//frameworks/base/core/java/android/app/ApplicationLoaders.java
ClassLoader getClassLoaderWithSharedLibraries(...) {
return getClassLoader(...);
}
//frameworks/base/core/java/android/app/ApplicationLoaders.java
private ClassLoader getClassLoader(...) {
ClassLoader baseParent = ClassLoader.getSystemClassLoader().getParent();
synchronized (mLoaders) {
if (parent == null) {//parent为null，把baseParent赋值给parent
parent = baseParent;
}
...
if (parent == baseParent) {
...
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, zip);
//创建PathClassLoader加载应用APK的Dex类，并增加相应的systrace tag
ClassLoader classloader = ClassLoaderFactory.createClassLoader(
zip, librarySearchPath, libraryPermittedPath, parent,
targetSdkVersion, isBundled, classLoaderName, sharedLibraries,
nativeSharedLibraries, sharedLibrariesLoadedAfterApp);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "setLayerPaths");
//设置layer路径
GraphicsEnvironment.getInstance().setLayerPaths(
classloader, librarySearchPath, libraryPermittedPath);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
...
}
...
}
}
//frameworks/base/core/java/com/android/internal/os/ClassLoaderFactory.java
public static ClassLoader createClassLoader(String dexPath,
String librarySearchPath, String libraryPermittedPath, ClassLoader parent,
int targetSdkVersion, boolean isNamespaceShared, String classLoaderName,
List<ClassLoader> sharedLibraries, List<String> nativeSharedLibraries,
List<ClassLoader> sharedLibrariesAfter) {
final ClassLoader classLoader = createClassLoader(dexPath, librarySearchPath, parent,
classLoaderName, sharedLibraries, sharedLibrariesAfter);
...
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "createClassloaderNamespace");
//创建类加载器的命名空间
String errorMessage = createClassloaderNamespace(...);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
...
}
//frameworks/base/core/java/com/android/internal/os/ClassLoaderFactory.java
public static ClassLoader createClassLoader(String dexPath,
String librarySearchPath, ClassLoader parent, String classloaderName,
List<ClassLoader> sharedLibraries, List<ClassLoader> sharedLibrariesLoadedAfter) {
//通过new的方式创建ClassLoader对象，最终会触发art虚拟机加载APK的dex文件
ClassLoader[] arrayOfSharedLibraries = (sharedLibraries == null)
? null
: sharedLibraries.toArray(new ClassLoader[sharedLibraries.size()]);
ClassLoader[] arrayOfSharedLibrariesLoadedAfterApp = (sharedLibrariesLoadedAfter == null)
? null
: sharedLibrariesLoadedAfter.toArray(
new ClassLoader[sharedLibrariesLoadedAfter.size()]);
if (isPathClassLoaderName(classloaderName)) {
return new PathClassLoader(dexPath, librarySearchPath, parent, arrayOfSharedLibraries,
arrayOfSharedLibrariesLoadedAfterApp);
} else if (isDelegateLastClassLoaderName(classloaderName)) {
...
}
}2.4.6 ResourcesManager.createResources
获取资源文件，主要完成以下工作
- 创建AssetManager对象
- 创建ResourcesImpl对象
- 加载应用类资源
- 调用Native层的系统system/lib/libandroidfw.so库中的相关C函数实现对APK文件压缩包的解析与加载
//frameworks/base/core/java/android/app/ResourcesManager.java
public Resources getResources(...) {
try {
Trace.traceBegin(Trace.TRACE_TAG_RESOURCES, "ResourcesManager#getResources");
...
//activityToken传入的是null，走else
if (activityToken != null) {
...
} else {
resources = createResources(key, classLoader, assetsSupplier);
}
return resources;
} finally {
Trace.traceEnd(Trace.TRACE_TAG_RESOURCES);
}
}
//frameworks/base/core/java/android/app/ResourcesManager.java
private Resources createResources(@NonNull ResourcesKey key, @NonNull ClassLoader classLoader,
@Nullable ApkAssetsSupplier apkSupplier) {
synchronized (mLock) {
...
ResourcesImpl resourcesImpl = findOrCreateResourcesImplForKeyLocked(key, apkSupplier);
...
return createResourcesLocked(classLoader, resourcesImpl, key.mCompatInfo);
}
}
//frameworks/base/core/java/android/app/ResourcesManager.java
private @Nullable ResourcesImpl findOrCreateResourcesImplForKeyLocked(
@NonNull ResourcesKey key, @Nullable ApkAssetsSupplier apkSupplier) {
...
if (impl == null || impl.getAppliedSharedLibsHash() != mSharedLibAssetsMap.size()) {
//执行创建Resources资源对象
impl = createResourcesImpl(key, apkSupplier);
if (impl != null) {//把Resources资源对象存入mResourceImpls中
mResourceImpls.put(key, new WeakReference<>(impl));
}
}
return impl;
}
//frameworks/base/core/java/android/app/ResourcesManager.java
private @Nullable ResourcesImpl createResourcesImpl(@NonNull ResourcesKey key,
@Nullable ApkAssetsSupplier apkSupplier) {
//创建AssetManager对象
final AssetManager assets = createAssetManager(key, apkSupplier);
...
//创建ResourcesImpl对象
final ResourcesImpl impl = new ResourcesImpl(assets, displayMetrics, config, daj);
...
}
//frameworks/base/core/java/android/app/ResourcesManager.java
protected @Nullable AssetManager createAssetManager(@NonNull final ResourcesKey key,
@Nullable ApkAssetsSupplier apkSupplier) {
final AssetManager.Builder builder = new AssetManager.Builder().setNoInit();
final ArrayList<ApkKey> apkKeys = extractApkKeys(key);
for (int i = 0, n = apkKeys.size(); i < n; i++) {
final ApkKey apkKey = apkKeys.get(i);
try {
builder.addApkAssets(
(apkSupplier != null) ? apkSupplier.load(apkKey) : loadApkAssets(apkKey));
} catch (IOException e) {
...
}
}
...
return builder.build();
}
//frameworks/base/core/java/android/app/ResourcesManager.java
private @NonNull ApkAssets loadApkAssets(@NonNull final ApkKey key) throws IOException {
...
if (key.overlay) {
//加载overlay资源
apkAssets = ApkAssets.loadOverlayFromPath(overlayPathToIdmapPath(key.path), flags);
} else {
//加载应用类资源
apkAssets = ApkAssets.loadFromPath(key.path, flags);
}
...
}
//frameworks/base/core/java/android/content/res/ApkAssets.java
public static @NonNull ApkAssets loadFromPath(@NonNull String path, @PropertyFlags int flags)
throws IOException {
return new ApkAssets(FORMAT_APK, path, flags, null /* assets */);
}
//frameworks/base/core/java/android/content/res/ApkAssets.java
private ApkAssets(@FormatType int format, @NonNull String path, @PropertyFlags int flags,
@Nullable AssetsProvider assets) throws IOException {
...
mNativePtr = nativeLoad(format, path, flags, assets);
...
}
//frameworks/base/core/jni/android_content_res_ApkAssets.cpp
static jlong NativeLoad(JNIEnv* env, jclass /*clazz*/, const format_type_t format,
jstring java_path, const jint property_flags, jobject assets_provider) {
...
switch (format) {
case FORMAT_APK: {
auto assets = MultiAssetsProvider::Create(std::move(loader_assets),
ZipAssetsProvider::Create(path.c_str(),
property_flags));
//调用Native层的系统system/lib/libandroidfw.so库中的相关C函数实现对APK文件压缩包的解析与加载
apk_assets = ApkAssets::Load(std::move(assets), property_flags);
break;
}
...
}
...
}2.4.7 LoadedApk.makeApplicationInner
初始化主线程的ClassLoader
- 创建Context对象
- 创建Application对象
- 调用Application的attach函数
//frameworks/base/core/java/android/app/LoadedApk.java
private Application makeApplicationInner(boolean forceDefaultAppClass,
Instrumentation instrumentation, boolean allowDuplicateInstances) {
...
if (Trace.isTagEnabled(Trace.TRACE_TAG_ACTIVITY_MANAGER)) {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "makeApplication");
}
...
try {
...
Application app = null;
...
try {
//获取ClassLoader对象
final java.lang.ClassLoader cl = getClassLoader();
if (!mPackageName.equals("android")) {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER,
"initializeJavaContextClassLoader");
//初始化主线程的ClassLoader
initializeJavaContextClassLoader();
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
}
...
SparseArray<String> packageIdentifiers = getAssets().getAssignedPackageIdentifiers(
false, false);
for (int i = 0, n = packageIdentifiers.size(); i < n; i++) {
final int id = packageIdentifiers.keyAt(i);
if (id == 0x01 || id == 0x7f) {
continue;
}
//更新R文件引用资源（应用内图片、字符串等资源都可以通过R.string.xxx方式获取到资源id）
rewriteRValues(cl, packageIdentifiers.valueAt(i), id);
}
...
//创建Context对象
appContext = ContextImpl.createAppContext(mActivityThread, this);
...
//创建Application对象
app = mActivityThread.mInstrumentation.newApplication(
cl, appClass, appContext);
}
...
//更新Application
mActivityThread.mAllApplications.add(app);
mApplication = app;
if (!allowDuplicateInstances) {
synchronized (sApplications) {
sApplications.put(mPackageName, app);
}
}
...
}
...
}
//frameworks/base/core/java/android/app/Instrumentation.java
public Application newApplication(ClassLoader cl, String className, Context context)
throws InstantiationException, IllegalAccessException,
ClassNotFoundException {
//最终通过ClassLoader.loadClass创建Application对象
Application app = getFactory(context.getPackageName())
.instantiateApplication(cl, className);
//调用Application的attach函数
app.attach(context);
return app;
}2.5 Activity的启动
2.5.1 ActivityManagerService.finishAttachApplication
- 移除Application超时检测的message，避免触发ANR
- 启动Activity
- 启动服务
- 检查下一个广播接收者是否是此进程（开始接收注册的广播）
//frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
public final void finishAttachApplication(long startSeq, long timestampApplicationOnCreateNs) {
...
try {
finishAttachApplicationInner(startSeq, uid, pid);
} finally {
Binder.restoreCallingIdentity(origId);
}
...
}
//frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
private void finishAttachApplicationInner(long startSeq, int uid, int pid) {
...
//移除Application超时检测的message，避免触发ANR
if (app != null && app.getStartUid() == uid && app.getStartSeq() == startSeq) {
mHandler.removeMessages(BIND_APPLICATION_TIMEOUT_SOFT_MSG, app);
mHandler.removeMessages(BIND_APPLICATION_TIMEOUT_HARD_MSG, app);
}
...
synchronized (this) {
...
//启动Activity
if (normalMode) {
try {
didSomething = mAtmInternal.attachApplication(app.getWindowProcessController());
} catch (Exception e) {}
}
//启动服务
if (!badApp) {
try {
didSomething |= mServices.attachApplicationLocked(app, processName);
+ "after mServices.attachApplicationLocked");
} catch (Exception e) {}
}
//检查下一个广播接收者是否是此进程（开始接收注册的广播）
if (!badApp) {
try {
didSomething |= mBroadcastQueue.onApplicationAttachedLocked(app);
} catch (BroadcastDeliveryFailedException e) {}
}
...
}
...
}2.5.2 ActivityTaskSupervisor.realStartActivityLocked
通过LifecycleManager触发Activity生命周期的调用
//frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
final class LocalService extends ActivityTaskManagerInternal {
public boolean attachApplication(WindowProcessController wpc) throws RemoteException {
synchronized (mGlobalLockWithoutBoost) {
if (Trace.isTagEnabled(TRACE_TAG_WINDOW_MANAGER)) {
Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, "attachApplication:" + wpc.mName);
}
try {
return mRootWindowContainer.attachApplication(wpc);
} finally {
Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);
}
}
}
//frameworks/base/services/core/java/com/android/server/wm/RootWindowContainer.java
boolean attachApplication(WindowProcessController app) throws RemoteException {
//获取将要启动的Activity的列表
final ArrayList<ActivityRecord> activities = mService.mStartingProcessActivities;
...
for (int i = activities.size() - 1; i >= 0; i--) {
final ActivityRecord r = activities.get(i);
...
try {
final boolean canResume = r.isFocusable() && r == tf.topRunningActivity();
//启动Activity
if (mTaskSupervisor.realStartActivityLocked(r, app, canResume,
true /* checkConfig */)) {
hasActivityStarted = true;
}
}
...
}
...
}
//frameworks/base/services/core/java/com/android/server/wm/ActivityTaskSupervisor.java
boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
boolean andResume, boolean checkConfig) throws RemoteException {
...
final Task task = r.getTask();
if (andResume) {
//尝试暂停任务栈中处于resume状态的Activity
if (task.pauseActivityIfNeeded(r, "realStart")) {
return false;
}
final TaskFragment taskFragment = r.getTaskFragment();
if (taskFragment != null && taskFragment.getResumedActivity() != null) {
if (taskFragment.startPausing(mUserLeaving, false /* uiSleeping */, r,
"realStart")) {
return false;
}
}
}
...
try {
...
try {
...
//桌面应用特殊处理
updateHomeProcessIfNeeded(r);
...
final LaunchActivityItem launchActivityItem = LaunchActivityItem.obtain(r.token,
r.intent, System.identityHashCode(r), r.info,
procConfig, overrideConfig, deviceId,
r.getFilteredReferrer(r.launchedFromPackage), task.voiceInteractor,
proc.getReportedProcState(), r.getSavedState(), r.getPersistentSavedState(),
results, newIntents, r.takeSceneTransitionInfo(), isTransitionForward,
proc.createProfilerInfoIfNeeded(), r.assistToken, activityClientController,
r.shareableActivityToken, r.getLaunchedFromBubble(), fragmentToken,
r.initialCallerInfoAccessToken, activityWindowInfo);
final ActivityLifecycleItem lifecycleItem;
if (andResume) {
lifecycleItem = ResumeActivityItem.obtain(r.token, isTransitionForward,
r.shouldSendCompatFakeFocus());
}
...
//触发Activity生命周期的调用
mService.getLifecycleManager().scheduleTransactionAndLifecycleItems(
proc.getThread(), launchActivityItem, lifecycleItem,
// Immediately dispatch the transaction, so that if it fails, the server can
// restart the process and retry now.
true /* shouldDispatchImmediately */);
...
}
...
}
...
if (andResume && readyToResume()) {
//更新ActivityRecord的状态为RESUMED
r.setState(RESUMED, "realStartActivityLocked");
r.completeResumeLocked();
}
...
}2.5.3 TransactionExecutor.executeTransactionItems
- 把LaunchActivityItem加入到mActivityCallbacks集合中
- 把ResumeActivityItem加入到mLifecycleStateRequest集合中
- 遍历列出来所有的待处理的事务，依次处理每个事务
//frameworks/base/services/core/java/com/android/server/wm/ClientLifecycleManager.java
void scheduleTransactionAndLifecycleItems(@NonNull IApplicationThread client,
@NonNull ClientTransactionItem transactionItem,
@NonNull ActivityLifecycleItem lifecycleItem,
boolean shouldDispatchImmediately) throws RemoteException {
if (Flags.bundleClientTransactionFlag()) {
...
} else {
final ClientTransaction clientTransaction = ClientTransaction.obtain(client);
clientTransaction.addTransactionItem(transactionItem);
clientTransaction.addTransactionItem(lifecycleItem);
scheduleTransaction(clientTransaction);
}
}
//frameworks/base/core/java/android/app/servertransaction/ClientTransaction.java
public void addTransactionItem(@NonNull ClientTransactionItem item) {
...
if (item.isActivityLifecycleItem()) {//ResumeActivityItem会走这里
setLifecycleStateRequest((ActivityLifecycleItem) item);
} else {//LaunchActivityItem走这里
addCallback(item);
}
}
//frameworks/base/core/java/android/app/servertransaction/ClientTransaction.java
private void addCallback(@NonNull ClientTransactionItem activityCallback) {
...
//把LaunchActivityItem加入到mActivityCallbacks集合中
mActivityCallbacks.add(activityCallback);
...
}
//frameworks/base/core/java/android/app/servertransaction/ClientTransaction.java
private void setLifecycleStateRequest(@NonNull ActivityLifecycleItem stateRequest) {
...
//把ResumeActivityItem加入到mLifecycleStateRequest集合中
mLifecycleStateRequest = stateRequest;
...
}
//frameworks/base/services/core/java/com/android/server/wm/ClientLifecycleManager.java
void scheduleTransaction(@NonNull ClientTransaction transaction) throws RemoteException {
final IApplicationThread client = transaction.getClient();
try {
transaction.schedule();
} catch (RemoteException e) {
...
} finally {
...
}
}
//frameworks/base/core/java/android/app/servertransaction/ClientTransaction.java
public void schedule() throws RemoteException {
mClient.scheduleTransaction(this);
}
//frameworks/base/core/java/android/app/ActivityThread.java
private class ApplicationThread extends IApplicationThread.Stub {
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
ActivityThread.this.scheduleTransaction(transaction);
}
}
//frameworks/base/core/java/android/app/ClientTransactionHandler.java
void scheduleTransaction(ClientTransaction transaction) {
transaction.preExecute(this);
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
//frameworks/base/core/java/android/app/ActivityThread.java
class H extends Handler {
public void handleMessage(Message msg) {
switch (msg.what) {
case EXECUTE_TRANSACTION:
...
try {
mTransactionExecutor.execute(transaction);
}
...
}
}
}
//frameworks/base/core/java/android/app/servertransaction/TransactionExecutor.java
public void execute(@NonNull ClientTransaction transaction) {
...
try {
if (transaction.getTransactionItems() != null) {
//开始处理单个事务
executeTransactionItems(transaction);
} else {
...
}
}
...
}
//frameworks/base/core/java/android/app/servertransaction/TransactionExecutor.java
public void executeTransactionItems(@NonNull ClientTransaction transaction) {
//遍历列出来所有的待处理的事务（LaunchActivityItem和ResumeActivityItem）
final List<ClientTransactionItem> items = transaction.getTransactionItems();
final int size = items.size();
for (int i = 0; i < size; i++) {
final ClientTransactionItem item = items.get(i);
//LaunchActivityItem比ResumeActivityItem先加入，所以会先走else，再走if
if (item.isActivityLifecycleItem()) {//ResumeActivityItem会走这里
executeLifecycleItem(transaction, (ActivityLifecycleItem) item);
} else {//LaunchActivityItem走这里
executeNonLifecycleItem(transaction, item,
shouldExcludeLastLifecycleState(items, i));
}
}
}2.5.4 Activity.performCreate
- 初始化WindowManagerGlobal的sWindowManagerService对象
- 初始化Activity对象
- 调用Activity的attach函数
- 初始化PhoneWindow、WindowManager对象
- 调用应用里Activity的onCreate函数
- 更新Activity的状态为ON_CREATE
//frameworks/base/core/java/android/app/servertransaction/TransactionExecutor.java
private void executeNonLifecycleItem(@NonNull ClientTransaction transaction,
@NonNull ClientTransactionItem item, boolean shouldExcludeLastLifecycleState) {
...
//执行LaunchActivityItem的execute
item.execute(mTransactionHandler, mPendingActions);
item.postExecute(mTransactionHandler, mPendingActions);
...
}
//frameworks/base/core/java/android/app/servertransaction/LaunchActivityItem.java
public void execute(@NonNull ClientTransactionHandler client,
@NonNull PendingTransactionActions pendingActions) {
Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
final ActivityClientRecord r = new ActivityClientRecord(...);
client.handleLaunchActivity(r, pendingActions, mDeviceId, null /* customIntent */);
Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}
//frameworks/base/core/java/android/app/ActivityThread.java
public Activity handleLaunchActivity(ActivityClientRecord r,
PendingTransactionActions pendingActions, int deviceId, Intent customIntent) {
...
//初始化WindowManagerGlobal的sWindowManagerService对象
WindowManagerGlobal.initialize();
...
//执行启动Activity
final Activity a = performLaunchActivity(r, customIntent);
if (a != null) {
...
//触发ActivityWindowInfo回调
handleActivityWindowInfoChanged(r);
}
...
}
//frameworks/base/core/java/android/app/ActivityThread.java
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
...
Activity activity = null;
try {
java.lang.ClassLoader cl;
if (isSandboxedSdkContextUsed) {
...
} else {
cl = activityBaseContext.getClassLoader();
}
//初始化Activity对象
activity = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent);
...
}
...
try {
Application app = r.packageInfo.makeApplicationInner(false, mInstrumentation);
...
//把新的Activity更新到mActivities中
synchronized (mResourcesManager) {
mActivities.put(r.token, r);
}
if (activity != null) {
...
//调用Activity的attach函数
activity.attach(activityBaseContext, this, getInstrumentation(), r.token,
r.ident, app, r.intent, r.activityInfo, title, r.parent,
r.embeddedID, r.lastNonConfigurationInstances, config,
r.referrer, r.voiceInteractor, window, r.activityConfigCallback,
r.assistToken, r.shareableActivityToken, r.initialCallerInfoAccessToken);
...
//设置主题
int theme = r.activityInfo.getThemeResource();
if (theme != 0) {
activity.setTheme(theme);
}
...
if (r.isPersistable()) {//persist进程
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {//非persist进程
mInstrumentation.callActivityOnCreate(activity, r.state);
}
...
}
//更新Activity的状态为ON_CREATE
r.setState(ON_CREATE);
...
}
}
//frameworks/base/core/java/android/app/Activity.java
final void attach(...) {
...
//初始化PhoneWindow对象
mWindow = new PhoneWindow(this, window, activityConfigCallback);
...
//初始化WindowManager对象
mWindowManager = mWindow.getWindowManager();
...
}
//frameworks/base/core/java/android/app/Instrumentation.java
public void callActivityOnCreate(Activity activity, Bundle icicle) {
prePerformCreate(activity);
//调用Activity的performCreate函数
activity.performCreate(icicle);
postPerformCreate(activity);
}
//frameworks/base/core/java/android/app/Activity.java
final void performCreate(Bundle icicle, PersistableBundle persistentState) {
if (Trace.isTagEnabled(Trace.TRACE_TAG_WINDOW_MANAGER)) {
Trace.traceBegin(Trace.TRACE_TAG_WINDOW_MANAGER, "performCreate:"
+ mComponent.getClassName());
}
...
final long startTime = SystemClock.uptimeMillis();
if (persistentState != null) {
onCreate(icicle, persistentState);
} else {
//调用应用里Activity的onCreate函数
onCreate(icicle);
}
...
final long duration = SystemClock.uptimeMillis() - startTime;
//把Activity执行onCreate时间输出在event log中
EventLogTags.writeWmOnCreateCalled(mIdent, getComponentName().getClassName(),
"performCreate", duration);
...
Trace.traceEnd(Trace.TRACE_TAG_WINDOW_MANAGER);
}2.5.5 Activity.performStart
onStart的执行，是通过起始（ON_CREATE）和结束（ON_RESUME）的状态，通过TransactionExecutorHelper的getLifecyclePath计算出来的。在执行完onCreate之后，此时事务的状态是ON_CREATE，会循环执行事务直到事务状态变成ON_RESUME。
在执行完Activity的onStart后，会更新Activity的状态为ON_START。
//frameworks/base/core/java/android/app/servertransaction/TransactionExecutor.java
private void executeLifecycleItem(@NonNull ClientTransaction transaction,
@NonNull ActivityLifecycleItem lifecycleItem) {
...
//循环执行事务直到事务变成最终状态
cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */, transaction);
//执行ResumeActivityItem的execute函数
lifecycleItem.execute(mTransactionHandler, mPendingActions);
...
}
//frameworks/base/core/java/android/app/servertransaction/TransactionExecutor.java
private void cycleToPath(ActivityClientRecord r, int finish, boolean excludeLastState,
ClientTransaction transaction) {
final int start = r.getLifecycleState();
...
//这里start是LaunchActivityItem对应的状态（即ON_CREATE），finish是ResumeActivityItem对应的状态（即ON_RESUME）
final IntArray path = mHelper.getLifecyclePath(start, finish, excludeLastState);
performLifecycleSequence(r, path, transaction);
}
//frameworks/base/core/java/android/app/servertransaction/TransactionExecutorHelper.java
public IntArray getLifecyclePath(int start, int finish, boolean excludeLastState) {
...
if (finish >= start) {
if (start == ON_START && finish == ON_STOP) {
...
} else {
//找到大于ON_CREATE，小于等于ON_RESUME的状态放入mLifecycleSequence中
for (int i = start + 1; i <= finish; i++) {
mLifecycleSequence.add(i);
}
}
}
if (excludeLastState && mLifecycleSequence.size() != 0) {
//把mLifecycleSequence中最终状态移除，这时候mLifecycleSequence只有ON_START一个值
mLifecycleSequence.remove(mLifecycleSequence.size() - 1);
}
return mLifecycleSequence;
}
//frameworks/base/core/java/android/app/servertransaction/TransactionExecutor.java
private void performLifecycleSequence(ActivityClientRecord r, IntArray path,
ClientTransaction transaction) {
final int size = path.size();
for (int i = 0, state; i < size; i++) {
state = path.get(i);
switch (state) {
...
case ON_START:
//mTransactionHandler是ActivityThread
mTransactionHandler.handleStartActivity(r, mPendingActions,
null /* sceneTransitionInfo */);
break;
...
}
}
}
//frameworks/base/core/java/android/app/ActivityThread.java
public void handleStartActivity(ActivityClientRecord r,
PendingTransactionActions pendingActions, SceneTransitionInfo sceneTransitionInfo) {
final Activity activity = r.activity;
...
//调用Activity的performStart函数
activity.performStart("handleStartActivity");
//更新Activity的状态为ON_START
r.setState(ON_START);
...
}
//frameworks/base/core/java/android/app/Activity.java
final void performStart(String reason) {
if (Trace.isTagEnabled(Trace.TRACE_TAG_WINDOW_MANAGER)) {
Trace.traceBegin(Trace.TRACE_TAG_WINDOW_MANAGER, "performStart:"
+ mComponent.getClassName());
}
...
final long startTime = SystemClock.uptimeMillis();
mInstrumentation.callActivityOnStart(this);
final long duration = SystemClock.uptimeMillis() - startTime;
//在event log中打印Activity执行onStart耗时
EventLogTags.writeWmOnStartCalled(mIdent, getComponentName().getClassName(), reason,
duration);
...
Trace.traceEnd(Trace.TRACE_TAG_WINDOW_MANAGER);
}
//frameworks/base/core/java/android/app/Instrumentation.java
public void callActivityOnStart(Activity activity) {
//调用应用里Activity的onStart函数
activity.onStart();
}2.5.6 Activity.performResume
在执行完Activity的onResume函数后，更新Activity的状态为ON_RESUME，并使Activity可见
//frameworks/base/core/java/android/app/servertransaction/ResumeActivityItem.java
public void execute(@NonNull ClientTransactionHandler client, @NonNull ActivityClientRecord r,
@NonNull PendingTransactionActions pendingActions) {
Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityResume");
//调用ActivityThread的handleResumeActivity函数
client.handleResumeActivity(r, true /* finalStateRequest */, mIsForward,
mShouldSendCompatFakeFocus, "RESUME_ACTIVITY");
Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}
//frameworks/base/core/java/android/app/ActivityThread.java
public void handleResumeActivity(ActivityClientRecord r, boolean finalStateRequest,
boolean isForward, boolean shouldSendCompatFakeFocus, String reason) {
...
if (!performResumeActivity(r, finalStateRequest, reason)) {
return;
}
...
final Activity a = r.activity;
...
if (!r.activity.mFinished && willBeVisible && r.activity.mDecor != null && !r.hideForNow) {
//获取Activity对应的ViewRootImpl对象
ViewRootImpl impl = r.window.getDecorView().getViewRootImpl();
WindowManager.LayoutParams l = impl != null
? impl.mWindowAttributes : r.window.getAttributes();
...
mNumVisibleActivities++;
if (r.activity.mVisibleFromClient) {
r.activity.makeVisible();//使Activity可见
}
...
}
//把Activity加入到mNewActivities中
mNewActivities.add(r);
...
}
//frameworks/base/core/java/android/app/ActivityThread.java
public boolean performResumeActivity(ActivityClientRecord r, boolean finalStateRequest,
String reason) {
...
try {
...
//调用Activity的performResume函数
r.activity.performResume(r.startsNotResumed, reason);
//更新Activity的状态为ON_RESUME
r.setState(ON_RESUME);
...
}
...
}
//frameworks/base/core/java/android/app/Activity.java
final void performResume(boolean followedByPause, String reason) {
if (Trace.isTagEnabled(Trace.TRACE_TAG_WINDOW_MANAGER)) {
Trace.traceBegin(Trace.TRACE_TAG_WINDOW_MANAGER, "performResume:"
+ mComponent.getClassName());
}
...
final long startTime = SystemClock.uptimeMillis();
mInstrumentation.callActivityOnResume(this);
final long duration = SystemClock.uptimeMillis() - startTime;
//在event log中打印Activity执行onResume耗时
EventLogTags.writeWmOnResumeCalled(mIdent, getComponentName().getClassName(), reason,
duration);
...
Trace.traceEnd(Trace.TRACE_TAG_WINDOW_MANAGER);
}
//frameworks/base/core/java/android/app/Instrumentation.java
public void callActivityOnResume(Activity activity) {
activity.mResumed = true;
//调用应用里Activity的onResume函数
activity.onResume();
...
}三：小结
3.1 Activity Lifecycle状态值定义的地方
//frameworks/base/core/java/android/app/servertransaction/ActivityLifecycleItem.java
public static final int UNDEFINED = -1;
public static final int PRE_ON_CREATE = 0;
public static final int ON_CREATE = 1;
public static final int ON_START = 2;
public static final int ON_RESUME = 3;
public static final int ON_PAUSE = 4;
public static final int ON_STOP = 5;
public static final int ON_DESTROY = 6;
public static final int ON_RESTART = 7;
3.2 zygote介绍
进程包括system_server基本都是由zygote fork出来的，zygote自身是如何启动的，如何启动system_server，如何通过socket保持对fork请求的监听，可以查看文章Zygote启动流程（AndroidV）-CSDN博客。