Android 中如何正确等待Service与Activity绑定完成后执行相关操作

核心思路是通过Kotlin协程的suspendCancellableCoroutine将异步的Service绑定回调转为可等待的挂起函数，既不阻塞主线程，也能保证拿到binder实例后再执行后续操作。

1. 封装绑定服务的挂起扩展函数 #

import android.content.ComponentName
import android.content.Context
import android.content.Intent
import android.content.ServiceConnection
import android.os.IBinder
import kotlin.coroutines.resume
import kotlin.coroutines.suspendCancellableCoroutine

suspend fun Context.bindServiceForResult(intent: Intent, flags: Int): Pair<IBinder, ServiceConnection> = suspendCancellableCoroutine { cont ->
    // 局部ServiceConnection用于接收绑定回调
    val connection = object : ServiceConnection {
        override fun onServiceConnected(className: ComponentName, service: IBinder) {
            if (cont.isActive) {
                // 绑定成功，返回binder和当前connection实例
                cont.resume(Pair(service, this))
            }
        }

        override fun onServiceDisconnected(arg0: ComponentName) {
            // 服务意外断开时取消协程
            if (cont.isActive) {
                cont.cancel(RuntimeException("Service disconnected unexpectedly"))
            }
        }
    }
    // 执行绑定操作
    bindService(intent, connection, flags)
    // 协程取消时自动解绑，避免内存泄漏
    cont.invokeOnCancellation {
        unbindService(connection)
    }
}

2. Activity中的完整实现 #

import android.content.ServiceConnection
import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import androidx.lifecycle.lifecycleScope
import kotlinx.coroutines.launch

class YourActivity : AppCompatActivity() {
    private var myBinder: MyService.LocalBinder? = null
    // 全局存储ServiceConnection实例，用于后续解绑
    private var serviceConnection: ServiceConnection? = null
    private val serviceIntent by lazy { Intent(this, MyService::class.java) }

    override fun onResume() {
        super.onResume()
        // 使用和Activity生命周期绑定的lifecycleScope，页面销毁时自动取消协程
        lifecycleScope.launch {
            // 避免重复绑定，已存在binder直接复用
            val binder = myBinder ?: run {
                val (service, conn) = bindServiceForResult(serviceIntent, Context.BIND_AUTO_CREATE)
                serviceConnection = conn
                (service as MyService.LocalBinder).also {
                    myBinder = it
                }
            }
            // 此时已经拿到有效binder，可以安全执行你的业务逻辑
            val service = binder.getService()
            // 1. 读取状态标记配置UI
            val stateFlags = service.getStateFlags()
            updateUi(stateFlags)
            // 2. 检查adapter启用状态
            if (service.isAdapterEnabled()) {
                // 对应业务逻辑
            }
            // 3. 调用Service的其他方法
            service.doSomeWork()
        }
    }

    override fun onStop() {
        super.onStop()
        // 页面不可见时解绑，清空引用
        serviceConnection?.let {
            unbindService(it)
            myBinder = null
            serviceConnection = null
        }
    }

    private fun updateUi(flags: Int) {
        // 你的UI更新逻辑
    }
}

常见问题说明 #

之前的方案为什么不可行 #

• lateinit方案：仅在编译期跳过空检查，没有解决绑定异步的时序问题，绑定完成前访问依然会抛出未初始化异常。
• 循环阻塞方案：主线程死循环会阻塞UI线程Looper，所有触摸、绘制事件都无法处理，直接触发ANR崩溃。
• 原有协程方案：没有挂起等待绑定回调触发，直接返回了当前的绑定状态值，本质上还是没有解决异步等待的问题。

为什么需要局部+全局两个ServiceConnection #

局部ServiceConnection是在挂起函数内创建的，用于接收系统的绑定回调；全局存储的ServiceConnection是因为Android系统要求解绑服务时，必须传入绑定时使用的同一个ServiceConnection实例，所以需要把绑定返回的connection实例存到成员变量中，供onStop解绑时使用。

内容的提问来源于stack exchange，提问作者snuff