Messenger IPC 通信全面笔记

Messenger 是 Android 提供的一种轻量级跨进程通信（IPC）方式，基于 Binder 实现。

核心组件：

• Handler：负责接收和处理消息
• Messenger：封装 Handler，提供跨进程收发消息的能力
• Message：消息体，数据载体是内部的 Bundle（msg.data）
• Service：跨进程通信的"基地"，通过 onBind 暴露 Messenger 的 IBinder

相同点：最终跨进程传递的数据都是 Bundle，都受 Binder 1MB 限制，都必须实现 Parcelable。

1. 服务端实现（Service）

class MessengerService : Service() {
    private val handler = object : Handler(Looper.getMainLooper()) {
        override fun handleMessage(msg: Message) {
            val name = msg.data.getString("name")
            // 处理消息...
        }
    }
    private val messenger = Messenger(handler)

    override fun onBind(intent: Intent): IBinder = messenger.binder
}

记得在 AndroidManifest.xml 中声明 Service，如需跨应用可设置 exported="true"。

2. 客户端绑定并发送消息

class MainActivity : AppCompatActivity() {
    private var serviceMessenger: Messenger? = null

    private val connection = object : ServiceConnection {
        override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
            serviceMessenger = Messenger(service)
            val msg = Message.obtain().apply {
                data = Bundle().apply { putString("name", "张三") }
            }
            serviceMessenger?.send(msg)
        }
        override fun onServiceDisconnected(name: ComponentName?) { serviceMessenger = null }
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val intent = Intent(this, MessengerService::class.java)
        bindService(intent, connection, Context.BIND_AUTO_CREATE)
    }

    override fun onDestroy() {
        super.onDestroy()
        unbindService(connection)
    }
}

要让服务端也能给客户端发消息，客户端需要把自己的 Messenger 通过 msg.replyTo告诉服务端。

1. 客户端构建回信地址

private val replyHandler = object : Handler(Looper.getMainLooper()) {
    override fun handleMessage(msg: Message) {
        val reply = msg.data.getString("reply")
        // 显示/处理回复
    }
}
private val clientMessenger = Messenger(replyHandler)

发送消息时设置 replyTo：

val msg = Message.obtain().apply {
    data = Bundle().apply { putString("name", "张三") }
    replyTo = clientMessenger   // 把自己的 Messenger 传过去
}
serviceMessenger?.send(msg)

2. 服务端回复

override fun handleMessage(msg: Message) {
    val replyMessenger = msg.replyTo
    val replyMsg = Message.obtain().apply {
        data = Bundle().apply { putString("reply", "收到") }
    }
    replyMessenger?.send(replyMsg)
}

服务端维护一个 Map<String, Messenger>，每个客户端在连接后先"注册"，把自己的名字和 Messenger 告诉服务端，之后可实现客户端之间的消息转发。

1. 服务端维护客户端列表

private val clients = mutableMapOf<String, Messenger>()

// 处理注册
MessengerConstant.MSG_REGISTER -> {
    val clientMessenger = msg.replyTo
    val clientName = msg.data.getString("client_name")
    if (clientMessenger != null && clientName != null) {
        clients[clientName] = clientMessenger
        // 回复注册成功
    }
}

// 处理转发
MessengerConstant.MSG_SEND_ANOTHER -> {
    val target = msg.data.getString("target")
    val message = msg.data.getString("msg")
    val messenger = clients[target] ?: return
    messenger.send(Message.obtain().apply {
        data = Bundle().apply { putString("msg", message) }
    })
}

2. 客户端注册

override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
    serviceMessenger = Messenger(service)
    val msg = Message.obtain().apply {
        what = MSG_REGISTER
        data = Bundle().apply { putString("client_name", "MainActivity") }
        replyTo = clientMessenger   // 传自己的 Messenger
    }
    serviceMessenger?.send(msg)
}

1. 强引用链导致 Activity 无法回收

从 Service 到 Activity 存在一条强引用链：

Service 的 clients Map (强引用)
    → Messenger (内部持有)
    → Handler (匿名内部类隐式持有)
    → Activity 实例

2. 进程存活 ≠ Activity 存活

• Activity 销毁后，其所在的独立进程不一定会立即被杀（取决于系统内存和其他组件）
• Handler 依附于主线程的 Looper，与进程同生命周期，所以消息仍能投递和处理
• 但 Toast 等 UI 操作会因 Context 失效而失败

3. 消息积压现象

• 退出 Activity 后，服务端继续发送消息，这些消息会排队在主线程的消息队列中
• 当 Activity 重新打开（同一进程）时，这些积压的消息会瞬间全部弹出（Toast 显示）

客户端（Activity）销毁时必须：

1. 清空自己 Handler 的消息队列（防积压）
2. 发送注销消息给 Service（切断强引用链）
3. 解绑服务

override fun onDestroy() {
    // 1. 清空 Handler 所有消息，防止积压
    handler.removeCallbacksAndMessages(null)

    // 2. 通知 Service 移除自己
    messengerService?.send(Message.obtain().apply {
        what = MSG_UNREGISTER
        data = Bundle().apply { putString("client_name", MY_NAME) }
    })

    // 3. 解绑
    if (isBound) {
        unbindService(messengerConnection)
        isBound = false
    }
    super.onDestroy()
}

服务端处理注销

MSG_UNREGISTER -> {
    val name = msg.data.getString("client_name")
    clients.remove(name)
}

服务端发送消息时捕获异常

try {
    messenger.send(msg)
} catch (e: Exception) {
    clients.remove(target)  // 发送失败时清理失效客户端
}

使用 弱引用（WeakReference）来观察 Activity 是否被回收。

companion object {
    var weakActivity: WeakReference<SecondActivity>? = null
}

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    weakActivity = WeakReference(this)
}

// 在需要检查的地方
Log.d("GC_Check", "Activity是否存活？ ${SecondActivity.weakActivity?.get() != null}")

• 如果输出 false，说明 Activity 已被 GC 回收
• WeakReference 不会阻止对象被 GC 回收，适合用于监控对象生命周期