Binder C++层基础 ⭐⭐

// 文件: frameworks/native/libs/binder/include/binder/IBinder.h
// IBinder 是 Binder 对象模型的根抽象接口
 
class IBinder : public virtual RefBase {
public:
    // 事务标志位 (Transaction flags)
    enum {
        FIRST_CALL_TRANSACTION = 0x00000001,  // 用户自定义事务码的起始值
        LAST_CALL_TRANSACTION  = 0x00ffffff,  // 用户自定义事务码的最大值
        PING_TRANSACTION       = B_PACK_CHARS('_','P','N','G'),  // 用于探测对端是否存活
        DUMP_TRANSACTION       = B_PACK_CHARS('_','D','M','P'),  // 请求服务 dump 调试信息
        SHELL_COMMAND_TRANSACTION = B_PACK_CHARS('_','C','M','D'), // shell 命令
        INTERFACE_TRANSACTION  = B_PACK_CHARS('_','N','T','F'),  // 查询接口描述符
        SYSPROPS_TRANSACTION   = B_PACK_CHARS('_','S','P','R'),  // 系统属性同步
    };
 
    // 事务发送的标志 (Flags for transact())
    enum {
        FLAG_ONEWAY = 0x00000001,  // 异步调用, 不等待返回 (one-way / fire-and-forget)
    };
 
    // ========== 核心虚函数 ==========
 
    // 查询该 Binder 对象的接口描述符 (Interface Descriptor)
    // 返回类似 "android.os.IServiceManager" 的字符串
    virtual const String16& getInterfaceDescriptor() const = 0;
 
    // 判断该 Binder 对象所在的进程/线程是否仍然存活
    virtual bool            isBinderAlive() const = 0;
 
    // 发送 PING_TRANSACTION, 检测对端是否响应
    virtual status_t        pingBinder() = 0;
 
    // 注册死亡通知回调, 当远端 Binder 死亡时触发
    // recipient: 回调对象 (DeathRecipient)
    virtual status_t        linkToDeath(const sp<DeathRecipient>& recipient,
                                        void* cookie = nullptr,
                                        uint32_t flags = 0) = 0;
 
    // 取消之前注册的死亡通知
    virtual status_t        unlinkToDeath(const wp<DeathRecipient>& recipient,
                                          void* cookie = nullptr,
                                          uint32_t flags = 0,
                                          wp<DeathRecipient>* outRecipient = nullptr) = 0;
 
    // ★ 最核心的方法 ★
    // 发起一次 Binder 事务 (transaction)
    // code:  事务码, 标识要调用的远端方法
    // data:  发送给对端的序列化数据 (Parcel)
    // reply: 对端返回的序列化数据 (Parcel)
    // flags: 0 表示同步调用, FLAG_ONEWAY 表示异步
    virtual status_t        transact(uint32_t code,
                                     const Parcel& data,
                                     Parcel* reply,
                                     uint32_t flags = 0) = 0;
 
    // ========== 类型识别方法 ==========
 
    // 如果自身是本地 Binder 实体 (BBinder), 则返回 this; 否则返回 nullptr
    virtual BBinder*        localBinder();
 
    // 如果自身是远程 Binder 代理 (BpBinder), 则返回 this; 否则返回 nullptr
    virtual BpBinder*       remoteBinder();
 
protected:
    virtual                 ~IBinder();  // 析构函数, protected 防止栈上构造
};

// 默认实现: 都返回 nullptr (在 IBinder 基类中)
BBinder*  IBinder::localBinder()  { return nullptr; }  // 默认: 我不是本地对象
BpBinder* IBinder::remoteBinder() { return nullptr; }  // 默认: 我也不是远程代理
 
// BBinder 重写: 表明"我是本地实体"
BBinder* BBinder::localBinder() { return this; }       // 是的, 我是本地 BBinder
 
// BpBinder 重写: 表明"我是远程代理"
BpBinder* BpBinder::remoteBinder() { return this; }   // 是的, 我是远程 BpBinder

// 示例: 判断一个 IBinder 对象是本地还是远程
void inspectBinder(const sp<IBinder>& binder) {
    // 尝试获取本地 BBinder 指针
    BBinder* local = binder->localBinder();
    if (local != nullptr) {
        // 同进程调用! 无需经过 Binder 驱动, 可以直接本地调用
        // 这就是 Binder 的 "短路优化" (short-circuit optimization)
        ALOGI("This is a LOCAL binder object");
    } else {
        // 跨进程调用, 底层会走 ioctl 到 Binder 驱动
        ALOGI("This is a REMOTE binder proxy");
        BpBinder* proxy = binder->remoteBinder();
        // proxy->handle() 可以获取该代理在驱动中的句柄值
    }
}

// DeathRecipient 是 IBinder 内部定义的嵌套类
class IBinder::DeathRecipient : public virtual RefBase {
public:
    // 当所监听的远端 Binder 对象死亡时, 此回调被调用
    // who: 死亡的那个 IBinder 对象的弱引用
    virtual void binderDied(const wp<IBinder>& who) = 0;
};

// 1. 自定义一个 DeathRecipient 子类
class MyDeathRecipient : public IBinder::DeathRecipient {
public:
    // 当远端服务进程意外退出时, 该方法被 Binder 框架调用
    virtual void binderDied(const wp<IBinder>& who) override {
        ALOGE("Oh no! The remote service has died!");
        // 在此执行清理逻辑, 如: 重新连接服务、释放资源等
    }
};
 
// 2. 获取远端服务的 IBinder 引用
sp<IBinder> remote = /* 从 ServiceManager 获取 */;
 
// 3. 创建并注册死亡通知
sp<MyDeathRecipient> dr = new MyDeathRecipient();
status_t err = remote->linkToDeath(dr);  // 向 Binder 驱动注册监听
if (err != NO_ERROR) {
    ALOGE("Failed to link to death: %d", err);
}
 
// 4. 不再需要监听时, 取消注册
remote->unlinkToDeath(dr);

// 客户端发送时: 在 data 头部写入接口描述符
data.writeInterfaceToken(IMyService::getInterfaceDescriptor());
 
// 服务端接收时: 验证接口描述符是否匹配
status_t MyService::onTransact(uint32_t code, const Parcel& data,
                                Parcel* reply, uint32_t flags) {
    // enforceInterface 会读取 data 中的 token 并与预期值比较
    // 如果不匹配则返回 BAD_TYPE, 防止客户端错误地调用了不属于该服务的方法
    CHECK_INTERFACE(IMyService, data, reply);
    // ... 处理业务逻辑
}

// AIDL 自动生成的事务码示例
enum {
    // 第一个方法 => FIRST_CALL_TRANSACTION + 0
    TRANSACTION_getStatus = IBinder::FIRST_CALL_TRANSACTION + 0,  // = 1
    // 第二个方法 => FIRST_CALL_TRANSACTION + 1
    TRANSACTION_setConfig = IBinder::FIRST_CALL_TRANSACTION + 1,  // = 2
    // 第三个方法 => FIRST_CALL_TRANSACTION + 2
    TRANSACTION_doAction  = IBinder::FIRST_CALL_TRANSACTION + 2,  // = 3
};

// sp<IBinder> 内部会自动调用 incStrong / decStrong
{
    sp<IBinder> binder = getService();  // 引用计数 +1 (strong ref)
    // 使用 binder...
    binder->transact(...);
}
// 离开作用域, sp 析构, 引用计数 -1
// 当 strong ref 降为 0 时, 对象被自动销毁
 
// wp<IBinder> 是弱引用, 不阻止对象销毁
wp<IBinder> weakRef = binder;           // 弱引用计数 +1
sp<IBinder> promoted = weakRef.promote(); // 尝试提升为强引用
if (promoted != nullptr) {
    // 对象还活着, 可以安全使用
} else {
    // 对象已被销毁
}

// 文件: BpBinder.h (精简核心结构)
class BpBinder : public IBinder {
public:
    // 静态工厂方法，根据 handle 创建 BpBinder
    // BinderHandle 是对 int32_t handle 的封装
    static sp<BpBinder> create(int32_t handle);
 
    // 获取此代理对应的 Binder 驱动句柄
    int32_t             handle() const;
 
    // 核心：向远程服务发起事务调用
    // code     - 方法编号（如 TRANSACTION_xxx）
    // data     - 发送的序列化数据（Parcel）
    // reply    - 接收返回数据的 Parcel 指针
    // flags    - 标志位，0 表示同步，FLAG_ONEWAY 表示异步
    virtual status_t    transact(uint32_t code,
                                 const Parcel& data,
                                 Parcel* reply,
                                 uint32_t flags = 0);
 
    // 注册 Binder 死亡通知回调
    // recipient - 死亡通知接收者
    virtual status_t    linkToDeath(const sp<DeathRecipient>& recipient,
                                    void* cookie = nullptr,
                                    uint32_t flags = 0);
 
    // 取消死亡通知回调
    virtual status_t    unlinkToDeath(const wp<DeathRecipient>& recipient,
                                      void* cookie = nullptr,
                                      uint32_t flags = 0,
                                      wp<DeathRecipient>* outRecipient = nullptr);
 
    // 查询此 Binder 是否仍然存活
    virtual bool        isBinderAlive() const;
 
    // 发送 PING 事务探测远程服务是否存活
    virtual status_t    pingBinder();
 
private:
    // 私有构造函数，只能通过 create() 工厂方法创建
    explicit            BpBinder(int32_t handle);
 
    // Binder 驱动中的句柄号——BpBinder 最核心的数据
    const int32_t       mHandle;
 
    // 标记远程 Binder 是否已死亡
    volatile int32_t    mAlive;
 
    // 死亡通知回调列表
    // Obituary 结构保存了 recipient、cookie 和 flags
    Vector<Obituary>    mObituaries;
 
    // 保护 mObituaries 的互斥锁
    Mutex               mLock;
};

// 文件: ProcessState.cpp (关键逻辑精简)
sp<IBinder> ProcessState::getStrongProxyForHandle(int32_t handle) {
    sp<IBinder> result;
 
    // 1. 在进程级别的"句柄查找表"中查找或创建条目
    //    mHandleToObject 是一个 Vector，下标就是 handle
    handle_entry* e = lookupHandleLocked(handle);
 
    if (e != nullptr) {
        // 2. 尝试从已有条目中提升弱引用为强引用
        //    如果之前已经为这个 handle 创建过 BpBinder，直接复用
        IBinder* b = e->binder;               // 获取缓存的裸指针
        if (b == nullptr ||                    // 从未创建过
            !e->refs->attemptIncStrong(this))  // 弱引用已失效
        {
            // 3. handle 0 是 ServiceManager，跳过存活检查
            if (handle == 0) {
                // ServiceManager 在系统启动期间一定存在
                // 直接创建其 BpBinder，不需要 PING 探测
            }
 
            // 4. 核心：创建新的 BpBinder 对象
            //    BpBinder::create 内部会调用私有构造函数
            //    并通过 IPCThreadState 向驱动发送 BC_INCREFS
            //    增加内核中 binder_ref 的引用计数
            sp<BpBinder> b = BpBinder::create(handle);
 
            // 5. 缓存到查找表中，下次直接复用
            e->binder = b.get();               // 存储裸指针（弱引用语义）
            e->refs = b->getWeakRefs();         // 存储弱引用控制块
            result = b;                         // 返回强引用
        } else {
            // 已有的 BpBinder 仍然存活，直接使用
            result.force_set(b);
        }
    }
 
    return result;  // 返回 sp<IBinder>，向上层隐藏 BpBinder 类型
}

// 文件: BpBinder.cpp
status_t BpBinder::transact(
    uint32_t code,           // 事务编号，标识要调用的具体方法
    const Parcel& data,      // 请求数据（已序列化的参数）
    Parcel* reply,           // 响应数据的容器（输出参数）
    uint32_t flags)          // 0=同步阻塞, FLAG_ONEWAY=异步单向
{
    // 1. 检查远程 Binder 是否仍然存活
    //    mAlive 在收到死亡通知时会被置为 0
    if (mAlive) {
        // 2. 检查当前传输是否允许该事务
        //    某些安全策略可能会阻止特定调用
        bool privateVendor = /* flags 检查 */;
 
        // 3.【核心】将调用委托给 IPCThreadState
        //    IPCThreadState 是线程单例，负责与 Binder 驱动通信
        //    参数说明：
        //      mHandle - 目标服务的驱动句柄
        //      code    - 方法编号
        //      data    - 发送数据
        //      reply   - 接收数据
        //      flags   - 同步/异步标志
        status_t status = IPCThreadState::self()->transact(
            mHandle,         // 告诉驱动要把数据发给哪个 binder_node
            code,            // 服务端 onTransact() 的 code 参数
            data,            // 服务端 onTransact() 的 data 参数
            reply,           // 服务端返回数据写入此 Parcel
            flags);          // 控制调用语义
 
        // 4. 如果返回 DEAD_OBJECT，说明远程服务已死
        if (status == DEAD_OBJECT) mAlive = 0;
 
        return status;
    }
 
    // 远程服务已死亡，直接返回错误
    return DEAD_OBJECT;
}

// 注册死亡通知回调
status_t BpBinder::linkToDeath(
    const sp<DeathRecipient>& recipient,  // 回调对象，需实现 binderDied()
    void* cookie,                          // 用户自定义数据，透传给回调
    uint32_t flags)                        // 保留标志，通常为 0
{
    // 1. 加锁保护 mObituaries 列表
    AutoMutex _l(mLock);
 
    // 2. 如果远程 Binder 已经死了，直接返回 DEAD_OBJECT
    if (!mAlive) {
        return DEAD_OBJECT;
    }
 
    // 3. 如果这是第一个注册的死亡回调，需要向驱动注册
    //    驱动层会在 binder_ref 上设置 death 标记
    if (mObituaries == nullptr) {
        mObituaries = new Vector<Obituary>;
 
        // 4.【关键】通知 Binder 驱动：请在目标 binder_node 死亡时通知我
        //    发送 BC_REQUEST_DEATH_NOTIFICATION 命令
        IPCThreadState::self()->requestDeathNotification(
            mHandle, this);
 
        // 5. 刷新命令到驱动
        IPCThreadState::self()->flushCommands();
    }
 
    // 6. 将回调添加到列表
    Obituary ob;
    ob.recipient = recipient;       // 回调接口
    ob.cookie = cookie;             // 用户数据
    ob.flags = flags;               // 标志位
    mObituaries->add(ob);           // 加入列表
 
    return NO_ERROR;
}

// 文件: BpBinder.cpp
void BpBinder::sendObituary() {
    // 1. 加锁，取出死亡回调列表
    mLock.lock();
    Vector<Obituary>* obits = mObituaries;
    mObituaries = nullptr;         // 清空，防止重复派发
 
    // 2. 标记为已死亡
    mAlive = 0;
 
    // 3. 如果存在回调列表，逐个通知
    if (obits != nullptr) {
        mLock.unlock();            // 先释放锁再回调，避免死锁
 
        const size_t N = obits->size();
        for (size_t i = 0; i < N; i++) {
            // 4. 调用每个 DeathRecipient 的 binderDied()
            //    传入 wp<IBinder> 指向当前 BpBinder
            (*obits)[i].recipient->binderDied(wp<IBinder>(this));
        }
        delete obits;              // 释放列表内存
    }
 
    // 5. 告知驱动：已处理完死亡通知，清理驱动端资源
    //    发送 BC_DEAD_BINDER_DONE
    IPCThreadState::self()->clearDeathNotification(mHandle, this);
    IPCThreadState::self()->flushCommands();
}

// 文件: BpBinder.cpp
// 当 BpBinder 的最后一个强引用被释放时自动调用
void BpBinder::onLastStrongRef(const void* /*id*/) {
    // 1. 如果有已注册的死亡通知，先清理
    if (mObituaries != nullptr) {
        // 取消驱动端的死亡通知注册
        IPCThreadState::self()->clearDeathNotification(
            mHandle, this);
        // 释放回调列表
        delete mObituaries;
        mObituaries = nullptr;
    }
 
    // 2.【关键】通知 Binder 驱动减少引用计数
    //    发送 BC_RELEASE 命令
    //    驱动会减少 binder_ref 的强引用计数
    //    如果计数归零，驱动会释放 binder_ref
    //    如果所有客户端都释放了，binder_node 也可能被释放
    IPCThreadState::self()->decStrongHandle(mHandle);
}
 
// 当 BpBinder 的最后一个弱引用被释放时自动调用
void BpBinder::onLastWeakRef(const void* /*id*/) {
    // 通知驱动减少弱引用计数
    // 发送 BC_DECREFS 命令
    IPCThreadState::self()->decWeakHandle(mHandle);
}

用户空间操作                      内核空间效果
──────────────────────────────────────────────────────
BpBinder::create()          →     BC_INCREFS  → binder_ref.weak++
                                  BC_ACQUIRE  → binder_ref.strong++
sp<BpBinder> 赋值           →     (用户空间 strong++ 仅本地)
sp<BpBinder> 释放           →     (用户空间 strong-- 仅本地)
onLastStrongRef()           →     BC_RELEASE  → binder_ref.strong--
onLastWeakRef()             →     BC_DECREFS  → binder_ref.weak--

// 文件: IInterface.h
template<typename INTERFACE>
class BpInterface : public INTERFACE, public BpRefBase {
public:
    explicit BpInterface(const sp<IBinder>& remote);
    // INTERFACE 中定义的纯虚方法在此实现
};
 
// BpRefBase 持有一个 sp<IBinder>，实际上就是 BpBinder
class BpRefBase : public virtual RefBase {
protected:
    // 返回内部持有的 BpBinder（以 IBinder 接口暴露）
    inline IBinder* remote() { return mRemote; }
 
private:
    IBinder* const mRemote;  // 实际类型是 BpBinder
};

// 示例：ICameraService 的代理实现
class BpCameraService : public BpInterface<ICameraService> {
public:
    // 构造函数：将 BpBinder 传给基类
    explicit BpCameraService(const sp<IBinder>& impl)
        : BpInterface<ICameraService>(impl) {}
 
    // 实现 ICameraService 定义的业务方法
    virtual status_t getNumberOfCameras(int32_t* numCameras) {
        Parcel data, reply;
 
        // 1. 写入接口描述符（安全校验用）
        data.writeInterfaceToken(
            ICameraService::getInterfaceDescriptor());
 
        // 2.【核心】调用 remote()->transact()
        //    remote() 返回的就是 BpBinder
        //    TRANSACTION_GET_NUMBER_OF_CAMERAS 是方法编号
        status_t status = remote()->transact(
            GET_NUMBER_OF_CAMERAS,  // 事务 code
            data,                    // 请求数据
            &reply);                 // 响应数据
 
        // 3. 从 reply 中读取返回值
        if (status == NO_ERROR) {
            *numCameras = reply.readInt32();
        }
        return status;
    }
};

// BpCameraService 对象的内存布局（概念性）
//
// +-----------------------------------+
// | BpCameraService                   |
// |   +-------------------------------+
// |   | BpInterface<ICameraService>   |
// |   |   +---------------------------+
// |   |   | ICameraService (vtable)   |  ← 业务接口的虚函数表
// |   |   +---------------------------+
// |   |   | BpRefBase                 |
// |   |   |   mRemote ──────────────────→ BpBinder(handle=N)
// |   |   |                           |      ├── mHandle = N
// |   |   +---------------------------+      ├── mAlive = 1
// |   +-------------------------------+      └── mObituaries
// +-----------------------------------+

// 文件: frameworks/native/include/binder/Binder.h
// BBinder 继承自 IBinder，是服务端 Binder 对象的基类
class BBinder : public IBinder {
public:
    BBinder();                                          // 构造函数
 
    // ---- 来自 IBinder 的重要覆写 ----
    virtual const String16& getInterfaceDescriptor() const; // 返回接口描述符
    virtual bool            isBinderAlive() const;          // 本地对象永远 alive
    virtual status_t        pingBinder();                   // ping 测试，直接返回 OK
    virtual status_t        dump(int fd, const Vector<String16>& args); // dump 信息
 
    // 核心：接收并处理来自远端的事务调用
    virtual status_t        transact(uint32_t code,         // 事务码
                                     const Parcel& data,    // 输入数据
                                     Parcel* reply,         // 输出回复
                                     uint32_t flags = 0);   // 标志位
 
    virtual status_t        linkToDeath(const sp<DeathRecipient>& recipient,
                                        void* cookie = nullptr,
                                        uint32_t flags = 0);
 
    virtual status_t        unlinkToDeath(const wp<DeathRecipient>& recipient,
                                          void* cookie = nullptr,
                                          uint32_t flags = 0,
                                          wp<DeathRecipient>* outRecipient = nullptr);
 
    // 关键：区分本地/远程
    virtual BBinder*        localBinder();                  // 返回 this
    // remoteBinder() 继承自 IBinder，默认返回 nullptr
 
protected:
    virtual                 ~BBinder();                     // 析构函数
 
    // ★★★ 最核心的虚函数 ★★★
    // 子类必须覆写此方法来处理具体的业务逻辑
    virtual status_t        onTransact(uint32_t code,       // 事务码
                                       const Parcel& data,  // 客户端发来的数据
                                       Parcel* reply,       // 要回复给客户端的数据
                                       uint32_t flags = 0); // 标志位
 
private:
    BBinder(const BBinder& o);                              // 禁止拷贝
    BBinder& operator=(const BBinder& o);                   // 禁止赋值
 
    class Extras;                                           // 内部扩展数据类
    std::atomic<Extras*>    mExtras;                        // 原子指针，懒加载
    void*                   mReserved0;                     // 保留字段
};

// 文件: frameworks/native/libs/binder/Binder.cpp
// BBinder::transact() —— 服务端事务处理的入口点
status_t BBinder::transact(
    uint32_t code,          // 事务码，标识客户端要调用哪个方法
    const Parcel& data,     // 客户端发送过来的序列化数据
    Parcel* reply,          // 用于写入返回给客户端的数据
    uint32_t flags)         // 标志位，如 FLAG_ONEWAY 表示异步
{
    // 设置当前 Parcel 的严格模式策略（用于安全检查）
    data.setDataPosition(0);  // 确保从头开始读取数据
 
    status_t err = NO_ERROR;  // 初始化返回状态
 
    switch (code) {
        case PING_TRANSACTION:
            // 系统内置的 ping 事务，用于检测服务是否存活
            // 直接回复空数据即可，不需要转发给 onTransact
            err = pingBinder();
            break;
 
        default:
            // ★ 所有非系统预留的事务码，都转发给 onTransact()
            // 这就是 Template Method 模式的核心：
            // 基类控制流程框架，子类实现具体业务
            err = onTransact(code, data, reply, flags);
            break;
    }
 
    return err;  // 返回处理结果状态码
}

// 文件: frameworks/native/libs/binder/Binder.cpp
// BBinder::onTransact() 的默认实现
// 子类如果不覆写，走到这里就返回 UNKNOWN_TRANSACTION
status_t BBinder::onTransact(
    uint32_t code,             // 事务码
    const Parcel& data,        // 输入数据（未使用，用 [[maybe_unused]] 也可）
    Parcel* reply,             // 回复数据
    uint32_t flags)            // 标志位
{
    (void)code;                // 消除未使用参数的编译警告
    (void)data;
    (void)reply;
    (void)flags;
 
    // 默认返回 UNKNOWN_TRANSACTION
    // 表示当前 BBinder 不识别该事务码
    return UNKNOWN_TRANSACTION;
}

// 文件: frameworks/native/libs/binder/Binder.cpp
 
// 本地 Binder 永远是"活着"的——因为它就在当前进程中
bool BBinder::isBinderAlive() const {
    return true;                     // 永远返回 true
}
 
// ping 操作对本地对象来说无意义，直接返回成功
status_t BBinder::pingBinder() {
    return NO_ERROR;                 // 直接返回 NO_ERROR
}
 
// 返回自身指针，表明"我是本地 Binder 对象"
BBinder* BBinder::localBinder() {
    return this;                     // 返回 this 指针
}
 
// 死亡通知对本地对象无意义
status_t BBinder::linkToDeath(
    const sp<DeathRecipient>& /*recipient*/,
    void* /*cookie*/,
    uint32_t /*flags*/) {
    return INVALID_OPERATION;        // 本地对象不支持死亡监听
}
 
// 同理，取消死亡通知也无意义
status_t BBinder::unlinkToDeath(
    const wp<DeathRecipient>& /*recipient*/,
    void* /*cookie*/,
    uint32_t /*flags*/,
    wp<DeathRecipient>* /*outRecipient*/) {
    return INVALID_OPERATION;        // 本地对象不支持取消死亡监听
}

// 文件: MySimpleService.h
// 一个直接继承 BBinder 的最简 Binder 服务示例
#include <binder/Binder.h>         // BBinder 头文件
#include <binder/Parcel.h>         // Parcel 头文件
#include <utils/Log.h>             // Android 日志
 
using namespace android;           // 使用 android 命名空间
 
// 定义事务码常量（必须 >= FIRST_CALL_TRANSACTION）
enum {
    // IBinder::FIRST_CALL_TRANSACTION 的值为 1
    // 自定义事务码从这个基准值开始递增
    CYCLOPEDIA_SAY_HELLO = IBinder::FIRST_CALL_TRANSACTION,  // 事务码 = 1
    CYCLOPEDIA_ADD       = IBinder::FIRST_CALL_TRANSACTION + 1, // 事务码 = 2
};
 
// 直接继承 BBinder，实现一个简单的 Binder 服务
class MySimpleService : public BBinder {
public:
    MySimpleService() {
        // 构造时打印日志，方便追踪对象生命周期
        ALOGI("MySimpleService created");
    }
 
protected:
    virtual ~MySimpleService() {
        // 析构时打印日志
        ALOGI("MySimpleService destroyed");
    }
 
    // ★ 覆写 onTransact()，处理来自客户端的请求
    virtual status_t onTransact(
        uint32_t code,              // 客户端指定的事务码
        const Parcel& data,         // 客户端发来的数据
        Parcel* reply,              // 回复给客户端的数据
        uint32_t flags) override    // 标志位
    {
        switch (code) {
 
            case CYCLOPEDIA_SAY_HELLO: {
                // --- 处理 sayHello 请求 ---
                // 1. 读取接口描述符并校验（安全检查）
                CHECK_INTERFACE(IMyService, data, reply);
 
                // 2. 从 Parcel 中读取客户端传来的名字
                String16 name = data.readString16();     // 读取一个 UTF-16 字符串
 
                // 3. 拼接问候语
                String8 greeting = String8::format(      // 格式化字符串
                    "Hello, %s! Welcome to Binder world.",
                    String8(name).c_str());               // String16 转 String8
 
                // 4. 将结果写入 reply Parcel
                reply->writeNoException();               // 写入"无异常"标记
                reply->writeString8(greeting);           // 写入问候语字符串
 
                // 5. 返回成功状态
                return NO_ERROR;                         // 表示处理成功
            }
 
            case CYCLOPEDIA_ADD: {
                // --- 处理 add 请求 ---
                CHECK_INTERFACE(IMyService, data, reply);
 
                // 1. 从 Parcel 中依次读取两个整数
                int32_t a = data.readInt32();            // 读取第一个整数
                int32_t b = data.readInt32();            // 读取第二个整数
 
                // 2. 执行加法运算
                int32_t sum = a + b;                     // 计算结果
 
                // 3. 将结果写入 reply
                reply->writeNoException();               // 无异常
                reply->writeInt32(sum);                  // 写入计算结果
 
                return NO_ERROR;                         // 处理成功
            }
 
            default:
                // 未识别的事务码，交给父类 BBinder 处理
                // 父类默认返回 UNKNOWN_TRANSACTION
                return BBinder::onTransact(code, data, reply, flags);
        }
    }
};

// 伪代码：展示 BBinder 的多线程调用场景
// 服务端的 Binder 线程池中有多个线程在循环等待
 
// 线程 1：处理来自客户端 A 的请求
void binderThread1() {
    // IPCThreadState::self() 是线程局部单例 (Thread-Local Singleton)
    IPCThreadState::self()->joinThreadPool();  // 加入线程池
    // 内部循环：
    //   talkWithDriver()  -> 读取 BR_TRANSACTION
    //   executeCommand()  -> 调用 target BBinder 的 transact()
    //                     -> 最终调用 onTransact()
}
 
// 线程 2：同时处理来自客户端 B 的请求
void binderThread2() {
    IPCThreadState::self()->joinThreadPool();  // 同样加入线程池
    // 可能同时调用同一个 BBinder 的 onTransact()！
}

// 线程安全的 BBinder 子类示例
class ThreadSafeService : public BBinder {
private:
    mutable Mutex mLock;          // 互斥锁，用 mutable 修饰以便在 const 方法中使用
    int mCounter = 0;             // 共享可变状态
 
protected:
    status_t onTransact(uint32_t code, const Parcel& data,
                        Parcel* reply, uint32_t flags) override {
        switch (code) {
            case INCREMENT_COUNTER: {
                // 使用 Autolock 自动获取和释放锁（RAII 模式）
                Mutex::Autolock _l(mLock);   // 构造时加锁
                mCounter++;                   // 安全地修改共享状态
                reply->writeInt32(mCounter);  // 写入当前值
                return NO_ERROR;
                // _l 析构时自动解锁
            }
            default:
                return BBinder::onTransact(code, data, reply, flags);
        }
    }
};

// frameworks/native/libs/binder/include/binder/IInterface.h（简化版）
 
class IInterface : public virtual RefBase {  
    // 继承自 RefBase，获得智能指针引用计数能力
public:
    IInterface();                             // 默认构造
    static sp<IBinder> asBinder(const IInterface*);  // 从 IInterface 获取其底层 IBinder
    static sp<IBinder> asBinder(const sp<IInterface>&); // 重载版本，接受智能指针
 
protected:
    virtual IBinder* onAsBinder() = 0;        // 纯虚函数，子类必须实现
                                               // BnXxx 返回 this（自己就是 BBinder）
                                               // BpXxx 返回内部持有的 BpBinder
};

// IDemo.h —— 业务接口声明
 
#include <binder/IInterface.h>   // 引入 IInterface 基类
 
class IDemo : public IInterface { 
    // IDemo 继承 IInterface，成为一个"Binder 业务接口"
public:
    // DECLARE_META_INTERFACE 宏（稍后详细展开）
    // 它会自动声明：
    //   static const std::string descriptor;        // 接口描述符
    //   static sp<IDemo> asInterface(const sp<IBinder>&); // 从 IBinder 转为 IDemo
    //   virtual const String16& getInterfaceDescriptor() const;
    DECLARE_META_INTERFACE(Demo);
 
    // ===== 以下才是真正的业务方法 =====
    virtual int add(int a, int b) = 0;        // 纯虚函数：加法
    virtual String16 greet(const String16& name) = 0; // 纯虚函数：问候
};

// 简化后的 BpInterface 模板定义
 
template<typename INTERFACE>
class BpInterface : public INTERFACE,     // 继承业务接口（如 IDemo）
                    public BpRefBase {     // 继承 BpRefBase（内部持有 BpBinder）
public:
    explicit BpInterface(const sp<IBinder>& remote);
    // remote 参数就是底层的 BpBinder 对象
 
protected:
    virtual IBinder* onAsBinder();
    // 实现 IInterface 的纯虚函数
    // 返回 BpRefBase::remote()，即内部持有的 BpBinder
};

// BpDemo.cpp —— 代理端业务方法实现
 
class BpDemo : public BpInterface<IDemo> {
    // 继承 BpInterface<IDemo>，获得 remote() 方法（返回 BpBinder）
public:
    explicit BpDemo(const sp<IBinder>& impl)
        : BpInterface<IDemo>(impl) {}
        // 将 BpBinder 传给 BpInterface 构造函数保存
 
    // ========== 实现 IDemo::add ==========
    int add(int a, int b) override {
        Parcel data, reply;                         // 创建发送包和回复包
        data.writeInterfaceToken(                   // 写入接口描述符（安全校验用）
            IDemo::getInterfaceDescriptor());
        data.writeInt32(a);                         // 序列化参数 a
        data.writeInt32(b);                         // 序列化参数 b
 
        remote()->transact(                         // 调用 BpBinder::transact
            ADD_TRANSACTION,                        // 自定义的事务码（枚举常量）
            data,                                   // 发送数据
            &reply);                                // 接收回复
 
        return reply.readInt32();                   // 从回复中反序列化结果
    }
 
    // ========== 实现 IDemo::greet ==========
    String16 greet(const String16& name) override {
        Parcel data, reply;                         // 创建发送包和回复包
        data.writeInterfaceToken(                   // 写入接口描述符
            IDemo::getInterfaceDescriptor());
        data.writeString16(name);                   // 序列化参数 name
 
        remote()->transact(                         // 发起 IPC 调用
            GREET_TRANSACTION,                      // 事务码
            data,
            &reply);
 
        return reply.readString16();                // 反序列化并返回结果
    }
};

// 简化后的 BnInterface 模板定义
 
template<typename INTERFACE>
class BnInterface : public INTERFACE,     // 继承业务接口（如 IDemo）
                    public BBinder {       // 继承 BBinder（服务端 Binder 实体）
public:
    virtual sp<IInterface> queryLocalInterface(const String16& _descriptor);
    // 如果 descriptor 匹配，返回 this（说明在同进程，不需要走 IPC）
 
protected:
    virtual IBinder* onAsBinder();
    // 实现 IInterface 的纯虚函数
    // 直接返回 this（BnXxx 自己就是 BBinder）
};

// BnDemo.cpp —— 服务端事务分发 + 业务实现
 
class BnDemo : public BnInterface<IDemo> {
    // 继承 BnInterface<IDemo>，自身就是 BBinder
public:
    // ========== onTransact：事务分发入口 ==========
    status_t onTransact(
        uint32_t code,                              // 事务码，对应 BpDemo 中的常量
        const Parcel& data,                         // 客户端发来的数据包
        Parcel* reply,                              // 待填写的回复包
        uint32_t flags = 0) override {              // 标志位（同步/异步等）
 
        switch (code) {                             // 根据事务码分发
 
            case ADD_TRANSACTION: {                 // 处理 add 请求
                CHECK_INTERFACE(IDemo, data, reply);// 校验接口描述符（安全宏）
                int a = data.readInt32();           // 反序列化参数 a
                int b = data.readInt32();           // 反序列化参数 b
                int result = add(a, b);             // 调用自身的 add 实现（虚函数）
                reply->writeInt32(result);          // 将结果序列化到回复包
                return NO_ERROR;                    // 返回成功
            }
 
            case GREET_TRANSACTION: {               // 处理 greet 请求
                CHECK_INTERFACE(IDemo, data, reply);// 校验接口描述符
                String16 name = data.readString16();// 反序列化参数 name
                String16 result = greet(name);      // 调用自身的 greet 实现
                reply->writeString16(result);       // 序列化回复
                return NO_ERROR;
            }
 
            default:                                // 未知事务码
                return BBinder::onTransact(         // 交给父类 BBinder 处理
                    code, data, reply, flags);
        }
    }
 
    // ========== 真正的业务逻辑 ==========
    int add(int a, int b) override {
        return a + b;                               // 实际计算加法
    }
 
    String16 greet(const String16& name) override {
        String16 prefix("Hello, ");                 // 构造问候语
        return prefix + name;                       // 拼接并返回
    }
};

// DECLARE_META_INTERFACE(Demo) 展开结果
 
static const android::String16 descriptor;            
// 接口描述符字符串，如 "android.demo.IDemo"
 
static android::sp<IDemo> asInterface(               
    const android::sp<android::IBinder>& obj);        
// 核心方法：将 IBinder 转换为 IDemo 智能指针
// 这就是"从管道到接口"的魔法入口
 
virtual const android::String16& getInterfaceDescriptor() const;
// 返回 descriptor

// IMPLEMENT_META_INTERFACE(Demo, "android.demo.IDemo") 展开（简化）
 
const android::String16 IDemo::descriptor("android.demo.IDemo");
// 定义描述符常量
 
const android::String16& IDemo::getInterfaceDescriptor() const {
    return IDemo::descriptor;                         // 返回描述符
}
 
android::sp<IDemo> IDemo::asInterface(
    const android::sp<android::IBinder>& obj) {
    
    android::sp<IDemo> intr;                          // 待返回的接口指针
    if (obj != nullptr) {                             // 传入的 IBinder 非空
        intr = static_cast<IDemo*>(                   // 先尝试本地查询
            obj->queryLocalInterface(                 // 如果 obj 就是 BnDemo（同进程）
                IDemo::descriptor).get());            // 直接强转，避免 IPC 开销
        if (intr == nullptr) {                        // 本地查询失败（跨进程场景）
            intr = new BpDemo(obj);                   // 创建 BpDemo 代理对象
                                                      // obj 此时是 BpBinder
        }
    }
    return intr;                                      // 返回 IDemo 接口指针
}

// BnInterface 中的 queryLocalInterface 实现
template<typename INTERFACE>
sp<IInterface> BnInterface<INTERFACE>::queryLocalInterface(
    const String16& _descriptor) {
    
    if (_descriptor == INTERFACE::descriptor) {       // 描述符匹配
        return sp<IInterface>::fromExisting(          // 返回 this
            static_cast<IInterface*>(this));           // BnXxx 自己就是 IInterface 的子类
    }
    return nullptr;                                   // 不匹配则返回空
}

// 内存模型对比
 
// 场景 A：同进程
// ┌──────────────────────────────────────┐
// │          Process A                    │
// │                                       │
// │  Client ──→ sp<IDemo>                │
// │                  │                    │
// │                  ▼                    │
// │             BnDemo (BBinder)          │
// │             直接调用 add()             │
// │             无 IPC 开销               │
// └──────────────────────────────────────┘
 
// 场景 B：跨进程
// ┌─────────────────┐    ┌─────────────────┐
// │   Process A      │    │   Process B      │
// │                  │    │                  │
// │ Client           │    │   BnDemo         │
// │   │              │    │     ▲            │
// │   ▼              │    │     │            │
// │ BpDemo           │    │   BBinder        │
// │   │              │    │     ▲            │
// │   ▼              │    │     │            │
// │ BpBinder ════════╪════╪═══ Binder Driver │
// └─────────────────┘    └─────────────────┘

// IInterface.h 中的定义
template<typename INTERFACE>
inline sp<INTERFACE> interface_cast(const sp<IBinder>& obj) {
    return INTERFACE::asInterface(obj);               // 直接委托给 asInterface
}
 
// 使用示例
sp<IBinder> binder = sm->getService(String16("demo"));  // 从 ServiceManager 获取 IBinder
sp<IDemo> demo = interface_cast<IDemo>(binder);          // 转为业务接口
// 等价于：sp<IDemo> demo = IDemo::asInterface(binder);
 
demo->add(3, 5);  // 像本地调用一样使用

// 层级划分示例
 
// 第一层：纯接口
class IDemo : public IInterface {
    virtual int add(int a, int b) = 0;                // 纯虚
};
 
// 第二层：Bn 端只做协议分发
class BnDemo : public BnInterface<IDemo> {
    status_t onTransact(...) override;                // 解包 + 分发
    // add() 仍然是纯虚的！不在这里实现
};
 
// 第三层：真正的服务实现
class DemoService : public BnDemo {
    int add(int a, int b) override {                  // 最终的业务实现
        LOG("add called: %d + %d", a, b);             // 可以加日志
        return a + b;                                  // 返回结果
    }
};

// 推荐的事务码定义方式
enum {
    ADD_TRANSACTION   = IBinder::FIRST_CALL_TRANSACTION,      // = 1
    GREET_TRANSACTION = IBinder::FIRST_CALL_TRANSACTION + 1,  // = 2
    // ... 依次递增
};

// ======= Parcel 核心成员（简化示意） =======
class Parcel {
private:
    uint8_t*        mData;          // 指向数据缓冲区起始地址
    size_t          mDataSize;      // 当前已写入的有效数据大小（字节）
    size_t          mDataCapacity;  // 缓冲区总容量（字节）
    mutable size_t  mDataPos;       // 当前读/写游标位置（字节偏移）
 
    binder_size_t*  mObjects;       // "对象偏移量"数组，记录每个特殊对象在 mData 中的偏移
    size_t          mObjectsSize;   // mObjects 数组中有效元素个数
    size_t          mObjectsCapacity; // mObjects 数组容量
    // ...
};

// ============== Parcel 内存布局示意 ==============
//
//  mData 缓冲区（连续内存）
//  ┌──────────┬──────────┬─────────────────────┬──────────┬──────────────┐
//  │ int32    │ int32    │ flat_binder_object   │ String16 │ int64        │
//  │ (code)   │ (flags)  │ (Binder 引用)        │ (name)   │ (timestamp)  │
//  │ offset:0 │ offset:4 │ offset:8             │ offset:? │ offset:?     │
//  └──────────┴──────────┴─────────────────────┴──────────┴──────────────┘
//        ▲                       ▲
//        │                       │
//  mObjects 数组                 │
//  ┌─────────────┐               │
//  │ objects[0]=8 │──────────────┘  (记录 flat_binder_object 在 mData 中的偏移)
//  └─────────────┘
//
//  mDataPos (游标) ──────────────────────────────────────────► 指向下一个可写位置

// ============== 基本类型写入示例 ==============
#include <binder/Parcel.h>  // Parcel 头文件
 
using namespace android;
 
void demonstrateBasicWrite() {
    Parcel data;                             // 创建一个空的 Parcel 对象
 
    // --- 写入整型 ---
    data.writeInt32(42);                     // 写入 4 字节有符号整数，mDataPos += 4
    data.writeInt64(1234567890123LL);        // 写入 8 字节有符号整数，mDataPos += 8
    data.writeUint32(0xDEADBEEF);           // 写入 4 字节无符号整数
 
    // --- 写入浮点 ---
    data.writeFloat(3.14f);                  // 写入 4 字节 float
    data.writeDouble(2.718281828);           // 写入 8 字节 double
 
    // --- 写入布尔（实际存为 int32） ---
    data.writeBool(true);                    // 内部调用 writeInt32(val ? 1 : 0)
 
    // --- 写入字符串 ---
    String16 name("AndroidService");         // Binder 中字符串通常使用 UTF-16 编码
    data.writeString16(name);                // 先写入长度(int32)，再写入 UTF-16 字符数据，末尾补对齐
 
    String8 tag("debug_tag");                // 也支持 UTF-8 字符串
    data.writeString8(tag);                  // 先写入长度(int32)，再写入 UTF-8 字符数据
 
    // --- 写入原始字节块 ---
    uint8_t buffer[] = {0x01, 0x02, 0x03};   // 原始字节数据
    data.write(buffer, sizeof(buffer));       // 按原始字节写入，自动 4 字节对齐填充
}

// ============== 基本类型读取示例 ==============
void demonstrateBasicRead(Parcel& data) {
    data.setDataPosition(0);                 // ★ 重置游标到缓冲区起始位置
 
    // --- 读取时必须与写入顺序完全一致 ---
    int32_t code = data.readInt32();         // 读取 4 字节，mDataPos += 4
    int64_t big  = data.readInt64();         // 读取 8 字节，mDataPos += 8
    uint32_t hex = data.readUint32();        // 读取 4 字节无符号
 
    float  f = data.readFloat();             // 读取 4 字节 float
    double d = data.readDouble();            // 读取 8 字节 double
 
    bool flag = data.readBool();             // 内部 readInt32() != 0
 
    String16 name = data.readString16();     // 先读长度，再读字符数据
    String8  tag  = data.readString8();      // 同上，UTF-8 版本
 
    uint8_t buf[3];                          // 准备接收缓冲区
    data.read(buf, sizeof(buf));             // 按字节读取原始数据
}

// ============== writeInt32 内部实现（简化） ==============
status_t Parcel::writeInt32(int32_t val) {
    return writeAligned(val);                // 调用模板化的对齐写入方法
}
 
template<class T>
status_t Parcel::writeAligned(T val) {
    // 检查类型大小是否满足 4 字节对齐要求
    static_assert(sizeof(T) % 4 == 0, "Must be 4-byte aligned");
 
    // 如果剩余容量不足，尝试扩容
    if ((mDataPos + sizeof(val)) > mDataCapacity) {
        status_t err = growData(sizeof(val));// 扩容：至少容纳 sizeof(val) 字节
        if (err != NO_ERROR) return err;     // 扩容失败则返回错误
    }
 
    // ★ 核心操作：将数据直接拷贝到 mData + mDataPos 位置
    *reinterpret_cast<T*>(mData + mDataPos) = val;
 
    mDataPos += sizeof(val);                 // 游标前进 sizeof(T) 字节
    if (mDataPos > mDataSize) {
        mDataSize = mDataPos;                // 更新有效数据大小
    }
    return NO_ERROR;                         // 返回成功
}

// ============== PAD_SIZE 宏：计算对齐后大小 ==============
// 这个宏在 Parcel.cpp 中定义，用于将任意大小向上对齐到 4 字节边界
#define PAD_SIZE_UNSAFE(s) (((s) + 3) & ~3)
 
// 示例：
// PAD_SIZE_UNSAFE(1)  => ((1+3) & ~3) = (4 & 0xFFFFFFFC) = 4
// PAD_SIZE_UNSAFE(2)  => ((2+3) & ~3) = (5 & 0xFFFFFFFC) = 4
// PAD_SIZE_UNSAFE(3)  => ((3+3) & ~3) = (6 & 0xFFFFFFFC) = 4
// PAD_SIZE_UNSAFE(4)  => ((4+3) & ~3) = (7 & 0xFFFFFFFC) = 4
// PAD_SIZE_UNSAFE(5)  => ((5+3) & ~3) = (8 & 0xFFFFFFFC) = 8
// PAD_SIZE_UNSAFE(7)  => ((7+3) & ~3) = (10& 0xFFFFFFFC) = 8
// PAD_SIZE_UNSAFE(9)  => ((9+3) & ~3) = (12& 0xFFFFFFFC) = 12

// ============== writeString16 内部逻辑（简化） ==============
status_t Parcel::writeString16(const String16& str) {
    const size_t len = str.size();           // 获取字符串长度（UTF-16 字符数，非字节数）
    
    if (len > INT32_MAX) {                   // 长度越界检查
        return BAD_VALUE;
    }
 
    // Step 1: 先写入字符串长度（int32），作为后续读取的"契约"
    status_t err = writeInt32(len);          // 4 字节
    if (err != NO_ERROR) return err;
 
    // Step 2: 写入 UTF-16 字符数据 + 结尾空字符 '\0'
    // 每个 char16_t 占 2 字节，总共 (len + 1) * sizeof(char16_t) 字节
    // 然后 PAD_SIZE 对齐到 4 字节边界
    err = write(str.string(), (len + 1) * sizeof(char16_t));  
    return err;
}

// ============== String16("OK") 的 Parcel 二进制布局 ==============
//
//  偏移量   内容（十六进制）            含义
//  ─────────────────────────────────────────────────────
//  [0x00]   02 00 00 00               长度 = 2（int32，2个UTF-16字符）
//  [0x04]   4F 00                     'O' 的 UTF-16 编码 (0x004F)
//  [0x06]   4B 00                     'K' 的 UTF-16 编码 (0x004B)
//  [0x08]   00 00                     结尾空字符 '\0' (UTF-16)
//  [0x0A]   00 00                     2 字节填充（PAD 到 4 字节对齐）
//  ─────────────────────────────────────────────────────
//  总占用 = 4 (长度) + 6 (字符+null) + 2 (pad) = 12 字节

// ============== flat_binder_object 结构体（内核定义） ==============
// 定义在 <linux/android/binder.h>
struct flat_binder_object {
    __u32               hdr_type;    // 类型标识：BINDER_TYPE_BINDER 或 BINDER_TYPE_HANDLE
    __u32               flags;       // 标志位（如调度策略）
    union {
        binder_uintptr_t binder;     // 本地 Binder 地址（仅同进程使用）
        __u32            handle;     // 远程 Binder 句柄（跨进程使用）
    };
    binder_uintptr_t    cookie;      // 附加数据（通常存 BBinder* 指针）
};

// ============== writeStrongBinder 实现（简化） ==============
status_t Parcel::writeStrongBinder(const sp<IBinder>& val) {
    return flattenBinder(val);               // 委托给 flattenBinder
}
 
status_t Parcel::flattenBinder(const sp<IBinder>& binder) {
    flat_binder_object obj;                  // 创建内核结构体
 
    if (binder != nullptr) {
        BBinder* local = binder->localBinder();  // 尝试获取本地 BBinder 指针
 
        if (local != nullptr) {
            // ★ 情况1：binder 是本进程内的真实服务对象（BBinder）
            obj.hdr_type = BINDER_TYPE_BINDER;   // 类型：本地 Binder 实体
            obj.binder   = reinterpret_cast<uintptr_t>(local->getWeakRefs());
            obj.cookie   = reinterpret_cast<uintptr_t>(local);  // 存储 BBinder* 指针
        } else {
            // ★ 情况2：binder 是远程代理（BpBinder），取出其 handle 值
            obj.hdr_type = BINDER_TYPE_HANDLE;   // 类型：远程句柄
            obj.handle   = binder->remoteBinder()->getHandle(); // 获取 handle 编号
        }
    } else {
        // ★ 情况3：传入的是 null
        obj.hdr_type = BINDER_TYPE_BINDER;
        obj.binder   = 0;
        obj.cookie   = 0;
    }
 
    obj.flags = 0x7f | FLAT_BINDER_FLAG_ACCEPTS_FDS;  // 设置默认优先级和标志
 
    // 将 flat_binder_object 写入 mData 缓冲区
    status_t status = writeObject(obj, false);
    return status;
}

// ============== 文件描述符的写入与读取 ==============
void sendFd(Parcel& data) {
    int fd = open("/data/local/tmp/test.txt", O_RDONLY);  // 打开文件，获取 fd
    if (fd < 0) return;
 
    // writeFileDescriptor 内部会创建 BINDER_TYPE_FD 类型的 flat_binder_object
    // 并将 fd 值写入，驱动负责在目标进程中 dup 出新的 fd
    data.writeFileDescriptor(fd, true);      // 第二个参数 takeOwnership=true
                                             // 表示 Parcel 析构时会自动 close(fd)
}
 
void receiveFd(const Parcel& data) {
    // 读取端拿到的是目标进程中新分配的 fd（值可能不同，但指向同一个文件）
    int fd = data.readFileDescriptor();      // 返回的 fd 在当前进程中有效
    if (fd >= 0) {
        char buf[256];
        read(fd, buf, sizeof(buf));          // 直接使用 fd 读取文件内容
    }
}

// ============== fd 跨进程传递的内核视角 ==============
//
//  进程 A (sender)            Binder 驱动 (kernel)          进程 B (receiver)
//  ┌─────────────┐           ┌──────────────────┐          ┌─────────────┐
//  │ fd=5         │           │                  │          │ fd=12        │
//  │   ↓          │           │  1. 取出 A 的 fd=5│          │   ↓          │
//  │ struct file──┼──────────▶│  2. 获取 file*   │──────────┼─►struct file │
//  │ (test.txt)   │           │  3. 在 B 中分配   │          │ (same file!) │
//  │              │           │     新 fd=12      │          │              │
//  └─────────────┘           └──────────────────┘          └─────────────┘
//
//  A 的 fd=5 和 B 的 fd=12 指向内核中同一个 struct file 对象
//  即同一个文件的同一个打开实例（共享文件偏移量等）

// ============== 客户端写入（BpXxxService::someMethod） ==============
Parcel data, reply;
data.writeInterfaceToken(String16("android.app.IActivityManager"));  // ★ 写入 token
data.writeInt32(userId);                     // 写入业务参数
data.writeString16(packageName);             // 写入业务参数
remote()->transact(SOME_TRANSACTION, data, &reply);  // 发起事务
 
// ============== 服务端校验（BnXxxService::onTransact） ==============
status_t BnActivityManager::onTransact(uint32_t code, const Parcel& data,
                                        Parcel* reply, uint32_t flags) {
    // ★ 校验 token，防止客户端发错了接口
    CHECK_INTERFACE(IActivityManager, data, reply);
    // 上面的宏展开后大致为：
    // if (!data.enforceInterface(String16("android.app.IActivityManager"))) {
    //     return PERMISSION_DENIED;
    // }
 
    int32_t userId = data.readInt32();       // 读取业务参数
    String16 pkg   = data.readString16();    // 读取业务参数
    // ... 执行业务逻辑 ...
    return NO_ERROR;
}

// ============== binder_transaction_data（内核结构体，简化） ==============
struct binder_transaction_data {
    union {
        __u32 handle;                        // 目标 Binder 的 handle（客户端填写）
        binder_uintptr_t ptr;                // 目标 Binder 的地址（驱动填写）
    } target;
    __u32          code;                     // 事务码（如 FIRST_CALL_TRANSACTION + N）
    __u32          flags;                    // 标志（如 TF_ONE_WAY 单向调用）
 
    binder_uintptr_t data_buffer;            // ★ 指向 Parcel 的 mData 缓冲区
    binder_size_t    data_size;              // ★ 对应 Parcel 的 mDataSize
 
    binder_uintptr_t data_offsets;           // ★ 指向 Parcel 的 mObjects 数组
    binder_size_t    offsets_size;           // ★ mObjects 数组的字节大小
};

// ============== 带错误处理的读写模式 ==============
status_t BnMyService::onTransact(uint32_t code, const Parcel& data,
                                  Parcel* reply, uint32_t flags) {
    switch (code) {
    case MY_TRANSACTION: {
        // 校验接口 token
        CHECK_INTERFACE(IMyService, data, reply);
 
        // ★ 使用带 status_t 返回值的读取方式（Android 新版推荐）
        int32_t param1;
        status_t err = data.readInt32(&param1);  // 传入指针，返回状态码
        if (err != NO_ERROR) {
            // 读取失败（如数据不足），返回错误
            return err;                          // 会被转换为 DeadObjectException 等
        }
 
        String16 param2;
        err = data.readString16(&param2);        // 同样检查返回值
        if (err != NO_ERROR) return err;
 
        // 执行业务逻辑...
        int32_t result = doSomething(param1, param2);
 
        // 写入返回值
        reply->writeNoException();               // ★ 告知客户端没有异常发生
        reply->writeInt32(result);               // 写入结果
 
        return NO_ERROR;
    }
    default:
        return BBinder::onTransact(code, data, reply, flags);  // 未知事务码，交给父类
    }
}

// 业务层代理 —— 开发者可见
// BpCalculator 继承自 BpInterface<ICalculator>
class BpCalculator : public BpInterface<ICalculator> {
    // add() 看起来像本地调用，实际会跨进程
    int add(int a, int b) override {
        Parcel data, reply;               // 准备数据容器
        data.writeInterfaceToken(...);    // 写入接口描述符用于校验
        data.writeInt32(a);               // 序列化参数 a
        data.writeInt32(b);               // 序列化参数 b
        // remote() 返回 BpBinder，transact() 走 IPC
        remote()->transact(ADD, data, &reply);
        return reply.readInt32();         // 从回复中反序列化结果
    }
};