Android Binder 框架完全解析:IPC 原理、AIDL 服务与 Fibonacci 实战
Android Binder 框架完全解析:IPC 原理、AIDL 服务与 Fibonacci 实战
Binder 是 Android 系统进程间通信(IPC)的核心框架,从 Activity 生命周期回调、系统服务调用到应用跨进程通信,底层都由它驱动。本文基于《Android 开发技术前线》项目 issue-22/Binder框架解析.md(Marakana 培训课程「Android Internals and Security」的中文翻译)展开,并结合仓库内姊妹篇 issue-45/安卓Binder架构概述.md,系统讲解 Binder 的诞生动机、运行原理、术语体系、AIDL 定义方式,并通过完整的 Fibonacci 服务端/客户端工程演示从接口定义、服务实现、绑定查找到异步回调的端到端实战。读完本文,你将能回答"Binder 到底是什么"这一 Android 开发者最经典的面试题,并具备独立设计、实现和调试 AIDL 跨进程服务的能力。
为什么 Android 需要 Binder:进程隔离带来的通信需求
出于安全性、稳定性和内存管理三方面的考虑,Android 的应用和系统服务运行在分离的进程中,但进程之间仍然需要通信和共享数据:
- 安全性:每一个进程就是一个沙盒,运行在不同的系统标识(UID)中,天然隔离;
- 稳定性:如果一个进程失常(例如崩溃),它不影响其它进程;
- 内存管理:"不需要"的进程会被移除,为新进程释放资源(主要是内存);
- 事实上,一个单独的 Android 应用甚至可以让自己的组件运行在不同的进程中。
进程隔离带来了"谁能和谁说话、谁能读写谁的内存"的硬边界,但同时也带来了"如何高效通信"的难题,这就需要 IPC(Inter-Process Communication,进程间通信)。
传统 IPC 在 Android 上为何不可行
Android 的 libc(即 bionic 库)不支持 System V IPC:没有 SysV 信号量、共享内存、消息队列等机制。原因很实际——当一个进程被终止时,"忘记"释放 IPC 共享资源,System V IPC 会报内存资源泄露的错误;而 bug、恶意代码或一个正常应用在低内存(LMK)情况下都会被无条件终止,这种环境对传统 IPC 是"敌对的"。
Binder 来拯救
与 System V IPC 不同,Binder 内置了针对"对象"引用的引用计数器与消亡提醒机制,让它天然适用于低内存强杀的"敌对"环境:当一个 Binder 服务没有任何终止引用时,它的所有者可以自动收到提醒,去处理自己(释放资源)。
此外,Binder 还提供了一系列传统 IPC 不具备的面向对象特性:
- 线程迁移:远程对象可以像本地对象一样被调用,调用线程自动"跳转"到其它进程中执行,线程池由框架自动管理;
- 支持同步和**异步(单向,oneway)**两种调用模式;
- 分辨发送者和接收者(通过 UID/PID),这对安全至关重要;
- 独特的跨进程边界对象映射:一个远程对象的引用可以传递到另外的进程中,并且可以当作标志令牌(token)使用;
- 各进程之间可以发送文件描述符(fd);
- 简单的 Android 接口定义语言(AIDL);
- 内置支持很多编组(marshalling)的常见数据类型;
- 通过**自动生成的代理(Proxy)和存根(Stub)**简化事务调用模型(Java 侧);
- 跨进程递归:调用本地对象上的方法时,语义与递归一致;
- 如果客户端和服务器运行在同一个进程中,会走本地执行模式(不做 IPC 数据编组),性能与直接调用一致。
当然 Binder 也有边界:
- 不支持 RPC(Remote Procedure Call,仅支持本地 IPC 语义);
- 客户端与服务之间是基于消息的通信,不适合流式数据;
- 没有被 POSIX 或任何其他标准定义,是 Android 独有的方案。
事实上,大多数应用程序和核心系统服务都依赖 Binder:应用大部分生命周期回调(如
onResume()、onDestroy()等)都是经由 Binder 被ActivityManagerService调用的;关闭 binder,整个系统会慢慢停止(无显示、无音频、无输入、无传感器……)。少数场景(如 RILD 与 Radio 通信)会使用 Unix 域 socket。
Binder 是什么:一个面向对象的 IPC 组件
Binder 是一个 IPC 组件,用于开发面向对象的操作系统服务。它不是一个"另一个面向对象内核",而是运行在传统内核(Linux)之上、提供面向对象环境的组件,是 Android 的关键基础设施。
Binder 的源头是 OpenBinder,其历史脉络大致如下:
- 发源于 Be, Inc,作为 "next generation BeOS"(约 2001 年)的关键部分;
- 后被 PalmSource 收购,最初用于 Palm Cobalt(基于微内核的操作系统);
- Palm 切换到 Linux,Binder 被移植到 Linux 并开源(约 2005 年);
- 谷歌雇佣了 OpenBinder 的核心工程师 Dianne Hackborn 加入 Android 团队(约 2008 年);
- OpenBinder 不再维护,但 Binder 长存于 Android。
Binder 的设计目标专注于:可伸缩性、稳定性、灵活性、低延迟和开销、简单的编程模型。
Binder 与 Intent / ContentProvider / Messenger 式 IPC 的对比
Android 通过 Intent 和 ContentProvider 也支持一种简单形式的 IPC,但它们在架构层次上都是 Binder 的高级抽象,底层通信依然是 Binder。
Intent:异步、松耦合、低结构化的消息传递
Intent 的消息传递是 Android 组件之间异步通信的框架:
- 这些组件可能运行在相同的或不同的应用中(即多进程);
- 支持点对点和发布-订阅消息传递域;
- Intent 本身是一个包含操作描述和传给接受者数据的载体;
- 隐式 Intent 能够给 API 解耦合。
以调用 ZXing 二维码扫描为例,客户端与服务端之间通过 Intent 完成一次"请求-回调"式 IPC:
public class ProductLookupActivity extends Activity {
private static final int SCAN_REQ = 0;
public void onClick(View view) {
Intent intent = new Intent("com.google.zxing.client.android.SCAN"); // 1 指定我们要调用的是谁
intent.setPackage("com.google.zxing.client.android"); // 1
intent.putExtra("SCAN_MODE", "PRODUCT_MODE"); // 2 指定输入参数
super.startActivityForResult(intent, SCAN_REQ); // 3 启动异步调用
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) { // 4 通过回调接收响应
if (requestCode == SCAN_REQ && resultCode == RESULT_OK) { // 5 确认这是预期响应
String barcode = data.getStringExtra("SCAN_RESULT"); // 6 得到响应
String format = data.getStringExtra("SCAN_RESULT_FORMAT"); // 6
super.startActivity(new Intent(Intent.ACTION_VIEW,
Uri.parse("http://www.upcdatabase.com/item/" + barcode))); // 7 发起另一个 IPC 请求,但不期望结果
}
}
}
服务端(扫描结果返回方)的应答逻辑则是把结果放进新的 Intent 中异步发回:
private void handleDecodeExternally(Result rawResult, ...) {
Intent intent = new Intent(getIntent().getAction());
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET);
intent.putExtra(Intents.Scan.RESULT, rawResult.toString()); // 8 服务端把结果放入新的 Intent
intent.putExtra(Intents.Scan.RESULT_FORMAT,
rawResult.getBarcodeFormat().toString());
super.setResult(Activity.RESULT_OK, intent);
super.finish(); // 9 异步发回结果
}
ContentResolver 则通过稳定的 CRUD API 与 ContentProvider(典型运行在不同应用中)同步通信。但这类 IPC 的问题是:
- 不是真正的面向对象(没有方法签名级契约);
- 只有基于 Intent 的异步通信;
- 不适合低延时场景;
- API 定义松散,容易发生运行时错误(而非编译期错误);
- 所有底层通信仍然基于 Binder,Intent 和 ContentProvider 只是 Binder 的高层抽象,方便系统服务(如
ActivityManagerService、PackageManagerService)扩展。
Messenger:面向消息的折中方案
Android 的 Messenger 表示一个可以通过 Intent 发送到远程进程中的 Handler 引用:
- Messenger 的引用可以通过 Intent 传递,借助前述 IPC 机制实现;
- 远程进程通过 Messenger 发送消息到本地的 Handler 中;
- Messenger 像 Intent 一样,可以指定"行为"(
Message.what)和数据(Message.getData()); - 仍然是异步,但延迟/开销更低;
- 支持从服务端到客户端高效的回调;
- 消息默认在循环器(Looper)线程中处理;
- 所有底层通信依然基于 Binder。
客户端侧定义回调 Handler,并把 Messenger 随 Intent 一并发送给服务端:
public class DownloadClientActivity extends Activity {
private static final int CALLBACK_MSG = 0;
public void onClick(View view) {
Intent intent = new Intent("com.marakana.android.download.service.SERVICE"); // 1 指定要调用的对象
ArrayList<Uri> uris = ...;
intent.putExtra("uris", uris); // 2 指定输入参数
Messenger messenger = new Messenger(new ClientHandler(this)); // 3 在 handler 中创建 messenger
intent.putExtra("callback-messenger", messenger); // 4 messenger 也是输入参数
super.startService(intent); // 5 启动异步调用
}
private static class ClientHandler extends Handler {
private final WeakReference<DownloadClientActivity> clientRef; // 6 handler 保存客户端弱引用
public ClientHandler(DownloadClientActivity client) {
this.clientRef = new WeakReference<DownloadClientActivity>(client);
}
@Override
public void handleMessage(Message msg) { // 7 通过 handler 回调接收响应
Bundle data = msg.getData();
DownloadClientActivity client = clientRef.get();
if (client != null && msg.what == CALLBACK_MSG && data != null) {
Uri completedUri = data.getString("completed-uri"); // 8 获取响应数据
}
}
}
}
服务端在 IntentService 中取出 Messenger 后回发消息:
public class MessengerDemoService extends IntentService {
private static final int CALLBACK_MSG = 0;
@Override
protected void onHandleIntent(Intent intent) { // 1 处理客户端请求(可能是本地或远程的)
ArrayList<Uri> uris = intent.getParcelableArrayListExtra("uris"); // 2 获取请求数据
Messenger messenger = intent.getParcelableExtra("callback-messenger"); // 3 获取 messenger 引用
for (Uri uri : uris) {
// download the uri
if (messenger != null) {
Message message = Message.obtain(); // 4 用 Message 作为数据的通用信封
message.what = CALLBACK_MSG;
Bundle data = new Bundle(1);
data.putParcelable("completed-uri", uri); // 5 设置应答
message.setData(data);
try {
messenger.send(message); // 6 发送应答
} catch (RemoteException e) {
...
} finally {
message.recycle();
}
}
}
}
}
Binder 术语表:一次厘清所有关键概念
Binder 框架涉及一组容易被混淆的术语,先建立统一认知:
| 术语 | 含义 |
|---|---|
| Binder(框架) | 所有的 IPC 架构 |
| Binder Driver | 内核级别的驱动,处理各进程之间的通信 |
| Binder Protocol | 底层协议(基于 ioctl),用于与 Binder 驱动通信 |
| IBinder Interface | 定义良好的行为(例如方法),Binder 对象必须实现 |
| AIDL | Android 接口定义语言,用于描述 IBinder 接口的业务操作 |
| Binder(对象) | 通用 IBinder 接口的实现 |
| Binder Token | 抽象的 32 位数值,在系统所有进程中唯一标识一个 Binder 对象 |
| Binder Service | 真正实现 Binder(对象)业务操作的服务 |
| Binder Client | 使用 Binder 服务提供的行为的对象 |
| Binder Transaction | 远程 Binder 对象调用一个行为(例如一个方法),基于 Binder 协议,可能涉及发送、接收的数据 |
| Parcel | "可以在 IBinder 中发送消息的容器(数据和对象的引用)",事务处理的数据单元——一个用作流出请求,另一个用作流入响应 |
| Marshalling(编组) | 将高级的应用程序数据结构(请求、响应参数)转化成 Parcel 对象的过程,目的是将它们嵌套进 Binder 事务中 |
| Unmarshalling(解组) | 将 Binder 事务中获取到的 Parcel 对象重构为高级应用数据结构的过程 |
| Proxy(代理) | AIDL 接口的实现,编组/解组数据,映射调用事务的方法,将一个封装的 IBinder 引用指向 Binder 对象(位于客户端) |
| Stub(存根) | AIDL 接口局部的实现,当编组/解组数据时,映射事务到 Binder Service 调用(位于服务端) |
| Context Manager(a.k.a. servicemanager) | 一个特殊的、已知的 Binder 对象,用于其它 Binder 的注册与查询 |
Binder 通信模型与服务的发现
对于关心的客户端而言,它只是想使用服务;但由于进程不能直接操作其它进程(或读写其数据),而内核可以,因此客户端与服务端通过 Binder 驱动沟通。
驱动与协议
Binder 驱动通过 /dev/binder 暴露出来,并提供基于 open、release、poll、mmap、flush、ioctl 的操作。事实上,大多数通信都是通过 ioctl(binderFd, BINDER_WRITE_READ, &bwd) 进行的,其中 bwd 定义为:
struct binder_write_read {
signed long write_size; /* bytes to write */
signed long write_consumed; /* bytes consumed by driver */
unsigned long write_buffer;
signed long read_size; /* bytes to read */
signed long read_consumed; /* bytes consumed by driver */
unsigned long read_buffer;
};
write_buffer包含一系列操作驱动的命令:包括簿记(book-keeping)命令,如增加、减少 Binder 对象的引用,请求、清除消亡通知;也包括请求响应的命令,如BC_TRANSACTION;read_buffer包含用户操作的命令:簿记命令,以及操作响应命令或执行嵌套(递归)请求处理。
客户端通过事务(Transaction)与服务端通信,事务中携带一个 Binder token、方法体、原始缓存数据,以及驱动自动添加的发送者 PID/UID。
客户端和服务端使用的大多数底层操作和数据结构(例如 Parcel)都是 libbinder 的抽象。为了避免客户端和服务端了解 Binder 协议和 libbinder 的全部细节,它们使用代理(Proxy)和存根(Stub)——基于 Java 的代理和存根可以通过描述服务的 aidl 工具自动生成。
事实上,大多数客户端都不知道它们正在使用 IPC,从来没有提过 Binder 或代理,因为它们依靠抽象来管理复杂性。这一点对系统服务尤其正确:它们使用管理器(Manager),只向客户端暴露 API 的一个子集。
服务发现:Servicemanager
客户端怎么获取到它想要会话的 handle 呢?只需要"问" Servicemanager(Binder 的 CONTEXT_MGR),前提是目标服务已经注册了自己的 handle。出于安全与健康的原因,Binder 驱动一次只接受一个 CONTEXT_MGR 注册,这就是为什么 Android 中的 Servicemanager 是第一批启动的服务。
想查看当前已注册的服务清单,运行:
$ adb shell service list
Found 71 services:
0 sip: [android.net.sip.ISipService]
1 phone: [com.android.internal.telephony.ITelephony]
...
20 location: [android.location.ILocationManager]
...
55 activity: [android.app.IActivityManager]
56 package: [android.content.pm.IPackageManager]
...
67 SurfaceFlinger: [android.ui.ISurfaceComposer]
68 media.camera: [android.hardware.ICameraService]
69 media.player: [android.media.IMediaPlayerService]
70 media.audio_flinger: [android.media.IAudioFlinger]
以 Location 服务为例,客户端通过 LocationManager 这个"管理器"间接使用 LocationManagerService 提供的 Binder 服务,客户端侧甚至不需要接触 Binder 对象。
AIDL:定义基于 Binder 的服务接口
AIDL(Android Interface Definition Language)是 Android 的接口定义语言,用于定义基于 Binder 的服务接口:
- AIDL 遵循类似 Java 的接口语法,允许定义自己的"业务"方法;
- 每一个基于 Binder 的服务都被定义在
.aidl文件中,经典命名如IFooService.aidl,并保存在src/目录下。
一个最小的 AIDL 接口
// src/com/example/app/IFooService.aidl
package com.example.app;
import com.example.app.Bar;
interface IFooService {
void save(inout Bar bar);
Bar getById(int id);
void delete(in Bar bar);
List<Bar> getAll();
}
aidl 编译工具(Android SDK 的一部分)会从每个 .aidl 文件生成真正的 Java 接口,连同提供 Android 的 android.os.IBinder 的 Stub,放入工程的 gen/ 目录下:
// gen/com/example/app/IFooService.java
package com.example.app;
public interface IFooService extends android.os.IInterface {
public static abstract class Stub extends android.os.Binder implements com.example.app.IFooService {
...
public static com.example.app.IFooService asInterface(android.os.IBinder obj) {
...
return new com.example.app.IFooService.Stub.Proxy(obj);
}
...
public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException {
switch (code) {
...
case TRANSACTION_save: {
...
com.example.app.Bar _arg0;
...
_arg0 = com.example.app.Bar.CREATOR.createFromParcel(data);
this.save(_arg0);
...
}
...
}
}
...
private static class Proxy implements com.example.app.IFooService {
private android.os.IBinder mRemote;
...
public void save(com.example.app.Bar bar) throws android.os.RemoteException {
...
android.os.Parcel _data = android.os.Parcel.obtain();
...
bar.writeToParcel(_data, 0);
...
mRemote.transact(Stub.TRANSACTION_save, _data, _reply, 0);
...
}
}
}
void save(com.example.app.Bar bar) throws android.os.RemoteException;
com.example.app.Bar getById(int id) throws android.os.RemoteException;
void delete(com.example.app.Bar bar) throws android.os.RemoteException;
java.util.List<Bar> getAll() throws android.os.RemoteException;
}
可以看到自动生成代码的关键分工:Proxy(客户端侧)把方法参数写入 _data Parcel,调用 mRemote.transact() 发起事务;Stub.onTransact()(服务端侧)按 code 分派到具体实现方法,并把 _reply Parcel 解组为返回值。整个"编组—驱动传输—解组"的细节对开发者完全透明。每次 Eclipse ADT(或现代的 Gradle 插件)在 src/ 目录下发现 .aidl 文件,就会自动调用 aidl 工具。
AIDL 支持的数据类型
AIDL 默认支持以下类型:
null;- 基本类型及其数组:
boolean/boolean[]、byte/byte[]、char[]、int/int[]、long/long[]、float/float[]、double/double[]; java.lang.CharSequence、java.lang.String(按字符串传输);java.io.FileDescriptor—— 以原始文件描述符的 dup 形式传输(指向同一底层流和位置);java.io.Serializable—— 不推荐,效率低(过于冗长);java.util.Map<String, Object>—— 元素必须是受支持类型(重建后总是java.util.HashMap);android.os.Bundle—— 专用的 Map 封装,只接受 AIDL 支持的数据类型;java.util.List—— 元素必须是受支持类型(重建后总是java.util.ArrayList);java.lang.Object[]—— 元素必须是受支持类型(包括基本类型包装类);android.util.SparseArray、android.util.SparseBooleanArray;android.os.IBinder、android.os.IInterface—— 按(全局唯一的)引用传输(作为 "strong binder",即 handle),可用于回调发送者;android.os.Parcelable—— 自定义类型。
自定义 Parcelable 类型
自定义类型必须实现 Parcelable。以 Bar 为例:
// src/com/example/app/Bar.java
package com.example.app;
import android.os.Parcel;
import android.os.Parcelable;
public class Bar implements Parcelable {
private int id;
private String data;
public Bar(int id, String data) {
this.id = id;
this.data = data;
}
// getters and setters omitted
...
public int describeContents() {
return 0;
}
public void writeToParcel(Parcel parcel, int flags) {
parcel.writeInt(this.id);
parcel.writeString(this.data);
}
public void readFromParcel(Parcel parcel) {
this.id = parcel.readInt();
this.data = parcel.readString();
}
public static final Parcelable.Creator<Bar> CREATOR = new Parcelable.Creator<Bar>() {
public Bar createFromParcel(Parcel parcel) {
return new Bar(parcel.readInt(), parcel.readString());
}
public Bar[] newArray(int size) {
return new Bar[size];
}
};
}
两点值得注意:
public void readFromParcel(Parcel)方法不是Parcelable接口定义的,这里是为Bar的可变性服务——期望远程端能在void save(inout Bar bar)方法中修改它;public static final Parcelable.Creator<Bar> CREATOR同样不是接口定义的(明显),它从save事务的_data中、从getById操作的_reply中重构Bar。
这些自定义类还必须在它们自己的 .aidl 文件中声明:
// src/com/example/app/Bar.aidl
package com.example.app;
parcelable Bar;
注意:AIDL 接口必须
import自定义的 parcelable 类,即使它们在同一个包中。前面示例中IFooService.aidl必须import com.example.app.Bar。
AIDL 语法约束
- AIDL 定义的方法可以不传或传入多个参数,但必须返回一个值或者 void;
- 所有非基本类型的参数需要一个方向标签
in、out、inout三选一:- 基本数据类型的指向一直是
in(可以省略); - 编组数据时方向标签会传递给 Binder,因此对性能有直接影响(
out/inout意味着双向编组);
- 基本数据类型的指向一直是
- 所有
.aidl注释都应该被拷贝到生成的 Java 接口中(import和package语句之前的除外); - 默认只支持以下异常:
SecurityException、BadParcelableException、IllegalArgumentException、NullPointerException、IllegalStateException; .aidl文件中不支持静态成员。
跨进程映射 Binder 对象引用
Binder 对象的引用有以下两种形态:
- 在同一个进程中:Binder 对象的一个真实的虚拟地址;
- 在另外一个进程中:Binder 对象的一个抽象的 32 位 handle。
在每一个事务中,Binder 驱动都会自动地将远程的 Binder handle 映射成本地的地址,将本地的地址映射成远程的 Binder handle。这种映射服务于:
- Binder 事务的目标;
- IBinder 对象的引用作为参数或返回值跨进程共享(嵌套在事务数据中)。
为了能够工作:
- Binder 驱动在进程之间维持本地地址和远程 handle 的映射(每一个进程都作为一个二叉树),因此 Binder 可以传送;
- 嵌套在事务中的引用基于客户端提供的偏移。
Binder 驱动不知道不与远程进程共享的 Binder 对象。一旦一个新的 Binder 对象引用在事务中被发现,它就会被记录在驱动中;任何时候 Binder 引用与其它进程共享,驱动的引用计数器就会增长;当进程消亡时,计数器会明确地减少或自动地减少;当一个引用不再需要时,它的所有者会收到提醒释放它,并且 Binder 会删除自己的映射。这正是 Binder 能在"低内存强杀"的 Android 环境中不产生内存泄露的关键设计。
实战:用三个工程构建基于 Binder 的 Fibonacci 服务端与客户端
为演示基于 Binder 的服务端和客户端,我们创建三个独立的工程(以下完整示例来自 Marakana 的 FibonacciBinderDemo 课程工程):
- FibonacciCommon 库工程 —— 定义 AIDL 接口、自定义类型(参数和返回值);
- FibonacciService 工程 —— 实现 AIDL 接口,并暴露给客户端;
- FibonacciClient 工程 —— 连接并使用 AIDL 服务。
第一步:FibonacciCommon —— 定义 AIDL 接口与自定义类型
创建一个新的 Android 库工程(服务端和客户端共享的 API 文件):
- 工程名:
FibonacciCommon - 构建目标:Android 2.2+(API 8+)
- 包名:
com.marakana.android.fibonaccicommon - 最低 SDK 版本:8+
- 不需要指定应用名或 Activity
转换为库工程:访问 properties → Android → Library,勾选 Library;也可以手动添加 android.library=true 到 FibonacciCommon/default.properties,然后刷新工程。因为库工程永远不会进入实际的 APK,清单文件可以极简:
<!-- FibonacciCommon/AndroidManifest.xml -->
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.marakana.android.fibonaccicommon" android:versionCode="1"
android:versionName="1.0">
</manifest>
并移除 FibonacciCommon/res/ 目录下的任何文件。
定义 AIDL 接口:
// FibonacciCommon/src/com/marakana/android/fibonaccicommon/IFibonacciService.aidl
package com.marakana.android.fibonaccicommon;
import com.marakana.android.fibonaccicommon.FibonacciRequest;
import com.marakana.android.fibonaccicommon.FibonacciResponse;
interface IFibonacciService {
long fibJR(in long n);
long fibJI(in long n);
long fibNR(in long n);
long fibNI(in long n);
FibonacciResponse fib(in FibonacciRequest request);
}
接口依赖两个自定义 Java 类型,定义在它们自己的 .aidl 文件中。FibonacciRequest 携带输入参数(N 与算法类型枚举):
// FibonacciCommon/src/com/marakana/android/fibonaccicommon/FibonacciRequest.java
package com.marakana.android.fibonaccicommon;
import android.os.Parcel;
import android.os.Parcelable;
public class FibonacciRequest implements Parcelable {
public static enum Type {
RECURSIVE_JAVA, ITERATIVE_JAVA, RECURSIVE_NATIVE, ITERATIVE_NATIVE
}
private final long n;
private final Type type;
public FibonacciRequest(long n, Type type) {
this.n = n;
if (type == null) {
throw new NullPointerException("Type must not be null");
}
this.type = type;
}
public long getN() { return n; }
public Type getType() { return type; }
public int describeContents() { return 0; }
public void writeToParcel(Parcel parcel, int flags) {
parcel.writeLong(this.n);
parcel.writeInt(this.type.ordinal());
}
public static final Parcelable.Creator<FibonacciRequest> CREATOR =
new Parcelable.Creator<FibonacciRequest>() {
public FibonacciRequest createFromParcel(Parcel in) {
long n = in.readLong();
Type type = Type.values()[in.readInt()];
return new FibonacciRequest(n, type);
}
public FibonacciRequest[] newArray(int size) {
return new FibonacciRequest[size];
}
};
}
// FibonacciCommon/src/com/marakana/android/fibonaccicommon/FibonacciRequest.aidl
package com.marakana.android.fibonaccicommon;
parcelable FibonacciRequest;
FibonacciResponse 携带结果与耗时(用于演示跨进程通信的开销测量):
// FibonacciCommon/src/com/marakana/android/fibonaccicommon/FibonacciResponse.java
package com.marakana.android.fibonaccicommon;
import android.os.Parcel;
import android.os.Parcelable;
public class FibonacciResponse implements Parcelable {
private final long result;
private final long timeInMillis;
public FibonacciResponse(long result, long timeInMillis) {
this.result = result;
this.timeInMillis = timeInMillis;
}
public long getResult() { return result; }
public long getTimeInMillis() { return timeInMillis; }
public int describeContents() { return 0; }
public void writeToParcel(Parcel parcel, int flags) {
parcel.writeLong(this.result);
parcel.writeLong(this.timeInMillis);
}
public static final Parcelable.Creator<FibonacciResponse> CREATOR =
new Parcelable.Creator<FibonacciResponse>() {
public FibonacciResponse createFromParcel(Parcel in) {
return new FibonacciResponse(in.readLong(), in.readLong());
}
public FibonacciResponse[] newArray(int size) {
return new FibonacciResponse[size];
}
};
}
// FibonacciCommon/src/com/marakana/android/fibonaccicommon/FibonacciResponse.aidl
package com.marakana.android.fibonaccicommon;
parcelable FibonacciResponse;
构建后,gen/ 目录中会自动生成 IFibonacciService.java:接口继承 android.os.IInterface,内含继承 android.os.Binder 的抽象类 Stub(提供 asInterface() 静态方法与 asBinder()),以及声明好的五个业务方法(均抛出 android.os.RemoteException)。
第二步:FibonacciService —— 实现并暴露 AIDL 服务
创建新的 Android 工程(编译目标 Android 2.2+,包名 com.marakana.android.fibonacciservice,应用名 Fibonacci Service,最小 SDK 8+,不需要指定 Activity),并将工程链接到 FibonacciCommon(工程名称 → Android → Library → Add... → FibonacciCommon)。链接完成后,FibonacciService/default.properties 中会出现 android.library.reference.1=../FibonacciCommon,.project 也链接到了 FibonacciCommon。
服务端使用实现了斐波那契算法的 com.marakana.android.fibonaccinative.FibLib(Java + JNI 实现),将 FibonacciNative 工程的 Java 类与 jni/ 实现拷贝过来后,记得在 FibonacciService/ 下运行 ndk-build 生成所需的本地库。
现在实现 AIDL 接口——通过继承自动生成的 IFibonacciService.Stub(它继承于 android.os.Binder):
// FibonacciService/src/com/marakana/android/fibonacciservice/IFibonacciServiceImpl.java
package com.marakana.android.fibonacciservice;
import android.os.SystemClock;
import android.util.Log;
import com.marakana.android.fibonaccicommon.FibonacciRequest;
import com.marakana.android.fibonaccicommon.FibonacciResponse;
import com.marakana.android.fibonaccicommon.IFibonacciService;
import com.marakana.android.fibonaccinative.FibLib;
public class IFibonacciServiceImpl extends IFibonacciService.Stub {
private static final String TAG = "IFibonacciServiceImpl";
public long fibJI(long n) {
Log.d(TAG, String.format("fibJI(%d)", n));
return FibLib.fibJI(n);
}
public long fibJR(long n) {
Log.d(TAG, String.format("fibJR(%d)", n));
return FibLib.fibJR(n);
}
public long fibNI(long n) {
Log.d(TAG, String.format("fibNI(%d)", n));
return FibLib.fibNI(n);
}
public long fibNR(long n) {
Log.d(TAG, String.format("fibNR(%d)", n));
return FibLib.fibNR(n);
}
public FibonacciResponse fib(FibonacciRequest request) {
Log.d(TAG, String.format("fib(%d, %s)", request.getN(), request.getType()));
long timeInMillis = SystemClock.uptimeMillis();
long result;
switch (request.getType()) {
case ITERATIVE_JAVA: result = this.fibJI(request.getN()); break;
case RECURSIVE_JAVA: result = this.fibJR(request.getN()); break;
case ITERATIVE_NATIVE: result = this.fibNI(request.getN()); break;
case RECURSIVE_NATIVE: result = this.fibNR(request.getN()); break;
default: return null;
}
timeInMillis = SystemClock.uptimeMillis() - timeInMillis;
return new FibonacciResponse(result, timeInMillis);
}
}
为了让客户端能够使用服务,首先客户端需要绑定服务;为了让客户端能够绑定,服务端需要把 Binder 对象通过 android.app.Service.onBind(Intent) 暴露出去:
// FibonacciService/src/com/marakana/android/fibonacciservice/FibonacciService.java
package com.marakana.android.fibonacciservice;
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.util.Log;
public class FibonacciService extends Service { // 1 继承 android.app.Service,目的是暴露 Binder 服务
private static final String TAG = "FibonacciService";
private IFibonacciServiceImpl service; // 2 本地单例引用(所有客户端共享一个实例)
@Override
public void onCreate() {
super.onCreate();
this.service = new IFibonacciServiceImpl(); // 3 初始化服务实现;若需要 Context,可把 Service 传进去
Log.d(TAG, "onCreate()'ed");
}
@Override
public IBinder onBind(Intent intent) { // 4 通过 onBind 把 IBinder 交给客户端
Log.d(TAG, "onBind()'ed");
return this.service;
}
@Override
public boolean onUnbind(Intent intent) {
Log.d(TAG, "onUnbind()'ed");
return super.onUnbind(intent);
}
@Override
public void onDestroy() {
Log.d(TAG, "onDestroy()'ed");
this.service = null;
super.onDestroy();
}
}
这里选择了单例模式(所有客户端共享同一个 IFibonacciServiceImpl 实例),也可以选择给每个客户端一个独立实例。最后在 AndroidManifest.xml 中注册服务,让客户端可以找到它:
<!-- FibonacciService/AndroidManifest.xml -->
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.marakana.android.fibonacciservice" android:versionCode="1" android:versionName="1.0">
<uses-sdk android:minSdkVersion="8" />
<application android:icon="@drawable/icon" android:label="@string/app_name">
<service android:name=".FibonacciService">
<intent-filter>
<action android:name="com.marakana.android.fibonaccicommon.IFibonacciService" /> <!-- 1 名称可自定义,通常使用派生 AIDL 接口的全名 -->
</intent-filter>
</service>
</application>
</manifest>
第三步:FibonacciClient —— 连接并使用 AIDL 服务
创建新的 Android 工程(包名 com.marakana.android.fibonacciclient,应用名 Fibonacci Client,Activity 名为 FibonacciActivity,最小 SDK 8+),同样链接到 FibonacciCommon。这样服务端和客户端共享同一份 AIDL 接口定义与 Parcelable 类型,避免在两端重复拷贝代码。
客户端的 UI 布局(输入 N、选择算法类型、按钮与结果输出):
<!-- FibonacciClient/res/layout/main.xml -->
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent">
<TextView android:text="@string/hello" android:layout_height="wrap_content"
android:layout_width="fill_parent" android:textSize="25sp" android:gravity="center"/>
<EditText android:layout_height="wrap_content"
android:layout_width="match_parent" android:id="@+id/input" android:hint="@string/input_hint"
android:inputType="number" android:gravity="right" />
<RadioGroup android:orientation="horizontal" android:layout_width="match_parent"
android:id="@+id/type" android:layout_height="wrap_content">
<RadioButton android:layout_height="wrap_content" android:checked="true"
android:id="@+id/type_fib_jr" android:text="@string/type_fib_jr"
android:layout_width="match_parent" android:layout_weight="1" />
<RadioButton android:layout_height="wrap_content" android:id="@+id/type_fib_ji"
android:text="@string/type_fib_ji" android:layout_width="match_parent" android:layout_weight="1" />
<RadioButton android:layout_height="wrap_content" android:id="@+id/type_fib_nr"
android:text="@string/type_fib_nr" android:layout_width="match_parent" android:layout_weight="1" />
<RadioButton android:layout_height="wrap_content" android:id="@+id/type_fib_ni"
android:text="@string/type_fib_ni" android:layout_width="match_parent" android:layout_weight="1" />
</RadioGroup>
<Button android:text="@string/button_text" android:id="@+id/button"
android:layout_width="match_parent" android:layout_height="wrap_content" />
<TextView android:id="@+id/output" android:layout_width="match_parent"
android:layout_height="match_parent" android:textSize="20sp" android:gravity="center|top"/>
</LinearLayout>
核心客户端逻辑:Activity 实现 ServiceConnection,在 onResume() 中 bindService(),在 onServiceConnected() 回调中通过 IFibonacciService.Stub.asInterface(service) 拿到代理,点击按钮后在后台线程中发起同步调用:
// FibonacciClient/src/com/marakana/android/fibonacciclient/FibonacciActivity.java
package com.marakana.android.fibonacciclient;
import android.app.Activity;
import android.app.ProgressDialog;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.IBinder;
import android.os.RemoteException;
import android.os.SystemClock;
import android.text.TextUtils;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.RadioGroup;
import android.widget.TextView;
import android.widget.Toast;
import com.marakana.android.fibonaccicommon.FibonacciRequest;
import com.marakana.android.fibonaccicommon.FibonacciResponse;
import com.marakana.android.fibonaccicommon.IFibonacciService;
public class FibonacciActivity extends Activity implements OnClickListener, ServiceConnection {
private static final String TAG = "FibonacciActivity";
private EditText input;
private Button button;
private RadioGroup type;
private TextView output;
private IFibonacciService service; // 指向远程服务的代理引用
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
super.setContentView(R.layout.main);
this.input = (EditText) super.findViewById(R.id.input);
this.button = (Button) super.findViewById(R.id.button);
this.type = (RadioGroup) super.findViewById(R.id.type);
this.output = (TextView) super.findViewById(R.id.output);
this.button.setOnClickListener(this);
this.button.setEnabled(false); // 连接到服务后才启用按钮
}
@Override
protected void onResume() {
Log.d(TAG, "onResume()'ed");
super.onResume();
// 按服务名查找并绑定 FibonacciService,把自身作为 ServiceConnection
if (!super.bindService(new Intent(IFibonacciService.class.getName()),
this, BIND_AUTO_CREATE)) {
Log.w(TAG, "Failed to bind to service");
}
}
@Override
protected void onPause() {
Log.d(TAG, "onPause()'ed");
super.onPause();
super.unbindService(this); // 不需要时及时解绑
}
public void onServiceConnected(ComponentName name, IBinder service) {
Log.d(TAG, "onServiceConnected()'ed to " + name);
this.service = IFibonacciService.Stub.asInterface(service); // 关键:把 IBinder 包装成接口代理
this.button.setEnabled(true);
}
public void onServiceDisconnected(ComponentName name) {
Log.d(TAG, "onServiceDisconnected()'ed to " + name);
this.service = null;
this.button.setEnabled(false);
}
public void onClick(View view) {
final long n;
String s = this.input.getText().toString();
if (TextUtils.isEmpty(s)) return;
try {
n = Long.parseLong(s);
} catch (NumberFormatException e) {
this.input.setError(super.getText(R.string.input_error));
return;
}
final FibonacciRequest.Type type;
switch (FibonacciActivity.this.type.getCheckedRadioButtonId()) {
case R.id.type_fib_jr: type = FibonacciRequest.Type.RECURSIVE_JAVA; break;
case R.id.type_fib_ji: type = FibonacciRequest.Type.ITERATIVE_JAVA; break;
case R.id.type_fib_nr: type = FibonacciRequest.Type.RECURSIVE_NATIVE; break;
case R.id.type_fib_ni: type = FibonacciRequest.Type.ITERATIVE_NATIVE; break;
default: return;
}
final FibonacciRequest request = new FibonacciRequest(n, type);
final ProgressDialog dialog = ProgressDialog.show(this, "",
super.getText(R.string.progress_text), true);
// 计算可能耗时较长,放到后台线程避免阻塞 UI
new AsyncTask<Void, Void, String>() {
@Override
protected String doInBackground(Void... params) {
try {
long totalTime = SystemClock.uptimeMillis();
FibonacciResponse response = FibonacciActivity.this.service.fib(request); // 远程同步调用
totalTime = SystemClock.uptimeMillis() - totalTime;
return String.format("fibonacci(%d)=%d\nin %d ms\n(+ %d ms)",
n, response.getResult(), response.getTimeInMillis(),
totalTime - response.getTimeInMillis());
} catch (RemoteException e) {
Log.wtf(TAG, "Failed to communicate with the service", e);
return null;
}
}
@Override
protected void onPostExecute(String result) {
dialog.dismiss();
if (result == null) {
Toast.makeText(FibonacciActivity.this, R.string.fib_error, Toast.LENGTH_SHORT).show();
} else {
FibonacciActivity.this.output.setText(result);
}
}
}.execute();
}
}
说明:应尽量避免在 Activity 中调用匿名 AsyncTask,这里为了演示走了捷径。另外,整个调用链中唯一"IPC 化"的入口是
IFibonacciService.Stub.asInterface(service)——它把系统返回的IBinder包装为 Proxy,此后service.fib(request)在开发者眼里与本地方法调用无异。响应结果中response.getTimeInMillis()是服务端计算耗时,外层totalTime减去它就是一次往返的 IPC 开销,可以用来实测 Binder 的低延迟特性。
客户端 Activity 在 AndroidManifest.xml 中注册为标准 LAUNCHER Activity 后即可运行。
异步 Binder IPC:oneway 与监听器回调
在 AIDL 接口中用 oneway 声明,Binder 允许客户端与服务端之间异步通信。我们仍然关心结果,通常通过监听器回调的方式:
- 客户端提供一个引用作为回调监听器;
- 当监听器被调用时,客户端与服务端的角色互换:客户端的监听器变成了"服务端",原来的服务端变成了"客户端"。
定义单向接口
首先需要一个本身是单向"服务"的监听器:
// FibonacciCommon/src/com/marakana/android/fibonaccicommon/IFibonacciServiceResponseListener.aidl
package com.marakana.android.fibonaccicommon;
import com.marakana.android.fibonaccicommon.FibonacciRequest;
import com.marakana.android.fibonaccicommon.FibonacciResponse;
oneway interface IFibonacciServiceResponseListener {
void onResponse(in FibonacciResponse response);
}
然后定义单向(异步)的主服务接口,fib() 不再返回结果,而是接收一个监听器参数:
// FibonacciCommon/src/com/marakana/android/fibonaccicommon/IFibonacciService.aidl
package com.marakana.android.fibonaccicommon;
import com.marakana.android.fibonaccicommon.FibonacciRequest;
import com.marakana.android.fibonaccicommon.FibonacciResponse;
import com.marakana.android.fibonaccicommon.IFibonacciServiceResponseListener;
oneway interface IFibonacciService {
void fib(in FibonacciRequest request, in IFibonacciServiceResponseListener listener);
}
服务端实现:调用监听器而不是返回结果
// FibonacciService/src/com/marakana/android/fibonacciservice/IFibonacciServiceImpl.java
package com.marakana.android.fibonacciservice;
import android.os.RemoteException;
import android.os.SystemClock;
import android.util.Log;
import com.marakana.android.fibonaccicommon.FibonacciRequest;
import com.marakana.android.fibonaccicommon.FibonacciResponse;
import com.marakana.android.fibonaccicommon.IFibonacciService;
import com.marakana.android.fibonaccicommon.IFibonacciServiceResponseListener;
import com.marakana.android.fibonaccinative.FibLib;
public class IFibonacciServiceImpl extends IFibonacciService.Stub {
private static final String TAG = "IFibonacciServiceImpl";
@Override
public void fib(FibonacciRequest request,
IFibonacciServiceResponseListener listener) throws RemoteException {
long n = request.getN();
Log.d(TAG, "fib(" + n + ")");
long timeInMillis = SystemClock.uptimeMillis();
long result;
switch (request.getType()) {
case ITERATIVE_JAVA: result = FibLib.fibJI(n); break;
case RECURSIVE_JAVA: result = FibLib.fibJR(n); break;
case ITERATIVE_NATIVE: result = FibLib.fibNI(n); break;
case RECURSIVE_NATIVE: result = FibLib.fibNR(n); break;
default: result = 0;
}
timeInMillis = SystemClock.uptimeMillis() - timeInMillis;
Log.d(TAG, String.format("Got fib(%d) = %d in %d ms", n, result, timeInMillis));
listener.onResponse(new FibonacciResponse(result, timeInMillis)); // 回调客户端监听器
}
}
注意:服务端不会因监听返回而阻塞,因为监听器本身也是单向(oneway)的。
客户端实现:实现监听器
客户端自身必须实现服务端的监听器接口。核心改动是:onClick() 中不再等待返回值,而是调用 service.fib(request, this.responseListener) 提交请求后立即返回;监听器通过 Handler 把结果投递回 UI 线程。关键片段如下(其余绑定逻辑与同步版相同):
public class FibonacciActivity extends Activity implements OnClickListener, ServiceConnection {
private static final int RESPONSE_MESSAGE_ID = 1;
private static final int PROGRESS_DIALOG_ID = 1;
private IFibonacciService service;
// 响应监听器:远程进程回调时,服务端变成"客户端"、本监听器变成"服务端"
private final IFibonacciServiceResponseListener responseListener =
new IFibonacciServiceResponseListener.Stub() {
@Override
public void onResponse(FibonacciResponse response) throws RemoteException {
// 把结果封装为 Message 发送到 Handler(主线程)处理
responseHandler.obtainMessage(RESPONSE_MESSAGE_ID, response).sendToTarget();
}
};
private final Handler responseHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
if (msg.what == RESPONSE_MESSAGE_ID) {
FibonacciResponse response = (FibonacciResponse) msg.obj;
dismissDialog(PROGRESS_DIALOG_ID);
output.setText(String.format("fibonacci result = %d, service took %d ms",
response.getResult(), response.getTimeInMillis()));
}
}
};
public void onClick(View view) {
// ... 解析 n 与 type,构造 FibonacciRequest ...
try {
Log.d(TAG, "Submitting request...");
long time = SystemClock.uptimeMillis();
// 提交请求;响应将通过 responseListener 异步返回,本方法立即返回
this.service.fib(request, this.responseListener);
time = SystemClock.uptimeMillis() - time;
Log.d(TAG, "Submitted request in " + time + " ms");
super.showDialog(PROGRESS_DIALOG_ID); // 对话框由 responseHandler 关闭
} catch (RemoteException e) {
Log.wtf(TAG, "Failed to communicate with the service", e);
}
}
}
注意:监听器(匿名内部类)会持有 Activity 的强引用,这里为了简明起见忽略了正确性;生产代码中应使用弱引用并在解绑时移除监听,以避免内存泄漏。
oneway 修饰符对应调用时传入 IBinder.FLAG_ONEWAY 标志——调用立即返回、不等任何返回值。正如姊妹篇 issue-45/安卓Binder架构概述.md 所述,默认情况下 transact() 会阻塞客户端线程直到远端 onTransact() 执行完毕,FLAG_ONEWAY 正是打破这一阻塞的关键。
通过 Binder 共享内存:文件描述符与 ashmem
Binder 事务处理的数据是通信中的部分拷贝——如果传送很多数据是不明智的。事实上 Binder 通过事务强制限制了发送数据的大小。共享大数据的三种思路:
- 共享文件:只需要发送文件的描述符(fd)。这也是让媒体播放器去播放音频、视频文件的方式——发送文件描述符到软件驱动中,而不是传输文件内容;
- 分多次发送:把内存中的数据分多次发送,而不是一次发送所有数据——但这会让设计复杂化;
- 利用 Android 的 ashmem(Ashmem 匿名共享内存)工具:它的 Java 封装
android.os.MemoryFile不是用于第三方应用共享内存的,需通过本地(JNI)直接使用 ashmem。
本地共享内存通过 frameworks/base/libs/binder/Parcel.cpp 实现:void Parcel::writeBlob(size_t len, WritableBlob outBlob) 与 status_t Parcel::readBlob(size_t len, ReadableBlob outBlob)。以下是简化的实现示意:
客户端(写入方):
size_t len = 4096;
int fd = ashmem_create_region("Parcel Blob", len);
ashmem_set_prot_region(fd, PROT_READ | PROT_WRITE);
void* ptr = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
ashmem_set_prot_region(fd, PROT_READ);
writeFileDescriptor(fd, true); // 通过 Binder 事务把 fd 传给服务端
// write into ptr for len as desired
...
munmap(ptr, len);
close(fd);
服务端(读取方):
int fd = readFileDescriptor();
void* ptr = mmap(NULL, len, PROT_READ, MAP_SHARED, fd, 0);
// read from ptr up to len as desired
...
munmap(ptr, len);
注意:示例为便于说明省略了错误处理;
writeFileDescriptor(...)与readFileDescriptor(...)是 libbinder 提供的函数。核心思想是:大数据不随事务拷贝,只传一个 fd,双方 mmap 同一块匿名共享内存。
Binder 的局限性
- 每个进程最多支持 15 个 Binder 线程。
frameworks/base/libs/binder/ProcessState.cpp中的open_driver()显示:
static int open_driver() {
int fd = open("/dev/binder", O_RDWR);
if (fd >= 0) {
...
size_t maxThreads = 15;
result = ioctl(fd, BINDER_SET_MAX_THREADS, &maxThreads);
...
}
...
return fd;
}
因此要避免阻塞 Binder 线程(例如不要在服务端方法里做耗时 I/O);如果需要执行长任务,最好创建自己的线程。相关译文 issue-45/安卓Binder架构概述.md 中记为 16,不同版本资料表述略有差异,以具体源码为准。
- Binder 限制运行在每个进程中的并发事务缓存为 1M:
- 如果参数或返回值的大小超过了缓存,就会抛出
TransactionTooLargeException; - 因为指定进程中的所有事务共享同一个缓存,所以很多中等大小的事务也会耗尽缓存;
- 当异常抛出时,我们无法确定是发送请求出错还是接收响应出错;
- 对策:让事务数据尽量小,或者使用共享内存(ashmem)。
- 如果参数或返回值的大小超过了缓存,就会抛出
Binder 安全机制
Binder 确实需要直接处理"安全"问题,但它只会在"可信的"执行环境和 DAC(自主访问控制)中运行。
服务注册的准入控制
Binder 驱动只允许注册一个 CONTEXT_MGR(例如 servicemanager)。drivers/staging/android/binder.c 中:
static long binder_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) {
...
switch (cmd) {
...
case BINDER_SET_CONTEXT_MGR:
if (binder_context_mgr_node != NULL) {
printk(KERN_ERR "binder: BINDER_SET_CONTEXT_MGR already set\n");
ret = -EBUSY;
goto err;
}
...
binder_context_mgr_node = binder_new_node(proc, NULL, NULL);
...
}
...
}
servicemanager 同样只允许从受信任的 UID 中注册服务(比如 system、radio、media 等等)。frameworks/base/cmds/servicemanager/service_manager.c 中维护了一张白名单:
static struct {
unsigned uid;
const char *name;
} allowed[] = {
#ifdef LVMX
{ AID_MEDIA, "com.lifevibes.mx.ipc" },
#endif
{ AID_MEDIA, "media.audio_flinger" },
{ AID_MEDIA, "media.player" },
{ AID_MEDIA, "media.camera" },
{ AID_MEDIA, "media.audio_policy" },
{ AID_DRM, "drm.drmManager" },
{ AID_NFC, "nfc" },
{ AID_RADIO, "radio.phone" },
{ AID_RADIO, "radio.sms" },
{ AID_RADIO, "radio.phonesubinfo" },
{ AID_RADIO, "radio.simphonebook" },
/* TODO: remove after phone services are updated: */
{ AID_RADIO, "phone" },
{ AID_RADIO, "sip" },
{ AID_RADIO, "isms" },
{ AID_RADIO, "iphonesubinfo" },
{ AID_RADIO, "simphonebook" },
};
int svc_can_register(unsigned uid, uint16_t *name) {
unsigned n;
if ((uid == 0) || (uid == AID_SYSTEM))
return 1;
for (n = 0; n < sizeof(allowed) / sizeof(allowed[0]); n++)
if ((uid == allowed[n].uid) && str16eq(name, allowed[n].name))
return 1;
return 0;
}
int do_add_service(struct binder_state *bs, uint16_t *s, unsigned len, void *ptr, unsigned uid) {
...
if (!svc_can_register(uid, s)) {
LOGE("add_service('%s',%p) uid=%d - PERMISSION DENIED\n", str8(s), ptr, uid);
return -1;
}
...
}
调用者身份识别与权限校验
每个 Binder 事务发送者的 UID 和 PID 很容易访问到:
android.os.Binder.getCallingPid()android.os.Binder.getCallingUid()
拿到 UID 后,可以通过 PackageManager.getPackagesForUid(int uid) 解析调用方应用,再通过 PackageManager.getPackageInfo(String packageName, int flags)(检查 PackageManager.GET_PERMISSIONS 标志)检查应用是否具有权限。但更简单的方式是:
Context.checkCallingOrSelfPermission(String permission):如果调用进程被授予了权限就返回PackageManager.PERMISSION_GRANTED,否则返回PackageManager.PERMISSION_DENIED;Context.enforceCallingPermission(String permission, String message):如果调用者没有请求的权限,就抛出SecurityException。
应用框架服务就是如此执行权限的。例如 frameworks/base/services/java/com/android/server/VibratorService.java:
package com.android.server;
...
public class VibratorService extends IVibratorService.Stub {
...
public void vibrate(long milliseconds, IBinder token) {
if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.VIBRATE)
!= PackageManager.PERMISSION_GRANTED) {
throw new SecurityException("Requires VIBRATE permission");
}
...
}
...
}
再看 frameworks/base/services/java/com/android/server/LocationManagerService.java,它对不同 provider 施加细粒度权限:
package com.android.server;
...
public class LocationManagerService extends ILocationManager.Stub implements Runnable {
...
private static final String ACCESS_FINE_LOCATION =
android.Manifest.permission.ACCESS_FINE_LOCATION;
private static final String ACCESS_COARSE_LOCATION =
android.Manifest.permission.ACCESS_COARSE_LOCATION;
...
private void checkPermissionsSafe(String provider) {
if ((LocationManager.GPS_PROVIDER.equals(provider)
|| LocationManager.PASSIVE_PROVIDER.equals(provider))
&& (mContext.checkCallingOrSelfPermission(ACCESS_FINE_LOCATION)
!= PackageManager.PERMISSION_GRANTED)) {
throw new SecurityException("Provider " + provider
+ " requires ACCESS_FINE_LOCATION permission");
}
if (LocationManager.NETWORK_PROVIDER.equals(provider)
&& (mContext.checkCallingOrSelfPermission(ACCESS_FINE_LOCATION)
!= PackageManager.PERMISSION_GRANTED)
&& (mContext.checkCallingOrSelfPermission(ACCESS_COARSE_LOCATION)
!= PackageManager.PERMISSION_GRANTED)) {
throw new SecurityException("Provider " + provider
+ " requires ACCESS_FINE_LOCATION or ACCESS_COARSE_LOCATION permission");
}
}
...
private Location _getLastKnownLocationLocked(String provider) {
checkPermissionsSafe(provider);
...
}
...
public Location getLastKnownLocation(String provider) {
...
_getLastKnownLocationLocked(provider);
...
}
}
Binder 消亡通知:linkToDeath 与 DeathRecipient
持有 IBinder 对象的引用后,我们可以:
- 询问远程对象是否存活:
Binder.isBinderAlive()和Binder.pingBinder(); - 获取远程对象消亡的通知:
Binder.linkToDeath(IBinder.DeathRecipient recipient, int flags); - 借此清除与远程 Binder 对象关联的不可用资源(如监听器)。
LocationManagerService 是经典范例:它为每个监听器包装一个 Receiver,并通过 linkToDeath 注册消亡回调,一旦客户端(监听器持有方)进程死亡就自动清除更新:
public class LocationManagerService extends ILocationManager.Stub implements Runnable {
...
private Receiver getReceiver(ILocationListener listener) {
IBinder binder = listener.asBinder();
Receiver receiver = mReceivers.get(binder);
if (receiver == null) {
receiver = new Receiver(listener);
...
receiver.getListener().asBinder().linkToDeath(receiver, 0);
...
}
return receiver;
}
private final class Receiver implements IBinder.DeathRecipient, PendingIntent.OnFinished {
final ILocationListener mListener;
...
Receiver(ILocationListener listener) {
mListener = listener;
...
}
...
public void binderDied() {
...
removeUpdatesLocked(this); // 客户端死亡,自动移除其监听器
}
...
}
...
}
这正是本文开头提到的 Binder"引用计数 + 消亡通知"机制在框架服务中的直接体现。
Binder 报告与调试
在活动/失败的事务中,Binder 驱动通过 /proc/binder/ 报告多种状态:
/proc/binder/failed_transaction_log/proc/binder/state/proc/binder/stats/proc/binder/transaction_log/proc/binder/transactions/proc/binder/proc/<pid>
注意:在某些设备上,上述文件位于
/sys/kernel/debug/binder,需要将 debugfs 设置为 enable 后才能查看。这些 proc 节点是排查 Binder 事务积压、进程间死锁等问题的第一手现场。
总结
围绕"Android 为什么需要自己的 IPC、Binder 如何工作、如何用 AIDL 落地一个跨进程服务"这条主线,本文梳理了完整的知识闭环:
- 为什么需要 Binder:进程隔离带来安全、稳定与内存管理收益,bionic 不支持 System V IPC,而 Binder 以引用计数与消亡通知机制天然适配"低内存强杀"环境;
- Binder 是什么:源自 OpenBinder 的面向对象 IPC 组件,聚焦可伸缩性、稳定性、灵活性、低延迟与简单编程模型;
- 与高层抽象的关系:Intent、ContentProvider、Messenger 都是基于 Binder 的高级抽象,适合不同场景但有各自的局限;
- 术语与通信模型:Proxy/Stub 屏蔽了编组与事务细节,驱动通过 ioctl +
binder_write_read传输,servicemanager 负责服务注册与发现; - AIDL 实战:从接口定义、Parcelable 自定义类型到三个工程(Common/Service/Client)的完整 Fibonacci 示例,再到 oneway 异步回调;
- 进阶主题:Binder 对象引用跨进程映射、ashmem 共享内存、15 线程与 1M 事务缓存限制、基于 UID/PID 的安全模型、
linkToDeath消亡通知与/proc/binder报告。
如果想进一步巩固,可继续阅读仓库内另一篇主题文章 issue-45/安卓Binder架构概述.md,它以"事务(transaction)/ transact() / onTransact() / Binder 线程池"的视角补充了本文未展开的执行细节;而本文中的完整工程示例(FibonacciBinderDemo 与 FibonacciAsyncBinderDemo)则是最佳的动手实践起点。