java.lang.NegativeArraySizeException: -1537060379

at <http://io.ktor.utils.io|io.ktor.utils.io>.core.StringsKt.readBytes(Strings.kt:165)

at <http://io.ktor.utils.io|io.ktor.utils.io>.core.StringsKt.readBytes$default(Strings.kt:162)

at io.ktor.client.call.SavedCallKt.save(SavedCall.kt:73)

at io.ktor.client.call.SavedCallKt$save$1.invokeSuspend(SavedCall.kt)

at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)

at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:106)

at kotlinx.coroutines.internal.LimitedDispatcher.run(LimitedDispatcher.kt:39)

at kotlinx.coroutines.scheduling.TaskImpl.run(Tasks.kt:95)

at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:571)

at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:750)

at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:678)

at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:665)

GlobalScope

while(true) {
	yield() <--- In practise it seems yield emulates <http://Handler.post|Handler.post>
	emit(Unit)
}

private var running = true

scope.launch {
    flow {
        var counter = 0
        while (true) {
            Log.d("Default", "waiting...")
            while (running) {
                delay(200)
                emit(counter++)
            }
        }
    }
        .collect {
            Log.d("Default", "value=$it")
        }
}

fun pause() {
    running = false
}

fun resume() {
    running = true
}

running == false

coroutines-test:1.5

TestCoroutineScheduler

fun ProgressThingy(duration: Long, running: Flow<Boolean>): Flow<Float> {
    return callbackFlow {
        val animator = ValueAnimator.ofFloat(0F, 1F)
        animator.duration = duration
        animator.addUpdateListener {
            trySend(it.animatedFraction)
        }
        animator.addListener(onCancel = {
            cancel()
        })
        animator.start()

        running.collect {
            if (it) animator.resume() else animator.pause()
        }

        awaitClose {
            animator.cancel()
        }
    }
}

Flow#flatMapMerge

Flow

CancellationException

CoroutineScope

fun foo(){ // do something}
coroutineScope.launch{ foo }

suspend fun foo(){ // do something}
coroutineScope.launch{ foo }

CoroutineExceptionHandler

launch

1.6.1

CoroutineScope

fun main() {

    val coroutineExceptionHandler = CoroutineExceptionHandler { coroutineContext, exception ->
        println("Handle $exception in CoroutineExceptionHandler")
    }

    val topLevelScope = CoroutineScope(Job())

    topLevelScope.launch {
        launch(coroutineExceptionHandler) {
            throw RuntimeException("RuntimeException in nested coroutine")
        }
    }

    Thread.sleep(100)
}

fun CoroutineScope.launchIO(block: suspend CoroutineScope.() -> Unit): Job {
    return launch(
        context = IO,
        start = CoroutineStart.DEFAULT,
        block = block
    )
}

java.lang.NoSuchMethodError: 'kotlinx.coroutines.Job com.some.misc.ExtensionsKt.launchIO(kotlinx.coroutines.CoroutineScope, kotlin.jvm.functions.Function2)'

suspend fun sendAndWait(message: Message): Message = withTimeout(5000) {
  launch {
    send(message)
  }
  // 'incoming' is a Flow<Message>
  incoming.first { /* logic here which matches outbound messages with inbound ones by some matching id */ }
}

send(message)

incoming.first { }

withTimeout

CoroutineScope

kotlinx-coroutines-test:1.6.1

CoroutineScope(Job() + testScheduler)

CoroutineScope(Job() + coroutineContext)

differentScope

TestScope

fun tickTest() = runTest {
        val differentScope = CoroutineScope(Job() + testScheduler)

        val ticks = mutableListOf<Int>()

        val tickJob = differentScope.launch {
            var time = 0
            while (true) {
                delay(1_000)
                ticks.add(++time)
            }
        }

        advanceTimeBy(5_001)

        tickJob.cancel()

        println(ticks)
        assert(ticks.size == 5)
    }

fun doThing() {
  viewModelScope.launch {
    repository.getDocument()
...

suspend fun getDocument() {
  return FirebaseFirestore.getInstance()
      .collection("mycollec")
      .document("mydoc")
      .get()
      .await()
      .toObject<MyDoc>()
}

runBlocking {
        val error = IllegalAccessException("Bad things are happening!")
        val message = "Isn't it a nice day"
        Span.current()?.let { span ->
            val attributes = Attributes.builder().apply {
                message?.let { put("error_message", it) }
            }
                .build()

            span.setStatus(StatusCode.ERROR)
            span.recordException(throwable, attributes)
        }
        
        launch { 
            // This will cause the spans to get linked together and then sync metadata from the above. 
            @WithSpan
            suspendFunction()
        }
    }

viewModelScope.launch {
  repository.getBooks().collect { list ->
    state.books.clear()
    state.books.addAll(list)
  }

  repository.doSomething() <--- Will never get called
}

firstFlow.combine(secondFlow) { text: String, role: Role ->
            repository.getProcessList(role.apiParam, text)//returns new flow each time
        }.flatMapLatest {
            it
        }

isActive

isActive