async

withContext(<http://Dispatches.IO|Dispatches.IO>)

fun <T> CoroutineScope.myRestTemplateAsync(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> T
): Deferred<T> {
    return async(context, start) {
        withContext(<http://Dispatchers.IO|Dispatchers.IO>) { block() }
    }
}

Flow<State>

Channel<Event>

Flow.debounce

runBlockingTest

class DebounceTest(scope: CoroutineScope) {
    private val stateFlow = MutableStateFlow("")
    val resultFlow = MutableStateFlow("")

    init {
        stateFlow.debounce(500)
            .onEach {
                resultFlow.value = it
            }
            .launchIn(scope)
    }

    fun search(text: String){
        stateFlow.value = text
    }
}

@Test
    fun debounceTest() = runBlockingTest {
        val sut = DebounceTest(this)
        sut.search("test")
        assertThat(sut.resultFlow.value).isEqualTo("test")
    }

resultFlow.value

test

runBlockingTest {
  val mutex = Mutex(true)
  val mockedApi = mock<MyApi> {
    onBlocking { invoke() } doSuspendableAnswer {
      mutex.withLock {
        // wait unlock to run
      }
    }
  }
  val sut = MyTestedClass(
    api = mockedApi,
  )

  println("async callA"}
  val callA = async { sut.doCall() }
  println("async callB"}
  val callB = async { sut.doCall() }

  mutex.unlock()
  // ....
}

async callA

async callB

MyTestedClass

class MyTestedClass(private val api: MyApi) {
  fun doCall() { // this is NOT suspendable
    runBlocking {
      api() // but this is suspendable
    }
  }
}

doSomething

suspend fun doSomething() {
    suspendingFun1()
    suspendingFun2()
    suspendingFun3()
  }

suspend fun main() {
    flow {
        flowOf(1).collectLatest { emit(it) }
    }.collect { println(it) }
}

IllegalStateException: Flow invariant is violated

with(GlobalScope){ launch{} }

GlobalScope.launch{}

with()

GlobalScope

api

object

android.os.NetworkOnMainThreadException

at android.os.StrictMode$AndroidBlockGuardPolicy.onNetwork(StrictMode.java:1605)

private fun setupLogout() {
    logoutButton.setOnClickListener {
        LoginHelper.logout()
    }
}
fun logout() {
    logD("logout")
    deleteSession()
    .... more function
} 
private fun deleteSession() {
    runBlocking {
        Tokenclass.getToken()?.let {
            logE("token ::-> $it")
            apiCall.deleteSession(it).execute()
        }
    }
}

interface MyDispatchers {
  val main: CoroutineDispatcher
  val io: CoroutineDispatcher
  val computation: CoroutineDispatcher
  val unconfined: CoroutineDispatcher
}

Dispatchers.*

Dispatchers.*

Dispatchers.*

expensiveLookup

suspend fun expensiveLookup(id: String): ExpensiveResult {
  val cached = cache.get(id)
  if (cache != null) {
    return cached
  }

  val result = // logic here
  
  cache.put(id, result)
  return result
}

coroutineScope.launch {
   // some work 
}

coroutineScope.launch {
   // some other work 
}

// Some work

suspend

java.lang.IllegalArgumentException: userUUID must not be empty

coroutineScope.coroutineContext.cancelChildren

coroutineScope.cancel