Android Binder 框架完全解析:IPC 原理、AIDL 服务与 Fibonacci 实战

原创2026-10-09 18:53:531,870 阅读
文章标签:文档教程知识库

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];
        }
    };
}

两点值得注意:

  1. public void readFromParcel(Parcel) 方法不是 Parcelable 接口定义的,这里是为 Bar 的可变性服务——期望远程端能在 void save(inout Bar bar) 方法中修改它;
  2. 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 课程工程):

  1. FibonacciCommon 库工程 —— 定义 AIDL 接口、自定义类型(参数和返回值);
  2. FibonacciService 工程 —— 实现 AIDL 接口,并暴露给客户端;
  3. 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 通过事务强制限制了发送数据的大小。共享大数据的三种思路:

  1. 共享文件:只需要发送文件的描述符(fd)。这也是让媒体播放器去播放音频、视频文件的方式——发送文件描述符到软件驱动中,而不是传输文件内容;
  2. 分多次发送:把内存中的数据分多次发送,而不是一次发送所有数据——但这会让设计复杂化;
  3. 利用 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)则是最佳的动手实践起点。

登录后查看全文
android-tech-frontier