这篇文章记录一下对于AIDL 的理解和总结。 我自己最早有个误解:context.getSystemService(ACTIVITY_SERVICE) 拿到的那个 ActivityManager,就是 AMS 的 Binder 代理。
但其实不是。中间还隔着一层。而恰好是这一层,解释了为什么 Google 敢每个版本都大改 AMS 的接口,却不会把所有 app 都搞崩。
要说清楚这件事,得先看 AIDL 到底生成了什么。
一、AIDL 生成的三件套
写一个 IFoo.aidl:
interface IFoo {
int doSomething(int arg);
}
编译期 aidl 工具生成一个 IFoo.java,一个文件里塞了三样东西。
public interface IFoo extends android.os.IInterface {
int doSomething(int arg) throws RemoteException;
// ① 服务端基类
public static abstract class Stub extends Binder implements IFoo {
private static final String DESCRIPTOR = "com.example.IFoo";
static final int TRANSACTION_doSomething = FIRST_CALL_TRANSACTION + 0;
public Stub() {
this.attachInterface(this, DESCRIPTOR);
}
public static IFoo asInterface(IBinder obj) {
if (obj == null) return null;
IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (iin != null && iin instanceof IFoo) {
return (IFoo) iin; // 同进程,直接给实现对象
}
return new Stub.Proxy(obj); // 跨进程,包一层代理
}
@Override
public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
throws RemoteException {
switch (code) {
case TRANSACTION_doSomething: {
data.enforceInterface(DESCRIPTOR);
int _arg0 = data.readInt();
int _result = this.doSomething(_arg0); // 调自己
reply.writeNoException();
reply.writeInt(_result);
return true;
}
}
return super.onTransact(code, data, reply, flags);
}
// ② 客户端代理
private static class Proxy implements IFoo {
private IBinder mRemote;
Proxy(IBinder remote) { mRemote = remote; }
@Override
public int doSomething(int arg) throws RemoteException {
Parcel data = Parcel.obtain();
Parcel reply = Parcel.obtain();
int _result;
try {
data.writeInterfaceToken(DESCRIPTOR);
data.writeInt(arg);
mRemote.transact(TRANSACTION_doSomething, data, reply, 0);
reply.readException();
_result = reply.readInt();
} finally {
reply.recycle();
data.recycle();
}
return _result;
}
}
}
}
③ 是你自己写的实现,继承 Stub:
public class FooService extends IFoo.Stub {
@Override
public int doSomething(int arg) {
return arg * 2; // 真逻辑在这
}
}
机制本身没什么玄学:Proxy 把参数塞进 Parcel 发出去,Stub 在对端把 Parcel 拆开、按 code 找到对应方法、把返回值塞回 reply。transact 最后那个 flags 参数默认是 0,表示同步等待;AIDL 里方法声明成 oneway 时才会变成 FLAG_ONEWAY,发完就返回。
读这段代码有两个地方特别容易说错。
Stub 不转发给别人,它分发给自己
onTransact 里 switch 完 code 之后调的是 this.doSomething(_arg0),this 就是 Stub 自己。Stub 是 abstract 的,doSomething 在这里没有实现体,实现落在你写的子类上。
所以 Stub 的职责就三件事:解包 Parcel、按 code 分发到自己的抽象方法、把结果打包进 reply。它不认识任何别的 service,也不负责路由。“Stub 根据 code 调用不同的 service” 这个说法是错的——同一个 Stub 从头到尾只服务一个实现对象。
asInterface 有一条同进程短路
Stub 的构造函数里调了 attachInterface(this, DESCRIPTOR),把自己和描述符绑在了一起。于是:
- 如果
obj是本进程的Binder对象,queryLocalInterface(DESCRIPTOR)描述符对得上,直接把实现对象还给你 - 如果
obj是BinderProxy(跨进程拿到的句柄),queryLocalInterface恒返回null,这才走new Stub.Proxy(obj)
这不是什么可以忽略的优化细节,它会改变你对调用栈的判断。同一行 IFoo.Stub.asInterface(b).doSomething(1),在 app 进程里是一次完整的跨进程 transact,在服务自己所在的进程里就是一次普通虚方法调用——连 Parcel.obtain() 都不会发生。后面讲 AMS 的时候这一点还会再咬一次。
顺便提一句容易踩的坑:Binder 的事务缓冲区每个进程只有 1MB 左右,而且是整个进程所有并发事务共享的。往 AIDL 方法里传大 Bitmap 或者几万条记录的 List,TransactionTooLargeException 就是这么来的。
二、AMS 这条链上多了一层门面
现在回到开头那个误解。ActivityManager 和 ActivityManagerService 之间,完整的层次是这样:
App 代码
│ context.getSystemService(ACTIVITY_SERVICE)
▼
android.app.ActivityManager 门面(facade),公开 SDK
│ 内部调 ActivityManager.getService()
▼
IActivityManager AIDL 接口,@hide
│
IActivityManager.Stub.Proxy 真正的客户端代理
│
═══ Binder 驱动 ═══ 跨进程
│
IActivityManager.Stub.onTransact()
▼
ActivityManagerService extends IActivityManager.Stub system_server 里的实现
ActivityManager 不是 Proxy,它是 Proxy 外面的一层壳。
为什么要多这一层
IActivityManager 是 @hide 的,不在 SDK 里。它的方法签名几乎每个版本都在变——加参数、改类型、拆方法。如果 app 直接面对它,Android 的每次大版本升级都会是一场屠杀。
门面挡在前面之后,ActivityManager 的公开方法签名可以保持稳定,底下的 AIDL 随便改。除此之外门面还承担一些杂活:参数校验、常量定义、本地缓存,以及若干根本不需要 IPC 的便利方法。
历史包袱
IActivityManager 在 Android 8.0 之前根本不是 AIDL,是手写的:
ActivityManagerNative extends Binder implements IActivityManager——手写的 Stub,onTransact是一个几百行的巨型 switchActivityManagerProxy implements IActivityManager——手写的 Proxy- 拿代理走
ActivityManagerNative.getDefault()
8.0 改成了 AIDL 自动生成,ActivityManagerNative 被删掉,获取代理的入口搬到了 ActivityManager.getService()。所以看老文章或者老项目里的 ActivityManagerNative.getDefault(),那是 7.x 及以前的写法。
三、两条完全不同的获取路径
这是我认为最容易混的地方:门面对象和 Proxy,走的是两条毫不相干的路。
路径 A:拿门面 —— 走 Context
ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
ContextImpl.getSystemService(name)
→ SystemServiceRegistry.getSystemService(this, name)
→ 静态 Map SYSTEM_SERVICE_FETCHERS.get(name)
→ CachedServiceFetcher.getService(ctx)
→ new ActivityManager(ctx.getOuterContext(), handler)
SystemServiceRegistry 在类静态初始化阶段就把几十个 Manager 的构造方式注册进一张表:
registerService(Context.ACTIVITY_SERVICE, ActivityManager.class,
new CachedServiceFetcher<ActivityManager>() {
@Override
public ActivityManager createService(ContextImpl ctx) {
return new ActivityManager(ctx.getOuterContext(), ctx.mMainThread.getHandler());
}
});
Fetcher 有几种,决定了实例的生命周期:
CachedServiceFetcher——按 ContextImpl 缓存,存在ctx.mServiceCache数组里。同一个 Activity 里反复getSystemService拿到的是同一个对象,但换一个 Context 就是另一个实例StaticServiceFetcher——进程级单例,不需要 ContextStaticApplicationContextServiceFetcher——进程级单例,但构造时要 Application Context
这也顺带解释了一个常见问题:为什么有些 Manager 用 Activity Context 和用 Application Context 行为不一样。答案取决于它注册时用的是哪种 fetcher。
路径 B:拿 Proxy —— 不走 Context
// android.app.ActivityManager
private static final Singleton<IActivityManager> IActivityManagerSingleton =
new Singleton<IActivityManager>() {
@Override
protected IActivityManager create() {
final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
return IActivityManager.Stub.asInterface(b);
}
};
public static IActivityManager getService() {
return IActivityManagerSingleton.get();
}
注意这是 static 方法、进程级单例,跟 Context 一点关系没有。门面类只是恰好把它封在自己身上,概念上两者是独立的。
所以对"这个 manager 是通过 context 获取的对吗"这个问题,准确的答案是:门面对象是,底下的 Proxy 不是。
ServiceManager 这一跳怎么自举
这里有个鸡生蛋的问题:要找 AMS 得问 servicemanager,那 servicemanager 自己的 Binder 从哪来?
ServiceManager.getService("activity")
→ getIServiceManager()
→ ServiceManagerNative.asInterface(BinderInternal.getContextObject())
└─ native 方法,固定返回 handle = 0
BinderInternal.getContextObject() 落到 native 是 ProcessState::getContextObject(),最终 getStrongProxyForHandle(0)。handle 0 是全系统约定死的 servicemanager,不需要查询,这是整个 Binder 体系的引导点。
ServiceManager 里还有个 sCache。AMS 在 bindApplication 的时候会顺手把几个常用服务的 binder 一起塞给新进程,ActivityThread.handleBindApplication 调 ServiceManager.initServiceCache() 填进去,省掉冷启动时的几次 IPC。
而 AMS 能被查到,是因为 system_server 主动登记过。登记的位置不在构造函数里,而在 setSystemProcess():
// ActivityManagerService.setSystemProcess()
ServiceManager.addService(Context.ACTIVITY_SERVICE, this, /* allowIsolated= */ true,
DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PRIORITY_NORMAL | DUMP_FLAG_PROTO);
这个方法由 SystemServer.startBootstrapServices() 在 AMS 构造完之后调用。
四、完整链路串一遍
① system_server 启动
AMS = new ActivityManagerService() // extends IActivityManager.Stub
AMS.setSystemProcess()
→ ServiceManager.addService("activity", AMS)
② App: context.getSystemService(ACTIVITY_SERVICE)
SystemServiceRegistry → new ActivityManager(ctx) // 门面,按 Context 缓存
③ App: am.getRunningAppProcesses()
ActivityManager.getService() // 首次调用
→ ServiceManager.getService("activity")
→ handle 0(servicemanager)→ 返回 AMS 的 binder 句柄
→ IActivityManager.Stub.asInterface(b)
→ queryLocalInterface() == null(跨进程)
→ new IActivityManager.Stub.Proxy(b) // 代理在这一刻诞生
④ Proxy.getRunningAppProcesses()
writeInterfaceToken + 写参数
mRemote.transact(code, data, reply, 0)
═══ Binder 驱动 ═══
system_server 的 Binder 线程池
→ AMS.onTransact(code, ...) // 继承自 Stub
→ switch(code) → AMS.getRunningAppProcesses() // 真实现
结果写进 reply,原路返回
五、几个容易踩的点
在 system_server 里拿到的不是 Proxy
承接前面那条同进程短路。ActivityManager.getService() 在 system_server 自己进程里调用时,queryLocalInterface() 命中,返回的就是 AMS 对象本身。
同一行代码在 app 里是 IPC、在 system_server 里是普通方法调用。调 debug 的时候看到的调用栈会完全不一样,知道这件事能省很多困惑。
framework 内部大多绕过门面
门面类主要是给 app 开发者用的。framework 自己(ActivityThread、Instrumentation、ContextImpl)基本都是直接拿 Proxy。startActivity 就是典型:
Activity.startActivity()
→ Instrumentation.execStartActivity()
→ ActivityTaskManager.getService().startActivity(...)
这里还藏着一个版本变化:Android 10 把 AMS 拆了。Activity、窗口、任务栈相关的逻辑搬到了 ActivityTaskManagerService,对应 IActivityTaskManager;AMS 留下进程管理、广播、ContentProvider、内存。所以现在 startActivity 的对端是 ATMS 不是 AMS,看老文章里画的 AMS.startActivity 已经不准了。
反方向也有一套 Stub
AMS 要回调 app 的时候,走的是 IApplicationThread。实现类 ActivityThread.ApplicationThread extends IApplicationThread.Stub,住在 app 进程里。
所以 app 既是 Binder 的 client 也是 server,这套机制是对称的。AMS 持有每个 app 进程的 IApplicationThread 代理,app 持有 AMS 的 IActivityManager 代理。
这里要纠正一个过时的说法。Android 9 之前,IApplicationThread 上是一堆细粒度方法:scheduleLaunchActivity、scheduleResumeActivity、scheduleStopActivity……Android 9 重构成了事务模式:
// 现在只有这一个入口
void scheduleTransaction(ClientTransaction transaction);
server 侧把若干 ClientTransactionItem(回调)和一个 ActivityLifecycleItem(目标生命周期状态)打包成一个 ClientTransaction,由 ClientLifecycleManager 一次性发过去;app 侧 ActivityThread.scheduleTransaction() 收到后丢一个 EXECUTE_TRANSACTION 消息到主线程队列,再由 TransactionExecutor 逐项执行。
好处是生命周期切换变成了一次 IPC 加一个状态机,而不是多次 IPC 互相竞争。读 Android 9 之后的源码,如果还在找 scheduleLaunchActivity,是找不到的。
不是所有 Manager 都包着 Binder 代理
这条链条讲完容易产生一个印象:Manager 背后一定有个远端服务。其实不一定。
ActivityManager→IActivityManager代理,有 IPCPackageManager(ApplicationPackageManager)→IPackageManager代理,有 IPCWindowManager→WindowManagerImpl→WindowManagerGlobal→IWindowManager/IWindowSession,结构更绕LayoutInflater→ 纯本地,一个 Binder 都没有
六、版本差异速查
| 变化 | 版本 | 说明 |
|---|---|---|
IActivityManager 从手写改为 AIDL | 8.0 (API 26) | ActivityManagerNative / ActivityManagerProxy 被删,入口改为 ActivityManager.getService() |
IApplicationThread 改为事务模式 | 9.0 (API 28) | scheduleXxxActivity 系列被 scheduleTransaction(ClientTransaction) 取代 |
| AMS 拆出 ATMS | 10 (API 29) | Activity / 窗口 / 任务栈归 ActivityTaskManagerService,IActivityTaskManager |
最后
整件事的结构其实很简单,就是一句话:AIDL 给你 Proxy 和 Stub,Manager 是 Proxy 外面的门面,Proxy 靠 ServiceManager(handle 0)找到对端。
容易绕进去的地方在于三个"看起来是一个东西但不是":
ActivityManager不是IActivityManager,更不是ActivityManagerServicegetSystemService()给你门面,ServiceManager.getService()给你句柄,两条路asInterface()不保证返回代理,同进程时它返回的是实现对象本身
把这三条分清楚,剩下的都是查源码的体力活。
1952



被折叠的 条评论
为什么被折叠?



