深入AMS源码（一）——ActivityManagerService的基础知识
自从读过Android内核剖析这本书之后，对整个安卓的系统有了更深的认识和理解，前面写了3篇文章（深入PMS源码）分析了PMS的相关代码，之后会将相关知识都整理在博客上，本篇开始将从源码角度分析AMS的执行逻辑，AMS作为Android的核心服务，了解其内部流程会让开发者对程序的执行有更深刻的认识，主要的流程逻辑放在下一篇中分析，这里先分析下基础部分便于更好的理解之后的内容；
1、AMS重要数据结构
- Activity栈模型
- 每个活动Activity在AMS中都会创建对应的ActivityRecord对象；
- 这些ActivityRecord对象被管理在各自的任务栈中，每个TaskStack可以添加多了任务对象；
- 所有的TaskStack都被ActivityStack统一管理，负责TaskStack的顺序、入栈和出栈；
- ActivityRecord：记录所有Activity的信息，属性如下：
- service：ActivityManagerService的引用
- info：Activity注册的全部信息
- appInfo：此活动对应的应用程序信息
- launchedFromPackage：启动此Activity程序对应的包名
- app：所在进程信息ProcessRecord对象
- launchMode：启动模式
- task：此Activity所属的任务栈，TaskRecord
- taskAffinity：Activity设置的归属栈名称
- packageName：包含Activity的包名
- processName：程序的进程名称
- userId：当前活动运行所在的用户ID
- ActivityRecord resultTo：此活动需要回复数据的ActivityRecord对象
- requestCode：请求的状态码
- Bundle icicle：保存Activity的数据
- state：Activity的当前状态
- icon：应用程序图标Icon
- logo：应用程序图标Logo
- theme：应用程序图标theme
- labelRes：应用程序图标labelRes
- TaskRecord：Activity所属的任务栈
- AMS中使用任务栈记录每个Activity的状态和启动顺序，使每个Activity都有各自的任务栈，在执行启动和退出时可以在栈中有序进行；
- 默认A启动新的ActivityB，那新的B就加入A所在的任务栈中；
- TaskRecord属性：
- taskId：任务栈的Id，唯一标志
- affinity：任务栈的倾向性名称
- intent：启动这个栈的Intent意图
- userId：此栈所属的用户ID
- mActivities：任务栈中所有的Activity信息
- mStack：当前的栈所属的管理类ActivityStack对象
- mService：保存AMS引用
- ActivityStack：Activity的栈管理类，管理进程中所有的TaskRecord对象
- mService：AMS引用
- mWindowManager：WMS引用
- ArrayList mTaskHistory：所有的活动历史记录栈，集合中最顶的栈为当前栈
- mLRUActivities：保存最近最少使用的活动
- mPausingActivity：保存正在暂停的Activity
- mLastPausedActivity：最近一个已经Paused状态的活动
- mResumedActivity：当前正在运行的活动
- mLastNoHistoryActivity：最近一个NoHistory的活动
- mStackId：栈管理的id
- mHandler：ActivityStackHandler对象，执行Handler消息事件
2、AMS的启动过程
AMS作为系统的主要服务，也是在Android系统启动后由系统来启动，由Android系统启动过程知道系统启动服务通过SystemServer完成，在SystemServer中调用startBootstrapServices（）启动核心服务，AMS也是在此方法中完成启动
private void startBootstrapServices() {
559 mActivityManagerService = mSystemServiceManager.startService(
560 ActivityManagerService.Lifecycle.class).getService(); //1、使用SystemServiceManager创建AMS对象
561 mActivityManagerService.setSystemServiceManager(mSystemServiceManager); //赋值AMS中mSystemServiceManager
562 mActivityManagerService.setInstaller(installer); //赋值AMS中的installer
}
上面的代码也是在Android系统启动过程中出现过的，使用SystemServiceManager.startService()方法，传入ActivityManagerService.Lifecycle.class启动服务，由前面的学习知道startService（）方法中会创建Lifecycle对象，并调用onStart（）方法
public static final class Lifecycle extends SystemService {
private final ActivityManagerService mService;
public Lifecycle(Context context) {
super(context);
mService = new ActivityManagerService(context); // 1、创建AMS对象
}
@Override
public void onStart() {
mService.start(); // 2、执行start（）方法
}
public ActivityManagerService getService() { // 3、返回AMS对象
return mService;
}
}
在Lifecycle的构造函数中直接创建ActivityManagerService对象，然后调用ActivityManagerService.start()方法
- ActivityManagerService构造函数
public ActivityManagerService(Context systemContext) {
mSystemThread = ActivityThread.currentActivityThread(); // 1、获取ActivityThread实例
mHandlerThread = new ServiceThread(TAG, THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
mHandlerThread.start();
mHandler = new MainHandler(mHandlerThread.getLooper()); // 2、使用HandlerThread初始化一个线程和Handler对象
mProcStartHandlerThread = new ServiceThread(TAG + ":procStart”, // 3、初始化用于进程启动的ProcStartHandle对象
THREAD_PRIORITY_FOREGROUND, false /* allowIo */);
mProcStartHandlerThread.start();
mProcStartHandler = new Handler(mProcStartHandlerThread.getLooper());
if (sKillHandler == null) {
sKillThread = new ServiceThread(TAG + ":kill",
THREAD_PRIORITY_BACKGROUND, true /* allowIo */);
sKillThread.start();
sKillHandler = new KillHandler(sKillThread.getLooper()); // 4、初始化用于杀死进程的sKillHandler对象
}
mServices = new ActiveServices(this);
mProviderMap = new ProviderMap(this); // 初始化属性
File dataDir = Environment.getDataDirectory();
File systemDir = new File(dataDir, "system”); // 创建/system/文件夹
systemDir.mkdirs();
mLifecycleManager = new ClientLifecycleManager();//初始化ClientLifecycleManager对象
mProcessCpuThread = new Thread("CpuTracker") {。。。。。。} // 创建mProcessCpuThread线程
}
在实例化ActivityManagerService对象时，主要执行以下操作：
- 调用ActivityThread.currentActivityThread()获取ActivityThread对象，此对象在ActivityThread中创建；
- 使用HandlerThread初始化工作线程和Handler对象；
- 初始化用于进程启动的线程和ProcStartHandle对象；
- 创建用于杀死进程的sKillHandler对象；
- 初始化属性信息和创建文件夹；
- 创建用于生命周期管理的ClientLifecycleManager对象；
- 创建mProcessCpuThread线程；
- AMS.start()
private void start() {
mProcessCpuThread.start(); // 1、
mBatteryStatsService.publish();
mAppOpsService.publish(mContext); //
LocalServices.addService(ActivityManagerInternal.class, new LocalService()); // 2、
try {
mProcessCpuInitLatch.await(); //3、
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new IllegalStateException("Interrupted wait during start");
}
}
在start（）方法中，首先启动mProcessCpuThread线程，使用LocalServices注册ActivityManagerInternal类型的LocalService对象，关于LocalServices它功能类似于ServiceManager，在内部使用静态变量保存注册的Class和对象的关系，在使用时直接获取使用，不过它只能在相同线程中使用，最后调用使用CountDownLatch同步线程，等待mProcessCpuThread线程启动完成；
3、AMS对Activity生命周期的管理
第二个部分主要介绍AMS是如何管理生命周期，如何回调生命周期方法的，在Android内核剖析书中主要针对Android 2.3版本，从其源码中可以看出，当时的AMS中功能是十分臃肿的，而且对生命周期的回调也是直接调用的，代码从理解上来说会不较容易，笔者在看完Android 2.3源码后又学习的Android P的源码，在Android P中将对生命周期的管理单独抽取封装成模块，本片文章就看下Android P中的源码，在AndroidP中执行程序的onPause（）方法的过程被封装成
mService.getLifecycleManager().scheduleTransaction(prev.app.thread, prev.appToken,
PauseActivityItem.obtain(prev.finishing, userLeaving,
prev.configChangeFlags, pauseImmediately));
使用模版模式，将所有对生命周期的回调都封装成统一的样式，通过创建不同的对象达到不同的效果，在介绍上述代码执行前先介绍下主要的几个类；
- ActivityLifecycleItem
public abstract class ActivityLifecycleItem extends ClientTransactionItem {
@IntDef(prefix = { "UNDEFINED", "PRE_", "ON_" }, value = {
UNDEFINED,
PRE_ON_CREATE,
ON_CREATE,
ON_START,
ON_RESUME,
ON_PAUSE,
ON_STOP,
ON_DESTROY,
ON_RESTART
})
@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;
@LifecycleState
public abstract int getTargetState(); // 返回相应的状态
@Override
public void recycle() { // 生命空的recycle（）方法
}
}
在Android系统中将每个生命周期都抽象成单独的Item，然后创建抽象的ActivityLifecycleItem类，在其中声明方法周期注解、抽象方法和对应的常量，另外ActivityLifecycleItem继承了ClientTransactionItem类，如果说ActivityLifecycleItem类是统一所有生命周期Item的Base类，那ClientTransactionItem就是定义了如何使用每个Item 的框架类；
- ClientTransactionItem
public class ClientTransaction implements Parcelable, ObjectPoolItem {
private List<ClientTransactionItem> mActivityCallbacks;
private ActivityLifecycleItem mLifecycleStateRequest; // 要执行的lifecycle
private IApplicationThread mClient; // 发起请求的Client
private IBinder mActivityToken;
// 1、获取ClientTransaction对象
public static ClientTransaction obtain(IApplicationThread client, IBinder activityToken) {
ClientTransaction instance = ObjectPool.obtain(ClientTransaction.class);
if (instance == null) {
instance = new ClientTransaction();
}
instance.mClient = client;
instance.mActivityToken = activityToken;
return instance;
}
public void setLifecycleStateRequest(ActivityLifecycleItem stateRequest) {
mLifecycleStateRequest = stateRequest; // 2、设置执行生命周期对应的 Item
}
// 3、执行ClientTransaction对象的方法
public void schedule() throws RemoteException {
mClient.scheduleTransaction(this); //
}
}
@Override
public void recycle() { //4、
if (mActivityCallbacks != null) {
int size = mActivityCallbacks.size();
for (int i = 0; i < size; i++) {
mActivityCallbacks.get(i).recycle();
}
mActivityCallbacks.clear();
}
if (mLifecycleStateRequest != null) {
mLifecycleStateRequest.recycle();
mLifecycleStateRequest = null;
}
mClient = null;
mActivityToken = null;
ObjectPool.recycle(this);
}
上述代码为ClientTransaction中主要的功能部分：
- 获取ClientTransaction对象，ClientTransaction内部使用对象缓存池ObjectPool缓存对象，同时保存mClient对象；
- 使用setLifecycleStateRequest（）设置内部要执行的生命周期的Item对象，这里类似于Okhttp中的Reuqest；
- 在schedule（）方法中调用mClient.scheduleTransaction()中方法并传入this对象，执行具体的任务；
- 在recycle（）方法中清除当前对象的所有状态和信息，然后缓存ClientTransaction对象；
上面的执行过程中除了创建对象、设置请求Request、回收对象真正执行任务是在Client中，这里的Client是ApplicaitonThread对象中方法
void scheduleTransaction(ClientTransaction transaction) {
transaction.preExecute(this); // 1、执行preExecute（）
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction); //2、发送事件执行transaction，在ActivityThread中
}
在scheduleTransaction（）方法中首先调用transaction.preExecute()方法，preExecute会回调每个Item.preExecute（）,主要做执行前的准备工作，然后调用sendMessage（）发送时间消息，处理事件是在ActivityThread中
case EXECUTE_TRANSACTION:
final ClientTransaction transaction = (ClientTransaction) msg.obj;
mTransactionExecutor.execute(transaction) ; // 调用TransactionExecutor执行transaction对象
if (isSystem()) {
transaction.recycle(); // 释放、回收资源
}
break;
在获取到消息事件中的ClientTransaction对象后，调用TransactionExecutor中方法执行transaction对象，在execute（）方法中会调用executeLifecycleState（）
private void executeLifecycleState(ClientTransaction transaction) {
final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest(); // 1、获取传入的LifecycleItem
final IBinder token = transaction.getActivityToken();
final ActivityClientRecord r = mTransactionHandler.getActivityClient(token); // 2、获取要执行的ActivityRecord
if (r == null) {
return;
}
cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */);
lifecycleItem.execute(mTransactionHandler, token, mPendingActions); // 3、执行LifecycleItem的execute（）
lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions); // 4、执行postExecute（）回调通知执行结果
}
在executeLifecycleState（）中首先获取要执行的Request，其实获取的就是要执行的生命周期的Item，然后执行Item的execute（）和postExecute（）方法，execute主要执行任务而postExecute在执行任务结束后回到结果，下面以Activity的onPause为例
- PauseActivityItem
public class PauseActivityItem extends ActivityLifecycleItem { //
private boolean mFinished;
private boolean mUserLeaving;
private int mConfigChanges;
private boolean mDontReport;
@Override
public void execute(ClientTransactionHandler client, IBinder token,
PendingTransactionActions pendingActions) {
client.handlePauseActivity(token, mFinished, mUserLeaving, mConfigChanges, pendingActions,
"PAUSE_ACTIVITY_ITEM”); // 1、
}
@Override
public int getTargetState() {
return ON_PAUSE;
}
@Override
public void postExecute(ClientTransactionHandler client, IBinder token,
PendingTransactionActions pendingActions) {
if (mDontReport) {
return;
}
try {
ActivityManager.getService().activityPaused(token); // 2
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
private PauseActivityItem() {}
public static PauseActivityItem obtain(boolean finished, boolean userLeaving, int configChanges,
boolean dontReport) {
PauseActivityItem instance = ObjectPool.obtain(PauseActivityItem.class);//使用对象池复用对象
if (instance == null) {
instance = new PauseActivityItem();
}
instance.mFinished = finished;
instance.mUserLeaving = userLeaving;
instance.mConfigChanges = configChanges;
instance.mDontReport = dontReport;
return instance;
}
@Override
public void recycle() {
super.recycle();
mFinished = false;
mUserLeaving = false;
mConfigChanges = 0;
mDontReport = false;
ObjectPool.recycle(this); // 回收对象
}
}
在PauseItem中主要执行以下逻辑：
1、生命周期回调框架会调用其execute（），在execute（）中调用I ApplicationThread.handlePauseActivity()方法，处理方法暂停
2、在执行完Activity的pause之后会调用postExecute（），在postExecute中回调通知AMS.activityPaused()，通知AMS方法暂停完成；
mService.getLifecycleManager().scheduleTransaction(prev.app.thread, prev.appToken,
PauseActivityItem.obtain(prev.finishing, userLeaving,
prev.configChangeFlags, pauseImmediately));
现在来解释下开始时给出的代码，使用的执行架构就是上面分析的内容，那getLifecycleManager()获取的是什么呢？获取的其实是ClientLifecycleManager对象，就是AMS在构造函数中初始化的，ClientLifecycleManager的作用封装了ClientTransaction
对象的创建、设置请求Request、schedule（）执行、recycle（）回收部分；
- ClientLifecycleManager
class ClientLifecycleManager {
// 使用此方法可以实现回调生命周期中的方法
void scheduleTransaction(@NonNull IApplicationThread client, @NonNull IBinder activityToken,
@NonNull ActivityLifecycleItem stateRequest) throws RemoteException {
final ClientTransaction clientTransaction = transactionWithState(client, activityToken,stateRequest);
scheduleTransaction(clientTransaction);
}
//根据请求的参数，封装ClientTransaction对象
private static ClientTransaction transactionWithState(@NonNull IApplicationThread client,
@NonNull IBinder activityToken, @NonNull ActivityLifecycleItem stateRequest) {
final ClientTransaction clientTransaction = ClientTransaction.obtain(client, activityToken);
clientTransaction.setLifecycleStateRequest(stateRequest);
return clientTransaction;
}
// 执行具体的ClientTransaction对象
void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
final IApplicationThread client = transaction.getClient();
transaction.schedule(); // 调用schedule（）
if (!(client instanceof Binder)) {
transaction.recycle();//调用recycle（）
}
}
}
在调用scheduleTransaction（）传入参数后，首先调用transactionWithState（）使用参数创建ClientTransaction对象，然后调用scheduleTransaction（），在scheduleTransaction中触发schedule的执行，然后系统就会执行相应的Item，在执行结束后调用recycle（）回收对象；
上面就是AMS中数据结构和两个基础模块的分析，下一篇文章将带着这些基础去分析AMS如何管理和调度Activity的。