ActivityManagerService
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 ActivityManagerNativeimplements 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"); // 1if (false) {Log.v("ActivityManager", "default service binder = " + b);}IActivityManager am = asInterface(b); // 2if (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); // 1if (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); // 1reply.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>() {@Overrideprotected IActivityManager create() {final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE); // 1final IActivityManager am = IActivityManager.Stub.asInterface(b); // 2return 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 {...// 创建消息 LooperLooper.prepareMainLooper(); // Initialize native services. 加载动态库 libandroid_servers.soSystem.loadLibrary("android_servers"); // 1 performPendingShutdown();// Initialize the system context. 创建系统的 ContextcreateSystemContext(); // Create the system service manager. 创建 SystemServiceManagermSystemServiceManager = new SystemServiceManager(mSystemContext); // 2mSystemServiceManager.setRuntimeRestarted(mRuntimeRestart);LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);// Prepare the thread pool for init tasks that can be parallelizedSystemServerInitThreadPool.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(); // 1mActivityManagerService = ActivityManagerService.Lifecycle.startService(mSystemServiceManager, atm); // 2mActivityManagerService.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); // 1return 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() { // 3return 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; // 1String hostingType = "service";ProcessRecord app;if (!isolated) {app = mAm.getProcessRecordLocked(procName, r.appInfo.uid, false); // 2if (DEBUG_MU) Slog.v(TAG_MU, "bringUpServiceLocked: appInfo.uid=" + r.appInfo.uid+ " app=" + app);if (app != null && app.thread != null) { // 3try {app.addPackage(r.appInfo.packageName, r.appInfo.versionCode, mAm.mProcessStats);// 启动 ServicerealStartServiceLocked(r, app, execInFg); // 4return 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) { // 6String 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 进程创建需要的应用程序进程;
本文来自互联网用户投稿,文章观点仅代表作者本人,不代表本站立场,不承担相关法律责任。如若转载,请注明出处。 如若内容造成侵权/违法违规/事实不符,请点击【内容举报】进行投诉反馈!
