1 AMS 家族
ActivityManagerService（AMS）主要负责系统中四大组件的启动、切换、调度以及应用程序的管理和调度工作，其职责与操作系统中的进程管理和调度模块类似。ActivityManagerService 进行初始化的时机很明确，就是在 system_server 进程开启的时候，就会初始化 ActivityManagerService。（启动 APP 的时候，是需要 AMS 通知 Zygote 进程，所有的 Activity 的生命周期都需要 AMS 来控制）
ActivityThread 在 Android 中代表主线程，在 APP 进程创建完成之后，就会加载 ActivityThread.main 函数，然后执行 Looper.loop() 循环，使当前线程进入消息循环。ApplicationThread 是 ActivityThread 的内部类，继承了 IApplicationThread.Stub。如果需要在目标进程中启动 Activity，就要通过 ApplicationThread 与 AMS 所在的进程（system_server 进程）进行通信。
1.1 Android 7.0 的 AMS 家族
ActivityManager 是一个和 AMS 相关联的类，主要是对运行中的 Activity 进行管理，但是，这些管理工作并不是直接由 ActivityManager 管理的，而是交由 AMS 来处理。
ActivityManager 中的方法会通过 ActivityManagerNative(AMN).getDefault() 方法来得到 ActivityManagerProxy（AMP），通过 AMP 就可以和 AMN 进行通信。AMN 是一个抽象类，它将功能交给它的子类 AMS 来处理，因此，AMP 就是 AMS 的代理类。
以下是相关类：
public interface IInterface{
public IBinder asBinder();
}
public interface IBinder {
public boolean transact(int code, Parcel data, Parcel reply, int flags) throws RemoteException;
}
public class Binder implements IBinder { }
public interface IActivityManager extends IInterface { }
public abstract class ActivityManagerNative extends Binder implements IActivityManager {
class ActivityManagerProxy implements IActivityManager { }
}
public final class ActivityManagerService extends ActivityManagerNative
implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback { }
AMS 作为系统服务，很多 API 是不会暴露给 ActivityManager 的，因此 ActivityManager 并不算是 AMS 家族中的一份子。以下会以 Android 7.0 的 Activity 启动过程来举例，在 Activity 的启动过程中会调用 Instrumentation.execStartActivity 方法：
// /frameworks/base/core/java/android/app/Instrumentation.java
public ActivityResult execStartActivity(
...
try {
intent.migrateExtraStreamToClipData();
intent.prepareToLeaveProcess(who);
int result = ActivityManagerNative.getDefault()
.startActivity(whoThread, who.getBasePackageName(), intent,
intent.resolveTypeIfNeeded(who.getContentResolver()),
token, target, requestCode, 0, null, options);
checkStartActivityResult(result, intent);
} catch (RemoteException e) {
throw new RuntimeException("Failure from system", e);
}
return null;
}
AMS 和 ActivityThread 之间，比如 Activity 的创建、暂停等交互工作实际上是由 Instumentation 具体操作的。每个 Activity 都持有一个 Instrumentation 对象的引用，整个进程中也只有一个 Instrumentation。mInstrumentation 的初始化在 ActivityThread.handleBindApplication 函数中，可以用来独立地控制某个组件的生命周期。Activity.startActivity 方法调用 mInstrumentation.execStartActivity 方法，最终，通过 AMS 告知 Zygote 进程 fork 子进程。
// /frameworks/base/core/java/android/app/ActivityThread.java
private void handleBindApplication(AppBindData data) {
...
if (ii != null) {
...
try {
final ClassLoader cl = instrContext.getClassLoader();
mInstrumentation = (Instrumentation)
cl.loadClass(data.instrumentationName.getClassName()).newInstance();
} catch (Exception e) {
throw new RuntimeException(
"Unable to instantiate instrumentation "
+ data.instrumentationName + ": " + e.toString(), e);
}
...
} else {
mInstrumentation = new Instrumentation();
}
}
在 Instrumentation.execStartActivity 方法中会调用 ActivityManagerNative(AMN).getDefault() 方法来获取 AMS 的代理类 AMP，接着调用了 ActivityManagerProxy(AMP).startActivity 方法。 首先来看 ActivityMangerNative.getDefault() 方法：
/frameworks/base/core/java/android/app/ActivityManagerNative.java
static public IActivityManager getDefault() {
return gDefault.get();
}
private static final Singleton<IActivityManager> gDefault = new Singleton<IActivityManager>() {
protected IActivityManager create() {
IBinder b = ServiceManager.getService("activity"); // 1
if (false) {
Log.v("ActivityManager", "default service binder = " + b);
}
IActivityManager am = asInterface(b); // 2
if (false) {
Log.v("ActivityManager", "default service = " + am);
}
return am;
}
};
// frameworks/base/core/java/android/util/Singleton.java
public abstract class Singleton<T> {
private T mInstance;
protected abstract T create();
public final T get() {
synchronized (this) {
if (mInstance == null) {
mInstance = create();
}
return mInstance;
}
}
}
在 ActivityManagerNative.getDefault() 方法中调用了 gDefault.get() 方法，gDefault 是一个 Singleton 类。在注释1 处得到名为 “activity” 的 Service 引用，也就是 IBinder 类型的 AMS 的引用。接着在注释 2 处将它封装成 AMP 类型对象，并将它保存到 gDefault 中，此后调用 ActivityManagerNative.getDefault() 方法就会直接获取 AMS 的代理对象 AMP。 注释 2 处的 asInterface 方法如下所示：
/frameworks/base/core/java/android/app/ActivityManagerNative.java
static public IActivityManager asInterface(IBinder obj) {
if (obj == null) {
return null;
}
IActivityManager in =
(IActivityManager)obj.queryLocalInterface(descriptor); // 1
if (in != null) {
return in;
}
return new ActivityManagerProxy(obj); // 2
}
注释 1 处的 descriptor 值为 android.app.IActivityManager，注释 1 处的代码主要用来查询本地进程是否有 IActivityManager 接口的实现，如果有则返回，如果没有，就在注释 2 处将 IBinder 类型的 AMS 引用封装成 AMP，AMP 的构造方法如下所示：
/frameworks/base/core/java/android/app/ActivityManagerNative.java
class ActivityManagerProxy implements IActivityManager {
public ActivityManagerProxy(IBinder remote) {
mRemote = remote;
}
...
}
在 AMP 的构造方法中将 AMS 的引用赋值给变量 mRemote，这样在 AMP 中就可以使用 AMS 了。其中，IActivityManager 是一个接口，AMN 和 AMP 都实现了这个接口，用于实现代理模式和 Binder 通信。
再回到 Instrumentation.execStartActivity 方法中，查看 ActivityManagerProxy(AMP).startActivity 方法，AMP 是 AMN 的内部类，代码如下所示：
/frameworks/base/core/java/android/app/ActivityManagerNative.java
public int startActivity(IApplicationThread caller, String callingPackage, Intent intent,
String resolvedType, IBinder resultTo, String resultWho, int requestCode,
int startFlags, ProfilerInfo profilerInfo, Bundle options) throws RemoteException {
...
data.writeInt(requestCode);
data.writeInt(startFlags);
...
mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0); // 1
reply.readException();
int result = reply.readInt();
reply.recycle();
data.recycle();
return result;
}
首先将传入的参数写入到 Parcel 类型的 data 中。在注释 1 处，通过 IBinder 类型对象 mRemote（AMS 的引用）向服务端的 AMS 发送一个 START_ACTIVITY_TRANSACTION 类型的进程间通信请求，之后，服务端 AMS 就会从 Binder 线程池中读取客户端发来的数据，最终会调用 ActivityManagerNative.onTransact 方法，如下所示：
/frameworks/base/core/java/android/app/ActivityManagerNative.java
@Override
public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
throws RemoteException {
switch (code) {
case START_ACTIVITY_TRANSACTION:
{
...
int result = startActivity(app, callingPackage, intent, resolvedType,
resultTo, resultWho, requestCode, startFlags, profilerInfo, options);
reply.writeNoException();
reply.writeInt(result);
return true;
}
...
}
在 ActivityManagerNative.onTransact 方法中会调用 ActivityManagerService.startActivity 方法，如下所示：
/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
@Override
public final int startActivity(IApplicationThread caller, String callingPackage,
Intent intent, String resolvedType, IBinder resultTo,
String resultWho, int requestCode, int startFlags,
ProfilerInfo profilerInfo, Bundle bOptions) {
return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
resultWho, requestCode, startFlags, profilerInfo, bOptions,
UserHandle.getCallingUserId());
}
startActivityAsUser 方法最后会返回 ActivityStarter 的 startActivityMayWait 方法。
以下是时序图：
以下是 AMS 家族：
AMP 是 AMN 的内部类，它们都实现了 IActivityManager 接口，这样它们就可以实现代理模式，具体来讲是远程代理：AMN 和 AMP 是运行在两个进程中的，AMP 是 Client 端，AMN 则是 Server 端，而 Server 端中具体的功能都是由 AMN 的子类 AMS 来实现的。因此，AMP 就是 AMS 在 Client 端的代理类。AMN 又实现了 Binder 类，这样 AMP 和 AMS 就可以通过 Binder 来进行进程间通信。ActivityManager 通过 AMN 的 getDefault() 方法得到 AMP，通过 AMP 就可以和 AMS 进行通信。 除了 ActivityManager，有些需要与 AMS 进行通信的类也需要通过 AMP，如图所示：
1.2 Android 8.0 的家族
Android 8.0 的 AMS 家族和 Android 7.0 有一些差别。以下是相关类：
interface IActivityManager { }
public class ActivityManagerService extends IActivityManager.Stub
implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback { }
还是以 Activity 的启动过程举例，在 Activity 的启动过程中会调用 Instrumentation.execStartActivity 方法：
frameworks/base/core/java/android/app/Instrumentation.java
public ActivityResult execStartActivity(Context who, IBinder contextThread, IBinder token,
String target, Intent intent, int requestCode,
Bundle options) {
...
try {
intent.migrateExtraStreamToClipData();
intent.prepareToLeaveProcess(who);
int result = ActivityManager.getService()
.startActivity(whoThread, who.getBasePackageName(), intent,
intent.resolveTypeIfNeeded(who.getContentResolver()),
token, target, requestCode, 0, null, options);
checkStartActivityResult(result, intent);
} catch (RemoteException e) {
throw new RuntimeException("Failure from system", e);
}
return null;
}
这里调用的是 ActivityManager.getService() 方法，如下所示：
/frameworks/base/core/java/android/app/ActivityManager.java
public static IActivityManager getService() {
return IActivityManagerSingleton.get();
}
private static final Singleton<IActivityManager> IActivityManagerSingleton =
new Singleton<IActivityManager>() {
@Override
protected IActivityManager create() {
final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE); // 1
final IActivityManager am = IActivityManager.Stub.asInterface(b); // 2
return am;
}
};
ActivityManager.getService() 方法调用了 IAcitivitySingleton.get() 方法，IActivityManagerSingleton 是一个 Singleton 类。在注释 1 出得到名为 “activity” 的 Service 引用（Context.ACTIVITY_SERVICE 的值为 “activity”），也就是 IBinder 类型的 AMS 的引用。接着在注释 2 处将它转换成 IActivityManager 类型的对象，这段代码采用的是 AIDL，IActivityManager 类是由 AIDL 工具在编译时自动生成的，IActivityManager.aidl 的文件路径为 /frameworks/base/core/java/android/app/IActivityManager.aidl。要实现进程间通信，服务器端也就是 AMS 只需要继承 IActivityManager.Stub 类并实现相应的方法就可以了。
采用 AIDL 后就不需要使用 AMS 的代理类 AMP 了，因此，Android 8.0 去掉了 AMP，代替它的是 IAcitivityManager，它是 AMS 的本地代理。
以下是 Android 8.0 的时序图：
对比之下，Android 8.0 的 AMS 家族要简单的多，ActivityManager.getService() 方法会得到 IActivityManager，AMS 只需要继承 IAcitivytManager.Stub 类，就可以和 ActivityManager 实现进程间通信了。
2 AMS 的启动过程
ActivityManagerService 的启动是在 system_server 进程中启动的，以下是 SystemServer.main 方法的相关代码：
// /frameworks/base/services/java/com/android/server/SystemServer.java
public static void main(String[] args) {
new SystemServer().run();
}
SystemServer.main 方法只调用了 SystemServe().run() 方法，代码如下所示：
// /frameworks/base/services/java/com/android/server/SystemServer.java
private void run() {
try {
...
// 创建消息 Looper
Looper.prepareMainLooper();
// Initialize native services. 加载动态库 libandroid_servers.so
System.loadLibrary("android_servers"); // 1
performPendingShutdown();
// Initialize the system context. 创建系统的 Context
createSystemContext();
// Create the system service manager. 创建 SystemServiceManager
mSystemServiceManager = new SystemServiceManager(mSystemContext); // 2
mSystemServiceManager.setRuntimeRestarted(mRuntimeRestart);
LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
// Prepare the thread pool for init tasks that can be parallelized
SystemServerInitThreadPool.get();
} finally {
traceEnd(); // InitBeforeStartServices
}
// Start services.
try {
traceBeginAndSlog("StartServices");
startBootstrapServices(); // 3 启动引导服务
startCoreServices(); // 4 启动核心服务
startOtherServices(); // 5 启动其他服务
SystemServerInitThreadPool.shutdown();
} catch (Throwable ex) {
Slog.e("System", "******************************************");
Slog.e("System", "************ Failure starting system services", ex);
throw ex;
} finally {
traceEnd();
}
...
// Loop forever.
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
在 SystemServer.run() 方法中，注释 1 处加载了动态库 libandroid_servers.so，在注释 2 处创建了 SystemServiceManager，它会对系统的服务进行创建、启动和生命周期管理。在注释 3 处的 startBootstrapServices() 方法中用 SystemServiceManager 启动了 ActivityManagerService、PowerManagerService、PackageManagerService 等服务。在注释 4 处的 startCoreServices() 方法中则启动了 DropBoxManagerService、BatterService、UsageStatsService 和 WebViewUpdateService。在注释 5 处的 startOtherService() 方法中启动了 CameraService、AlarmManagerService、VrManagerService 等服务。从注释 3、注释 4、注释 5 处的方法可以看出，官方把系统服务分成了 3 种类型，分别是引导服务、核心服务和其他服务，其中其他服务是一些非紧要和不需要立即启动的服务。 这里主要是看 AMS 是如何启动的，注释 3 处的 startBooststrapServices() 方法如下所示：
// /frameworks/base/services/java/com/android/server/SystemServer.java
private void startBootstrapServices() {
...
traceBeginAndSlog("StartActivityManager");
// TODO: Might need to move after migration to WM.
ActivityTaskManagerService atm = mSystemServiceManager.startService(
ActivityTaskManagerService.Lifecycle.class).getService(); // 1
mActivityManagerService = ActivityManagerService.Lifecycle.startService(
mSystemServiceManager, atm); // 2
mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
mActivityManagerService.setInstaller(installer);
mWindowManagerGlobalLock = atm.getGlobalLock();
traceEnd();
...
}
注释 1 处的 ActivityTaskManagerService(ATMS) 是 Android 10 新增加的系统服务类，承担了 ActivityManagerService(AMS) 的部分工作，以下是它的解释：管理 Activity 和它的相关容器的系统服务。
System service for managing activities and their containers (task, stacks, displays,... ).
在注释 2 处调用了 ActivityManagerService.Lifecycle.startService 方法，Lifecycle 是 ActivityManagerService 的一个内部类，继承了 SystemService：
// frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
public static final class Lifecycle extends SystemService {
...
public static ActivityManagerService startService(
SystemServiceManager ssm, ActivityTaskManagerService atm) {
sAtm = atm;
return ssm.startService(ActivityManagerService.Lifecycle.class).getService(); // 1
}
...
}
在注释 1 处首先调用了 SystemServiceManager.startService 方法，代码如下所示：
// /frameworks/base/services/core/java/com/android/server/SystemServiceManager.java
@SuppressWarnings("unchecked")
public <T extends SystemService> T startService(Class<T> serviceClass) {
try {
final String name = serviceClass.getName();
Slog.i(TAG, "Starting " + name);
Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "StartService " + name);
// Create the service.
...
final T service;
try {
Constructor<T> constructor = serviceClass.getConstructor(Context.class);
service = constructor.newInstance(mContext);
} catch (InstantiationException ex) {
...
}
startService(service); // 1
return service; // 2
} finally {
Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
}
}
public void startService(@NonNull final SystemService service) {
// Register it. 完成注册
mServices.add(service);
// Start it.
long time = SystemClock.elapsedRealtime();
try {
service.onStart();
} catch (RuntimeException ex) {
throw new RuntimeException("Failed to start service " + service.getClass().getName()
+ ": onStart threw an exception", ex);
}
warnIfTooLong(SystemClock.elapsedRealtime() - time, service, "onStart");
}
在这个方法中，传入的参数是 SystemService 的子类 ActivityManagerService.Lifecycle.class。在注释 1 处将 service 对象添加到 ArrayList 类型的 mServices 中来完成注册。在注释 2 处返回 ActivityManagerService.Lifecycle 类型的对象。
接着回到 ActivityManagerService.Lifecycle.startService 方法中，调用的是 AcitivityManagerService.Lifcycle.getService() 方法：
public static final class Lifecycle extends SystemService {
private final ActivityManagerService mService;
public ActivityManagerService getService() { // 3
return mService;
}
}
这样就完成了 ActivityManagerService 的注册，并且获得了 ActivityManagerService 的实例。
3 AMS 与应用进程
在 Zygote 的 Java 框架层中，会创建一个 Server 端的 Socket，这个 Socket 用来等待 AMS 请求 Zygote 来创建新的应用程序进程。要启动一个应用程序，首先要保证这个应用程序所需要的应用程序进程已经存在。在启动应用程序时 AMS 会检查这个应用程序需要的应用程序进程是否存在，不存在就会请求 Zygote 进程创建需要的应用程序进程。
这里以 Service 的启动过程为例来分析 AMS 与应用程序进程的关系。Service 在启动过程中会调用 ActivityServices.bringUpServiceLocked 方法，如下所示：
// /frameworks/base/services/core/java/com/android/server/am/ActiveServices.java
private String bringUpServiceLocked(ServiceRecord r, int intentFlags, boolean execInFg,
boolean whileRestarting, boolean permissionsReviewRequired)
throws TransactionTooLargeException {
...
// 获取 Service 想要在哪个进程运行
final String procName = r.processName; // 1
String hostingType = "service";
ProcessRecord app;
if (!isolated) {
app = mAm.getProcessRecordLocked(procName, r.appInfo.uid, false); // 2
if (DEBUG_MU) Slog.v(TAG_MU, "bringUpServiceLocked: appInfo.uid=" + r.appInfo.uid
+ " app=" + app);
if (app != null && app.thread != null) { // 3
try {
app.addPackage(r.appInfo.packageName, r.appInfo.versionCode, mAm.mProcessStats);
// 启动 Service
realStartServiceLocked(r, app, execInFg); // 4
return null;
} catch (TransactionTooLargeException e) {
throw e;
} catch (RemoteException e) {
Slog.w(TAG, "Exception when starting service " + r.shortName, e);
}
}
} else {
app = r.isolatedProc;
if (WebViewZygote.isMultiprocessEnabled()
&& r.serviceInfo.packageName.equals(WebViewZygote.getPackageName())) {
hostingType = "webview_service";
}
}
// 如果用来运行 Service 的应用程序进程不存在
if (app == null && !permissionsReviewRequired) { // 5
// 创建应用程序进程
if ((app=mAm.startProcessLocked(procName, r.appInfo, true, intentFlags,
hostingType, r.name, false, isolated, false)) == null) { // 6
String msg = "Unable to launch app "
+ r.appInfo.packageName + "/"
+ r.appInfo.uid + " for service "
+ r.intent.getIntent() + ": process is bad";
Slog.w(TAG, msg);
bringDownServiceLocked(r);
return msg;
}
if (isolated) {
r.isolatedProc = app;
}
}
...
return null;
}
在注释 1 出得到 ServiceRecord.processName 的值并赋值给 procName，其中，processName 用来描述 Service 想要在那个进程中运行，默认是当前进程，也可以在 AndroidManifest 文件中设置 android:process 属性来新开启一个进程运行 Service。在注释 2 处将 procName 和 Service 的 uid 传入到 AMS.getProcessRecordLocked 方法中，来查询是否存在一个与 Service 对应的 ProcessRecord 类型的对象 app，ProcessRecord 主要用来描述运行的应用程序进程的信息。在注释 5 处判断 Service 对应的 app == null 则说明用来运行 Service 的应用程序进程不存在，则调用注释 6 处的 AMS.startProcessLocked 方法来创建对应的应用程序进程。在注释 3 处判断如果用来运行 Service 的应用程序进程存在，则调用注释 4 处的 realStartServiceLocked 方法来启动 Service。
AMS 与应用程序进程的关系主要有以下两点：
- 启动应用程序时 AMS 会检查这个应用程序需要的应用程序进程是否存在；
- 如果需要的应用程序进程不存在，AMS 就会请求 Zygote 进程创建需要的应用程序进程；
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
