Cómo esperar adecuadamente a que un Servicio de Android se vincule a una Actividad.

Estoy desarrollando una aplicación en la cual varias actividades están vinculadas a un servicio una vez que son visibles para el usuario. Durante el inicio, cada actividad necesita:

• Revisar alguna bandera de estado del servicio, basándose en la cual algunos elementos de la interfaz de usuario son configurados.
• Revisar si un adaptador está habilitado, cuya referencia está dentro del servicio.
• Ejecutar algunas funciones del servicio.

Ya que las aplicaciones no deben obtener actualizaciones en segundo plano, me vinculo al servicio en onStart() y lo desvinculo en onStop(). Es decir, tengo algo así:

override fun onStart() {
    super.onStart()
    Intent(context, MyService::class.java).also { intent ->
        bindService(intent, serviceCallback, Context.BIND_AUTO_CREATE)
    }
}

Ahora quiero realizar las acciones anteriormente mencionadas dentro de onResume.

override fun onResume() {
    super.onResume()
    //Revisar las banderas
    //Revisar el estado del adaptador
    //Ejecutar funciones del servicio
}

El problema es que la vinculación a un servicio es asíncrona y no tengo una referencia válida al vinculador del servicio dentro de onResume(). En consecuencia, la aplicación se detendrá con una excepción de puntero nulo.

Enfoque 1: Usando lateinit

Intenté resolver este problema usando la palabra clave lateinit. Es decir, defino la referencia al vinculador de la siguiente manera:

private lateinit var myBinder: MyService.LocalBinder

Problema: No puedo garantizar que el vinculador esté inicializado ya que es asíncrono. Por lo tanto, la aplicación fallará.

Enfoque 2: Esperando una devolución de llamada en un bucle while

En mi devolución de llamada de servicio, establezco una bandera de la siguiente manera:

val serviceCallback = object : ServiceConnection {

    override fun onServiceConnected(className: ComponentName, service: IBinder) {
        myBinder = service as MyService.LocalBinder
        isServiceBounded = true
    }

    override fun onServiceDisconnected(arg0: ComponentName) {
        isServiceBounded = false
        myBinder = null
    }
}

Luego, dentro de onResume, bloqueo la actividad hasta que la bandera es verdadera:

override fun onResume() {
    super.onResume()
    while(!isServiceBounded){
        //bloquear y esperar
    }
}

Problema: Tampoco funciona. La aplicación dejará de responder y fallará.

Enfoque 3: Usando funciones suspendidas y corutinas de Kotlin

Una función suspendida no continuará a menos que haya recibido un valor de retorno. Por lo tanto, puedo usarlo para esperar un evento. Entonces probé algo como esto:

override fun onStart() {
    super.onStart()
    CoroutineScope(Dispatchers.Main).launch {
        bindServiceAndWait(this@Activityname)
    }
}

suspend fun bindServiceAndWait(context: Context): Boolean{
    Intent(context, MyService::class.java).also { intent ->
        bindService(intent, serviceCallback, Context.BIND_AUTO_CREATE)
    }
    return isServiceBounded // Esta es la bandera de la devolución de llamada.
}

Problema: Esta función suspendida no espera realmente la devolución de llamada. Simplemente devuelve el valor actual de isServiceBounded.

Encontré una solución similar aquí, pero no entiendo del todo esta solución ya que tiene una devolución de llamada de servicio global (ServiceConnection), así como una local dentro de la función suspendida. Además, no entiendo cómo podría desvincular en este ejemplo proporcionado.

¿Cuál es la forma correcta de hacer esto?