asCoroutineDispatcher()

debounce

Flow

delay

debounce

lifecycleScope.launch {
                viewModel.playedTracks.collectLatest { pagingData: PagingData<TrackListItem> ->
                                       playedTracksAdapter.submitData(pagingData)
                                 }
}

var playedTracks: Flow<PagingData<TrackListItem>>

init {
    playedTracks = Pager(PagingConfig(pageSize = 20)) { PlayedTracksPagingSource(playedTracksRepository, epochAsZonedDateTime.value!!) }.flow
}

kotlinx.coroutines

1.4.1

SharedFlow

MDCCOntext

launch

flow {}

flowOn

init {
  GlobalScope.launch (<http://Dispatchers.IO|Dispatchers.IO>) {
    val logger = LoggerFactory.getLogger(javaClass)
    var exceptionsCounter = 0
    while (true) {
      delay(DELAY_IN_MS_BETWEEN_FLAGS_CHECKS)
      try {
        getFlags()
            .onEach {
              featureFlagsStatusGauge.labels(it.key).set(if (it.value) 1.0 else 0.0)
            }
        exceptionsCounter = 0
      } catch (e: Exception) {
        exceptionsCounter++
        if (exceptionsCounter > 6) logger.warn("Got exception while trying to update feature flags status for $exceptionsCounter times", e)
      }
    }
  }

private val mutableEvents = MutableSharedFlow<Event>()
    val events: SharedFlow<Event>
        get() = mutableEvents.asSharedFlow().onSubscription {
            if (something()) {
                emit(Event())
            }
        }

Flow

SharingStarted

data

delegates

suspend

completionHandler

val viewState: Flow<iewState> = viewState()
        .shareIn(viewModelScope, SharingStarted.Eagerly, 1)
        .onSubscription {
            optionallyTriggerActionAfterDelay()
        }

private suspend fun optionallyTriggerActionAfterDelay() {
    if (valueIsTrue) {
        delay(5000)
        triggerAction()
    }
}

private suspend fun optionallyTriggerActionAfterDelay() = coroutineScope {
    launch {
        if (valueIsTrue) {
            delay(5000)
            triggerAction()
        }
    }
}

viewModelScope.launch {
    if (valueIsTrue) {
        delay(5000)
        triggerAction()
    }
}

// Run multiple async tasks and combine them and enit as one flow
val finalFlow: Flow<SomeType> = flow{
    supervisorScope {
        val firstAsyncAction = async { firstAsyncActionFlow }
        val secondAsyncAction = async { secondAsyncActionFlow }
        val thirdAsyncAction = async { thirdAsyncActionFlow }

        emitAll(
            awaitAll(
                firstAsyncAction,
                secondAsyncAction,
                thirdAsyncAction
            ).merge()    
        )
    }
}

finalFlow.collect {
    // This runs multiple times discarding the previously sent items from the flow
}

val now: Flow<ZonedDateTime> = MutableStateFlow(clock.now()).transform {
    while (true) {
      emit(clock.now())
      delay(5.seconds)
    }
  }

transform()

MutableStateFlow

Dispatchers.DEFAULT

Dispatchers.Default

StackOverflowError

Job.toString

SharingStarted

fun

File(resource).useLines

1.4.2

StateFlow

SharedFlow