Android AIDL 跨进程通信

AIDL（Android Interface Definition Language）是 Android 用于跨进程通信（IPC）的接口定义语言。

• 底层实现：基于 Binder驱动
• 核心能力：支持方法调用、传递自定义 Parcelable对象以及双向通信（回调）

val intent = Intent(this, BookManagerService::class.java)
bindService(intent, connection, BIND_AUTO_CREATE)

• Intent：显式指定目标 Service 类
• bindService：异步操作，不会阻塞 UI
• BIND_AUTO_CREATE：若服务未启动，自动创建服务进程并调用 onCreate()→ onBind()

private val connection = object : ServiceConnection {
    override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
        bookManager = IBookManager.Stub.asInterface(service)
    }
    override fun onServiceDisconnected(name: ComponentName?) {
        bookManager = null // 服务意外死亡时回调
    }
}

• onServiceConnected：绑定成功后系统回调，参数 service是服务端 onBind返回的 IBinder
• onServiceDisconnected：仅在服务进程崩溃或被杀死时调用，主动 unbindService不会触发

class BookManagerService : Service() {
    private val binder = object : IBookManager.Stub() {
        override fun addBook(book: Book?) { ... }
        override fun getBookList(): List { ... }
    }
    override fun onBind(intent: Intent?): IBinder = binder
}

• 继承 AIDL 生成的 IBookManager.Stub，实现业务方法
• onBind返回该 Stub 实例

当定义 .aidl文件后，编译会生成同名的 Java 接口，内部包含：

• 接口：继承 IInterface
• Stub 抽象类：继承 Binder并实现接口
• Proxy 类：实现接口，持有 IBinder引用，方法调用通过 transact序列化发送

public static IBookManager asInterface(IBinder obj) {
    if (obj == null) return null;
    IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
    if (iin != null && iin instanceof IBookManager) {
        return (IBookManager) iin; // 同进程 -> 直接返回 Stub
    }
    return new Proxy(obj); // 跨进程 -> 返回 Proxy
}

• 同进程：queryLocalInterface返回非空，直接返回 Stub 实例，方法调用是普通的 Java 调用，无序列化开销
• 跨进程：返回 Proxy 代理，每次方法调用都会打包参数 → transact→ 驱动 → 服务端 onTransact执行

// IBookUpdateCallback.aidl
package com.example.woyaojindachang;
import com.example.woyaojindachang.modle.Book;

interface IBookUpdateCallback {
    void onBookAdded(in Book newBook);
}

// IBookManager.aidl
import ...IBookUpdateCallback;

interface IBookManager {
    void addBook(in Book book);
    List getBookList();
    void registerCallback(IBookUpdateCallback callback);
    void unregisterCallback(IBookUpdateCallback callback);
}

private val callback = object : IBookUpdateCallback.Stub() {
    override fun onBookAdded(newBook: Book?) {
        runOnUiThread { /* 更新 UI */ }
    }
}

// 在 onServiceConnected 中
bookManager?.registerCallback(callback)

• object : IBookUpdateCallback.Stub()创建的是一个 Binder对象（本地 Stub）
• 将该对象传给服务端，Binder 驱动会传递其引用，服务端获得的是一个 Proxy代理

private val callbacks = RemoteCallbackList()

override fun registerCallback(callback: IBookUpdateCallback?) {
    callback?.let { callbacks.register(it) }
}

private fun notifyBookAdded(book: Book?) {
    val n = callbacks.beginBroadcast()
    for (i in 0 until n) {
        try {
            callbacks.getBroadcastItem(i).onBookAdded(book)
        } catch (e: RemoteException) { }
    }
    callbacks.finishBroadcast()
}

• RemoteCallbackList是线程安全的集合，能自动清理死进程的回调
• beginBroadcast()与 finishBroadcast()成对使用，期间不可修改集合

• 正向：客户端持有服务端的 Proxy (bookManager)，调用服务端方法
• 反向：服务端持有客户端的 Proxy（回调对象），调用客户端方法

两端互相持有对方的 Binder 引用，即可实现双向调用。角色不互换：服务端仍是数据持有方和业务核心。

AIDL 方法调用（包括回调）是 同步阻塞的，默认运行在：

• 服务端方法：Binder 线程池
• 客户端方法：调用者线程

如果在 UI 线程调用，服务端方法若耗时过长（如 5 秒），会导致 ANR。

解决方案：

• 在客户端使用后台线程（lifecycleScope.launch(Dispatchers.IO)）
• 或将 AIDL 方法声明为 oneway void addBook(in Book book);（单向调用，无返回值，不阻塞）

回调方法运行在客户端的 Binder 线程池，不能直接操作 UI，必须：

• runOnUiThread
• 切换到主线程 Handler

在 onDestroy中调用 unbindService(connection)，否则会造成 Activity 泄漏。

在 onDestroy或 onServiceDisconnected中调用 bookManager?.unregisterCallback(callback)。

若 AIDL 方法参数或返回值使用自定义类（如 Book），需满足：

1. 该类实现 Parcelable接口（Kotlin 可用 @Parcelize配合插件）
2. 在 aidl目录下创建同包名的 .aidl文件：

   // Book.aidl
   package com.example.woyaojindachang.modle;
   parcelable Book;

3. 在主 AIDL 文件中导入该类：import com.example.woyaojindachang.modle.Book;