Как запустить несколько сопрограмм Kotlin параллельно и дождаться их завершения, прежде чем продолжить

Я бы предложил реализовать getInfo как функцию приостановки, которая знает контекст, в котором она должна работать. Таким образом, не имеет значения, из какого контекста вы его вызываете (*).

Кроме того, я бы не стал использовать обратные вызовы для продолжения после этого. Вы можете просто решить, что getInfo() вернет, как действовать (**).

На самом деле это самое лучшее в сопрограммах: вы можете превратить код, основанный на обратном вызове, в код, который читается как последовательный код.

Поскольку вам не важен результат getOne() и getTwo(), использование launch - правильный путь. Он возвращает Job. Вы можете приостановить сопрограмму до тех пор, пока обе функции не закончат работу с joinAll(), которая может быть вызвана на Collection<Job>.

suspend fun getInfo() = withContext(Dispatchers.IO) {
    try {
        listOf(
            launch { getOne() },
            launch { getTwo() }
        ).joinAll()
        false
    } catch (e: Throwable) {
        true
    }
}

Вам не нужно использовать GlobalScope, просто создайте свой (***).

Я использовал Default в качестве контекста для запуска getInfo, но любой другой контекст тоже подойдет, так как getInfo будет работать в том, что должен.

val newScope = CoroutineScope(Dispatchers.Default).launch {
    val error = getInfo()
    if(error) {
        onSuccess()
    } else {
        onError()
    }
}
// "newScope" can be cancelled any time

_{* На случай, если я использовал Dispatcher.IO, чтобы представить, что две функции выполняют какую-то длительную работу ввода-вывода.}

_{** Здесь я использовал простое логическое значение, но, конечно, вы можете вернуть что-нибудь более значимое.}

_{*** или подключитесь к некоторой области, заданной фреймворком sourrouding, который учитывает жизненный цикл}

Вы можете использовать любой прицел, какой захотите. Это не влияет на ваш вопрос. GlobalScope не приветствуется, потому что он не инкапсулирует ваши задачи.

Какую область действия на самом деле использовать для запуска вашей сопрограммы, будет полностью зависеть от контекста того, что вы делаете, и от того, какую стратегию инкапсуляции вы используете.

Чтобы запустить несколько сопрограмм одновременно и дождаться их всех, вы используете async и await(). Вы можете использовать awaitAll() в их списке, если вам просто нужно закончить их все, прежде чем продолжить.

Кажется странным, что вы используете диспетчер ввода-вывода для выполнения своих обратных вызовов, но я оставлю это, потому что я слеп к контексту вашего кода.

fun getInfo(onSuccess: () -> Unit, onError: () -> Unit) {
        GlobalScope.launch(Dispatchers.IO) {
            try {
                coroutineScope {
                    listOf(
                        async { getOne() }
                        async { getTwo() }
                    }.awaitAll()
                }
                onSuccess.invoke()
            } catch (e: Throwable) {
                onError.invoke()
            }
        }
    }

Вы можете создать CoroutineScope внутри класса, над которым вы работаете, и построить сопрограммы, просто вызвав launch builder. Что-то вроде этого:

class MyClass: CoroutineScope by CoroutineScope(Dispatchers.IO) { // or [by MainScope()]

    fun getInfo(onSuccess: () -> Unit, onError: () -> Unit) {
        launch {
            try {
                val jobA = launch { getOne() }
                val jobB = launch { getTwo() }
                joinAll(jobA, jobB)
                onSuccess.invoke()
            } catch (e: Throwable) {
                onError.invoke()
            }
        }
    }

    fun clear() { // Call this method properly
        this.cancel()
    }

}

Обязательно отмените любую сопрограмму, работающую в области видимости, правильно вызвав cancel.

Или, если вы работаете внутри ViewModel, просто используйте вместо этого viewModelScope.

На самом деле есть даже лучший способ, основанный на принятом ответе:

suspend fun getInfo() = withContext(Dispatchers.IO) {
try {
    coroutineScope {
        launch { getOne() }
        launch { getTwo() }
    }
    false
} catch (e: Throwable) {
    true
}

}