AMS重要的数据结构解析（三）：ActivityStack(1)

2401_84149916

于 2024-04-09 03:30:09 发布

阅读量891

点赞数 9

分类专栏：程序员文章标签：数据结构

本文链接：https://blog.csdn.net/2401_84149916/article/details/137531526

版权

程序员专栏收录该内容

123 篇文章 0 订阅

订阅专栏

通常情况下,一个App对应一个ActivityStack,ActivityStatck中会有一个TaskRecord列表,通常列表中仅有一个TaskRecord,维护Activity栈。

image

一个Activity启动时,归属的TaskRecord,通常是启动它的Activity 对应的TaskRecord。

如ActivtiyA启动ActivityB,那么ActivityB会被保存在ActivityA所属的TaskRecord中。

image

当一个Activity的launchmode 设置了SingleIntance,那么它启动的时候就会新建一个TaskRecord,这时ActvityStack中就会存在多个TaskRecord 栈结构。

image

当设置了Intent.FLAG_ACTIVITY_NEW_TASK和taskAffinity时,可能会出现多个app共享同一个ActivityStack的情况。

taskAffinity 可以指定Activity需要宿主TaskRecord的名字,当ActivityManagerService发现启动了一个带有 FLAG_ACTIVITY_NEW_TASK 标签的 Activity 时,会先去查找当前AMS中是否存在activity需要的ActivityStack和TaskRecord，如果存在则直接将ActivityRecord添加到对应ActivityStack的TaskRecord中去,否则会先新建一个TaskRecord,然后将ActvityRecord添加到新建的TaskRecord中。

adb shell dumpsys activity 查看activity栈的请款

ACTIVITY MANAGER ACTIVITIES (dumpsys activity activities)

Display #0 (activities from top to bottom):

Stack #1:

TaskRecord{4212758 #173 A=com.sogou.iot.testtouch1 U=0 StackId=1 sz=2}

Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.sogou.iot.testtouch1/.MainActivity }

Hist #1: ActivityRecord{4c91dda u0 com.sogou.iot.testtouch1/.SecondActivity t173}

Intent { cmp=com.sogou.iot.testtouch1/.SecondActivity }

ProcessRecord{3fd8bbc 23189:com.sogou.iot.testtouch1/u0a79}

Hist #0: ActivityRecord{93a3d53 u0 com.sogou.iot.testtouch1/.MainActivity t173}

Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.sogou.iot.testtouch1/.MainActivity bnds=[433,77][644,372] }

ProcessRecord{3fd8bbc 23189:com.sogou.iot.testtouch1/u0a79}

Running activities (most recent first):

TaskRecord{4212758 #173 A=com.sogou.iot.testtouch1 U=0 StackId=1 sz=2}

Run #1: ActivityRecord{4c91dda u0 com.sogou.iot.testtouch1/.SecondActivity t173}

Run #0: ActivityRecord{93a3d53 u0 com.sogou.iot.testtouch1/.MainActivity t173}

mResumedActivity: ActivityRecord{4c91dda u0 com.sogou.iot.testtouch1/.SecondActivity t173}

Stack #0:

TaskRecord{db2272c #1 A=com.huawei.android.launcher U=0 StackId=0 sz=1}

Intent { act=android.intent.action.MAIN cat=[android.intent.category.HOME] flg=0x10000300 cmp=com.huawei.android.launcher/.unihome.UniHomeLauncher }

Hist #0: ActivityRecord{60dec4e u0 com.huawei.android.launcher/.unihome.UniHomeLauncher t1}

Intent { act=android.intent.action.MAIN cat=[android.intent.category.HOME] flg=0x10000300 cmp=com.huawei.android.launcher/.unihome.UniHomeLauncher }

ProcessRecord{c03fa2 1781:com.huawei.android.launcher/u0a50}

Running activities (most recent first):

TaskRecord{db2272c #1 A=com.huawei.android.launcher U=0 StackId=0 sz=1}

Run #0: ActivityRecord{60dec4e u0 com.huawei.android.launcher/.unihome.UniHomeLauncher t1}

Stack #0: 代表一个ActivityStack, id = 0 说明是Launcher相关的ActivitStack。

Stack #1: ActivityStack id = 1 ,代表常规App的ActvityStack,其中存在一个TaskRecord栈,栈中有两个ActivityRecord (MainActivity和SecondActivity),SecondeActivity在栈顶,处于Resume状态

2.4、ActivityStackSupervisor

ActivityStackSupervisor是ActivityStack的管理者。

内部管理了mHomeStack、mFocusedStack和mLastFocusedStack三个ActivityStack。

其中，mHomeStack管理的是Launcher相关的Activity栈，stackId为0；

mFocusedStack管理的是当前显示在前台Activity的Activity栈；

mLastFocusedStack管理的是上一次显示在前台Activity的Activity栈。

image

ActivityDisplay表示一个屏幕，Android支持三种屏幕：主屏幕，外接屏幕（HDMI等），虚拟屏幕（投屏）。一般情况下，即只有主屏幕时，ActivityStackSupervisor与ActivityDisplay都是系统唯一；

ActivityDisplay是ActivityStackSupervisor的内部类，它相当于一个工具类，封装了移除和添加ActivityStack的方法。

2.5 ActivityThread:

ActivityThread 运行在UI线程（主线程），App的真正入口。

2.6 ApplicationThread

ApplicationThread是一个Binder类，即可实现跨进程通信。主要用于接受从AMS传递过来的IPC消息，继而做相应处理。

private class ApplicationThread extends IApplicationThread.Stub{

}

2.7 IActivityManager

继承与IInterface接口，用于app进程向ActivityManagerService 单向IPC通信

2.8、Instrumentation

仪表盘，负责调用Activity和Application生命周期，测试用到这个类比较多。

三、具体的启动过程

3.1、流程概述

Launcher：Launcher通知AMS要启动activity

startActivitySafely->startActivity->Instrumentation.execStartActivity()(AMP.startActivity)->AMS.startActivity

ActivitMapagerService:PackageManagerService的resoveIntent验证要启动activity是否匹配。

如果匹配，通过ApplicationThread发消息给Launcher所在的主线程，暂停当前Activity(Launcher);
暂停完，在该activity还不可见时，通知AMS，根据要启动的Activity配置ActivityStack。然后判断要启动的Activity进程是否存在?
- 存在：发送消息LAUNCH_ACTIVITY给需要启动的Activity主线程，执行handleLaunchActivity
- 不存在：通过socket向zygote请求创建进程。进程启动后，ActivityThread.attach

判断Application是否存在，若不存在，通过LoadApk.makeApplication创建一个。在主线程中通过thread.attach方法来关联ApplicationThread。
在通过ActivityStackSupervisor来获取当前需要显示的ActivityStack。
继续通过ApplicationThread来发送消息给主线程的Handler来启动Activity（handleLaunchActivity）
handleLauchActivity：调用了performLauchActivity，里边Instrumentation生成了新的activity对象，继续调用activity生命周期。

3.2、流程跟踪

阶段一:Launcher通知AMS要启动新的Activity（在Launcher所在的进程执行）

Activity.startActivity
Activity.startActivityForResult
Instrumentation.execStartActivity //交由Instrumentation代为发起请求
ActivityManager.getService().startActivity //通过IActivityManagerSingleton.get()得到一个AMP代理对象
ActivityManagerService.startActivity()

阶段二:AMS先校验一下Activity的正确性，如果正确的话，会暂存一下Activity的信息。然后AMS会通知Launcher程序pause Activity（在AMS所在进程执行）

ActivityManagerService.startActivity
ActivityManagerService.startActivityAsUser
ActivityStackSupervisor.startActivityMayWait
ActivityStarter.startActivityUnchecked
ActivityStarter.startActivity
ActivityStarter.startActivityUnchecked
ActivityStack.startActivityLocked
ActivityStackSupervisor.resumeFocusedStackTopActivityLocked
ActivityStack.resumeTopActivityUncheckedLocked
ActivityStack.resumeTopActivityInnerLocked

private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options){

if (mResumedActivity != null) {

if (DEBUG_STATES) Slog.d(TAG_STATES,

"resumeTopActivityLocked: Pausing " + mResumedActivity);

pausing |= startPausingLocked(userLeaving, false, next, false);

}

ActivityStack.startPausingLocked

if (prev.app != null && prev.app.thread != null) {

mService.getLifecycleManager().scheduleTransaction(prev.app.thread, prev.appToken,

PauseActivityItem.obtain(prev.finishing, userLeaving,

prev.configChangeFlags, pauseImmediately)

);

}

PauseActivityItem 为暂停Activity的一个ClientTransactionItem 事务,AMS对Activity的操作都封装成了事务来完成。

public class PauseActivityItem extends ActivityLifecycleItem {

private static final String TAG = “PauseActivityItem”;

private boolean mFinished;

private boolean mUserLeaving;

private int mConfigChanges;

private boolean mDontReport;

@Override

public void execute(ClientTransactionHandler client, IBinder token,

client.handlePauseActivity(token, mFinished, mUserLeaving, mConfigChanges, pendingActions,

“PAUSE_ACTIVITY_ITEM”);

}

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;

}

public class ClientTransaction implements Parcelable, ObjectPoolItem {

/** Target client. */

private IApplicationThread mClient;

}

public void schedule() throws RemoteException {

mClient.scheduleTransaction(this);

}

mService.getLifecycleManager().scheduleTransaction,最终调用了IApplciationThread.scheduleTransaction()

此时完成 ActivityManagerService->ApplicationThread发消息，暂停Activity的过程。

阶段三: pause Launcher的Activity，并通知AMS已经paused（在Launcher所在进程执行）

上文知ActivityManagerService向ApplicationThread发送了一个PauseActivity的Transaction事务,相应的调用

ApplicationThread.scheduleTransaction()
ActivityThread.scheduleTransaction()
ActivityThread 发送H.EXECUTE_TRANSACTION
ActivityThread.H.handleMessage
ActivityThread.handlePauseActivity
IActivityManager.activityPaused

ApplicationThread的scheduleTransaction()方法，最终调用了ActivityThread的父类ClientTransactionHandler中的方法，发送了一个H.EXECUTE_TRANSACTION消息到主线程Handler

public abstract class ClientTransactionHandler {

// Schedule phase related logic and handlers.

/** Prepare and schedule transaction for execution. */

void scheduleTransaction(ClientTransaction transaction) {

transaction.preExecute(this);

sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);

}

handleMessage 处理EXECUTE_TRANSACTION消息时会调用TransactionExecutor.execuate()

public void handleMessage(Message msg) {

case EXECUTE_TRANSACTION:

final ClientTransaction transaction = (ClientTransaction) msg.obj;

mTransactionExecutor.execute(transaction);

break;

}

public class TransactionExecutor {

public void execute(ClientTransaction transaction) {

executeCallbacks(transaction);

executeLifecycleState(transaction);

}

private void executeLifecycleState(ClientTransaction transaction) {

final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();

lifecycleItem.execute(mTransactionHandler, token, mPendingActions);

lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);

}

最终会调用ActivityThread的handlePauseActivity()方法

阶段四:检查activity所在进程是否存在，如果存在，就直接通知这个进程，在该进程中启动Activity；不存在的话，会调用Process.start创建一个新进程（执行在AMS进程）

ActivityManagerService.activityPaused

@Override

public final void activityPaused(IBinder token) {

final long origId = Binder.clearCallingIdentity();

synchronized(this) {

ActivityStack stack = ActivityRecord.getStackLocked(token);

if (stack != null) {

stack.activityPausedLocked(token, false);

}

Binder.restoreCallingIdentity(origId);

}

ActivityStack.activityPausedLocked

final void activityPausedLocked(IBinder token, boolean timeout) {

completePauseLocked(true /* resumeNext /, null / resumingActivity */);

}

ActivityStack.completePauseLocked
ActivityStackSupervisor.resumeFocusedStackTopActivityLocked
ActivityStack.resumeTopActivityUncheckedLocked
ActivityStack.resumeTopActivityInnerLocked
ActivityStack.startSpecificActivityLocked
ActivityStack.startSpecificActivityLocked

经过一系列调用，最终代码又回到了 ActivityStackSupervisor 中的 startSpecificActivityLocked 方法。

void startSpecificActivityLocked(ActivityRecord r,

boolean andResume, boolean checkConfig) {

//注释一:根据进程名和uuid判断Activity所属的进程是否创建

// Is this activity’s application already running?

ProcessRecord app = mService.getProcessRecordLocked(r.processName,

r.info.applicationInfo.uid, true);

if (app != null && app.thread != null) {

try {

if ((r.info.flags&ActivityInfo.FLAG_MULTIPROCESS) == 0

|| !“android”.equals(r.info.packageName)) {

// Don’t add this if it is a platform component that is marked

// to run in multiple processes, because this is actually

// part of the framework so doesn’t make sense to track as a

// separate apk in the process.

app.addPackage(r.info.packageName, r.info.applicationInfo.longVersionCode,

mService.mProcessStats);

}

//注释二

realStartActivityLocked(r, app, andResume, checkConfig);

return;

} catch (RemoteException e) {

Slog.w(TAG, "Exception when starting activity "

r.intent.getComponent().flattenToShortString(), e);

}

// If a dead object exception was thrown – fall through to

// restart the application.

}

//注释三调用ActivityManagerService 启动activity所在进程

mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,

“activity”, r.intent.getComponent(), false, false, true);

}

注释一根据进程名和 Application 的 uid，来判断目标进程是否已经创建，如果没有则代表进程未创建。
注释二如果acitivity所在的进程已经存在,则尝试启动Activity
注释三如果activity所在的进程不存在,则尝试调用ActivityManagerService来启动进程。

首次启动App,app进程为空,会尝试创建app进程,不会执行realStartActivityLocked

ActivityManagerService.startProcessLocked
Process.start //在这里创建了新进程，新的进程会导入ActivityThread类，并执行它的main函数

阶段五:进程创建后,执行ActivityThread.main()入口函数,

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）

最后

以前一直是自己在网上东平西凑的找，找到的东西也是零零散散，很多时候都是看着看着就没了，时间浪费了，问题却还没得到解决，很让人抓狂。

后面我就自己整理了一套资料，还别说，真香！

资料有条理，有系统，还很全面，我不方便直接放出来，大家可以先看看有没有用得到的地方吧。

系列教程图片

2020Android复习资料汇总.png

flutter

NDK

设计思想开源框架

微信小程序

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！

598639)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）

最后

以前一直是自己在网上东平西凑的找，找到的东西也是零零散散，很多时候都是看着看着就没了，时间浪费了，问题却还没得到解决，很让人抓狂。

后面我就自己整理了一套资料，还别说，真香！

资料有条理，有系统，还很全面，我不方便直接放出来，大家可以先看看有没有用得到的地方吧。

[外链图片转存中…(img-ArCPdy9i-1712604598639)]

[外链图片转存中…(img-T5R8SIwV-1712604598640)]

[外链图片转存中…(img-wuoa205z-1712604598640)]

[外链图片转存中…(img-TPrhg4gB-1712604598640)]

[外链图片转存中…(img-idXD4jMx-1712604598640)]

[外链图片转存中…(img-1qpzcsLo-1712604598641)]

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！

2401_84149916

关注

9
点赞
踩
29

收藏

觉得还不错? 一键收藏
0
评论
AMS重要的数据结构解析（三）：ActivityStack(1)

Launcher：Launcher通知AMS要启动activityActivitMapagerService:PackageManagerService的resoveIntent验证要启动activity是否匹配。如果匹配，通过ApplicationThread发消息给Launcher所在的主线程，暂停当前Activity(Launcher);暂停完，在该activity还不可见时，通知AMS，根据要启动的Activity配置ActivityStack。
复制链接

扫一扫