runBlocking

runBlocking

eventLoop

runBlocking

StateFlow

val newStateFlow = originalStateFlow
        .map { it.doTransform() }
        .stateIn(scope = CoroutineScope(Job()), started = SharingStarted.Eagerly, initialValue = false)

CoroutineScope(<http://Dispatchers.IO|Dispatchers.IO>).launch {
    launch {
        println("A")
        delay(5000)
        println("B")
    }
    launch(context = Job()) {
        delay(1000)
        throw IOException()
    }
}

B

Job()

job.join()

delay(1300)

override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        viewModel.uiEvent
            .flowWithLifecycle(lifecycle, Lifecycle.State.STARTED)
            .onEach { event ->
                when (event) {
                    // code there
                }
            }.launchIn(lifecycleScope)
}

lifecycleScope

viewLifecycleOwner.lifecycleScope

launch

CoroutineScope

CompletableDeferred

suspendCancellableCoroutine

suspend fun processAll(items: List<Item>) = coroutineScope {
  val channel = Channel<Item>(Channel.UNLIMITED)
  items.forEach { channel.trySendBlocking(it).getOrThrow() }

   repeat(4) {
        launch {
            for (item in channel) // process
        }
    }
}

@Throws(
        CancellationException::class,
        UnauthorizedError::class
    )
    suspend fun login() {
        runBlocking {
            val fakeWaitingTime = 300L
            delay(fakeWaitingTime)
        }
    }

Task {
    try? await Auth().login()
}

Function doesn't have or inherit @Throws annotation and thus exception isn't propagated from Kotlin to Objective-C/Swift as NSError.
It is considered unexpected and unhandled instead. Program will be terminated.
Uncaught Kotlin exception: kotlin.native.IncorrectDereferenceException: illegal attempt to access non-shared

const val coroutines = "1.6.0-native-mt"

reservation

This variable is inaccessible because it isn't used after the last suspension point

1.6.0

allowBlockingCallsInside

tasks.withType<Test> {
    useJUnitPlatform()
    jvmArgs = listOf("-XX:+AllowRedefinitionToAddDeleteMethods", "-ea", "-Dkotlinx.coroutines.debug=on", "-Dkotlinx.coroutines.stacktrace.recovery=true")
}

Flow

Flow<T>

CoroutineContext

ThreadLocal

<dependency>
  <groupId>org.jetbrains.kotlinx</groupId>
  <artifactId>kotlinx-coroutines-nio</artifactId>
  <version>0.26.1-eap13</version>
</dependency>

suspend fun <T> ???(millis: Long, action: suspend () -> T): T {
    val start = System.currentMillis()
    val value = action()
    val end = System.currentMillis()
    val took = end - start
    if (took < millis) {
        delay(millis - took)
    }
    return value
}

flow.first { .. }

take(1)

flow.filter { … }

flow.first { .. }

public suspend fun saveAuthToken(authToken: String): Result<String, Throwable> {
    return runCatching {
      require(authToken.isNotEmpty()) { "authToken cannot be empty" }

      val authTokenKey = stringPreferencesKey(AUTH_TOKEN_KEY)
      // Use the external scope here to save the auth token
      externalScope
        .launch(ioDispatcher) { authDataStore.edit { store -> store[authTokenKey] = authToken } }
        .join()

      authToken
    }
  }

IO dispatcher

package kotlinx.coroutines

import kotlin.coroutines.*

public actual object Dispatchers {
    public actual val Default: CoroutineDispatcher = createDefaultDispatcher()
    public actual val Main: MainCoroutineDispatcher = JsMainDispatcher(Default, false)
    public actual val Unconfined: CoroutineDispatcher = kotlinx.coroutines.Unconfined
}

class Test {
    val continuation = Continuation<Unit>(EmptyCoroutineContext) {
    }

    suspend fun testFire() = suspendCoroutineUninterceptedOrReturn<Unit> { cont ->
        println(continuation)
        println(cont)
        println(continuation == cont)
    }
    fun testMain() {
        val action: suspend () -> (Unit) = {
            testFire()
        }
        action.startCoroutineUninterceptedOrReturn(continuation)
    }
}

CoroutineScope

private val mainThreadSurrogate = newSingleThreadContext("UI thread")

    @Before
    fun setUp() {
        Dispatchers.setMain(mainThreadSurrogate)
    }

    @After
    fun tearDown() {
        Dispatchers.resetMain() // reset the main dispatcher to the original Main dispatcher
        mainThreadSurrogate.close()
    }

    @Test
    fun testTest(): Unit = runBlocking {
        launch(Dispatchers.Main) {
            val recorder = FakeRecordingsHandler()
            val sut = SomeClass(recorder, this.coroutineContext)
            recorder.currentTrack = flow { emit(DEMO_TRACK) }
            val isCurrentTrack = sut.isCurrentTrack(DEMO_TRACK.id)
            assertTrue(isCurrentTrack)
        }
    }
//    class SomeClass(
//        private val recorder: RecordingsHandler,
//        override val coroutineContext: CoroutineContext
//    ) : VoiceRecorder, CoroutineScope {
//
//        private var currentTrackId: String? by mutableStateOf(null)
//
//        init {
//            launch {
//                recorder.currentTrack.distinctUntilChanged().collect { demoTrack ->
//                    currentTrackId = demoTrack?.id
//            }
//         }
//
//        override fun isCurrentTrack(id: String) = currentTrackId == id
//    }