声明下，这篇文章只是为了加深印象进行了概括总结，原文点击下方链接
点这里，超详细的解释说明
这边会去掉关于启动进程 Launcher、孵化进程 Zygote 等有关的篇幅。
进入主题吧
当我们在面试的时候被问及Activity是如何启动的，我们应该怎么回答呢？回答这个问题，可以根据 Activity 的启动时机，从两个方面入手：
- 根 Activity 的启动流程： 又叫应用程序启动流程，即点击桌面上某一个应用图标到应用第一个Activity展示出来的流程。
- 普通 Activity 的启动流程： 即应用内启动一个 Activity 到展示出来的流程。
根 Activity 的启动流程包含普通 Activity 的启动流程，这边总结下。
应用的启动流程大致分为下面五个阶段：
- 应用启动进程 Launcher 调用 ATMS 系统进程的过程
- ATMS 向 AMS 发送创建应用进程的过程
- AMS 向 Zygote 进程发送创建应用进程 ActivityThread 的过程
- Zygote 进程接收请求 fork 并启动应用进程 ActivityThread 的过程
- 应用进程 ActivityThread 启动 Activity 的过程
Activity 启动过程
- 应用启动进程 Launcher 调用 ATMS 系统进程的过程
- ATMS 向 AMS 发送创建应用进程的过程
- AMS 向 Zygote 进程发送创建应用进程 ActivityThread 的过程
- Zygote 进程接收请求 fork 并启动应用进程 ActivityThread 的过程
- 应用进程 ActivityThread 启动 Activity 的过程
- 1.时序图
- 2. ActivityThread.main
- 3. AMS 绑定 ApplicationThread
- 4. ActivityThread 创建并绑定 Application
- 5. ProcessRecord 保存 ApplicationThread
- 6. ATMS 绑定 WindowProcessController、启动根 Activity
- 7. RootWindowContainer 绑定 WindowProcessController
- 8. 获取 ClientTransaction、添加 Callback、设置 LifecycleStateRequest
- 9. ClientTransaction 获取、添加事务回调
- 10. ClientLifecycleManager 客户端生命周期事务转换管理器
- 11. ClientTransaction # schedule() 调度事务
- 12. ActivityThread 调度事务
- 13. TransactionExecutor 事务转换执行器
- 14. LaunchActivityItem 请求启动 Activity
- 15. ActivityThread 执行启动 Activity 事务
- 16. TransactionExecutorHelper 获取待执行生命周期的状态序列
- 17. executeLifecycleState(transaction)
应用启动进程 Launcher 调用 ATMS 系统进程的过程
我们常说的桌面（Launcher ）是一个用于显示所有应用程序的一个系统级别的应用程序，通过 PackageManagerService 来获取已安装的所有应用程序信息。当系统开机后，Launcher 也会被 AMS（ActivityManagerService） 启动，然后将已经安装的应用程序图标显示到桌面上，当我们点击 Launcher 中某一个应用图标相当于点击 Activity 中的一个 Button，其相应事件就是 Launcher 进程请求 ATMS 来启动该应用程序。
1. 时序图
2. Launcher # startActivitySafely() 方法
Launcher其实就是一个APP，当我们点击图标的时候，Launcher 调用startActivitySafely() 方法
/**
* Default launcher application.
*/
public class Launcher extends StatefulActivity<LauncherState> implements LauncherExterns,
Callbacks, InvariantDeviceProfile.OnIDPChangeListener, PluginListener<OverlayPlugin>,
LauncherOverlayCallbacks {
@Override
public boolean startActivitySafely(View v, Intent intent, ItemInfo item) {
if (!hasBeenResumed()) {
addOnResumeCallback(() -> startActivitySafely(v, intent, item));
if (mOnDeferredActivityLaunchCallback != null) {
mOnDeferredActivityLaunchCallback.run();
mOnDeferredActivityLaunchCallback = null;
}
return true;
}
boolean success = super.startActivitySafely(v, intent, item);
if (success && v instanceof BubbleTextView) {
BubbleTextView btv = (BubbleTextView) v;
btv.setStayPressed(true);
addOnResumeCallback(() -> btv.setStayPressed(false));
}
return success;
}
}
/**
* Extension of BaseActivity allowing support for drag-n-drop
*/
@SuppressWarnings("NewApi")
public abstract class BaseDraggingActivity extends BaseActivity
implements OnColorsChangedListener, DisplayInfoChangeListener {
public boolean startActivitySafely(View v, Intent intent, @Nullable ItemInfo item) {
......
Bundle optsBundle = (v != null) ? getActivityLaunchOptions(v, item).toBundle() : null;
UserHandle user = item == null ? null : item.user;
// Prepare intent
// 添加 FLAG_ACTIVITY_NEW_TASK，即在新的 Task 中启动 Activity
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
if (v != null) {
intent.setSourceBounds(Utilities.getViewBounds(v));
}
try {
boolean isShortcut = (item instanceof WorkspaceItemInfo)
&& (item.itemType == Favorites.ITEM_TYPE_SHORTCUT
|| item.itemType == Favorites.ITEM_TYPE_DEEP_SHORTCUT)
&& !((WorkspaceItemInfo) item).isPromise();
if (isShortcut) {
// Shortcuts need some special checks due to legacy reasons.
startShortcutIntentSafely(intent, optsBundle, item);
} else if (user == null || user.equals(Process.myUserHandle())) {
// Could be launching some bookkeeping activity
// 点击 App 图标 启动 App
startActivity(intent, optsBundle);
} else {
getSystemService(LauncherApps.class).startMainActivity(
intent.getComponent(), user, intent.getSourceBounds(), optsBundle);
}
if (item != null) {
InstanceId instanceId = new InstanceIdSequence().newInstanceId();
logAppLaunch(getStatsLogManager(), item, instanceId);
}
return true;
} catch (NullPointerException | ActivityNotFoundException | SecurityException e) {
......
}
return false;
}
}
根 Activity 启动时，添加 FLAG_ACTIVITY_NEW_TASK，即在新的任务栈 Task 中启动 Activity，然后调⽤到 Activity # startActivity() ⽅法，传⼊参数为 intent 和 Bundle。
public class Activity extends ContextThemeWrapper
implements ... {
@Override
public void startActivity(Intent intent, @Nullable Bundle options) {
if (options != null) {
// 通过 startActivityForResult 启动 Activity
startActivityForResult(intent, -1, options);
} else {
startActivityForResult(intent, -1);
}
}
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
@Nullable Bundle options) {
// mParent 表示当前 Activity 的父 Activity，一般情况下 mParent 为空
if (mParent == null) {
options = transferSpringboardActivityOptions(options);
Instrumentation.ActivityResult ar =
mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, this,
intent, requestCode, options);
if (ar != null) {
mMainThread.sendActivityResult(
mToken, mEmbeddedID, requestCode, ar.getResultCode(),
ar.getResultData());
}
if (requestCode >= 0) {
mStartedActivity = true;
}
cancelInputsAndStartExitTransition(options);
} else {
if (options != null) {
mParent.startActivityFromChild(this, intent, requestCode, options);
} else {
mParent.startActivityFromChild(this, intent, requestCode);
}
}
}
}
接着Activity # startActivity() 方法调用 Activity # startActivityForResult() 方法，此时会调用 Instrumentation # execStartActivity() 方法。
到这里了，再想想时序图，加深印象！！
3. Instrumentation # execStartActivity() 方法
Instrumentation 负责调用 Activity 和 Application 的生命周期，每个 Activity 都持有 Instrumentation 对象的一个引用，但是整个进程只会存在一个 Instrumentation 对象。跟进去看看 Instrumentation # execStartActivity () 方法，
@UnsupportedAppUsage
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Activity target,
Intent intent, int requestCode, Bundle options) {
......
try {
intent.migrateExtraStreamToClipData();
intent.prepareToLeaveProcess(who);
// 获取 ActivityTaskManagerService 的代理对象
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);
} catch (RemoteException e) {
throw new RuntimeException("Failure from system", e);
}
return null;
}
Instrumentation # execStartActivity() 方法会调用 ActivityTaskManager # getService() 方法来获取 ActivityTaskManagerService 的代理对象，然后调用这个代理对象的 startActivity() 方法。接下来就到了ATMS了。
这里要说明下，ActivityTaskManagerService 作为服务端处于 system_server 进程，与当前作为客户端的 Launcher 进程不在同一个进程。看下面代码，所以需要返回的 IActivityTaskManager.Stub 的代理对象，而 ActivityTaskManagerService 则是对应的实现类，继承了 IActivityTaskManager.Stub 并实现相应的方法，就通过代理对象可以跨进程调用服务端 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);
}
};
ATMS 向 AMS 发送创建应用进程的过程
ATMS（ActivityTaskManagerService） 是Android 10 中新增的，本来都是 AMS 来管理，Google 考虑到 AMS 职责太多、代码太庞大，所以单独拆出来 ATMS 用于管理 Activity及其容器类，如 Task、Stack、Display 等，分担 AMS 部分职责。
1. 时序图
跟着图走哈
2. ATMS（ActivityTaskManagerService）
紧跟着上面，启动过程走到了 ATMS 中，调用 ATMS # startActivity() 方法，上代码，
@Override
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) {
// UserHandle.getCallingUserId() 方法会获取调用者的 UserId
return startActivityAsUser(caller, callingPackage, callingFeatureId, intent, resolvedType,
resultTo, resultWho, requestCode, startFlags, profilerInfo, bOptions,
UserHandle.getCallingUserId());
}
@Override
public int startActivityAsUser(IApplicationThread caller, String callingPackage,
String callingFeatureId, Intent intent, String resolvedType, IBinder resultTo,
String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo,
Bundle bOptions, int userId) {
return startActivityAsUser(caller, callingPackage, callingFeatureId, intent, resolvedType,
resultTo, resultWho, requestCode, startFlags, profilerInfo, bOptions, userId,
true /*validateIncomingUser*/);
}
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) {
assertPackageMatchesCallingUid(callingPackage);
// 检查调用者的进程是否隔离，如果 isIsolated 则抛出 SecurityException 异常
enforceNotIsolatedCaller("startActivityAsUser");
// 检查调用者权限，ATMS 根据传入的 UserId 来确定调用者的权限
userId = getActivityStartController().checkTargetUser(userId, validateIncomingUser,
Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");
// TODO: Switch to user app stacks here.
return getActivityStartController().obtainStarter(intent, "startActivityAsUser")
.setCaller(caller)
.setCallingPackage(callingPackage)
.setCallingFeatureId(callingFeatureId)
.setResolvedType(resolvedType)
.setResultTo(resultTo)
.setResultWho(resultWho)
.setRequestCode(requestCode)
.setStartFlags(startFlags)
.setProfilerInfo(profilerInfo)
.setActivityOptions(bOptions)
.setUserId(userId)
.execute();
}
// 获取 ActivityStartController
ActivityStartController getActivityStartController() {
return mActivityStartController;
}
调用 ATMS # startActivity() 方法通过getActivityStartController()获取到ActivityStartController再执行execute()，接着就进入ActivityStarter了。
先了解下ActivityStarter，ActivityStarter 是 Android 7.0 中增加的，用来加载启动 Activity 的控制类，负责启动Activity。它的主要功能包括将Intent和相关的flags转换为特定的Activity以及与之相关的任务栈。接着走。
3. ActivityStarter
在ActivityStarter # execute() 方法中，会继续调用 ActivityStarter # executeRequest() 方法，这里会处理启动 Activity 的请求，并开始一个 Activity 启动的流程。
class ActivityStarter {
@VisibleForTesting
interface Factory {
// Sets the {@link ActivityStartController} to be passed to {@link ActivityStarter}.
void setController(ActivityStartController controller);
// 生成一个准备处理新启动请求的 ActivityStarter，ActivityStartController 持有这个实例对象
ActivityStarter obtain();
// Recycles a starter for reuse.
void recycle(ActivityStarter starter);
}
// Default implementation of {@link StarterFactory}.
static class DefaultFactory implements Factory {
// 被激活的启动器的最大数
private final int MAX_STARTER_COUNT = 3;
private ActivityStartController mController;
private ActivityTaskManagerService mService;
private ActivityStackSupervisor mSupervisor;
private ActivityStartInterceptor mInterceptor;
private SynchronizedPool<ActivityStarter> mStarterPool =
new SynchronizedPool<>(MAX_STARTER_COUNT);
DefaultFactory(ActivityTaskManagerService service,
ActivityStackSupervisor supervisor, ActivityStartInterceptor interceptor) {
mService = service;
mSupervisor = supervisor;
mInterceptor = interceptor;
}
@Override
public void setController(ActivityStartController controller) {
mController = controller;
}
@Override
public ActivityStarter obtain() {
ActivityStarter starter = mStarterPool.acquire();
if (starter == null) {
starter = new ActivityStarter(mController, mService, mSupervisor, mInterceptor);
}
return starter;
}
@Override
public void recycle(ActivityStarter starter) {
starter.reset(true /* clearRequest*/);
mStarterPool.release(starter);
}
}
/**
* Resolve necessary information according the request parameters provided earlier, and execute
* the request which begin the journey of starting an activity.
* @return The starter result.
*/
int execute() {
try {
int res;
synchronized (mService.mGlobalLock) {
final boolean globalConfigWillChange = mRequest.globalConfig != null
&& mService.getGlobalConfiguration().diff(mRequest.globalConfig) != 0;
final ActivityStack stack = mRootWindowContainer.getTopDisplayFocusedStack();
if (stack != null) {
stack.mConfigWillChange = globalConfigWillChange;
}
final long origId = Binder.clearCallingIdentity();
res = resolveToHeavyWeightSwitcherIfNeeded();
if (res != START_SUCCESS) {
return res;
}
// 继续调用 executeRequest() 方法
res = executeRequest(mRequest);
Binder.restoreCallingIdentity(origId);
if (globalConfigWillChange) {
......
mService.updateConfigurationLocked(mRequest.globalConfig, null, false);
}
// Notify ActivityMetricsLogger that the activity has launched.
// ActivityMetricsLogger will then wait for the windows to be drawn and populate
// WaitResult.
mSupervisor.getActivityMetricsLogger().notifyActivityLaunched(launchingState, res,
mLastStartActivityRecord);
return getExternalResult(mRequest.waitResult == null ? res
: waitForResult(res, mLastStartActivityRecord));
}
} finally {
onExecutionComplete();
}
}
private int executeRequest(Request request) {
......
// 创建 ActivityRecord，保存 Activity 的所有信息
final ActivityRecord r = new ActivityRecord(mService, callerApp, callingPid, callingUid,
callingPackage, callingFeatureId, intent, resolvedType, aInfo,
mService.getGlobalConfiguration(), resultRecord, resultWho, requestCode,
request.componentSpecified, voiceSession != null, mSupervisor, checkedOptions,
sourceRecord);
mLastStartActivityRecord = r;
......
final ActivityStack stack = mRootWindowContainer.getTopDisplayFocusedStack();
mLastStartActivityResult = startActivityUnchecked(r, sourceRecord, voiceSession,
request.voiceInteractor, startFlags, true /* doResume */, checkedOptions, inTask,
restrictedBgActivity, intentGrants);
......
return mLastStartActivityResult;
}
private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
int startFlags, boolean doResume, ActivityOptions options, Task inTask,
boolean restrictedBgActivity, NeededUriGrants intentGrants) {
int result = START_CANCELED;
try {
mService.deferWindowLayout();
result = startActivityInner(r, sourceRecord, voiceSession, voiceInteractor,
startFlags, doResume, options, inTask, restrictedBgActivity, intentGrants);
}
......
return result;
}
@VisibleForTesting
int startActivityInner(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
int startFlags, boolean doResume, ActivityOptions options, Task inTask,
boolean restrictedBgActivity, NeededUriGrants intentGrants) {
......
if (mDoResume) {
final ActivityRecord topTaskActivity =
mStartActivity.getTask().topRunningActivityLocked();
if (!mTargetStack.isTopActivityFocusable()
|| (topTaskActivity != null && topTaskActivity.isTaskOverlay()
&& mStartActivity != topTaskActivity)) {
......
mTargetStack.ensureActivitiesVisible(null /* starting */,
0 /* configChanges */, !PRESERVE_WINDOWS);
// Go ahead and tell window manager to execute app transition for this activity
// since the app transition will not be triggered through the resume channel.
mTargetStack.getDisplay().mDisplayContent.executeAppTransition();
} else {
......
mRootWindowContainer.resumeFocusedStacksTopActivities(
mTargetStack, mStartActivity, mOptions);
}
}
}
}
ActivityStarter # executeRequest() 方法会进行初步的检查并且确认权限，并且在这里组装对应 Activity 的 ActivityRecord，其包含了对应 Activity 的所有信息，并储存在任务栈 TaskRecord 中。在 Activity 的启动过程中，Activity 都是通过 ActivityRecord 来表示的。然后继续调用 ActivityStarter # startActivityUnchecked() 方法，接着 ActivityStarter # startActivityUnchecked() 方法会调用 ActivityStarter # startActivityInner() 方法。
在 ActivityStarter # startActivityInner() 方法中，主要就是处理 Activity 的启动模式有关的逻辑，并且在 ActivityStack 中处理对应 Activity 在任务栈中的相关事宜，包括但不限于将对应的 ActivityRecord 添加到 TaskRecord 栈中、将对应的 ActivityRecord 提到 TaskRecord 栈中最顶部。
最后调用 RootWindowContainer # resumeFocusedStacksTopActivities() 方法，将启动流程交给 RootWindowContainer 处理。
4. RootWindowContainer
RootWindowContainer 是窗口容器（WindowContainer）的根容器，管理所有的窗口容器，设备上所有的窗口（Window）、显示（Display）都是由它来管理的。
boolean resumeFocusedStacksTopActivities(
ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
......
boolean result = false;
if (targetStack != null && (targetStack.isTopStackInDisplayArea()
|| getTopDisplayFocusedStack() == targetStack)) {
result = targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
}
for (int displayNdx = getChildCount() - 1; displayNdx >= 0; --displayNdx) {
boolean resumedOnDisplay = false;
......
if (!resumedOnDisplay) {
// In cases when there are no valid activities (e.g. device just booted or launcher
// crashed) it's possible that nothing was resumed on a display. Requesting resume
// of top activity in focused stack explicitly will make sure that at least home
// activity is started and resumed, and no recursion occurs.
final ActivityStack focusedStack = display.getFocusedStack();
if (focusedStack != null) {
result |= focusedStack.resumeTopActivityUncheckedLocked(target, targetOptions);
} else if (targetStack == null) {
result |= resumeHomeActivity(null /* prev */, "no-focusable-task",
display.getDefaultTaskDisplayArea());
}
}
}
return result;
}
RootWindowContainer # resumeFocusedStacksTopActivities() 方法会恢复对应任务栈顶部的 Activity，方法中会检查一些可见性相关的属性，后转交给 ActivityStack # resumeTopActivityUncheckedLocked() 方法来继续启动流程。
5. ActivityStack
ActivityStack 是一个管理类，用来管理系统所有 Activity 的各种状态，其内部维护了 TaskRecord 的列表。
@GuardedBy("mService")
boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
if (mInResumeTopActivity) {
// Don't even start recursing.
return false;
}
boolean result = false;
try {
// Protect against recursion.
mInResumeTopActivity = true;
result = resumeTopActivityInnerLocked(prev, options);
// When resuming the top activity, it may be necessary to pause the top activity (for
// example, returning to the lock screen. We suppress the normal pause logic in
// {@link #resumeTopActivityUncheckedLocked}, since the top activity is resumed at the
// end. We call the {@link ActivityStackSupervisor#checkReadyForSleepLocked} again here
// to ensure any necessary pause logic occurs. In the case where the Activity will be
// shown regardless of the lock screen, the call to
// {@link ActivityStackSupervisor#checkReadyForSleepLocked} is skipped.
final ActivityRecord next = topRunningActivity(true /* focusableOnly */);
if (next == null || !next.canTurnScreenOn()) {
checkReadyForSleep();
}
} finally {
mInResumeTopActivity = false;
}
return result;
}
@GuardedBy("mService")
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
if (next.attachedToProcess()) {
......
ActivityRecord lastResumedActivity =
lastFocusedStack == null ? null : lastFocusedStack.mResumedActivity;
final ActivityState lastState = next.getState();
next.setState(RESUMED, "resumeTopActivityInnerLocked");
next.app.updateProcessInfo(false /* updateServiceConnectionActivities */,
true /* activityChange */, true /* updateOomAdj */,
true /* addPendingTopUid */);
// From this point on, if something goes wrong there is no way
// to recover the activity.
try {
next.completeResumeLocked();
} catch (Exception e) {
......
mStackSupervisor.startSpecificActivity(next, true, false);
return true;
}
} else {
// Whoops, need to restart this activity!
......
}
return true;
}
由于在ActivityStarter已经将对应 Activity 的 ActivityRecord 添加到了栈顶，所以 ActivityStack # resumeTopActivityUncheckedLocked() 方法恢复的就是将启动的栈顶 Activity，然后继续调用 ActivityStack # resumeTopActivityInnerLocked() 方法来继续启动流程，该方法中做了一系列判断，确保待启动 Activity 可见性、预定 Activity 的切换动画等。后转交给 ActivityStackSupervisor # startSpecificActivity() 方法来启动栈顶特定的 Activity。
6. ActivityStackSupervisor
ActivityStackSupervisor 是用来辅助 ATMS 对 Activity 和 Task 进行管理的，其中 ActivityStackSupervisor 是对 ActivityStack 进行管理的，用 ActivityStack 对 Acitivity 进行状态管理。
void startSpecificActivity(ActivityRecord r, boolean andResume, boolean checkConfig) {
// Is this activity's application already running?
// 获取即将要启动的 Activity 的所在的应用程序进程已经运行了吗？
final WindowProcessController wpc =
mService.getProcessController(r.processName, r.info.applicationInfo.uid);
boolean knownToBeDead = false;
// wpc.hasThread() 内部通过判断 IApplicationThread 是否被赋值，如果已赋值，即应用进程已运行
// 启动 Activity 的应用程序进程已经创建运行则走 Activity 的生命周期
// 即普通 Activity 的启动走 realStartActivityLocked() 方法继续 Activity 的创建
if (wpc != null && wpc.hasThread()) {
try {
realStartActivityLocked(r, wpc, andResume, checkConfig);
return;
} catch (RemoteException e) {
......
}
// If a dead object exception was thrown -- fall through to
// restart the application.
knownToBeDead = true;
}
r.notifyUnknownVisibilityLaunchedForKeyguardTransition();
final boolean isTop = andResume && r.isTopRunningActivity();
// 如果未赋值，即应用进程还不存在，则需要创建应用进程，由于是根 Activity 的启动所以应用进程还未被创建并启动
mService.startProcessAsync(r, knownToBeDead, isTop, isTop ? "top-activity" : "activity");
}
ActivityStackSupervisor # startSpecificActivity() 方法中获取 WindowProcessController ，通过 wpc # hasThread() 方法判断应用进程是否已创建并运行中，其内部是通过 IApplicationThread 是否已经被赋值来判断的，如果已被赋值则表示应用进程已创建且运行中，此时进入判断体内部，走 ActivityStackSupervisor # realStartActivityLocked() 方法继续 Activity 的启动流程，即普通 Activity 的启动流程。如果未被赋值，则需要创建应用进程，调用**startProcessAsync)**来创建线程。
接下去就又要回到ATMS了。
7. startProcessAsync
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);
}
// Post message to start process to avoid possible deadlock of calling into AMS with the
// ATMS lock held.
// 发送 Handler 消息来启动进程，以避免在持有 ATMS 锁的情况下调用 AMS 时可能发生的死锁
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);
}
}
方法中需要发送 Handler 消息来启动进程，上面的消息最终就调用ActivityManagerInternal::startProcess。
ActivityManagerInternal 是一个抽象类，它是 Activity 管理本地服务接口的，它的实现为 AMS 的内部类 LocalService，在 AMS 启动的过程，通过 LocalServices # addService() 注册到 LocalServices。
LocalServices 可以理解为是一个公开缓存池，内部使用 ArrayMap 来存储本地服务对象。system_server 进程中每个服务都可以通过 LocalServices # addService() 注册到 LocalServices 中，需要使用存储的 LocalService 时通过 LocalServices # getService() 获取注册的本地服务。
8. startProcessLocked
public class ActivityManagerService extends IActivityManager.Stub
implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
@VisibleForTesting
public final class LocalService extends ActivityManagerInternal {
......
@Override
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) {
// If the process is known as top app, set a hint so when the process is
// started, the top priority can be applied immediately to avoid cpu being
// preempted by other processes before attaching the process of top app.
startProcessLocked(processName, info, knownToBeDead, 0 /* intentFlags */,
new HostingRecord(hostingType, hostingName, isTop),
ZYGOTE_POLICY_FLAG_LATENCY_SENSITIVE, false /* allowWhileBooting */,
false /* isolated */, true /* keepIfLarge */);
}
} finally {
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
}
}
......
}
@GuardedBy("this")
final ProcessRecord startProcessLocked(String processName,
ApplicationInfo info, boolean knownToBeDead, int intentFlags,
HostingRecord hostingRecord, int zygotePolicyFlags, boolean allowWhileBooting,
boolean isolated, boolean keepIfLarge) {
return mProcessList.startProcessLocked(processName, info, knownToBeDead, intentFlags,
hostingRecord, zygotePolicyFlags, allowWhileBooting, isolated, 0 /* isolatedUid */,
keepIfLarge, null /* ABI override */, null /* entryPoint */,
null /* entryPointArgs */, null /* crashHandler */);
}
}
startProcess() 方法调用 AMS # startProcessLocked() 方法，并返回 ProcessRecord 实例记录管理启动进程的信息。
AMS 向 Zygote 进程发送创建应用进程 ActivityThread 的过程
1. 时序图
2. ProcessList
@GuardedBy("mService")
final ProcessRecord startProcessLocked(String processName, ApplicationInfo info,
boolean knownToBeDead, int intentFlags, HostingRecord hostingRecord,
int zygotePolicyFlags, boolean allowWhileBooting, boolean isolated, int isolatedUid,
boolean keepIfLarge, String abiOverride, String entryPoint, String[] entryPointArgs,
Runnable crashHandler) {
......
// ProcessRecord 记录每个进程的信息，进程名、uid 等
ProcessRecord app = getProcessRecordLocked(processName, info.uid, keepIfLarge);
checkSlow(startTime, "startProcess: stepping in to startProcess");
final boolean success =
startProcessLocked(app, hostingRecord, zygotePolicyFlags, abiOverride);
checkSlow(startTime, "startProcess: done starting proc!");
return success ? app : null;
}
@GuardedBy("mService")
final boolean startProcessLocked(ProcessRecord app, HostingRecord hostingRecord,
int zygotePolicyFlags, String abiOverride) {
return startProcessLocked(app, hostingRecord, zygotePolicyFlags,
false /* disableHiddenApiChecks */, false /* disableTestApiChecks */,
false /* mountExtStorageFull */, abiOverride);
}
/**
* @return {@code true} if process start is successful, false otherwise.
*/
@GuardedBy("mService")
boolean startProcessLocked(ProcessRecord app, HostingRecord hostingRecord,
int zygotePolicyFlags, boolean disableHiddenApiChecks, boolean disableTestApiChecks,
boolean mountExtStorageFull, String abiOverride) {
......
try {
app.gids = gids;
app.setRequiredAbi(requiredAbi);
app.instructionSet = instructionSet;
// Start the process. It will either succeed and return a result containing
// the PID of the new process, or else throw a RuntimeException.
// 配置新创建进程的启动文件：ActivityThread，经过层层封装后经 Socket 传输到 Zygote 进程
// Zygote 进程 fork 出新进程后要加载启动的类文件名
final String entryPoint = "android.app.ActivityThread";
return startProcessLocked(hostingRecord, entryPoint, app, uid, gids,
runtimeFlags, zygotePolicyFlags, mountExternal, seInfo, requiredAbi,
instructionSet, invokeWith, startTime);
}
......
}
@GuardedBy("mService")
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 startTime) {
......
if (mService.mConstants.FLAG_PROCESS_START_ASYNC) {
......
} else {
try {
final Process.ProcessStartResult startResult = startProcess(hostingRecord,
entryPoint, app,
uid, gids, runtimeFlags, zygotePolicyFlags, mountExternal, seInfo,
requiredAbi, instructionSet, invokeWith, startTime);
handleProcessStartedLocked(app, startResult.pid, startResult.usingWrapper,
startSeq, false);
}
......
return app.pid > 0;
}
}
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 {
......
final Process.ProcessStartResult startResult;
if (hostingRecord.usesWebviewZygote()) {
startResult = startWebView(entryPoint,
app.processName, uid, uid, gids, runtimeFlags, mountExternal,
app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
app.info.dataDir, null, app.info.packageName, app.mDisabledCompatChanges,
new String[]{PROC_START_SEQ_IDENT + app.startSeq});
} else if (hostingRecord.usesAppZygote()) {
final AppZygote appZygote = createAppZygoteForProcessIfNeeded(app);
// We can't isolate app data and storage data as parent zygote already did that.
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,
/*zygotePolicyFlags=*/ ZYGOTE_POLICY_FLAG_EMPTY, isTopApp,
app.mDisabledCompatChanges, pkgDataInfoMap, whitelistedAppDataInfoMap,
false, false,
new String[]{PROC_START_SEQ_IDENT + app.startSeq});
} else {
startResult = Process.start(entryPoint,
app.processName, uid, uid, gids, runtimeFlags, mountExternal,
app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
app.info.dataDir, invokeWith, app.info.packageName, zygotePolicyFlags,
isTopApp, app.mDisabledCompatChanges, pkgDataInfoMap,
whitelistedAppDataInfoMap, bindMountAppsData, bindMountAppStorageDirs,
new String[]{PROC_START_SEQ_IDENT + app.startSeq});
}
return startResult;
} finally {
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
}
}
经过调用 4 个 startProcessLocked() 方法后，调用到了 startProcess() 方法，然后在 startProcess() 方法里做了一个判断，根据不同的参数调用不同的方法启动进程，接着调用Process # start()。
3. Process
/**
* State associated with the zygote process.
* @hide
*/
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,
int zygotePolicyFlags,
boolean isTopApp,
@Nullable long[] disabledCompatChanges,
@Nullable Map<String, Pair<String, Long>>
pkgDataInfoMap,
@Nullable Map<String, Pair<String, Long>>
whitelistedDataInfoMap,
boolean bindMountAppsData,
boolean bindMountAppStorageDirs,
@Nullable String[] zygoteArgs) {
return ZYGOTE_PROCESS.start(processClass, niceName, uid, gid, gids,
runtimeFlags, mountExternal, targetSdkVersion, seInfo,
abi, instructionSet, appDataDir, invokeWith, packageName,
zygotePolicyFlags, isTopApp, disabledCompatChanges,
pkgDataInfoMap, whitelistedDataInfoMap, bindMountAppsData,
bindMountAppStorageDirs, zygoteArgs);
}
ZygoteProcess 在 Process 类中的静态实例，所以Process # start()调用走到 ZygoteProcess # start() 方法继续进程的启动流程。
4. ZygoteProcess
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,
int zygotePolicyFlags,
boolean isTopApp,
@Nullable long[] disabledCompatChanges,
@Nullable Map<String, Pair<String, Long>>
pkgDataInfoMap,
@Nullable Map<String, Pair<String, Long>>
whitelistedDataInfoMap,
boolean bindMountAppsData,
boolean bindMountAppStorageDirs,
@Nullable String[] zygoteArgs) {
// TODO (chriswailes): Is there a better place to check this value?
if (fetchUsapPoolEnabledPropWithMinInterval()) {
informZygotesOfUsapPoolStatus();
}
try {
// 继续调用 startViaZygote，即通过 Zygote 来启动进程
return startViaZygote(processClass, niceName, uid, gid, gids,
runtimeFlags, mountExternal, targetSdkVersion, seInfo,
abi, instructionSet, appDataDir, invokeWith, /*startChildZygote=*/ false,
packageName, zygotePolicyFlags, isTopApp, disabledCompatChanges,
pkgDataInfoMap, whitelistedDataInfoMap, bindMountAppsData,
bindMountAppStorageDirs, zygoteArgs);
}
......
}
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,
int zygotePolicyFlags,
boolean isTopApp,
@Nullable long[] disabledCompatChanges,
@Nullable Map<String, Pair<String, Long>>
pkgDataInfoMap,
@Nullable Map<String, Pair<String, Long>>
whitelistedDataInfoMap,
boolean bindMountAppsData,
boolean bindMountAppStorageDirs,
@Nullable String[] extraArgs)
throws ZygoteStartFailedEx {
// 创建字符串列表 argsForZygote，将应用进程的启动参数保存在 argsForZygote 中
// 包括 uid、gid、targetSdkVersion、应用程序进程启动文件：android.app.ActivityThread 等参数
ArrayList<String> argsForZygote = new ArrayList<>();
...... // 添加各种参数值
argsForZygote.add(processClass);
......
synchronized(mLock) {
// The USAP pool can not be used if the application will not use the systems graphics
// driver. If that driver is requested use the Zygote application start path.
// 调用 zygoteSendArgsAndGetResult()，将传入的应用进程的启动参数 argsForZygote 写入到 ZygoteState 中
return zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi),
zygotePolicyFlags, argsForZygote);
}
}
ZygoteProcess # start() 方法中，继续调用 ZygoteProcess # startViaZygote() 方法，即通知 Zygote 来启动进程，方法流程如下：
- 建字符串列表 argsForZygote，将应用进程的启动参数保存在 argsForZygote 列表中，包括 uid、gid、targetSdkVersion、应用进程的启动文件：android.app.ActivityThread 等参数。
- 调用 ZygoteProcess # openZygoteSocketIfNeeded() 方法，如果与 Zygote 进程的 socket 连接未开启，则尝试开启，可能会产生阻塞和重试。连接调用的是 ZygoteState # connect() 方法，ZygoteState 是 ZygoteProcess 的内部类。
- 调用 ZygoteProcess # zygoteSendArgsAndGetResult() 方法，向 Zygote 进程发送参数列表，启动一个新的子进程并返回子进程的 pid。注意：当前实现将参数列表中的换行符替换为空格。
这边再说下，ZygoteProcess通过 openZygoteSocketIfNeeded() 方法，打开与 Zygote 进程的 socket 连接，如果连接未建立，则尝试调用 ZygoteState # connect() 方法创建一个使用给定 Zygote socket 地址的 Socket 连接，然后连接到 Zygote 的远程服务端，同时创建 BufferedWriter 和 DataInputStream 进行参数数据的传输与读取，最后将 socket、DataInputStream、BufferedWriter 等封装成 ZygoteState 对象供外部调用。
5. ZygoteProcess 发送请求参数
@GuardedBy("mLock")
private Process.ProcessStartResult zygoteSendArgsAndGetResult(
ZygoteState zygoteState, int zygotePolicyFlags, @NonNull ArrayList<String> args)
throws ZygoteStartFailedEx {
......
if (shouldAttemptUsapLaunch(zygotePolicyFlags, args)) {
try {
return attemptUsapSendArgsAndGetResult(zygoteState, msgStr);
} catch (IOException ex) {
// If there was an IOException using the USAP pool we will log the error and
// attempt to start the process through the Zygote.
Log.e(LOG_TAG, "IO Exception while communicating with USAP pool - "
+ ex.getMessage());
}
}
return attemptZygoteSendArgsAndGetResult(zygoteState, msgStr);
}
// 用来 fork 出一个新的 Launcher 进程
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();
// Always read the entire result from the input stream to avoid leaving
// bytes in the stream for future process starts to accidentally stumble
// upon.
Process.ProcessStartResult result = new Process.ProcessStartResult();
result.pid = zygoteInputStream.readInt();
result.usingWrapper = zygoteInputStream.readBoolean();
if (result.pid < 0) {
// 进程创建失败
throw new ZygoteStartFailedEx("fork() failed");
}
return result;
} catch (IOException ex) {
zygoteState.close();
Log.e(LOG_TAG, "IO Exception while communicating with Zygote - "
+ ex.toString());
throw new ZygoteStartFailedEx(ex);
}
}
通过调用ZygoteProcess # attemptZygoteSendArgsAndGetResult() 方法中使用创建的 ZygoteState 中保存的 BufferedWriter 和 DataInputStream 来进行 Socket 通信，通过它们进行数据流的传输与读取操作。system_server 进程通过 BufferedWriter 将参数写给 Zygote 进程的 socket 的 server 端，然后阻塞等待 Zygote 进程的 socket 返回 pid 和 usingWrapper 后封装到 ProcessStartResult。
Zygote 进程接收请求 fork 并启动应用进程 ActivityThread 的过程
这边Zygote怎么处理的就掠过吧，最终调用native层。
1. 小结
Zygote 进程启动流程：
- init 进程为用户空间（相对于内核空间）的第一个进程，根据 init.rc 启动 Zygote 进程。
- Zygote 进程启动步骤：创建虚拟机、注册JNI、执行 ZygoteInit # main() 方法。
- Zygote 进程启动 system_server 进程（Zygote 启动的第一个进程），这个本小节没有具体分析。
- Zygote 创建 socket 连接通道，阻塞并等待新建进程的指令到来，将存入字符串数组的数据封装成 ZygoteArguments 格式。通过 fork 新建用户进程并返回 pid，这里的 pid 并非是进程 id，而是返回结果值，0 表示创建成功，-1 则失败。。
- Zygote 新加了一个优化进程创建的机制，UsapPool - 池化机制，我跟了一下源码，是预先缓存了几个进程。
看到这我已经块麻了，坚持坚持！
应用进程 ActivityThread 启动 Activity 的过程
1.时序图
图片要放大看
2. ActivityThread.main
public final class ActivityThread extends ClientTransactionHandler {
// 初始化 ApplicationThread
final ApplicationThread mAppThread = new ApplicationThread();
// 初始化 Handler，ApplicationThread 和 ActivityThread 通信使用
final H mH = new H();
public static void main(String[] args) {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
......
// Call per-process mainline module initialization.
initializeMainlineModules();
Process.setArgV0("<pre-initialized>");
// 初始化主线程的 Looper
Looper.prepareMainLooper();
...... // 获取 startSeq
// 实例化 ActivityThread
ActivityThread thread = new ActivityThread();
//
thread.attach(false, startSeq);
if (sMainThreadHandler == null) {
// sMainThreadHandler = mH
sMainThreadHandler = thread.getHandler();
}
// End of event ActivityThreadMain.
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
// 开启 Looper 循环，等待接收消息
Looper.loop();
// 正常不会走到这里，除非是非正常退出了 looper 循环
throw new RuntimeException("Main thread loop unexpectedly exited");
}
private void attach(boolean system, long startSeq) {
sCurrentActivityThread = this;
mSystemThread = system;
if (!system) {
android.ddm.DdmHandleAppName.setAppName("<pre-initialized>",
UserHandle.myUserId());
RuntimeInit.setApplicationObject(mAppThread.asBinder());
final IActivityManager mgr = ActivityManager.getService();
try {
mgr.attachApplication(mAppThread, startSeq);
}
......
} else {
android.ddm.DdmHandleAppName.setAppName("system_process",
UserHandle.myUserId());
try {
mInstrumentation = new Instrumentation();
mInstrumentation.basicInit(this);
ContextImpl context = ContextImpl.createAppContext(
this, getSystemContext().mPackageInfo);
mInitialApplication = context.mPackageInfo.makeApplication(true, null);
mInitialApplication.onCreate();
}
......
}
......
}
}
ActivityThread # attach() 方法中，使用 Binder 通信跨进程调用到 system_server 进程中 AMS 的 attachApplication() 方法，并将 ApplicationThread 作为参数传递过去。
3. AMS 绑定 ApplicationThread
// ActivityTaskManagerInternal 是一个抽象类，实现类是 ATMS 的内部类 LocalService
// ATMS 启动的时候，通过 LocalServices # addService() 注册到 LocalServices
public ActivityTaskManagerInternal mAtmInternal;
public ActivityManagerService(Context systemContext, ActivityTaskManagerService atm) {
......
mAtmInternal = LocalServices.getService(ActivityTaskManagerInternal.class);
......
}
@Override
public final void attachApplication(IApplicationThread thread, long startSeq) {
if (thread == null) {
throw new SecurityException("Invalid application interface");
}
synchronized (this) {
int callingPid = Binder.getCallingPid();
final int callingUid = Binder.getCallingUid();
final long origId = Binder.clearCallingIdentity();
attachApplicationLocked(thread, callingPid, callingUid, startSeq);
Binder.restoreCallingIdentity(origId);
}
}
@GuardedBy("this")
private boolean attachApplicationLocked(@NonNull IApplicationThread thread,
int pid, int callingUid, long startSeq) {
......
// 保存当前正在运行的进程的所有信息
ProcessRecord app;
......
try {
......
// 跨进程调用应用进程 ApplicationThread # bindApplication()创建绑定 Application
thread.bindApplication(processName, appInfo, providerList, null, profilerInfo,
null, null, null, testMode,
mBinderTransactionTrackingEnabled, enableTrackAllocation,
isRestrictedBackupMode || !normalMode, app.isPersistent(),
new Configuration(app.getWindowProcessController().getConfiguration()),
app.compat, getCommonServicesLocked(app.isolated),
mCoreSettingsObserver.getCoreSettingsLocked(),
buildSerial, autofillOptions, contentCaptureOptions,
app.mDisabledCompatChanges);
// Make app active after binding application or client may be running requests (e.g
// starting activities) before it is ready.
// 保存 应用进程 IApplicationThread
app.makeActive(thread, mProcessStats);
......
}
......
boolean didSomething = false;
// See if the top visible activity is waiting to run in this process...
if (normalMode) {
try {
// 通过 ATMS 启动根 Activity
didSomething = mAtmInternal.attachApplication(app.getWindowProcessController());
}
......
}
return true;
}
AMS # attachApplication() 方法，在获取到 pid、uid 后继续调用 AMS # attachApplicationLocked() 方法。
AMS # attachApplicationLocked() 方法中关注以下流程：
- 通过跨进程通信调用应用进程中 ApplicationThread # bindApplication() 创建并绑定 Application。
- ProcessRecord 调用 makeActive() 方法保存应用进程 IApplicationThread。
- 通过 ActivityTaskManagerInternal 本地服务过渡到 ATMS 启动根 Activity。
4. ActivityThread 创建并绑定 Application
IApplicationThread # bindApplication() 方法调用的是应用进程中的实现类 ApplicationThread # bindApplication() 方法，方法中通过内部类 H 发送 Handler 消息，进而调用到 ActivityThread # handleBindApplication() 方法。
@UnsupportedAppUsage
private void handleBindApplication(AppBindData data) {
......
final ContextImpl appContext = ContextImpl.createAppContext(this, data.info);
updateLocaleListFromAppContext(appContext,
mResourcesManager.getConfiguration().getLocales());
......
if (ii != null) {
......
final LoadedApk pi = getPackageInfo(instrApp, data.compatInfo,
appContext.getClassLoader(), false, true, false);
final ContextImpl instrContext = ContextImpl.createAppContext(this, pi,
appContext.getOpPackageName());
try {
// 获取 ClassLoader 加载类文件
final ClassLoader cl = instrContext.getClassLoader();
// 获取 Instrumentation 类并构建实例对象
mInstrumentation = (Instrumentation)
cl.loadClass(data.instrumentationName.getClassName()).newInstance();
}
......
final ComponentName component = new ComponentName(ii.packageName, ii.name);
mInstrumentation.init(this, instrContext, appContext, component,
data.instrumentationWatcher, data.instrumentationUiAutomationConnection);
......
}
......
Application app;
......
try {
// 创建 Application
app = data.info.makeApplication(data.restrictedBackupMode, null);
......
mInitialApplication = app;
......
try {
mInstrumentation.onCreate(data.instrumentationArgs);
}
......
try {
// 内部调用 Application # onCreate() 的方法
// 故 Application # onCreate() 比 ActivityThread 的 main() 方法慢执行
// 但是会比所有该应用 Activity 的生命周期先调用，因为此时的 Activity 还没启动
mInstrumentation.callApplicationOnCreate(app);
}
......
}
......
}
5. ProcessRecord 保存 ApplicationThread
public void makeActive(IApplicationThread _thread, ProcessStatsService tracker) {
......
thread = _thread;
mWindowProcessController.setThread(thread);
}
方法内将流程交给 WindowProcessController 并调用其 setThread() 方法存储 IApplicationThread。
public class WindowProcessController extends ConfigurationContainer<ConfigurationContainer>
implements ConfigurationContainerListener {
private IApplicationThread mThread;
@HotPath(caller = HotPath.PROCESS_CHANGE)
public void setThread(IApplicationThread thread) {
synchronized (mAtm.mGlobalLockWithoutBoost) {
mThread = thread;
if (thread != null) {
setLastReportedConfiguration(getConfiguration());
}
}
}
IApplicationThread getThread() {
return mThread;
}
boolean hasThread() {
return mThread != null;
}
}
WindowProcessController # setThread() 方法中将传入的 IApplicationThread 赋值给 mThread 中保存，此时 WindowProcessController 中的 IApplicationThread 才有值，而我们在启动根 Activity 的时候。
6. ATMS 绑定 WindowProcessController、启动根 Activity
public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
// 启动的时候注册到 LocalServices 中
private void start() {
LocalServices.addService(ActivityTaskManagerInternal.class, mInternal);
}
final class LocalService extends ActivityTaskManagerInternal {
......
@HotPath(caller = HotPath.PROCESS_CHANGE)
@Override
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 {
// 调用 RootWindowContainer # attachApplication()
return mRootWindowContainer.attachApplication(wpc);
} finally {
Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);
}
}
}
......
}
}
ActivityTaskManagerInternal 是一个抽象类，实现类是 ATMS 的内部类 LocalService，这是一个本地服务，在 ATMS 启动的时候，通过 LocalServices # addService() 注册到 LocalServices 中。在 AMS 的构造方法中通过 LocalServices # getService() 方法获取到注册的本地服务。所以 AMS 中调用 ActivityTaskManagerInternal 的方法，实际上调用的是 ATMS 中的 实现类 LocalService 的方法。该方法继续调用 RootWindowContainer # attachApplication() 方法，启动流程交给 RootWindowContainer 处理。（上面好像说过了）
7. RootWindowContainer 绑定 WindowProcessController
boolean attachApplication(WindowProcessController app) throws RemoteException {
final String processName = app.mName;
boolean didSomething = false;
for (int displayNdx = getChildCount() - 1; displayNdx >= 0; --displayNdx) {
final DisplayContent display = getChildAt(displayNdx);
final ActivityStack stack = display.getFocusedStack();
if (stack == null) {
continue;
}
mTmpRemoteException = null;
mTmpBoolean = false; // Set to true if an activity was started.
final PooledFunction c = PooledLambda.obtainFunction(
RootWindowContainer::startActivityForAttachedApplicationIfNeeded, this,
PooledLambda.__(ActivityRecord.class), app, stack.topRunningActivity());
stack.forAllActivities(c);
c.recycle();
if (mTmpRemoteException != null) {
throw mTmpRemoteException;
}
didSomething |= mTmpBoolean;
}
if (!didSomething) {
ensureActivitiesVisible(null, 0, false /* preserve_windows */);
}
return didSomething;
}
private boolean startActivityForAttachedApplicationIfNeeded(ActivityRecord r,
WindowProcessController app, ActivityRecord top) {
if (r.finishing || !r.okToShowLocked() || !r.visibleIgnoringKeyguard || r.app != null
|| app.mUid != r.info.applicationInfo.uid || !app.mName.equals(r.processName)) {
return false;
}
try {
if (mStackSupervisor.realStartActivityLocked(r, app, top == r /*andResume*/,
true /*checkConfig*/)) {
mTmpBoolean = true;
}
} catch (RemoteException e) {
.....
return true;
}
return false;
}
RootWindowContainer # attachApplication() 方法中，调用到 RootWindowContainer # startActivityForAttachedApplicationIfNeeded() 方法，RootWindowContainer # startActivityForAttachedApplicationIfNeeded() 方法中继续调用 ActivityStackSupervisor # realStartActivityLocked() 方法来真正的启动 Activity。
8. 获取 ClientTransaction、添加 Callback、设置 LifecycleStateRequest
boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
boolean andResume, boolean checkConfig) throws RemoteException {
final Task task = r.getTask();
final ActivityStack stack = task.getStack();
beginDeferResume();
try {
r.startFreezingScreenLocked(proc, 0);
......
try {
......
// Create activity launch transaction.
// 获取 ClientTransaction 实例
final ClientTransaction clientTransaction = ClientTransaction.obtain(
proc.getThread(), r.appToken);
final DisplayContent dc = r.getDisplay().mDisplayContent;
// ClientTransaction 实例添加 ClientTransactionItem 类型的回调消息
clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
System.identityHashCode(r), r.info,
// TODO: Have this take the merged configuration instead of separate global
// and override configs.
mergedConfiguration.getGlobalConfiguration(),
mergedConfiguration.getOverrideConfiguration(), r.compat,
r.launchedFromPackage, task.voiceInteractor, proc.getReportedProcState(),
r.getSavedState(), r.getPersistentSavedState(), results, newIntents,
dc.isNextTransitionForward(), proc.createProfilerInfoIfNeeded(),
r.assistToken, r.createFixedRotationAdjustmentsIfNeeded()));
// 所需的最终生命周期状态请求
final ActivityLifecycleItem lifecycleItem;
// 判断此时的生命周期状态是走 onResume 还是 onPause
if (andResume) {
// 由于此时 ActivityStack 栈中只有一个 Activity，所以 top == r 为 true，因此应赋值为 ResumeActivityItem
lifecycleItem = ResumeActivityItem.obtain(dc.isNextTransitionForward());
} else {
lifecycleItem = PauseActivityItem.obtain();
}
// 设置执行 transaction 后的最终的生命周期状态请求
clientTransaction.setLifecycleStateRequest(lifecycleItem);
// ClientLifecycleManager 调度 ClientTransaction
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
......
} catch (RemoteException e) {
// 启动失败，移除 ActivityRecord
r.launchFailed = true;
proc.removeActivity(r);
throw e;
}
} finally {
endDeferResume();
}
return true;
}
该方法执行流程如下：
- 创建 ClientTransaction 实例，其中参数 proc.getThread() 是 IApplicationThread 类型，mActivityToken 为 IBinder 类型。
- ClientTransaction 实例添加 ClientTransactionItem 类型的回调消息，注意：这里添加的是 LaunchActivityItem 实例，* LaunchActivityItem 继承自 ClientTransactionItem 抽象类并实现其中的方法。
- 获取 ClientLifecycleManager 实例，调用其 scheduleTransaction() 方法去调度转换事务 Transaction 的执行。
9. ClientTransaction 获取、添加事务回调
// 客户端的单个回调列表
@UnsupportedAppUsage
private List<ClientTransactionItem> mActivityCallbacks;
// 执行事务后客户端活动应处于的最终生命周期状态
private ActivityLifecycleItem mLifecycleStateRequest;
/** Target client. */
private IApplicationThread mClient;
/** Target client activity. Might be null if the entire transaction is targeting an app. */
private IBinder mActivityToken;
/** Obtain an instance initialized with provided params. */
// 获取 ClientTransaction 实例
public static ClientTransaction obtain(IApplicationThread client, IBinder activityToken) {
ClientTransaction instance = ObjectPool.obtain(ClientTransaction.class);
if (instance == null) {
instance = new ClientTransaction();
}
instance.mClient = client;
instance.mActivityToken = activityToken;
return instance;
}
/**
* 在 ClientTransaction 的 callbacks 列表尾部添加 ClientTransactionItem 类型的消息
* 参数：包含生命周期请求或回调的单个消息
* @param activityCallback A single message that can contain a lifecycle request/callback.
*/
public void addCallback(ClientTransactionItem activityCallback) {
if (mActivityCallbacks == null) {
mActivityCallbacks = new ArrayList<>();
}
mActivityCallbacks.add(activityCallback);
}
/**
* Set the lifecycle state in which the client should be after executing the transaction.
* 设置客户端在执行事务后应处于的生命周期状态
* @param stateRequest A lifecycle request initialized with right parameters.
*/
public void setLifecycleStateRequest(ActivityLifecycleItem stateRequest) {
mLifecycleStateRequest = stateRequest;
}
ClientTransaction 是保存一系列待发送给客户端处理的事务消息的容器，包括一个 Callback 列表和一个最终生命周期状态。
10. ClientLifecycleManager 客户端生命周期事务转换管理器
/**
* Schedule a transaction, which may consist of multiple callbacks and a lifecycle request.
* 安排调度一个事务（启动、暂停等 Activity 事务），可能包含多个回调和一个生命周期请求
* @param transaction A sequence of client transaction items.
* @throws RemoteException
*
* @see ClientTransaction
*/
void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
final IApplicationThread client = transaction.getClient();
transaction.schedule();
if (!(client instanceof Binder)) {
// If client is not an instance of Binder - it's a remote call and at this point it is
// safe to recycle the object. All objects used for local calls will be recycled after
// the transaction is executed on client in ActivityThread.
transaction.recycle();
}
}
ClientLifecycleManager 能够组合多个客户端生命周期转换请求与回调，并将其作为单个事务调度执行。
11. ClientTransaction # schedule() 调度事务
/**
* Schedule the transaction after it was initialized. It will be send to client and all its
* individual parts will be applied in the following sequence:
* 1. The client calls {@link #preExecute(ClientTransactionHandler)}, which triggers all work
* that needs to be done before actually scheduling the transaction for callbacks and
* lifecycle state request.
* 2. The transaction message is scheduled.
* 3. The client calls {@link TransactionExecutor#execute(ClientTransaction)}, which executes
* all callbacks and necessary lifecycle transitions.
*/
public void schedule() throws RemoteException {
mClient.scheduleTransaction(this);
}
看一下方法的注释，大概意思是事务初始化之后调度事务，其所有单独部分将按以下顺序发送到客户端：
- 客户端调用 preExecute() 方法，在实际调度事务的回调和生命周期状态请求之前，触发所有需要完成的任务。
- 事务消息已被调度。
- 客户端调用 TransactionExecutor # execute() 方法，执行所有回调和必要的生命周期转换。
通过上面第 8、9 小节的源码解析可以看出，这里 mClient 是 IApplicationThread 类型，它是极其重要的一个 Binder 接口，维护了应用进程和 system_server 进程中 AMS 之间的 IPC 通讯，mClient 就是应用进程在系统进程中的代理对象，AMS 通过 mClient 与此时作为服务端的应用进程进行通信。而应用进程中的实现类 ApplicationThread 是 ActivityThread 的内部类，继承自 IApplicationThread.Stub，实现了 Binder 接口，此时作为服务端接受 system_server 进程中 AMS 发出的请求并执行，也就是流程切到应用进程继续执行。
12. ActivityThread 调度事务
public abstract class ClientTransactionHandler {
/** Prepare and schedule transaction for execution. */
void scheduleTransaction(ClientTransaction transaction) {
transaction.preExecute(this);
// 发送 Handler 消息到 ActivityThread.H 中
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
/**
* Get the {@link TransactionExecutor} that will be performing lifecycle transitions and
* callbacks for activities.
*/
abstract TransactionExecutor getTransactionExecutor();
// ActivityThread 实现该抽象方法，然后调用其内部的 mH 发送消息并处理
abstract void sendMessage(int what, Object obj);
}
public final class ActivityThread extends ClientTransactionHandler {
final H mH = new H();
// An executor that performs multi-step transactions.
private final TransactionExecutor mTransactionExecutor = new TransactionExecutor(this);
// 应用进程中 IApplicationThread 的实现类，继续调用 ActivityThread 的方法
private class ApplicationThread extends IApplicationThread.Stub {
@Override
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
// 执行父类 ClientTransactionHandler # scheduleTransaction()
ActivityThread.this.scheduleTransaction(transaction);
}
}
class H extends Handler {
......
public static final int EXECUTE_TRANSACTION = 159; // 执行事务
public void handleMessage(Message msg) {
......
switch (msg.what) {
......
case EXECUTE_TRANSACTION:
// 获取传递过来的 ClientTransaction
final ClientTransaction transaction = (ClientTransaction) msg.obj;
// TransactionExecutor
mTransactionExecutor.execute(transaction);
if (isSystem()) {
// Client transactions inside system process are recycled on the client side
// instead of ClientLifecycleManager to avoid being cleared before this
// message is handled.
transaction.recycle();
}
// TODO(lifecycler): Recycle locally scheduled transactions.
break;
......
}
......
}
}
void sendMessage(int what, Object obj) {
sendMessage(what, obj, 0, 0, false);
}
......
private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) {
......
Message msg = Message.obtain();
msg.what = what;
msg.obj = obj;
msg.arg1 = arg1;
msg.arg2 = arg2;
if (async) {
msg.setAsynchronous(true);
}
mH.sendMessage(msg);
}
}
执行流程如下：
- ApplicationThread # scheduleTransaction() 方法中又继续调用 ActivityThread # scheduleTransaction() 方法，而 ActivityThread 自身没有这个方法，因此执行父类 ClientTransactionHandler # scheduleTransaction() 方法。
- ClientTransactionHandler # scheduleTransaction() 方法中通过继承自 Handler 的实现类 H 发送消息到 ActivityThread 中，并重写了其 handleMessage() 方法。
- H # handleMessage() 方法中获取传递过来的 ClientTransaction，并由 TransactionExecutor # execute() 执行该 ClientTransaction 的转换。
13. TransactionExecutor 事务转换执行器
public void execute(ClientTransaction transaction) {
final IBinder token = transaction.getActivityToken();
if (token != null) {
final Map<IBinder, ClientTransactionItem> activitiesToBeDestroyed =
mTransactionHandler.getActivitiesToBeDestroyed();
final ClientTransactionItem destroyItem = activitiesToBeDestroyed.get(token);
if (destroyItem != null) {
if (transaction.getLifecycleStateRequest() == destroyItem) {
// 执行销毁与该 token 有关的 Activity 的事务，然后与此有关的记录将被移除
activitiesToBeDestroyed.remove(token);
}
if (mTransactionHandler.getActivityClient(token) == null) {
// Activity 还未完成创建就请求销毁，所以与这个 token 有关的事务都要取消
Slog.w(TAG, tId(transaction) + "Skip pre-destroyed transaction:\n"
+ transactionToString(transaction, mTransactionHandler));
return;
}
}
}
// 执行事务的回调 -- 第 8 小节中添加到 ClientTransaction 中的回调 -- LaunchActivityItem
executeCallbacks(transaction);
// 执行生命周期状态
executeLifecycleState(transaction);
mPendingActions.clear();
}
/**
* Cycle through all states requested by callbacks and execute them at proper times.
* 循环遍历回调列表中的所有状态请求，在适当的时间执行它们
*/
@VisibleForTesting
public void executeCallbacks(ClientTransaction transaction) {
final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
if (callbacks == null || callbacks.isEmpty()) {
return;
}
final IBinder token = transaction.getActivityToken();
ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
final ActivityLifecycleItem finalStateRequest = transaction.getLifecycleStateRequest();
final int finalState = finalStateRequest != null ? finalStateRequest.getTargetState()
: UNDEFINED;
// Index of the last callback that requests some post-execution state.
final int lastCallbackRequestingState = lastCallbackRequestingState(transaction);
final int size = callbacks.size();
for (int i = 0; i < size; ++i) {
final ClientTransactionItem item = callbacks.get(i);
......// 执行回调并输出日志
final int postExecutionState = item.getPostExecutionState();
final int closestPreExecutionState = mHelper.getClosestPreExecutionState(r,
item.getPostExecutionState());
if (closestPreExecutionState != UNDEFINED) {
cycleToPath(r, closestPreExecutionState, transaction);
}
// 获取到 LaunchActivityItem 并调用其 execute() 方法
item.execute(mTransactionHandler, token, mPendingActions);
item.postExecute(mTransactionHandler, token, mPendingActions);
if (r == null) {
// 启动活动请求将创建一个活动记录
r = mTransactionHandler.getActivityClient(token);
}
if (postExecutionState != UNDEFINED && r != null) {
final boolean shouldExcludeLastTransition =
i == lastCallbackRequestingState && finalState == postExecutionState;
cycleToPath(r, postExecutionState, shouldExcludeLastTransition, transaction);
}
}
}
TransactionExecutor # executeCallbacks() 方法中，循环遍历回调列表中的所有状态请求，并在适当的时间执行添加的状态请求。这个讲完之后接着讲executeLifecycleState(transaction)
14. LaunchActivityItem 请求启动 Activity
/**
1. Request to launch an activity.
2. 请求启动 Activity
3. @hide
*/
public class LaunchActivityItem extends ClientTransactionItem {
@Override
public void execute(ClientTransactionHandler client, IBinder token,
PendingTransactionActions pendingActions) {
Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
ActivityClientRecord r = new ActivityClientRecord(token, mIntent, mIdent, mInfo,
mOverrideConfig, mCompatInfo, mReferrer, mVoiceInteractor, mState, mPersistentState,
mPendingResults, mPendingNewIntents, mIsForward,
mProfilerInfo, client, mAssistToken, mFixedRotationAdjustments);
client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}
}
ClientTransactionHandler 是一个抽象类，ActivityThread 继承自 ClientTransactionHandler 并实现了其抽象方法，所以这里又回到了 ActivityThread 类，调用其 handleLaunchActivity() 方法来启动 Activity。
15. ActivityThread 执行启动 Activity 事务
@Override
public Activity handleLaunchActivity(ActivityClientRecord r,
PendingTransactionActions pendingActions, Intent customIntent) {
......
WindowManagerGlobal.initialize();
// Hint the GraphicsEnvironment that an activity is launching on the process.
GraphicsEnvironment.hintActivityLaunch();
final Activity a = performLaunchActivity(r, customIntent);
if (a != null) {
r.createdConfig = new Configuration(mConfiguration);
reportSizeConfigurations(r);
if (!r.activity.mFinished && pendingActions != null) {
pendingActions.setOldState(r.state);
pendingActions.setRestoreInstanceState(true);
pendingActions.setCallOnPostCreate(true);
}
} else {
// 启动 Activity 发生异常，不论是什么原因，通知 ATMS 终止此 Activity
try {
ActivityTaskManager.getService()
.finishActivity(r.token, Activity.RESULT_CANCELED, null,
Activity.DONT_FINISH_TASK_WITH_ACTIVITY);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
return a;
}
/** Core implementation of activity launch. */
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
ActivityInfo aInfo = r.activityInfo;
if (r.packageInfo == null) {
r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
Context.CONTEXT_INCLUDE_CODE);
}
......
// 创建 Activity 的 Context
ContextImpl appContext = createBaseContextForActivity(r);
Activity activity = null;
try {
// 通过 ClassLoader 反射获取 Activity 的实例
java.lang.ClassLoader cl = appContext.getClassLoader();
activity = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent);
StrictMode.incrementExpectedActivityCount(activity.getClass());
r.intent.setExtrasClassLoader(cl);
r.intent.prepareToEnterProcess();
if (r.state != null) {
r.state.setClassLoader(cl);
}
} catch (Exception e) {
......
}
try {
// 创建 Application
Application app = r.packageInfo.makeApplication(false, mInstrumentation);
......
if (activity != null) {
......
appContext.getResources().addLoaders(
app.getResources().getLoaders().toArray(new ResourcesLoader[0]));
appContext.setOuterContext(activity);
// 执行 Activity 的 attach、初始化 Window 等
activity.attach(appContext, this, getInstrumentation(), r.token,
r.ident, app, r.intent, r.activityInfo, title, r.parent,
r.embeddedID, r.lastNonConfigurationInstances, config,
r.referrer, r.voiceInteractor, window, r.configCallback,
r.assistToken);
......
activity.mCalled = false;
// 执行 Activity 的 onCreate
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
......
r.activity = activity;
mLastReportedWindowingMode.put(activity.getActivityToken(),
config.windowConfiguration.getWindowingMode());
}
// 设置生命周期的状态为 ON_CREATE
r.setState(ON_CREATE);
synchronized (mResourcesManager) {
mActivities.put(r.token, r);
}
}
......
return activity;
}
performLaunchActivity() 方法执行流程：
- 调用 createBaseContextForActivity() 方法创建 ContextImpl 对象，该方法中调用 ContextImpl # createActivityContext() 方法创建 ContextImpl 对象。
- 调用 Instrumentation # newActivity() 方法加载并新建 Activity，该方法中调用 AppComponentFactory # instantiateActivity() 方法，后* 通过在 performLaunchActivity() 方法中新建的 ClassLoader 加载新建 Activity 类。
- 通过 LoadApk # makeApplication() 方法创建一个 Application 对象，过程跟加载新建 Activity 类似，用到 ClassLoader。
- 执行 Activity # attach() 方法，ContextImpl 通过该方法来和 Activity 建立关联，除此之外，方法中还完成了 Window 实例的创建并建立自己和 Window 的关联，这样当 Window 接收到外部输入事件后就可以将事件传递给 Activity。
- 执行 Instrumentation # callActivityOnCreate() 方法，该方法中调用 Activity # performCreate() 方法，Activity # performCreate() 方法中调用 Activity # onCreate() 方法。
流程走到这里 Activity # onCreate() 方法执行完，并设置生命周期的状态为 ON_CREATE，那onStart、onResume什么时候会调用，往下看
16. TransactionExecutorHelper 获取待执行生命周期的状态序列
/**
* 请求 Activity 应该达到的生命周期状态
*/
public abstract class ActivityLifecycleItem extends ClientTransactionItem {
......
@Retention(RetentionPolicy.SOURCE)
public @interface LifecycleState{}
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;
/** A final lifecycle state that an activity should reach. */
@LifecycleState
public abstract int getTargetState();
}
与 Activity 生命周期有关的 StartActivityItem、ResumeActivityItem 等继承自该抽象类并实现其抽象方法 getTargetState()，方法中返回对应的生命周期，注意：LaunchActivityItem 直接继承自 ClientTransactionItem。
结合上面这个抽象类来分析 TransactionExecutorHelper # getLifecyclePath() 方法。
@VisibleForTesting
public IntArray getLifecyclePath(int start, int finish, boolean excludeLastState) {
......
// 清空生命周期状态序列
mLifecycleSequence.clear();
if (finish >= start) {
if (start == ON_START && finish == ON_STOP) {
// 如果很快从 ON_START 转换到 ON_STOP 状态，此时不需要经历恢复、暂停状态
mLifecycleSequence.add(ON_STOP);
} else {
// 添加 start 到 finish 之间的生命周期状态
for (int i = start + 1; i <= finish; i++) {
mLifecycleSequence.add(i);
}
}
}
......
// 根据条件判断移除最后的生命周期状态
if (excludeLastState && mLifecycleSequence.size() != 0) {
mLifecycleSequence.remove(mLifecycleSequence.size() - 1);
}
return mLifecycleSequence;
}
经过之前的分析，可知 TransactionExecutorHelper # getLifecyclePath() 方法中传入的 start 为 ON_CREATE，finish 为 ON_RESUME，excludeLastState 为 true。由 ActivityLifecycleItem 抽象类定义可知 finish >= start，因此方法中可以只关注这部分的逻辑处理，通过比较可以发现 ON_CREATE 和 ON_RESUME 中间还有 ON_START 这个中间状态，所以在 mLifecycleSequence 状态序列中将添加 ON_START 和 ON_RESUME 状态，此时因为 excludeLastState 为 true，所以最后会移除掉 ON_RESUME 状态，故返回的状态序列中只包含 ON_START 状态，即 cycleToPath() 方法中获得的 path 中只包含 ON_START 状态。
17. executeLifecycleState(transaction)
/** Transition to the final state if requested by the transaction. */
private void executeLifecycleState(ClientTransaction transaction) {
// 获取之前设置的生命周期状态请求
final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
if (lifecycleItem == null) {
// No lifecycle request, return early.
return;
}
final IBinder token = transaction.getActivityToken();
// 获取 ActivityClientRecord，该对象保存 Activity 的启动信息
final ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
......
if (r == null) {
// Ignore requests for non-existent client records for now.
return;
}
// Cycle to the state right before the final requested state.
// 执行当前已设置的生命周期请求最终状态之前的状态
cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */, transaction);
// Execute the final transition with proper parameters.
// 执行设置的生命周期事务的最终转换
lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
}
这里面有个重要的方法cycleToPath；
private void cycleToPath(ActivityClientRecord r, int finish, boolean excludeLastState,
ClientTransaction transaction) {
final int start = r.getLifecycleState();
......
final IntArray path = mHelper.getLifecyclePath(start, finish, excludeLastState);
performLifecycleSequence(r, path, transaction);
}
/** Transition the client through previously initialized state sequence. */
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_CREATE:
mTransactionHandler.handleLaunchActivity(r, mPendingActions,
null /* customIntent */);
break;
case ON_START:
mTransactionHandler.handleStartActivity(r.token, mPendingActions);
break;
......
}
}
}
TransactionExecutor # executeLifecycleState(transaction) 方法主要是用来转换 Activity 的生命周期状态至设置的最终状态并执行，流程如下：
- 调用getLifecycleStateRequest获取ActivityLifecycleItem ，
- 调用 cycleToPath() 方法获取并执行设置的生命周期请求最终状态之前的状态。
- 调用 ActivityLifecycleItem # execute() 方法执行设置的生命周期事务的最终转换。
到此为止吧，晕了晕了。
扫一扫
121
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
