Flow

someSuspendHttpRequestWithKtor

map

suspend fun someCRUDMethod(models: List<MyModel>) {
    val myModels = coroutineScope {
        async {
            models.map { myAPI.someSuspendHttpRequestWithKtor(it.id) }
        }
    }
    val myListOfModels = myModels.await()
    ....
}

class TestExample {

    class Example {
        var counter: Int = 0

        fun startCounter() {
            val coroutineScope = CoroutineScope(Dispatchers.Unconfined)

            coroutineScope.launch {
                while (counter <= 100) {
                    counter += 1
                    delay(100)
                }
            }
        }
    }

    @Test
    fun `test 1`() = runBlockingTest {
        val example = Example()
        example.startCounter()
        Assert.assertEquals(1, example.counter)
        advanceTimeBy(150)    // fails
        // Thread.sleep(150) // works
        Assert.assertEquals(2, example.counter)
    }
}

Retrofit 2.6.0

liveData

viewModelScope

val testLangLiveData : LiveData<String?> = liveData {
        viewModelScope.launch {
            try {
                emit(repository.getUser().data.attributes?.locale)
            } catch (e: Exception) {

            }
        }
    }

every function that is declared as extension on CoroutineScope returns immediately, but performs its actions concurrently with the rest of the program.

suspend fun

CoroutineScope.foo

CoroutineScope

"kotlinx.coroutines.channels.ClosedSendChannelException: Channel was closed"

SendChannel.send

produce

SendChannel.offer

false

TestObserver

Flow

java.util.concurrent

fun updateUserLang(user: UpdateUser) {
        viewModelScope.launch {
            try {

                val lang = repository.updateUser(user).data.attributes!!.locale

                _networkCallSuccess.postValue(Pair(lang!!, true))

            } catch (e: HttpException) {
                println("error: ${e.localizedMessage}")
            }
        }
    }

val trace = Thread.currentThread().stackTrace
    val handler = CoroutineExceptionHandler { _, throwable ->
        throwable.stackTrace += trace
        result(Result.failure(throwable))
    }

viewModelScope.launch{}

fun button1Clicked() {
GlobalScope.launch {
Toast.makeText(this@MainActivity, doSomethingLong(), Toast.LENGTH_LONG).show()
}
Toast.makeText(this@MainActivity, "Hello", Toast.LENGTH_LONG).show()
}

suspend fun doSomethingLong(): String =
withContext(Dispatchers.Default) {
delay(3000)
return@withContext "World"
}

try {
    coroutineScope {
        next()
    }
} catch (e: Exception) {
    if(e !is CancellationException) {
        onCancelled()
    }
    else {
        onFailure()
    }
}

fun <T> List<Flow<T>>.join() = channelFlow {
    for (flow in this@join) {
        launch { flow.collect {
            send(it)
        }}
    }
}

.offer(item)

false

<http://Dispatchers.IO|Dispatchers.IO>

Dispatchers.Default

.Default