【底层机制】【Android】Binder架构与原理

一、Binder 整体架构

1. 架构组成

• Client：服务调用方
• Server：服务提供方
• ServiceManager：服务管理器，Android 系统启动时初始化的特殊 Binder 服务
• Binder 驱动：内核空间的核心组件，负责进程间通信

2. 通信模型

Client Process      Kernel Space       Server Process
    |                   |                   |
    | -- IBinder.Proxy ->|                   |
    |                   | -- Binder Driver ->|
    |                   |                   | -- IBinder.Stub
    |                   | <- Transaction ---|
    | <- Result --------|                   |

二、Binder 驱动核心机制

1. 内存映射（mmap）

// Binder 驱动关键数据结构
struct binder_proc {
    struct hlist_node proc_node;
    struct rb_root threads;        // 线程红黑树
    struct rb_root nodes;          // Binder 节点
    struct list_head delivered_death; // 死亡通知列表
};

struct binder_thread {
    struct binder_proc *proc;      // 所属进程
    wait_queue_head_t wait;        // 等待队列
    struct binder_transaction *transaction_stack; // 事务栈
};

mmap 工作原理：

• 进程打开 /dev/binder 设备后调用 mmap()
• Binder 驱动在内核空间分配缓冲区
• 同时映射到内核空间和用户空间
• 一次拷贝机制：数据从客户端用户空间拷贝到内核缓冲区，服务端直接读取

2. 数据传输流程

1. Client 发送数据：

   • 数据打包为 binder_transaction_data
   • 通过 ioctl(BC_TRANSACTION) 发送到驱动
   • 驱动查找目标 Binder 实体

2. Server 接收数据：

   • 服务线程通过 ioctl(BC_ENTER_LOOPER) 进入循环
   • 调用 ioctl(BINDER_WRITE_READ) 读取事务
   • 驱动唤醒等待的服务线程

三、AIDL 本质解析

1. AIDL 生成的代码结构

// 自动生成的 Binder 接口
public interface IMyService extends android.os.IInterface {
    // Binder 本地对象（服务端实现）
    public static abstract class Stub extends android.os.Binder implements IMyService {
        @Override
        public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) {
            switch (code) {
                case INTERFACE_TRANSACTION:
                    reply.writeString(DESCRIPTOR);
                    return true;
                case TRANSACTION_doSomething:
                    data.enforceInterface(DESCRIPTOR);
                    int _arg0 = data.readInt();
                    String _result = this.doSomething(_arg0);
                    reply.writeNoException();
                    reply.writeString(_result);
                    return true;
            }
            return super.onTransact(code, data, reply, flags);
        }
    }

    // Binder 代理对象（客户端使用）
    private static class Proxy implements IMyService {
        private android.os.IBinder mRemote;
        
        @Override
        public String doSomething(int param) {
            android.os.Parcel _data = android.os.Parcel.obtain();
            android.os.Parcel _reply = android.os.Parcel.obtain();
            String _result;
            try {
                _data.writeInterfaceToken(DESCRIPTOR);
                _data.writeInt(param);
                mRemote.transact(Stub.TRANSACTION_doSomething, _data, _reply, 0);
                _reply.readException();
                _result = _reply.readString();
            } finally {
                _reply.recycle();
                _data.recycle();
            }
            return _result;
        }
    }
}

2. AIDL 本质

• 代码生成工具：将接口定义转换为 Binder 通信代码
• Proxy-Stub 模式实现 ：
  • Proxy：客户端代理，序列化参数并调用 transact()
  • Stub：服务端基类，反序列化参数并调用实际方法
• 接口描述符机制：确保客户端和服务端接口版本一致

---

startActivity 的 Binder 调用全过程

一、进程内准备阶段

1. 发起调用

// Activity.java
public void startActivity(Intent intent) {
    // 调用 ActivityTaskManager 服务
    ActivityTaskManager.getService().startActivity(
        mMainThread.getApplicationThread(), 
        mToken, 
        intent, 
        intent.resolveTypeIfNeeded(getContentResolver()),
        null, // resultTo
        null, // resultWho
        0,    // requestCode
        FLAG_ACTIVITY_NEW_TASK,
        null, // options
        null  // userId
    );
}

二、Binder 调用链详细流程

1. 客户端到系统进程（第一次 Binder 调用）

Client Process (App) → System Server Process (AMS)

调用路径：

• Activity.startActivity()
• ActivityTaskManager.getService().startActivity()
• IActivityTaskManager.Stub.Proxy.startActivity()

Binder 事务：

// IActivityTaskManager.aidl 生成的 Proxy 类
public int startActivity(IApplicationThread caller, String callingPackage,
        Intent intent, ...) {
    Parcel data = Parcel.obtain();
    Parcel reply = Parcel.obtain();
    data.writeStrongBinder(caller != null ? caller.asBinder() : null);
    data.writeString(callingPackage);
    intent.writeToParcel(data, 0);
    // ... 其他参数序列化
    mRemote.transact(TRANSACTION_startActivity, data, reply, 0);
    reply.readException();
    int result = reply.readInt();
    return result;
}

2. 系统进程处理（AMS 侧）

AMS 处理逻辑：

// ActivityTaskManagerService.java
public final int startActivity(IApplicationThread caller, ...) {
    return getActivityStartController().obtainStarter(intent, ...)
        .setCaller(caller)
        .execute();
}

关键步骤：

1. 权限验证：检查调用者权限
2. Intent 解析：解析目标 Activity 信息
3. 进程检查：判断目标 Activity 所在进程是否已启动
4. 栈管理：确定 Activity 应该放入哪个 Task

3. 暂停当前 Activity（第二次 Binder 调用）

System Server Process (AMS) → Client Process (App)

AMS 调用应用进程：

// 通过 ApplicationThread 的 Binder 接口
app.thread.schedulePauseActivity(token, finished, userLeaving, configChanges);

应用进程处理：

// ActivityThread.java - ApplicationThread 内部类
public final void schedulePauseActivity(IBinder token, ...) {
    sendMessage(H.PAUSE_ACTIVITY, token);
}

// H（Handler）处理消息
case PAUSE_ACTIVITY: {
    handlePauseActivity((IBinder)msg.obj, ...);
    break;
}

private void handlePauseActivity(IBinder token, ...) {
    ActivityClientRecord r = mActivities.get(token);
    if (r != null) {
        // 调用 Activity 的 onPause()
        performPauseActivity(r, finished, reason, pendingActions);
    }
}

4. 启动目标进程（如果需要）

进程创建流程：

1. AMS 通过 Process.start() 请求 Zygote
2. Zygote fork 新进程
3. 新进程入口：ActivityThread.main()

5. 启动目标 Activity（第三次 Binder 调用）

System Server Process (AMS) → Target Process (App)

AMS 调用目标进程：

// 通过目标进程的 ApplicationThread
thread.scheduleLaunchActivity(new Intent(r.intent), ...);

目标进程处理：

// ActivityThread.java
private void handleLaunchActivity(ActivityClientRecord r, ...) {
    // 1. 创建 Activity 实例
    Activity activity = mInstrumentation.newActivity(
        cl, component.getClassName(), r.intent);
    
    // 2. 创建 Application（如果不存在）
    Application app = r.packageInfo.makeApplication(false, mInstrumentation);
    
    // 3. 关联 Context
    activity.attach(appContext, ...);
    
    // 4. 调用 onCreate()
    mInstrumentation.callActivityOnCreate(activity, r.state);
    
    // 5. 调用 onStart()
    activity.performStart();
    
    // 6. 调用 onResume()
    activity.performResume();
}

三、Window 管理相关的 Binder 调用

1. 窗口创建（第四次 Binder 调用）

Target Process (App) → WindowManagerService (WMS)

调用流程：

// ActivityThread.handleResumeActivity()
final void handleResumeActivity(IBinder token, ...) {
    // 调用 Activity.onResume()
    ActivityClientRecord r = performResumeActivity(token, ...);
    
    if (r.activity.mVisibleFromClient) {
        // 添加窗口到 WMS
        ViewManager wm = r.activity.getWindowManager();
        wm.addView(decorView, layoutParams);
    }
}

// WindowManagerGlobal.addView()
public void addView(View view, ViewGroup.LayoutParams params, ...) {
    ViewRootImpl root = new ViewRootImpl(view.getContext(), display);
    root.setView(view, wparams, panelParentView);
}

ViewRootImpl 与 WMS 通信：

// ViewRootImpl.java
public void setView(View view, ...) {
    // 通过 Session 与 WMS 通信
    res = mWindowSession.addToDisplay(mWindow, ...);
}

四、Binder 驱动中的关键数据结构

1. 事务处理

struct binder_transaction_data {
    union {
        size_t handle;    // 对 Server 的引用
        void *ptr;        // Server 的本地地址
    } target;
    void *data.ptr;       // 数据缓冲区
    size_t data_size;     // 数据大小
};

// Binder 驱动处理事务
static void binder_transaction(struct binder_proc *proc,
                   struct binder_thread *thread,
                   struct binder_transaction_data *tr) {
    // 查找目标 Binder 节点
    target_node = binder_get_node(proc, tr->target.handle);
    // 分配事务缓冲区
    t = kzalloc(sizeof(*t), GFP_KERNEL);
    // 拷贝数据到目标进程
    t->buffer = binder_alloc_buf(target_proc, tr->data_size);
}

五、完整调用时序总结

[Client Process]           [Binder Driver]        [System Server]        [Target Process]
      |                           |                       |                       |
      |--- startActivity() ------>|                       |                       |
      |                           |-- TRANSACTION ------->|                       |
      |                           |                       |-- AMS.startActivity() |
      |                           |                       |                       |
      |                           |<-- schedulePauseActivity --|                  |
      |<-- onPause() ------------|                       |                       |
      |                           |                       |                       |
      |                           |                       |-- (如果需要)创建进程 -|
      |                           |                       |                       |
      |                           |<-- scheduleLaunchActivity -|                  |
      |                           |                       |                  |-- onCreate()
      |                           |                       |                  |-- onStart()  
      |                           |                       |                  |-- onResume()
      |                           |                       |                  |-- addView()
      |                           |                       |                  |   (WMS调用)

六、性能优化关键点

1. 一次拷贝优势：相比其他 IPC（如 Socket 需要 4 次拷贝），Binder 只需 1 次用户空间到内核空间的拷贝
2. 引用计数：Binder 对象自动管理生命周期，避免内存泄漏
3. 线程池管理：Binder 驱动维护线程池，避免频繁创建销毁线程
4. 死亡通知 ：通过 linkToDeath() 监控 Binder 服务状态，及时清理资源

整个 startActivity 过程涉及 3-4 次主要的 Binder 调用，通过精心设计的异步回调机制和状态管理，实现了跨进程的 Activity 启动流程。