Activity启动流程(基于Android26),Android开发必须要会
// 源 Activity 记录,即在哪个 Activity 进行 startActivity
ActivityRecord sourceRecord = null;
// 如果使用 startActivityForResult,result 返回的 Activity 称为结果 Activity
ActivityRecord resultRecord = null;
if (resultTo != null) {
// 获取 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
ActivityStack
ActivityStack.startActivityLocked
主要是创建 WindowContainer,同时显示 Window
ActivityStackSupervisor
ActivityStack
private boolean resumeTopActivityInnerLocked() {
if (!mStackSupervisor.allPausedActivitiesComplete()) {
// 如果存在暂停 Activity 的操作未完成
return false;
}
if (config != null) {
next.frozenBeforeDestroy = true
《Android学习笔记总结+最新移动架构视频+大厂安卓面试真题+项目实战源码讲义》
【docs.qq.com/doc/DSkNLaERkbnFoS0ZF】 完整内容开源分享
;
}
notUpdated = !mService.updateDisplayOverrideConfigurationLocked(config, next,
false /* deferResume */, mDisplayId);
}
if (notUpdated) {
// 配置发生更新无法保持已经存在的 Activity 实例
// 重新获取需要恢复的 Activity
ActivityRecord nextNext = topRunningActivityLocked();
// 确保 Activity 仍然保持在栈顶,同时安排另外一次执行
if (nextNext != next) {
mStackSupervisor.scheduleResumeTopActivities();
}
if (!next.visible || next.stopped) {
next.setVisibility(true);
}
next.completeResumeLocked();
return true;
}
try {
// 传递所有等待的结果
if (next.newIntents != null){
next.app.thread.scheduleNewIntent(
next.newIntents, next.appToken, false /* andPause */);
}
next.notifyAppResumed(next.stopped);
// 准备恢复 Activity
next.app.thread.scheduleResumeActivity(next.appToken, next.app.repProcState,
mService.isNextTransitionForward(), resumeAnimOptions);
} catch (Exception e){
// 发生异常,重新启动 Activity
mStackSupervisor.startSpecificActivityLocked(next, true, false);
return true;
}
try {
next.completeResumeLocked();
} catch(Exception e){
// 发生异常,结束 Activity
requestFinishActivityLocked(next.appToken, Activity.RESULT_CANCELED, null,
“resume-exception”, true);
return true;
}
} else {
// 需要启动 Activity
mStackSupervisor.startSpecificActivityLocked(next, true, true);
}
return true;
}
如果可以不需要重新启动 Activity,则直接恢复 Activity 即可,否则进行重新启动流程:
ActivityStackSupervisor
int idx = app.activities.indexOf®;
if (idx < 0) {
// 将 Activity 添加到应用进程中
app.activities.add®;
}
ApplicationThread
ActivityThread
private performLaunchActivity() {
// Activity 信息初始化
Activity启动流程(基于Android26),Android开发必须要会相关推荐
- Activity启动流程(基于Android26),Android面试超详细知识点
// 获取 Activity Stack 中已经存在的源 Activity 记录 sourceRecord = mSupervisor.isInAnyStackLocked(resultTo); if ...
- Android开发必须要会!分享两道阿里P7究极难度算法题,醍醐灌顶!
前文 本文希望通过揭开一些 React 隐藏的技术细节, 来辅助对官方文档中某些概念的理解 读者可以将本文看做对官方文档的补充 行文方式我采用的是提问-解答的方式, 即先根据官方文档给出的使用规则, ...
- 【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 启动流程 | Hook 插件包资源加载 ) ★★★
Android 插件化系列文章目录 [Android 插件化]插件化简介 ( 组件化与插件化 ) [Android 插件化]插件化原理 ( JVM 内存数据 | 类加载流程 ) [Android 插件 ...
- 【Android 插件化】Hook 插件化框架 ( 从 Hook 应用角度分析 Activity 启动流程 一 | Activity 进程相关源码 )
Android 插件化系列文章目录 [Android 插件化]插件化简介 ( 组件化与插件化 ) [Android 插件化]插件化原理 ( JVM 内存数据 | 类加载流程 ) [Android 插件 ...
- c++builder启动了怎么停止_App 竟然是这样跑起来的 —— Android App/Activity 启动流程分析...
在我的上一篇文章: AJie:按下电源键后竟然发生了这一幕 -- Android 系统启动流程分析zhuanlan.zhihu.com 我们分析了系统在开机以后的一系列行为,其中最后一阶段 AMS( ...
最新文章
- thinkphp整合系列之gulp实现前端自动化
- JZOJ 5425. 【NOIP2017提高A组集训10.25】数论
- 03_dbcp数据源依赖jar包,DBCP中API介绍,不同过dbcp方式使用dbcp数据库连接池,通过配置文件使用dbcp数据库连接池
- zip直链生成网站_安装网站程序
- 决策树剪枝算法(二)
- 最新发布!《统计学习方法》第二版无监督学习视频课上线了!
- Windows输入体验是什么,Windows11输入体验在哪里
- [转载] java构造函数初始化与执行顺序问题
- Lync问题解决之前端服务器Wmf2008R2错误
- 2020年acwifi拆过的无线路由器配置汇总
- AOP如何实现及实现原理
- Python3 - Dockerfile 最佳实践
- DNC: A deep neural network-based clustering-oriented network embedding algorithm 2021
- eCharts绘制双系列混合类型图表+额外tooltip信息
- 北漂三年多 我选择离开,眼神更加坚定!
- 读书笔记之《内向者优势》
- 游戏数学: 计算屏幕点中的平面上的点(上帝视角)
- 旋翼回收火箭系列博客1——研究生未来飞行器设计大赛火箭赛道介绍及分析
- C/C++常见面试知识点总结附面试真题----20220326更新
- 思博伦OpenFlow性能测试白皮书(上)
热门文章
- router-link的用法
- 一见钟情——[波兰]辛波丝卡--向左走,向右走中的那首波兰诗。
- 【水滴石穿】bstmy-blend-app
- Java_SE中的经典面试题
- PHP fread,PHP fread文件指针位置
- 记住下次看小电影前一定要检查一下域名是不是 HTTPS 的,别说小乐没提醒你……...
- SQL 删除表数据,id从1开始
- 东华进阶oj71-100 【蓝桥杯】
- flavor android build,Android build.gradle从另一个文件导入flavor
- 有人知道告诉一声谢谢