refCount

Flow<List<T>>

Flow<T>

flatten

offer

catch

val (firstImageBlobName, firstImageThumbnailBlobName, secondImageBlobName, secondImageThumbnailBlobName) = try {
    coroutineScope {
        AsyncImageUploads(
            firstImageBlobName = async {
                fileServiceInterface.uploadImage(
                    ...
                )
            },
            firstImageThumbnailBlobName = async {
                fileServiceInterface.uploadImage(
                    ...
                )
            },
            secondImageBlobName = async {
                fileServiceInterface.uploadImage(
                    ...
                )
            },
            secondImageThumbnailBlobName = async {
                fileServiceInterface.uploadImage(
                    ...
                )
            }
        )
    }
} catch (e: Exception) {
    ....
}

repository.save(
    model.copy(
        firstImage = firstImageRepository.save(
            FirstImage(
                imageURL = firstImageBlobName.await(),
                thumbnailURL = firstImageThumbnailBlobName.await(),
                model = model
            )
        ),
        secondImage = secondImageRepository.save(
            SecondImage(
                imageUrl = secondImageBlobName.await(),
                thumbnailUrl = secondImageThumbnailBlobName.await(),
                model = model
            )
        )
    )
)

BroadcastChannel

Flow

navigate

PublishSubject

navigate

firstOrNull()

import io.kotest.matchers.shouldBe
import kotlinx.coroutines.channels.BroadcastChannel
import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.flow.asFlow
import kotlinx.coroutines.flow.firstOrNull
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking
import org.junit.jupiter.api.Test

class RetainStateTest {

    val navigateChannel = BroadcastChannel<List<String>>(Channel.BUFFERED)
    val navigate = navigateChannel.asFlow()

    val data = listOf("blah", "foo")

    @Test
    fun `should not retain state`() {
        runBlocking {
            val jobPrecondition = launch {
                navigate.firstOrNull() shouldBe data
            }
            navigateChannel.send(data)
            jobPrecondition.join()

            val job = launch {
                navigate.firstOrNull() shouldBe null
            }
            job.join()
        }
    }
}

StateFlow

SharedFlow

SendChannel.offer should never throw

-native-mt

mutableSharedFlow.asSharedFlow()

mutableSharedFlow as SharedFlow

onEach

MutableStateFlow

MutableStateFlow

SavedStateHandle.getLiveData(key: String)

fun <T> SavedStateHandle.getStateFlow(key: String, defaultValue: T): MutableStateFlow<T> {
    return MutableStateFlow(this[key] ?: defaultValue).onEach {
        this[key] = it
    }
}

onEach

Flow

BroadcastChannel

emit(...)

events.offer(...)

viewModelScope.launch {
    events.emit(...)
}

inline class A(val value: String)

fun main() {
    runBlocking {
        val aFlow = flowOf(A("Hello"))
        combine(aFlow, aFlow) { a, b ->
            a to b
        }.toList()
    }
}

while

first()

override fun onCreateOptionsMenu(menu: Menu, inflater: MenuInflater) {
    
    [...]
    
    viewLifecycleOwner.lifecycleScope.launch {
        menu.findItem(R.id.action_hide_completed_tasks).isChecked =
            viewModel.preferencesFlow.first().hideCompleted
    }
}

flow {
val resultService = service.getWhatever()
val mapStuff = resultService.mapper() <-- it throws NullPointer
emit(mapStuff)
}

usecase.execute(2)
.catch{do something}
.collect{expectedStuff}

.catch

PublishSubject.create<T>()

MutableSharedFlow<T>(replay = 0, extraBufferCapacity = 1)

MutableSharedFlow<T>()

@ApplicationScope
@Provides
@Singleton
fun provideApplicationScope() = CoroutineScope(SupervisorJob())

implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.4.0-M1")

class DeleteAllCompletedViewModel @ViewModelInject constructor(
    private val taskDao: TaskDao,
    @ApplicationScope private val applicationScope: CoroutineScope
) :
    ViewModel() {

    fun deleteCompletedTasks() = applicationScope.launch {
        taskDao.deleteCompletedTasks()
    }
}

CompletionStage

CompletionStage

val person = cache.getAsync(id).await()
return if (person == null) repository.findById(id)
else person

@Module
@InstallIn(ApplicationComponent::class)
object AppModule {
    private lateinit var database: TaskDatabase

    @Provides
    @Singleton
    fun provideDatabase(
        app: Application,
        @ApplicationScope applicationScope: CoroutineScope
    ): TaskDatabase {
        database = Room.databaseBuilder(app, TaskDatabase::class.java, "task_database")
            .fallbackToDestructiveMigration()
            .addCallback(object : RoomDatabase.Callback() {
                override fun onCreate(db: SupportSQLiteDatabase) {
                    super.onCreate(db)
                    val dao = database.taskDao()

                    applicationScope.launch {
                        dao.insert(Task("Wash the dishes"))
                        dao.insert(Task("Do the laundry"))
                        dao.insert(Task("Buy groceries"))
                        dao.insert(Task("Call mom"))
                    }
                }
            })
            .build()
        return database
    }

    @Provides
    @Singleton
    fun provideTaskDao(db: TaskDatabase) = db.taskDao()

    @ApplicationScope
    @Provides
    @Singleton
    fun provideApplicationScope() = CoroutineScope(SupervisorJob())
}

@Retention(AnnotationRetention.BINARY)
@Qualifier
annotation class ApplicationScope