Activity启动流程(基于Android26)，Android面试超详细知识点

// 获取 Activity Stack 中已经存在的源 Activity 记录
sourceRecord = mSupervisor.isInAnyStackLocked(resultTo);
if (sourceRecord != null) {
if (requestCode >= 0 && !sourceRecord.finishing) {
// requestCode >= 0，源 Activity 同时为结果 Activity
resultRecord = sourceRecord;
}
}
}

final int launchFlags = intent.getFlags();

if ((launchFlags & Intent.FLAG_ACTIVITY_FORWARD_RESULT) != 0 && sourceRecord != null) {
// 使用 FLAG_ACTIVITY_FORWARD_RESULT，可以将返回结果的源 Activity 转移为当前正在新启动的 Activity
// 比如：A -> B,B - C 使用了 FLAG_ACTIVITY_FORWARD_RESULT,那么 C 的 setResult 会返回给 A
if (requestCode >= 0) {
// 不允许有 requestCode
ActivityOptions.abort(options);
return ActivityManager.START_FORWARD_AND_REQUEST_CONFLICT;
}
// 将源 Activity 的结果 Activity 设置为新 Activity 的结果 Activity
resultRecord = sourceRecord.resultTo;
if (resultRecord != null && !resultRecord.isInStackLocked()) {
resultRecord = null;
}
// requestCode 处理
resultWho = sourceRecord.resultWho;
requestCode = sourceRecord.requestCode;
sourceRecord.resultTo = null;
if (resultRecord != null) {
// 删除源 Activity 记录
resultRecord.removeResultsLocked(sourceRecord, resultWho, requestCode);
}
}

if (err == ActivityManager.START_SUCCESS && intent.getComponent() == null) {
// component 找不到
err = ActivityManager.START_INTENT_NOT_RESOLVED;
}

if (err == ActivityManager.START_SUCCESS && aInfo == null) {
// ActivityInfo 找不到
err = ActivityManager.START_CLASS_NOT_FOUND;
}

if (err == ActivityManager.START_SUCCESS && sourceRecord != null
&& sourceRecord.getTask().voiceSession != null) {
// 语音启动 Activity，检查是否符合
}

if (err == ActivityManager.START_SUCCESS && voiceSession != null) {
// 启动语音会话
}

final ActivityStack resultStack = resultRecord == null ? null : resultRecord.getStack();

if (err != START_SUCCESS) {
// 启动 Activity 失败
if (resultRecord != null) {
// 发送取消通知
resultStack.sendActivityResultLocked(
-1, resultRecord, resultWho, requestCode, RESULT_CANCELED, null);
}
ActivityOptions.abort(options);
return err;
}

// 进行一些权限检查，判断是否终止
if (abort) {
// 如果需要终止 Activity
if (resultRecord != null) {
resultStack.sendActivityResultLocked();
}
// 返回启动成功，实际终止
ActivityOptions.abort(options);
return START_SUCCESS;
}

// 如果权限检查是否在启动 Activity 之前，那么先启动权限检查的 Intent

// 处理 ephemeral app

// 构造一个 ActivityRecord
ActivityRecord r = new ActivityRecord();

final ActivityStack stack = mSupervisor.mFocusedStack;
if (voiceSession == null && (stack.mResumedActivity == null
|| stack.mResumedActivity.info.applicationInfo.uid != callingUid)) {
// 前台 stack 还没 resume 状态的 Activity，检查是否允许 app 切换
if (!mService.checkAppSwitchAllowedLocked() {
PendingActivityLaunch pal = new PendingActivityLaunch();
mPendingActivityLaunches.add(pal);
ActivityOptions.abort(options);
// 切换 app 失败
return ActivityManager.START_SWITCHES_CANCELED;
}
}

if (mService.mDidAppSwitch) {
// 从上次禁止 app 切换以来，这是第二次，允许 app 切换，并将切换时间设置为 0
mService.mAppSwitchesAllowedTime = 0;
} else {
mService.mDidAppSwitch = true;
}

// 执行因为不允许 app 切换，而加到等待启动的 Activity
doPendingActivityLaunchesLocked(false);

return startActivity();
}

private int startActivity() {
int result = START_CANCELED;
try {
mService.mWindowManager.deferSurfaceLayout();
// 下一步流程
result = startActivityUnchecked();
} finally {
// 如果启动 Activity 没有成功，从 task 中移除 Activity
if (!ActivityManager.isStartResultSuccessful(result)
&& mStartActivity.getTask() != null) {
mStartActivity.getTask().removeActivity(mStartActivity);
}

mService.mWindowManager.continueSurfaceLayout();
}

postStartActivityProcessing();

return result;
}

private int startActivityUnchecked() {

// 设置一些初始化状态
setInitialState();
// 计算 launch flags
computeLaunchingTaskFlags();
// 计算源 Task，源 Task 是否存在等
computeSourceStack();
// 获取是否存在可以复用的 Activity，根据 flags 和 launchMode
ActivityRecord reusedActivity = getReusableIntentActivity();
if (reusedActivity != null) {
// 存在可复用的 Activity，复用它
// 可能需要清除 Task 中其他 Activity，并将启动的 Activity 前置
}
if (mStartActivity.packageName == null) {
return START_CLASS_NOT_FOUND;
}
// 如果启动的 Activity 与当前 Task 顶部的 Activity 相同，判断是否需要继续启动新的 Activity
final boolean dontStart = top != null && mStartActivity.resultTo == null
&& top.realActivity.equals(mStartActivity.realActivity)
&& top.userId == mStartActivity.userId
&& top.app != null && top.app.thread != null
&& ((mLaunchFlags & FLAG_ACTIVITY_SINGLE_TOP) != 0
|| mLaunchSingleTop || mLaunchSingleTask);
if(dontStart){
// 传递一个新的 Intent 到 onNewIntent
top.deliverNewIntentLocked();
return START_DELIVERED_TO_TOP;
}

// 获取 mTargetStack
if (mStartActivity.resultTo == null && mInTask == null && !mAddingToTask
&& (mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0) {
newTask = true;
// 需要创建新的 Task
result = setTaskFromReuseOrCreateNewTask();
} else if (mSourceRecord != null) {
// 从源 Activity 中获取 Task
result = setTaskFromSourceRecord();
} else if (mInTask != null) {
// 从 InTask 中获取 Task
result = setTaskFromInTask();
} else {
// 可能创建新的 Task 或使用当前 Task，一般不会发生
setTaskToCurrentTopOrCreateNewTask();
}

// 使用 mTargetStack 启动 Activity
mTargetStack.startActivityLocked();

if (mDoResume) {
if (!mTargetStack.isFocusable()
|| (topTaskActivity != null && topTaskActivity.mTaskOverlay
&& mStartActivity != topTaskActivity)) {
// 目标 Task 不可聚焦，或者源 Task 栈顶 Activity 总是在其他 Activity 之上，并且不为源 Activity
// 那么我们不恢复目标 Task，只需要确保它可见即可
mTargetStack.ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
}
} else {
if (mTargetStack.isFocusable() && !mSupervisor.isFocusedStack(mTargetStack)) {
// 如果目标 Task 之前不是可聚焦，但是现在为可聚焦，那么移动到前台
mTargetStack.moveToFront(“startActivityUnchecked”);
}
// 恢复目标 Task
mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity,
mOptions);
} else {
// 如果不需要恢复，那么加到"最近活动"中
mTargetStack.addRecentActivityLocked(mStartActivity);
}

return START_SUCCESS;
}

private void setInitialState(){
// 获取 DisplayId
mSourceDisplayId = getSourceDisplayId();
// 获取用于启动 Activity 的范围，Rect
mLaunchBounds = getOerrideBounds();
// launchMode
mLaunchSingleTop = r.launchmode == LAUNCH_SINGLE_TOP;
mLaunchSingleInstance = r.launchMode == LAUNCH_SINGLE_INSTANCE;
mLaunchSingleTask = r.launchMode == LAUNCH_SINGLE_TASK;
// Intent flags 的处理，如果和 Manifest 存在冲突，以 Manifest 为主
// 如果 requestCode >= 0，同时启动的 Activity 位于新的 Task，发送取消的结果给源 Activity
sendNewTaskResultRequestIfNeeded();
}

private void computeLaunchingTaskFlags(){
if (mSourceRecord == null && mInTask != null && mInTask.getStack() != null){
// 如果不存在源 Activity
final Intent baseIntent = mInTask.getBaseIntent();
final ActivityRecord root = mInTask.getRootActivity();
if (baseIntent == null){
throw new IllegalArgumentException();
}
if (mLaunchSingleInstance || mLaunchSingleTask) {
// 如果设置了 SingleInstacne 或 SingleTask
if (!baseIntent.getComponent().equals(mStartActivity.intent.getComponent())){
// Task 不符合
throw new IllegalArgumentException();
}

if(root != null){
// 已经存在 Task 根 Activity
throw new IllegalArgumentException();
}
}

if (root == null) {
// 如果不存在根 Activity，重新设置 launch flags
mAddingToTask = true;
}else if ((mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0) {
mAddingToTask = false;
}else {
mAddingToTask = true;
}
}else {
if ((mStartActivity.isResolverActivity() || mStartActivity.noDisplay) && mSourceRecord != null
&& mSourceRecord.isFreeform()) {
// 如果使用 ResolverActivity 启动或者 noDisplay
mAddingToTask = true;
}
}

if(mInTask == null){
if (mSourceRecord == null) {
if ((mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) == 0 && mInTask == null) {
// 不存在 Task，并且不存在源 Activity
mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;
}
}else if (mSourceRecord.launchMode == LAUNCH_SINGLE_INSTANCE) {
// 如果源 Activity 的 launchMode 是 SingleInstance，要设置 NEW_TASK flag
mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;
}else if (mLaunchSingleInstance || mLaunchSingleTask) {
// 如果启动 Activity 的 launchMode 是 SingleInstance 或 SingleTask，需要设置 NEW_TASK flag
mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;
}
}

}

ActivityStarter 主要的作用是，计算 launch flags，创建或者复用合适的 Task，即 ActivityStack，从而启动 Activity

Activity启动流程(基于Android26)，Android面试超详细知识点相关推荐

Activity启动流程(基于Android26)，Android开发必须要会
// 源 Activity 记录,即在哪个 Activity 进行 startActivity ActivityRecord sourceRecord = null; // 如果使用 startAct ...
【Android 启动过程】Android 应用启动流程 | Activity 启动流程
文章目录一.Android 系统启动流程二.Activity 启动流程一.Android 系统启动流程打开 Android 手机电源键后 , 先运行 BootLoader , 然后使用 Boo ...
android activity启动流程_1307页！一线大厂Android面试全套真题解析！
/ 前言 / 金九银十到了,很多读者都反映有面试的需求,所以我特地给大家准备了一点资料! 下面的题目都是大家在面试一线互联网大厂时经常遇到的面试真题和答案解析,如果大家还有其他好的题目或者好的 ...
深入分析Android 9.0源代码——Activity启动流程
引言点击此处查看<深入分析Android 9.0源代码>系列的组织结构和相关说明. 1 应用进程发起启动请求本章的调用流程如下图所示: (Context) Activity Instr ...
framework之Activity启动流程（基于Android11源码）
一步步看,你就会对activity的启动流程有深刻的认知. 引言 Android11上,Activity的启动流程与Android10的实现(可以参考Activity的启动过程详解(基于10.0源码) ...
【Android 插件化】Hook 插件化框架 ( 从 Hook 应用角度分析 Activity 启动流程一 | Activity 进程相关源码 )
Android 插件化系列文章目录 [Android 插件化]插件化简介 ( 组件化与插件化 ) [Android 插件化]插件化原理 ( JVM 内存数据 | 类加载流程 ) [Android 插件 ...
c++builder启动了怎么停止_App 竟然是这样跑起来的 —— Android App/Activity 启动流程分析...
在我的上一篇文章: AJie:按下电源键后竟然发生了这一幕 -- Android 系统启动流程分析zhuanlan.zhihu.com 我们分析了系统在开机以后的一系列行为,其中最后一阶段 AMS( ...
【Android 插件化】Hook 插件化框架总结 ( 插件包管理 | Hook Activity 启动流程 | Hook 插件包资源加载 ) ★★★
Android 插件化系列文章目录 [Android 插件化]插件化简介 ( 组件化与插件化 ) [Android 插件化]插件化原理 ( JVM 内存数据 | 类加载流程 ) [Android 插件 ...
【Android 插件化】Hook 插件化框架 ( Hook Activity 启动流程 | 主线程创建 Activity 实例之前使用插件 Activity 类替换占位的组件 )
Android 插件化系列文章目录 [Android 插件化]插件化简介 ( 组件化与插件化 ) [Android 插件化]插件化原理 ( JVM 内存数据 | 类加载流程 ) [Android 插件 ...

Activity启动流程(基于Android26)，Android面试超详细知识点

ActivityStack

ActivityStackSupervisor

ActivityStack

ActivityStackSupervisor

ActivityStackSupervisor

Activity启动流程(基于Android26)，Android面试超详细知识点相关推荐

最新文章

热门文章