＜Android开发＞ Android内核系统开发- 管理 Activity和组件运行状态 的系统进程----ActivityManagerServer(AMS)

＜Android开发＞ Android内核系统开发- 管理 Activity和组件运行状态 的系统进程----ActivityManagerServer(AMS)

前言
Activity Manager Service(AMS)是Android提供的一个用于管理Activity（和其它组件）运行状态的系统进程，也是我们编写APK应用程序时使用得最频繁的一个系统服务。在Android 10开启AMS的启动流程做了修改，需注意，作者这里选用的源码是高通8155配套基线代码LA.1.1，该基线的Android版本是 10，所以AMS的流程是Android 10及以后版本上的。旧版AMS流程，读者有需要可参考其他资料学习。
本文章的详细流程图及电子文档在：文档链接，此可下载。

1 AMS功能概述
虽然开发者经常会使用Activity Manager Service (AMS)提供的一些功能，但是可能鲜有机会对它进行统一的整理与分析。因此我们先对AMS的功能进行整体概述，从而为后面分析其内部实现打下基础。

1.1 AMS启动分析
和WMS(WindowManagerService)一样，Activity Manager Service (AMS)也是寄生于SystemServer中的。它会在系统启动时创建一个线程来循环处理客户的请求。需要注意的是，Activity Manager Service (AMS)会向ServiceManager注册登记多种Binder Server，如“activity”、“meminfo”、“cpuinfo”等等，但是只有第一个“activity”才是Activity Manager Service (AMS)的主要功能内容，并由ActivityManagerService实现；其余服务的功能则是由其它类提供。
在之前分析的“启动过程详解”中，得到，AMS的启动位置在：init.rc→app_process→main@ZygoteInit→forkSystemServer()→Zygote.forkSystemServer()→handleSystemServerProcess()→ZygoteInit.zygoteInit()→main()@com.android.server.SystemServer->SystemServer().run()->startBootstrapService()；先看看startBootstrapService()中具体启动AMS的调用函数有哪些，源码内容如下：

/* frameworks/base/services/java/com/android/server/SystemServer.java    */
private void startBootstrapServices() {
   
…………
	// Activity manager runs the show.
	// 活动管理器运行节目。
	traceBeginAndSlog("StartActivityManager");//跟踪开始和 Slog
	// TODO: Might need to move after migration to WM.
	// TODO: 迁移到 WM 后可能需要移动。
	//启动ActivityTaskManagerService服务，简称ATM，Android10新引入功能，用来管理Activity的启动，调度等功能。
	ActivityTaskManagerService atm = mSystemServiceManager.startService( //在系统服务管理器 获取 ActivityTaskManagerService 类的服务信息
	ActivityTaskManagerService.Lifecycle.class).getService(); //就是创建AMS 
	mActivityManagerService = ActivityManagerService.Lifecycle.startService( //启动AMS 服务
	mSystemServiceManager, atm); 
	mActivityManagerService.setSystemServiceManager(mSystemServiceManager); 
	mActivityManagerService.setInstaller(installer);
	mWindowManagerGlobalLock = atm.getGlobalLock();
	traceEnd();//跟踪结束
…………
	// Set up the Application instance for the system process and get started.
	// 为系统进程设置应用程序实例并开始。
	traceBeginAndSlog("SetSystemProcess"); //跟踪开始和 Slog
	mActivityManagerService.setSystemProcess(); //向Service Manager 注册
	traceEnd(); //跟踪结束
…………
}

从上面可以看到 启动ActivityTaskManagerService服务，ActivityTaskManagerService简称ATM，Android10新引入功能，用来管理Activity的启动，调度等功能。而ActivityManagerService.Lifecycle.startService()才是真正启动AMS的。在后面的函数mActivityManagerService.setSystemProcess()则是用来向ServiceManager登记多种Binder Server，如“activity”、“meminfo”、“cpuinfo”、“gfxinfo”、“dbinfo”、 "permission"等等，后面会详细分析其源码。接下来一一分析这三个的具体内容。

1.2 ATM 管理服务

1.2.1 ActivityTaskManagerService.Lifecycle
ActivityTaskManagerService(ATM)启动最终调用的是ActivityTaskManagerService.Lifecycle.onStart()来启动ATM服务的，其源码如下：

/*  frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java  */
public static final class Lifecycle extends SystemService {
   
	private final ActivityTaskManagerService mService;
	public Lifecycle(Context context) {
   
		super(context);
		mService = new ActivityTaskManagerService(context);
	}
	@Override
	public void onStart() {
   
		publishBinderService(Context.ACTIVITY_TASK_SERVICE, mService);
		mService.start();
	}
	@Override
	public void onUnlockUser(int userId) {
   
		synchronized (mService.getGlobalLock()) {
   
			mService.mStackSupervisor.onUserUnlocked(userId);
		}
	}
	@Override
	public void onCleanupUser(int userId) {
   
		synchronized (mService.getGlobalLock()) {
   
			mService.mStackSupervisor.mLaunchParamsPersister.onCleanupUser(userId);
		}
	}
	public ActivityTaskManagerService getService() {
   
		return mService;
	}
}

在上述源码可看出ActivityTaskManagerService.Lifecycle是一个类，在其构造函数中new了一个ActivityTaskManagerService对象。

1.2.2 ActivityTaskManagerService类
在ActivityTaskManagerService类对象的创建过程做了一些事。该类源码如下：

/*  frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java  */
public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
   
	……………略
	final Context mUiContext;
	final ActivityThread mSystemThread;
	H mH;
	……………略
	final Object mGlobalLockWithoutBoost = mGlobalLock;
	ActivityStackSupervisor mStackSupervisor; //ActivityStackSupervisor 是ATM中用来管理Activity启动和调度的核心类
	RootActivityContainer mRootActivityContainer; //Activity 容器的根节点
	WindowManagerService mWindowManager; //WindowManagerService(WMS) 负责窗口的管理
	private UserManagerService mUserManager;
	private AppOpsService mAppOpsService;
	/** All active uids in the system. */
	/** 系统中所有活动的 uid。 */
	private final MirrorActiveUids mActiveUids = new MirrorActiveUids();
	private final SparseArray<String> mPendingTempWhitelist = new SparseArray<>();
	/** All processes currently running that might have a window organized by name. */
	/** 当前运行的所有进程可能有一个按名称组织的窗口。 */
	final ProcessMap<WindowProcessController> mProcessNames = new ProcessMap<>();
	/** All processes we currently have running mapped by pid and uid */
	/** 我们当前运行的所有进程都由 pid 和 uid 映射 */
	final WindowProcessControllerMap mProcessMap = new WindowProcessControllerMap();
	/** This is the process holding what we currently consider to be the "home" activity. */
	/** 这是持有我们目前认为是“home” activity的进程。 */
	WindowProcessController mHomeProcess;
	/** The currently running heavy-weight process, if any. */
	/** 当前运行的重量级进程，如果有的话。 */
	WindowProcessController mHeavyWeightProcess = null;
	boolean mHasHeavyWeightFeature;
	/**
	* This is the process holding the activity the user last visited that is in a different process
	* from the one they are currently in.
	*/
	/** 这是持有用户上次访问的活动的进程，该进程与他们当前所在的进程不同。*/
	WindowProcessController mPreviousProcess;
	/** The time at which the previous process was last visible. */
	/** 上一个进程最后一次可见的时间。 */
	long mPreviousProcessVisibleTime;

	/** List of intents that were used to start the most recent tasks. */
	/** 用于启动最近任务的意图列表。 */
	private RecentTasks mRecentTasks;
	/** State of external calls telling us if the device is awake or asleep. */
	/** 外部调用的状态告诉我们设备是醒着还是睡着了。 */
	private boolean mKeyguardShown = false;

	// Wrapper around VoiceInteractionServiceManager
	// VoiceInteractionServiceManager 的封装
	private AssistUtils mAssistUtils;
	……………略
	@VisibleForTesting(visibility = VisibleForTesting.Visibility.PACKAGE)
	public ActivityTaskManagerService(Context context) {
   
		mContext = context; //拿到System Context
		mFactoryTest = FactoryTest.getMode();
		//取出的是ActivityThread的静态变量sCurrentActivityThread
		//这意味着mSystemThread与SystemServer中的ActivityThread一致
		mSystemThread = ActivityThread.currentActivityThread();
		//拿到System UI Context
		mUiContext = mSystemThread.getSystemUiContext();
		mLifecycleManager = new ClientLifecycleManager();
		//拿到LocalService的对象
		mInternal = new LocalService();
		GL_ES_VERSION = SystemProperties.getInt("ro.opengles.version", 				                         	GL_ES_VERSION_UNDEFINED);
	}
	……………略
}

ActivityTaskManagerService类的创建时定义了一些变量，包括 ActivityStackSupervisor、RootActivityContainer、WindowManagerService、WindowProcessController等；ActivityStackSupervisor 是ATM中用来管理Activity启动和调度的核心类；Activity 容器的根节点；WMS 负责窗口的管理；WindowProcessController是我们目前认为是"Home" Activity的过程。

1.2.3 ActivityTaskManagerService.Lifecycle.onStart
在前面讲到ATM启动最终调用的是ActivityTaskManagerService.Lifecycle.onStart()来启动ATM服务的，在 onStart函数中又调用了ActivityTaskManagerService.start()函数，后者的内容如下：

/*  frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java */
//将ActivityTaskManagerInternal添加到本地服务的全局注册表中
private void start() {
   
	LocalServices.addService(ActivityTaskManagerInternal.class, mInternal);
}

上面的start函数是将ActivityTaskManagerInternal添加到本地服务的全局注册表中。
ActivityTaskManagerInternal为抽象类，其实现类为ActivityTaskManagerService#LocalService.class，所以实际是将 LocalService添加到本地服务的全局注册表中。
所以由上面分析ActivityTaskManagerService是用来管理Activity的启动和调度等功能的，这个管理服务是Android 10开始引入的新功能，在以往的android版本中不存在，所有AMS启动流程也会不同，这点读者需要根据自己的android版本进行区别。如需详细了解可自行查阅相关资料。

注意：上面讲的ActivityTaskManagerService 和接下来要讲的 ActivityManagerService 两个之间差了一个Task。实现的具体功能是不一样的。

1.3 AMS启动函数分析

1.3.1 ActivityManagerService.Lifecycle
ActivityTaskManagerService管理服务准备好了后，就要启动ActivityManagerService了，在 前面1.1小节中讲到了AMS启动涉及三个部分，在1.2小节中讲了第1部分ATM，接下来讲第2部分AMS。
同ActivityTaskManagerService一样，在[email protected]中调用ActivityManagerService.Lifecycle.startService()后最终调用ActivityManagerService.Lifecycle.onStart()。源码如下：

/*  frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java */
public static final class Lifecycle extends SystemService {
   
	private final ActivityManagerService mService;
	private static ActivityTaskManagerService sAtm;

	public Lifecycle(Context context) {
   
		super(context);
		mService = new ActivityManagerService(context, sAtm);
	}

	public static ActivityManagerService startService(
		SystemServiceManager ssm, ActivityTaskManagerService atm) {
   
		sAtm = atm;
		return ssm.startService(ActivityManagerService.Lifecycle.class).getService();
	}

	@Override
	public void onStart() {
   
		mService.start();
	}

	@Override
	public void onBootPhase(int phase) {
   
		mService.mBootPhase = phase;
		if (phase == PHASE_SYSTEM_SERVICES_READY) {
   
			mService.mBatteryStatsService.systemServicesReady();
			mService.mServices.systemServicesReady();
		} else if (phase == PHASE_ACTIVITY_MANAGER_READY) {
   
			mService.startBroadcastObservers();
		} else if (phase == PHASE_THIRD_PARTY_APPS_CAN_START) {
   
			mService.mPackageWatchdog.onPackagesReady();
		}
	}

	@Override
	public void onCleanupUser(int userId) {
   
		mService.mBatteryStatsService.onCleanupUser(userId);
	}

	public ActivityManagerService getService() {
   
		return mService;
	}
}

在ActivityManagerService.Lifecycle的构造函数中new了一个ActivityManagerService对象，后者的构造函数主要工作就是初始化一些变量，供之后的service，broadcast，provider的管理和调度。

1.3.2 ActivityManagerService类
因为ActivityManagerService的构造函数是重载函数， 根据new对象的传入参数可知ActivityManagerService调用的构造函数的源码如下：

/*  frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java */
// Note: This method is invoked on the main thread but may need to attach various
// handlers to other threads. So take care to be explicit about the looper.
// 注意：此方法在主线程上调用，但可能需要将各种处理程序附加到其他线程。 因此，请注意明确说明 looper。
public ActivityManagerService(Context systemContext, ActivityTaskManagerService atm) {
   
	LockGuard.installLock(this, LockGuard.INDEX_ACTIVITY);
	mInjector = new Injector();
	mContext = systemContext; //AMS的运行上下文与SystemServer一致
	// 1.系统Context 和 ActivityThread （将systemserver进程作为应用进程管理）
	//取出的是ActivityThread的静态变量sCurrentActivityThread
	//这意味着mSystemThread与SystemServer中的ActivityThread一致
	mFactoryTest = FactoryTest.getMode(); //获取工厂测试模式
	mSystemThread = ActivityThread.currentActivityThread(); //获取当前ActivityThread
	mUiContext = mSystemThread.getSystemUiContext(); //获取系统 UI 上下文

	Slog.i(TAG, "Memory class: " + ActivityManager.staticGetMemoryClass());
	// 2.AMS工作的线程和Handler，处理显示相关的UiHandler ---》知识点HandlerThread和Handler
	mHandlerThread = new ServiceThread(TAG,THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
	mHandlerThread.start(); //启动线程
	mHandler = new MainHandler(mHandlerThread.getLooper()); //处理AMS中消息的主力
	mUiHandler = mInjector.getUiHandler(this); //UiHandler对应于Android中的UiThread

	mProcStartHandlerThread = new ServiceThread(TAG + ":procStart",THREAD_PRIORITY_FOREGROUND, false /* allowIo */); //Proc 启动处理程序线程
	mProcStartHandlerThread.start(); //
	mProcStartHandler = new Handler(mProcStartHandlerThread.getLooper());

	mConstants = new ActivityManagerConstants(mContext, this, mHandler);
	final ActiveUids activeUids = new ActiveUids(this, true /* postChangesToAtm */); //发布对 Atm 的更改
	mProcessList.init(this, activeUids);
	mLowMemDetector = new LowMemDetector(this);
	mOomAdjuster = new OomAdjuster(this, mProcessList, activeUids);

	// Broadcast policy parameters
	// 广播策略参数
	// 3. 广播队列BroadcastQueue初始化：前台广播队列和后台广播队列
	final BroadcastConstants foreConstants = new BroadcastConstants(
	Settings.Global.BROADCAST_FG_CONSTANTS);
	foreConstants.TIMEOUT = BROADCAST_FG_TIMEOUT;

	final BroadcastConstants backConstants = new BroadcastConstants(
	Settings.Global.BROADCAST_BG_CONSTANTS);
	backConstants.TIMEOUT = BROADCAST_BG_TIMEOUT;

	final BroadcastConstants offloadConstants = new BroadcastConstants(
	Settings.Global.BROADCAST_OFFLOAD_CONSTANTS);
	offloadConstants.TIMEOUT = BROADCAST_BG_TIMEOUT;
	// by default, no "slow" policy in this queue
	// 默认情况下，此队列中没有“慢”策略
	offloadConstants.SLOW_TIME = Integer