private val categoryFilter = BrowseEventsFilter.CategoryFilter(category = MutableStateFlow(Category.All))
private val locationFilter = BrowseEventsFilter.LocationFilter(location = MutableStateFlow(null))
private val periodFilter = BrowseEventsFilter.PeriodFilter(
    period = MutableStateFlow(Period.Any),
    dateRange = MutableStateFlow(null)
)

var filtersState = MutableStateFlow(listOf(locationFilter, periodFilter, categoryFilter)) // collectAsState in the activity

// how they change
filterState?.enabled?.value = ChipStatus.ENABLED
filterState?.period?.value = period
filterState?.dateRange?.value = null

flowOf(periodFilter.period?.value,
    periodFilter.dateRange?.value,
    categoryFilter.category.value,
    locationFilter.location.value
).collect {

// do something everytime their values change
}

0  libsystem_kernel.dylib  ___pthread_kill
1  libsystem_pthread.dylib _pthread_kill
2  libsystem_c.dylib       _abort
3  BaseBetaiOS             konan::abort() (BaseBetaiOS)
4  BaseBetaiOS             (anonymous namespace)::terminateWithUnhandledException(ObjHeader*)::$_1::operator()() const (BaseBetaiOS)
5  BaseBetaiOS             void (anonymous namespace)::$_0::operator()<(anonymous namespace)::terminateWithUnhandledException(ObjHeader*)::$_1>((anonymous namespace)::terminateWithUnhandledException(ObjHeader*)::$_1) (BaseBetaiOS)
6  BaseBetaiOS             (anonymous namespace)::terminateWithUnhandledException(ObjHeader*) (BaseBetaiOS)
7  BaseBetaiOS             (anonymous namespace)::processUnhandledException(ObjHeader*) (BaseBetaiOS)
8  BaseBetaiOS             kfun:kotlinx.coroutines#handleCoroutineException(kotlin.coroutines.CoroutineContext;kotlin.Throwable){} (BaseBetaiOS)
9  BaseBetaiOS             kfun:kotlinx.coroutines.StandaloneCoroutine.handleJobException#internal (BaseBetaiOS)
10 BaseBetaiOS             kfun:kotlinx.coroutines.JobSupport.finalizeFinishingState#internal (BaseBetaiOS)
11 BaseBetaiOS             kfun:kotlinx.coroutines.JobSupport.tryMakeCompleting#internal (BaseBetaiOS)
12 BaseBetaiOS             kfun:kotlinx.coroutines.JobSupport#makeCompletingOnce(kotlin.Any?){}kotlin.Any? (BaseBetaiOS)
13 BaseBetaiOS             kfun:kotlinx.coroutines.AbstractCoroutine#resumeWith(kotlin.Result<1:0>){} (BaseBetaiOS)
14 BaseBetaiOS             kfun:kotlin.coroutines.native.internal.BaseContinuationImpl#resumeWith(kotlin.Result<kotlin.Any?>){} (BaseBetaiOS)
15 BaseBetaiOS             kfun:kotlinx.coroutines.DispatchedTask#run(){} (BaseBetaiOS)
16 BaseBetaiOS             kfun:kotlinx.coroutines.DarwinGlobalQueueDispatcher.$dispatch$lambda$0$FUNCTION_REFERENCE$693.$<bridge-UNN>invoke(){}#internal (BaseBetaiOS)
17 BaseBetaiOS             ___6f72672e6a6574627261696e732e6b6f746c696e783a6b6f746c696e782d636f726f7574696e65732d636f7265_knbridge762_block_invoke (BaseBetaiOS)
18 libdispatch.dylib       __dispatch_call_block_and_release
19 libdispatch.dylib       __dispatch_client_callout
20 libdispatch.dylib       __dispatch_root_queue_drain
21 libdispatch.dylib       __dispatch_worker_thread2
22 libsystem_pthread.dylib __pthread_wqthread

Executors.newFixedThreadPool(8)

fun addItem(item: String) {
    viewModelScope.launch {
        repository.saveDataInRoom(item)
        interactor.sendNotification(item)
        interactor2.updateWidget(item)
    }
}

saveDataInRoom()

ViewModel#onCleared()

@Test
    fun shouldExecuteOnDifferentThreads() {
        runBlocking {
            // Some blocking DB operation
            val firstThread = withContext(<http://Dispatchers.IO|Dispatchers.IO>) {
                Thread.currentThread()
            }

            // Another blocking DB operation
            val secondThread = withContext(<http://Dispatchers.IO|Dispatchers.IO>) {
                Thread.currentThread()
            }
            assertThat(firstThread).isNotSameAs(secondThread)
        }
    }

suspend fun loadData(
    scope: CoroutineScope,
    state: MutableStateFlow<ViewState>,
) {
    state.update {
        it.copy(
            data1 = it.data1.copy(status = AsyncDataStatus.LOADING),
            data2 = it.data2.copy(status = AsyncDataStatus.LOADING),
            data3 = it.data3.copy(status = AsyncDataStatus.LOADING),
        )
    }

    scope.launch { loadData1FromRepository(state) }
    scope.launch { loadData2FromRepository(state) }
    scope.launch { loadData3FromRepository(state) }
}

private suspend fun loadData1(
    state: MutableStateFlow<ViewState>
) = loadData1FromRepository().collect { result ->                // this is a flow of 2 either values coming from a database and network
    state.update { it.copy(data1 = newAsyncValue(result)) }
}

state.test {
    val loading = awaitItem()
    assertEquals(
        expected = initial.copy(
            data1 = initial.data1.copy(status = AsyncDataStatus.LOADING),
            data2 = initial.data2.copy(status = AsyncDataStatus.LOADING),
            data3 = initial.data3.copy(status = AsyncDataStatus.LOADING),
        ),
        actual = loading,
    ) // this passes correctly

    val data1Loaded = awaitItem()
    assertEquals(
        expected = loading.copy(
            data1 = initial.data1.copy(
                status = AsyncDataStatus.SUCCESS,
                data = someData1,
            ),
        ),
        actual = data1Loaded,
    ) // here I get the time out

currentCoroutineContext()

suspend

suspend

StateFlow

try

kotlinx-coroutines-test

runTest()

runTest()

runtTest()

native suspend fun

COROUTINE_SUSPENDED

resumeWith

suspend fun main(): Unit = coroutineScope {

    val sharedFlow = MutableSharedFlow<Int>()

    launch {
        sharedFlow
            .collect {
            println("Process $it")
            delay(1000)
            println("$it processed")
        }
    }

    launch {
        // 1 should be processed
        sharedFlow.emit(1)
        println("sharedFlow emits 1")

        // 2 should not be processed since downstream is busy
        sharedFlow.emit(2)
        println("sharedFlow emits 2")

        // 3 should be processed again
        delay(2000)
        sharedFlow.emit(3)
        println("sharedFlow emits 3")
    }
}

open class WrapperFlow {
    private val hotFlow = MutableSharedFlow<Int>()

    fun getFlow(): Flow<Int> = hotFlow

    @Transactional
    open suspend fun emit() {
        hotFlow.emit(10)
    }
}

suspend fun main() = coroutineScope {
    println("hi")
    val wrapperFlow = WrapperFlow()
    val job1 = launch {
        wrapperFlow.getFlow().collect {
            println("job1: $it")
        }
    }
    wrapperFlow.emit() // does not print job1: $it
    job1.cancelAndJoin()
}

Job

fun allJobs(): Job {
  val job1: Job
  val job2: Job
  val job3: Job
  return combine(job1, job2, job3) // HOW?
}

fun main() {
  allJobs().cancel() // cancels all 3 jobs
}

val flow: StateFlow<T>

protected abstract suspend fun initialState(): T

MutableSharedFlow<T>(replay = 1)

StateFlow

val flow: StateFlow<T> get() = backingFlow.onStart { emit(initialState()) }.stateIn(someScope)

stateIn(someScope)

try catch

CancellationException

val executor = Executors.singleThreadExecutor()

fun oneAtATime(workToDo: Boop) {
   return executor.submit {
      doSomethingWIthThe(workToDo)
   }.get()
}

oneAtATime(...)

Channel

receive*

delay

beginsAt: Timestamp

timer

combine(meetings, timer, ::combiner)

timer

timer

val uiState by viewModel.uiState.collectAsStateWithLifecycle()