Useful Coroutine patterns for Android applications @ErikHellman - github.com/ErikHellman - hellsoft.se https://speakerdeck.com/erikhellman 

Kotlin Coroutines are light-weight threads! 

Coroutines ARE light! import kotlinx.coroutines.* fun main() = runBlocking { repeat(100_000) { -/ launch a lot of coroutines GlobalScope.launch { delay(1000L) print(".") } } } 

Structured Concurrency 

“Coroutines are always related to some local scope in your application, which is an entity with a limited life-time, like a UI element.” - Structured concurrency by Roman Elizarov https://medium.com/@elizarov/structured-concurrency-722d765aa952 

Legacy - don’t do this! suspend fun loadAndCombine(name1: String, name2: String): Image { val deferred1 = async { loadImage(name1) } val deferred2 = async { loadImage(name2) } return combineImages(deferred1.await(), deferred2.await()) } 

Launch coroutines in a CoroutineScope suspend fun loadAndCombine(name1: String, name2: String): Image = coroutineScope { val deferred1 = async { loadImage(name1) } val deferred2 = async { loadImage(name2) } combineImages(deferred1.await(), deferred2.await()) } 

CoroutineScope interface public interface CoroutineScope { public val coroutineContext: CoroutineContext } 

CoroutineScope.launch() public fun CoroutineScope.launch( context: CoroutineContext = EmptyCoroutineContext, start: CoroutineStart = CoroutineStart.DEFAULT, block: suspend CoroutineScope.() -> Unit ): Job { val newContext = newCoroutineContext(context) val coroutine = if (start.isLazy) LazyStandaloneCoroutine(newContext, block) else StandaloneCoroutine(newContext, active = true) coroutine.start(start, coroutine, block) return coroutine } 

CoroutineScope.cancel() fun cancelScope(scope: CoroutineScope) { repeat(100_000) { scope.launch { delay(1000L) print(".") } } Thread.sleep(100) scope.cancel() } 

Android lifecycles (Activity & Fragment) 

When to cancel? 

Android Jetpack to the rescue! 

AndroidX Lifecycle KTX library dependencies { def lifecycle_version = "2.2.0" implementation "androidx.lifecycle:lifecycle-runtime-ktx:$lifecycle_version" implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version" implementation "androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version" } 

AndroidX Lifecycle KTX library val Lifecycle.coroutineScope: LifecycleCoroutineScope get() { while (true) { val existing = mInternalScopeRef.get() as LifecycleCoroutineScopeImpl? if (existing -= null) { return existing } val newScope = LifecycleCoroutineScopeImpl( this, kotlinx.coroutines.SupervisorJob() + kotlinx.coroutines.Dispatchers.Main.immediate ) if (mInternalScopeRef.compareAndSet(null, newScope)) { newScope.register() return newScope } } } 

AndroidX Lifecycle KTX library val LifecycleOwner.lifecycleScope: LifecycleCoroutineScope get() = lifecycle.coroutineScope 

Lifecycle scoped coroutine override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.login_form) val loginButton = findViewById(R.id.loginButton) loginButton.setOnClickListener { lifecycleScope.launch { val username = … val password = … doLogin(username, password) } } } 

Lifecycle scoped coroutine class MyViewModel(val authRepository: AuthRepository) : ViewModel() { fun doLogin(username: String, password: String) { viewModelScope.launch { authRepository.login(username, password) } } } 

Use Lifecycle KTX for Coroutines on Android! 

Where should you call launch? LoginFragment MainActivity AuthViewModel AuthRepository Longer lifecycle suspend fun login( username: String, password: String ) 

Where should you call launch? It Depends! 

launch() vs async() 

Login example class LoginApi { suspend fun login(username: String, password: String): AuthResult { -/ Call Login API and return AuthResult } } 

Login example - launch() class LoginFragment : Fragment() { lateinit var loginApi: LoginApi fun performLogin(username: String, password: String) { lifecycleScope.launch { val authResult = loginApi.login(username, password) if (authResult.isAuthenticated) { -/ Login ok! } else { -/ Login failed! } } } } 

Login example - async() fun performLogin(username: String, password: String) { val deferredResult = lifecycleScope.async { loginApi.login(username, password) } lifecycleScope.launch { val result = deferredResult.await() -/ Handle login result } } 

async() or launch()? It Depends! 

How about event streams? 

Instant Search 

Instant Search events SearchFragment SearchViewModel SearchRepository Search API Search query events Search result events 

Search Repository class SearchRepository { suspend fun performSearch(query: String): List { -/ Call online Search API here } } 

SearchViewModel class SearchViewModel : ViewModel() { val queryChannel = ConflatedBroadcastChannel() val searchResult = queryChannel .asFlow() .debounce(SEARCH_DELAY_MS) .mapLatest { searchApi.performSearch(it) } .asLiveData() } Equivalent to BehaviorSubject in RxJava Lifecycle KTX extension function! 

SearchActivity class SearchActivity : AppCompatActivity() { -/ Adapter for RecycleView displaying search result val searchAdapter = SearchAdapter() val viewModel: SearchViewModel by viewModels() -/ Setup the EditText for instant search fun setupSearchField(searchText: EditText) { searchText.doAfterTextChanged { editable -> viewModel.queryChannel.offer(editable.toString()) } } -/ Listen for search results fun handleSearchResult() { viewModel.searchResult.observe(this, searchAdapter-:submitList) } } 

Coroutine Channels - offer() fun testChannels(channel: Channel) { if (channel.offer(1)) { if (channel.offer(2)) { if (channel.offer(3)) { println("Sent three numbers!") } } } } 

Coroutine Channels - send() suspend fun testChannels(channel: Channel) { channel.send(1) channel.send(2) channel.send(3) println("Sent three numbers!") } 

Instant Search events SearchFragment SearchViewModel SearchRepository Search API Pass events down using a Channel Use Flow for events coming up Convert Flow to LiveData for simplicity! 

Coroutine Channel + Flow for events! 

What about error handling? 

Sealed classes to the rescue! sealed class SearchResult class ValidResult(val result: List) : SearchResult() object EmptyResult : SearchResult() object EmptyQuery : SearchResult() class ErrorResult(val e: IOException) : SearchResult() class TerminalError(val t: Throwable) : SearchResult() 

Sealed classes to the rescue! .mapLatest { try { if (it.length > 2) { val searchResult = searchApi.performSearch(it) if (searchResult.isNotEmpty()) { ValidResult(searchResult) } else { EmptyResult } } else { EmptyQuery } } catch (e: IOException) { ErrorResult(e) } } .catch { emit(TerminalError(it)) } 

Sealed classes to the rescue! fun handleSearchResult() { viewModel.searchResult.observe(this, this-:showSearchResult) } fun showSearchResult(searchResult: SearchResult) { when (searchResult) { is ValidResult -> displayResult(searchResult) is ErrorResult -> showErrorMessage(searchResult) is EmptyResult -> showNoResultMessage() is EmptyQuery -> showEmptyQueryWarning() is TerminalError -> showTerminalError(searchResult) } } 

Use sealed classes to handle results and errors! 

Instant Search Demo ● Blog post: ○ www.hellsoft.se/instant-search-with-kotlin-coroutines ● Source code for sample: ○ github.com/ErikHellman/InstantSearchDemo 

Thank you for listening!