AMS重要的数据结构解析（三）-CFANZ编程社区

final String shortComponentName; // the short component name of the intent

final String packageName; // the package implementing intent’s component

final String processName; // process where this component wants to run

final String taskAffinity; // as per ActivityInfo.taskAffinity

boolean fullscreen; // covers the full screen?

}

[](()2.2、TaskRecord

TaskRecord表示任务栈,是真正的一个先进后出的栈结构，用于记录activity开启的先后顺序。其所存放的Activity是不支持重新排序的，只能根据压栈和出栈操作更改Activity的顺序。有了TaskRecord，Android系统才能知道当一个Activity退出时，接下来该显示哪一个Activity。

final class TaskRecord {

/** List of all activities in the task arranged in history order */

final ArrayList mActivities;

}

[](()2.3、ActivityStack

ActivityStack 是TaskRecord的一个分组，用于管理TaskRecord列表,列表中的TaskRecord可以重排顺序。

final class ActivityStack {

/**

The back history of all previous (and possibly still
running) activities. It contains #TaskRecord objects.

private ArrayList mTaskHistory = new ArrayList<>();

}

[](()2.3.1 TaskRecord、ActivityStack关系。

通常情况下,一个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,

"resumeTopAct 《Android学习笔记总结+最新移动架构视频+大厂安卓面试真题+项目实战源码讲义》无偿开源徽信搜索公众号【编程进阶路】 ivityLocked: 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