Activity启动流程源码分析
- 调用Activity#startActivity
public void startActivity(Intent intent) {
this.startActivity(intent, null);
}
public void startActivity(Intent intent, @Nullable Bundle options) {
if (options != null) {
startActivityForResult(intent, -1, options);
} else {
// options == null
startActivityForResult(intent, -1);
}
}
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode) {
startActivityForResult(intent, requestCode, null);
}
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
@Nullable Bundle options) {
if (mParent == null) {
// 调用Instrumentation启动
Instrumentation.ActivityResult ar =
mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, this,
intent, requestCode, options);
if (ar != null) {
// 处理启动Activity结果
mMainThread.sendActivityResult(
mToken, mEmbeddedID, requestCode, ar.getResultCode(),
ar.getResultData());
}
}
}
- 调用Instrumentation#execStartActivity
public ActivityResult execStartActivity() {
// 获取到ActivityTaskManagerService，调用其startActivity方法
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);
// 检查启动结果，启动失败或一些非法操作则会抛出异常
checkStartActivityResult(result, intent);
return null;
}
- 调用ActivityTaskManagerService
public final int startActivity() {
// 获取callUserId后继续调用startActivityAsUser
return startActivityAsUser(xxx, UserHandle.getCallingUserId());
}
private int startActivityAsUser() {
// 获取ActivityStarter并设置相关内容，最后调用execute方法执行
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();
}
- 调用ActivityStarter#execute
int execute() {
int res = START_CANCELED;
res = executeRequest(mRequest);
return getExternalResult(res);
}
private int executeRequest(Request request) {
mLastStartActivityResult = startActivityUnchecked(r, sourceRecord, voiceSession,
request.voiceInteractor, startFlags, checkedOptions,
inTask, inTaskFragment, balVerdict, intentGrants, realCallingUid);
return mLastStartActivityResult;
}
private int startActivityUnchecked(xxx) {
int result = START_CANCELED;
result = startActivityInner(r, sourceRecord, voiceSession, voiceInteractor,
startFlags, options, inTask, inTaskFragment, balVerdict,
intentGrants, realCallingUid);
return result;
}
int startActivityInner(xxx) {
// 获取Task
final Task prevTopRootTask = mPreferredTaskDisplayArea.getFocusedRootTask();
final Task prevTopTask =
prevTopRootTask != null ? prevTopRootTask.getTopLeafTask() : null;
final Task reusedTask = getReusableTask();
final Task targetTask = reusedTask != null ? reusedTask : computeTargetTask();
final boolean newTask = targetTask == null;
// Task相关复用创建相关逻辑
...
if (mTargetRootTask == null) {
// 拿到启动的Activity对应的Task
mTargetRootTask = getOrCreateRootTask(mStartActivity, mLaunchFlags, targetTask,
mOptions);
}
// Task复用逻辑
if (newTask) {
final Task taskToAffiliate = (mLaunchTaskBehind && mSourceRecord != null)
? mSourceRecord.getTask() : null;
setNewTask(taskToAffiliate);
} else if (mAddingToTask) {
addOrReparentStartingActivity(targetTask, "adding to task");
}
if (mDoResume) {
// 继续启动Activity
mRootWindowContainer.resumeFocusedTasksTopActivities(
mTargetRootTask, mStartActivity, mOptions, mTransientLaunch);
}
}
- 调用RootWindowContainer#resumeFocusedTasksTopActivities
boolean resumeFocusedTasksTopActivities(
Task targetRootTask, ActivityRecord target, ActivityOptions targetOptions,
boolean deferPause) {
boolean result = false;
// 由Task自己继续启动
result = targetRootTask.resumeTopActivityUncheckedLocked(target, targetOptions,
deferPause);
return result;
}
- 调用Task#resumeTopActivityUncheckedLocked
boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options,
boolean deferPause) {
boolean someActivityResumed = false;
if (isLeafTask()) {
if (isFocusableAndVisible()) {
// 内部调用resumeTopActivityInnerLocked
someActivityResumed = resumeTopActivityInnerLocked(prev, options, deferPause);
}
}
return someActivityResumed;
}
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options,
boolean deferPause) {
// 位于栈顶的Activity，约等于要启动的Activity
final ActivityRecord topActivity = topRunningActivity(true /* focusableOnly */);
final boolean[] resumed = new boolean[1];
final TaskFragment topFragment = topActivity.getTaskFragment();
// TaskFragment继续启动
resumed[0] = topFragment.resumeTopActivity(prev, options, deferPause);
return resumed[0];
}
- 调用TaskFragment#resumeTopActivity
ActivityRecord next = topRunningActivity(true /* focusableOnly */);
boolean pausing = !skipPause && taskDisplayArea.pauseBackTasks(next);
if (mResumedActivity != null) {
// pause当前resumed的Activity
pausing |= startPausing(mTaskSupervisor.mUserLeaving, false /* uiSleeping */,
next, "resumeTopActivity");
}
if (next.attachedToProcess()) {
// 热启动，调度Activity生命周期，使其可见
} else {
// 冷启动
// 启动指定的Activity
mTaskSupervisor.startSpecificActivity(next, true, true);
}
return true;
- 调用ActivityTaskSupervisor#startSpecificActivity
void startSpecificActivity(ActivityRecord r, boolean andResume, boolean checkConfig) {
// Is this activity's application already running?
final WindowProcessController wpc =
mService.getProcessController(r.processName, r.info.applicationInfo.uid);
if (wpc != null && wpc.hasThread()) {
// Application存在，直接启动
realStartActivityLocked(r, wpc, andResume, checkConfig);
return;
}
// 不存在，让ActivityTaskManagerService先创建进程
mService.startProcessAsync(r, knownToBeDead, isTop,
isTop ? HostingRecord.HOSTING_TYPE_TOP_ACTIVITY
: HostingRecord.HOSTING_TYPE_ACTIVITY);
}
- 调用ActivityTaskManagerService#startProcessAsync
void startProcessAsync(ActivityRecord activity, boolean knownToBeDead, boolean isTop,
String hostingType) {
// 将调用封装到Callback中，最后生成Message对象，然后执行
// 相当于mAmInternal.startProcess
// 最后调用到ActivityManagerService#startProcess
final Message m = PooledLambda.obtainMessage(ActivityManagerInternal::startProcess,
mAmInternal, activity.processName, activity.info.applicationInfo, knownToBeDead,
isTop, hostingType, activity.intent.getComponent());
mH.sendMessage(m);
}
- 调用ActivityManagerService#startProcess
public void startProcess(String processName, ApplicationInfo info, boolean knownToBeDead,
boolean isTop, String hostingType, ComponentName hostingName) {
// 创建HostingRecord，指向socket地址
HostingRecord hostingRecord =
new HostingRecord(hostingType, hostingName, isTop);
// 获取进程信息
ProcessRecord rec = getProcessRecordLocked(processName, info.uid);
// 创建进程
ProcessRecord app = startProcessLocked(processName, info, knownToBeDead,
0 /* intentFlags */, hostingRecord,
ZYGOTE_POLICY_FLAG_LATENCY_SENSITIVE, false /* allowWhileBooting */,
false /* isolated */);
}
final ProcessRecord startProcessLocked(String processName,
ApplicationInfo info, boolean knownToBeDead, int intentFlags,
HostingRecord hostingRecord, int zygotePolicyFlags, boolean allowWhileBooting,
boolean isolated) {
// 交给ProcessList继续创建
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 */);
}
- 调用ProcessList#startProcessLocked
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) {
ProcessRecord app;
// isolated == false
if (!isolated) {
// 获取进程信息
app = getProcessRecordLocked(processName, info.uid);
}
// 创建进程
final boolean success =
startProcessLocked(app, hostingRecord, zygotePolicyFlags, abiOverride);
return success ? app : null;
}
boolean startProcessLocked(ProcessRecord app, HostingRecord hostingRecord,
int zygotePolicyFlags, String abiOverride) {
// 重载
return startProcessLocked(app, hostingRecord, zygotePolicyFlags,
false /* disableHiddenApiChecks */, false /* disableTestApiChecks */,
abiOverride);
}
boolean startProcessLocked(ProcessRecord app, HostingRecord hostingRecord,
int zygotePolicyFlags, boolean disableHiddenApiChecks, boolean disableTestApiChecks,
String abiOverride) {
// 构建Zygote参数，flags
...
// Start the process. It will either succeed and return a result containing
// the PID of the new process, or else throw a RuntimeException.
// 进程创建后启动的执行main方法的类
final String entryPoint = "android.app.ActivityThread";
// 重载
return startProcessLocked(hostingRecord, entryPoint, app, uid, gids,
runtimeFlags, zygotePolicyFlags, mountExternal, seInfo, requiredAbi,
instructionSet, invokeWith, startUptime, startElapsedTime);
}
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) {
// 真正创建进程的方法
final Process.ProcessStartResult startResult = startProcess(hostingRecord,
entryPoint, app,
uid, gids, runtimeFlags, zygotePolicyFlags, mountExternal, seInfo,
requiredAbi, instructionSet, invokeWith, startUptime);
handleProcessStartedLocked(app, startResult.pid, startResult.usingWrapper,
startSeq, false);
// 创建进程的pid>0则成功
return app.getPid() > 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) {
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.getDisabledCompatChanges(),
bindOverrideSysprops,
new String[]{PROC_START_SEQ_IDENT + app.getStartSeq()});
} 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.getDisabledCompatChanges(), pkgDataInfoMap, allowlistedAppDataInfoMap,
false, false, bindOverrideSysprops,
new String[]{PROC_START_SEQ_IDENT + app.getStartSeq()});
} else {
// hostingRecord默认为RegularZygote
regularZygote = true;
// 调用Process创建进程
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.getDisabledCompatChanges(), pkgDataInfoMap,
allowlistedAppDataInfoMap, bindMountAppsData, bindMountAppStorageDirs,
bindOverrideSysprops,
new String[]{PROC_START_SEQ_IDENT + app.getStartSeq()});
// By now the process group should have been created by zygote.
app.mProcessGroupCreated = true;
}
return startResult;
}
- 调用Process#start
public static final ZygoteProcess ZYGOTE_PROCESS = new ZygoteProcess();
public static ProcessStartResult start(xxx) {
// 使用单例ZygoteProcess进程创建
return ZYGOTE_PROCESS.start(xxx);
}
- 调用ZygoteProcess#start
public final Process.ProcessStartResult start(xxx) {
return startViaZygote(processClass, niceName, uid, gid, gids,
runtimeFlags, mountExternal, targetSdkVersion, seInfo,
abi, instructionSet, appDataDir, invokeWith, /*startChildZygote=*/ false,
packageName, zygotePolicyFlags, isTopApp, disabledCompatChanges,
pkgDataInfoMap, allowlistedDataInfoList, bindMountAppsData,
bindMountAppStorageDirs, zygoteArgs);
}
private Process.ProcessStartResult startViaZygote() {
// zygote参数
ArrayList<String> argsForZygote = new ArrayList<>();
// 添加zygote参数
...
synchronized(mLock) {
// 发送指令并获取结果
return zygoteSendArgsAndGetResult(
// 确保跟Zygote进程合适的socket连接
openZygoteSocketIfNeeded(abi),
zygotePolicyFlags,
argsForZygote
);
}
}
private Process.ProcessStartResult zygoteSendArgsAndGetResult(ZygoteState zygoteState, int zygotePolicyFlags, @NonNull ArrayList<String> args)
throws ZygoteStartFailedEx {
if (shouldAttemptUsapLaunch(zygotePolicyFlags, args)) {
// 能够使用USAP启动，直接将USAP进程转化为目标进程
return attemptUsapSendArgsAndGetResult(zygoteState, msgStr);
}
// 使用Zygote fork目标进程
return attemptZygoteSendArgsAndGetResult(zygoteState, msgStr);
}
private Process.ProcessStartResult attemptUsapSendArgsAndGetResult(
ZygoteState zygoteState, String msgStr)
throws ZygoteStartFailedEx, IOException {
// 获取USAP socket
try (LocalSocket usapSessionSocket = zygoteState.getUsapSessionSocket()) {
final BufferedWriter usapWriter =
new BufferedWriter(
new OutputStreamWriter(usapSessionSocket.getOutputStream()),
Zygote.SOCKET_BUFFER_SIZE);
final DataInputStream usapReader =
new DataInputStream(usapSessionSocket.getInputStream());
// 写入命令
usapWriter.write(msgStr);
usapWriter.flush();
Process.ProcessStartResult result = new Process.ProcessStartResult();
// 获取创建进程的pid
result.pid = usapReader.readInt();
// USAPs can't be used to spawn processes that need wrappers.
result.usingWrapper = false;
if (result.pid >= 0) {
// 返回创建结果
return result;
} else {
throw new ZygoteStartFailedEx("USAP specialization failed");
}
}
}
private Process.ProcessStartResult attemptZygoteSendArgsAndGetResult(
ZygoteState zygoteState, String msgStr) throws ZygoteStartFailedEx {
try {
// 获取Zygote输入输出流
final BufferedWriter zygoteWriter = zygoteState.mZygoteOutputWriter;
final DataInputStream zygoteInputStream = zygoteState.mZygoteInputStream;
// 发送命令
zygoteWriter.write(msgStr);
zygoteWriter.flush();
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);
}
}
- 执行ActivityThread#main方法
final ApplicationThread mAppThread = new ApplicationThread();
public static void main(String[] args) {
// 初始化Looper
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
// 绑定Application
thread.attach(false, startSeq);
// 开始接受消息
Looper.loop();
}
private void attach(boolean system, long startSeq) {
// system == false
if (!system) {
final IActivityManager mgr = ActivityManager.getService();
// 调用ActivityManagerService绑定application
mgr.attachApplication(mAppThread, startSeq);
}
}
- 执行ActivityManagerService#attachApplication方法
public final void attachApplication(IApplicationThread thread, long startSeq) {
synchronized (this) {
// 加锁调用
attachApplicationLocked(thread, callingPid, callingUid, startSeq);
}
}
private void attachApplicationLocked(@NonNull IApplicationThread thread,
int pid, int callingUid, long startSeq) {
// 进程名
final String processName = app.processName;
if (app.getIsolatedEntryPoint() != null) {
// 独立进程
} else if (instr2 != null) {
// 调用ApplicationThread#bindApplication
thread.bindApplication(xxx)
} else {
thread.bindApplication(xxx)
}
}
- 调用ApplicationThread#bindApplication方法
// ActivityThread.java
public final void bindApplication(xxx) {
AppBindData data = new AppBindData();
// 初始化AppBindData
...
// 发送消息
sendMessage(H.BIND_APPLICATION, data);
}
public void handleMessage(Message msg) {
switch (msg.what) {
case BIND_APPLICATION:
AppBindData data = (AppBindData)msg.obj;
// 处理消息
handleBindApplication(data);
break;
}
}
private void handleBindApplication(AppBindData data) {
final IActivityManager mgr = ActivityManager.getService();
Application app;
// 默认使用AppComponentFactory类创建Application对象，使用反射实现
app = data.info.makeApplicationInner(data.restrictedBackupMode, null);
// 调用Application#onCreate方法
// app.onCreate();
mInstrumentation.callApplicationOnCreate(app);
// ActivityManagerService完成最后的绑定操作
mgr.finishAttachApplication(mStartSeq);
}
- 调用ActivityManagerService#finishAttachApplication
public final void finishAttachApplication(long startSeq) {
// 系统进程不需要执行后续操作
if (pid == MY_PID && uid == SYSTEM_UID) {
return;
}
// 内部实现
finishAttachApplicationInner(startSeq, uid, pid);
}
private void finishAttachApplicationInner(long startSeq, int uid, int pid) {
final ProcessRecord app;
// 系统启动后，mProcessReady为ture
final boolean normalMode = mProcessesReady || isAllowedWhileBooting(app.info);
// 一直为true
if (normalMode) {
// 调用 ActivityTaskManagerInternal#attachApplication
didSomething = mAtmInternal.attachApplication(
app.getWindowProcessController());
}
}
- 调用ActivityTaskManagerInternal#attachApplication
public boolean attachApplication(WindowProcessController wpc) throws RemoteException {
// 交由RootWindowContainer处理
return mRootWindowContainer.attachApplication(wpc);
}
- 调用RootWindowContainer#attachApplication
boolean attachApplication(WindowProcessController app) throws RemoteException {
// 交由内部类AttachApplicationHelper处理
return mAttachApplicationHelper.process(app);
}
// 内部类
private class AttachApplicationHelper implements Consumer<Task>, Predicate<ActivityRecord> {
boolean process(WindowProcessController app) throws RemoteException {
for (int displayNdx = getChildCount() - 1; displayNdx >= 0; --displayNdx) {
// 获取的child为DisplayContent对象，其继承于WindowContainer
getChildAt(displayNdx).forAllRootTasks(this);
}
}
}
- 调用WindowContainer#forAllRootTasks
// WindowContainer.java
void forAllRootTasks(Consumer<Task> callback) {
forAllRootTasks(callback, true /* traverseTopToBottom */);
}
void forAllRootTasks(Consumer<Task> callback, boolean traverseTopToBottom) {
int count = mChildren.size();
// 一直为true
if (traverseTopToBottom) {
for (int i = count - 1; i >= 0; --i) {
// 这里的child为Task
mChildren.get(i).forAllRootTasks(callback, traverseTopToBottom);
}
}
}
// Task.java
void forAllRootTasks(Consumer<Task> callback, boolean traverseTopToBottom) {
// 是rootTask则调用callback#aceept
if (isRootTask()) {
callback.accept(this);
}
}
- 调用AttachApplicationHelper#accept
public void accept(Task rootTask) {
// Task继承WindowContainer，实际调用WindowContainer#forAllActivities
rootTask.forAllActivities(this);
}
- 调用WindowContainer#forAllActivities
boolean forAllActivities(Predicate<ActivityRecord> callback) {
return forAllActivities(callback, true /*traverseTopToBottom*/);
}
boolean forAllActivities(Predicate<ActivityRecord> callback, boolean traverseTopToBottom) {
// 一直为true
if (traverseTopToBottom) {
for (int i = mChildren.size() - 1; i >= 0; --i) {
// 这里的child为ActivityRecord
if (mChildren.get(i).forAllActivities(callback, traverseTopToBottom)) return true;
}
}
return false;
}
// ActivityRecord.java
boolean forAllActivities(Predicate<ActivityRecord> callback, boolean traverseTopToBottom) {
// 调用callback#test
// 实际调用AttachApplicationHelper#test
return callback.test(this);
}
- 调用AttachApplicationHelper#test
public boolean test(ActivityRecord r) {
// 调用ActivityTaskSupervisor#realStartActivityLocked方法
// 与启动Activity时进程已创建一样的流程
if (mTaskSupervisor.realStartActivityLocked(r, mApp,
mTop == r && r.getTask().canBeResumed(r) /* andResume */,
true /* checkConfig */)) {
mHasActivityStarted = true;
}
return false;
}
- 调用ActivityTaskSupervisor#realStartActivityLocked
boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
boolean andResume, boolean checkConfig) throws RemoteException {
final Task task = r.getTask();
if (andResume) {
// pause activity
if (task.pauseActivityIfNeeded(r, "realStart")) {}
}
// 检查进程是否创建
if (!proc.hasThread()) {
throw new RemoteException();
}
// 创建LaunchActivityItem transaction
final LaunchActivityItem launchActivityItem = LaunchActivityItem.obtain(xxx)
final ActivityLifecycleItem lifecycleItem;
// 创建ResumeActivityItem transaction
if (andResume) {
lifecycleItem = ResumeActivityItem.obtain(xxx);
}
// 使用ClientLifecycleManager调度 transactions
mService.getLifecycleManager().scheduleTransactionAndLifecycleItems(
proc.getThread(), launchActivityItem, lifecycleItem);
}
调用ClientLifecycleManager#scheduleTransactionAndLifecycleItems
void scheduleTransactionAndLifecycleItems(@NonNull IApplicationThread client,
@NonNull ClientTransactionItem transactionItem,
@NonNull ActivityLifecycleItem lifecycleItem) throws RemoteException {
if (Flags.bundleClientTransactionFlag()) {
// 使用IApplicationThread获取ClientTransaction
final ClientTransaction clientTransaction = getOrCreatePendingTransaction(client);
// 添加transactions
clientTransaction.addTransactionItem(transactionItem);
clientTransaction.addTransactionItem(lifecycleItem);
onClientTransactionItemScheduledLocked(clientTransaction);
}
}
private void onClientTransactionItemScheduledLocked(
@NonNull ClientTransaction clientTransaction) throws RemoteException {
// 调度
scheduleTransaction(clientTransaction);
}
void scheduleTransaction(@NonNull ClientTransaction transaction) throws RemoteException {
// 交由transaction实现
transaction.schedule();
}
// ClientTransaction.java
private IApplicationThread mClient;
public void schedule() throws RemoteException {
// 这里的mClient实际是ApplicationThread
// ApplicationThread继承于ClientTransactionHandler
// 实际交给了ClientTransactionHandler处理
mClient.scheduleTransaction(this);
}
- 调用ClientTransactionHandler#scheduleTransaction
void scheduleTransaction(ClientTransaction transaction) {
transaction.preExecute(this);
// 发送消息去执行
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
// ActivityThread.java
public void handleMessage(Message msg) {
switch (msg.what) {
case EXECUTE_TRANSACTION:
final ClientTransaction transaction = (ClientTransaction) msg.obj;
// 交由TransactionExecutor执行
mTransactionExecutor.execute(transaction);
break;
}
}
- 调用TransactionExecutor#execute
public void execute(@NonNull ClientTransaction transaction) {
if (transaction.getTransactionItems() != null) {
// 真正执行transactionItem
executeTransactionItems(transaction);
} else {
// 兼容旧版本
executeCallbacks(transaction);
executeLifecycleState(transaction);
}
}
public void executeTransactionItems(@NonNull ClientTransaction transaction) {
final List<ClientTransactionItem> items = transaction.getTransactionItems();
final int size = items.size();
for (int i = 0; i < size; i++) {
final ClientTransactionItem item = items.get(i);
if (item.isActivityLifecycleItem()) {
// 执行Activity生命周期Item
// 也就是ResumeActivityItem，后于LaunchActivityItem添加
executeLifecycleItem(transaction, (ActivityLifecycleItem) item);
} else {
// 执行非Activity生命周期Item
// 也就是LaunchActivityItem
executeNonLifecycleItem(transaction, item,
shouldExcludeLastLifecycleState(items, i));
}
}
}
// 先执行LaunchActivityItem
private void executeNonLifecycleItem(@NonNull ClientTransaction transaction,
@NonNull ClientTransactionItem item, boolean shouldExcludeLastLifecycleState) {
// 这里LaunchActivityItem为true
if (item.shouldHaveDefinedPreExecutionState()) {
// 这里LaunchActivityItem为UNDEFINED
final int closestPreExecutionState = mHelper.getClosestPreExecutionState(r,
postExecutionState);
if (closestPreExecutionState != UNDEFINED) {
cycleToPath(r, closestPreExecutionState, transaction);
}
}
// 交由Item自身执行
item.execute(mTransactionHandler, mPendingActions);
// 执行完成回调
item.postExecute(mTransactionHandler, mPendingActions);
// 这里LaunchActivityItem为UNDEFINED
if (postExecutionState != UNDEFINED && r != null) {
cycleToPath(r, postExecutionState, shouldExcludeLastLifecycleState, transaction);
}
}
- 调用LaunchActivityItem#execute
public void execute(@NonNull ClientTransactionHandler client,
@NonNull PendingTransactionActions pendingActions) {
ActivityClientRecord r = new ActivityClientRecord(xxx);
// client 为ActivityThread
client.handleLaunchActivity(r, pendingActions, mDeviceId, null /* customIntent */);
}
- 调用ActivityThread#handleLaunchActivity
public Activity handleLaunchActivity(ActivityClientRecord r,
PendingTransactionActions pendingActions, int deviceId, Intent customIntent) {
// 开始执行启动Activity的动作
final Activity a = performLaunchActivity(r, customIntent);
}
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
ActivityInfo aInfo = r.activityInfo;
ContextImpl activityBaseContext;
if (isSandboxActivityContext) {
} else {
// 非沙盒，创建Context
activityBaseContext = createBaseContextForActivity(r);
}
Activity activity = null;
// 使用AppComponentFactory创建Activity
// 默认使用反射创建
activity = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent);
// 获取Application对象
Application app = r.packageInfo.makeApplicationInner(false, mInstrumentation);
// activity绑定Application
// attach Context
// 初始化Window
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);
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
// 调用Activity#performCreate
mInstrumentation.callActivityOnCreate(activity, r.state);
}
// 设置状态为ON_CREATE
r.setState(ON_CREATE);
return activity;
}
private ContextImpl createBaseContextForActivity(ActivityClientRecord r) {
final int displayId = ActivityClient.getInstance().getDisplayId(r.token);
// 创建ActivityContext
ContextImpl appContext = ContextImpl.createActivityContext(
this, r.packageInfo, r.activityInfo, r.token, displayId, r.overrideConfig);
return appContext;
}
- 调用Instrumentation#callActivityOnCreate
public void callActivityOnCreate(Activity activity, Bundle icicle) {
prePerformCreate(activity);
// 调用对应Activity#performCreate
activity.performCreate(icicle);
postPerformCreate(activity);
}
- 调用Activity#performCreate
final void performCreate(Bundle icicle) {
performCreate(icicle, null);
}
final void performCreate(Bundle icicle, PersistableBundle persistentState) {
// 调用Activity#onCreate
if (persistentState != null) {
onCreate(icicle, persistentState);
} else {
onCreate(icicle);
}
// 分发到Fragment
mFragments.dispatchActivityCreated();
}
- 调用TranscationExecuter#executeLifecycleItem执行ResumeActivityItem
private void executeLifecycleItem(@NonNull ClientTransaction transaction,
@NonNull ActivityLifecycleItem lifecycleItem) {
final ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
// 这里会让Activity到onResume
cycleToPath(
r,
// targetState为ON_RESUME
lifecycleItem.getTargetState(),
true /* excludeLastState */,
transaction
);
// 执行ResumeActivityItem
lifecycleItem.execute(mTransactionHandler, mPendingActions);
}
private void cycleToPath(ActivityClientRecord r, int finish, boolean excludeLastState,
ClientTransaction transaction) {
// 之前设置为ON_CREATE
final int start = r.getLifecycleState();
// path = [2, 3]
final IntArray path = mHelper.getLifecyclePath(start, finish, excludeLastState);
performLifecycleSequence(r, path, transaction);
}
private void performLifecycleSequence(ActivityClientRecord r, IntArray path,
ClientTransaction transaction) {
final int size = path.size();
for (int i = 0, state; i < size; i++) {
switch (state) {
case ON_START:
// 先调用handleStartActivity
mTransactionHandler.handleStartActivity(r, mPendingActions,
null /* activityOptions */);
break;
case ON_RESUME:
// 再调用handleResumeActivity
mTransactionHandler.handleResumeActivity(r, false /* finalStateRequest */,
r.isForward, false /* shouldSendCompatFakeFocus */,
"LIFECYCLER_RESUME_ACTIVITY");
break;
}
}
}
// TransactionExcutorHelper.java
public IntArray getLifecyclePath(
int start, // ON_CREATE == 1
int finish, // ON_RESUME == 3
boolean excludeLastState // false
) {
if (finish >= start) {
// 这里会add ON_START(2) ON_RESUME(3)
for (int i = start + 1; i <= finish; i++) {
mLifecycleSequence.add(i);
}
}
return mLifecycleSequence;
}
- 调用ActivityThread#handleStartActivity及handleResumeActivity
public void handleStartActivity(ActivityClientRecord r,
PendingTransactionActions pendingActions, ActivityOptions activityOptions) {
final Activity activity = r.activity;
// 调用Activity#performStart
// 回调Activity#onStart
// 分发onStart给Fragment
activity.performStart("handleStartActivity");
// 设置状态为ON_START
r.setState(ON_START);
// 更新可见性
updateVisibility(r, true /* show */);
}
public void handleResumeActivity(
ActivityClientRecord r,
boolean finalStateRequest, // false
boolean isForward, boolean shouldSendCompatFakeFocus, String reason) {
if (!performResumeActivity(r, finalStateRequest, reason)) {
return;
}
if (r.activity.mVisibleFromClient) {
ViewManager wm = a.getWindowManager();
View decor = r.window.getDecorView();
// 更新layout
wm.updateViewLayout(decor, l);
}
if (r.activity.mVisibleFromClient) {
// 此时Activity可见
r.activity.makeVisible();
}
// 添加IdleHandler
Looper.myQueue().addIdleHandler(new Idler());
}
public boolean performResumeActivity(ActivityClientRecord r, boolean finalStateRequest,
String reason) {
// 这时state是onStart
if (r.getLifecycleState() == ON_RESUME) {
}
// 回调onResume
r.activity.performResume(r.startsNotResumed, reason);
// 设置状态为ON_RESUME
r.setState(ON_RESUME);
}
- 调用ResumeActivityItem#execute
public void execute(@NonNull ClientTransactionHandler client, @NonNull ActivityClientRecord r,
@NonNull PendingTransactionActions pendingActions) {
client.handleResumeActivity(r, true /* finalStateRequest */, mIsForward,
mShouldSendCompatFakeFocus, "RESUME_ACTIVITY");
}
- 调用ActivityThread#handleResumeActivity
public void handleResumeActivity(
ActivityClientRecord r,
boolean finalStateRequest, // true
boolean isForward, boolean shouldSendCompatFakeFocus, String reason) {
// 由于返回false
if (!performResumeActivity(r, finalStateRequest, reason)) {
return;
}
}
public boolean performResumeActivity(ActivityClientRecord r, boolean finalStateRequest,
String reason) {
// 此时Activity已经为ON_RESUME
if (r.getLifecycleState() == ON_RESUME) {
return false;
}
}
至此，Activity已经完全启动并可见。
