Android Dev Summit 2019 extended Seoul LiveData with Coroutines and Flow ੉਋୸ kakaopay 

dependencies { implementation knowledgebase('Android Architecture Component') // LiveData, ViewModel implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.1.0' // viewModelScope implementation 'androidx.lifecycle:lifecycle-runtime-ktx:2.2.0-rc03' // lifecycleScope implementation 'androidx.lifecycle:lifecycle-livedata-ktx:2.2.0-rc03' // liveData coroutine builder = CoroutineLiveData // Flow ... Summary 

Layered architecture 

Android Dev Summit 2019 extended Seoul Layered architecture View ViewModel LiveData Repository suspend fun DataSource suspend fun UseCase suspend fun Presentation Domain Data 

Android Dev Summit 2019 extended Seoul LiveData View ViewModel LiveData UseCase suspend fun Repository suspend fun DataSource suspend fun 

Android Dev Summit 2019 extended Seoul DataSource suspend fun Coroutine View ViewModel LiveData UseCase suspend fun Repository suspend fun 

Android Dev Summit 2019 extended Seoul 

Launching coroutines 

class MyViewModel : ViewModel(), CoroutineScope { override val coroutineContext: CoroutineContext get() = SupervisorJob() + Dispatchers.Main fun doSomething() { launch { // do something } } } ViewModel 

class MyViewModel : ViewModel(), CoroutineScope { override val coroutineContext: CoroutineContext get() = SupervisorJob() + Dispatchers.Main override fun onCleared() { cancel() // coroutineContext.cancel() } } ViewModel 

class MyViewModel : ViewModel() { fun doAnything() { GlobalScope.launch { // do anything } } } ViewModel 

androidx.lifecycle: lifecycle-viewmodel-ktx:2.1.0 

class MyViewModel : ViewModel() { init { viewModelScope.launch { // do something } } } ViewModel with viewModelScope 

ViewModel with viewModelScope val ViewModel.viewModelScope: CoroutineScope get() { val scope: CoroutineScope? = this.getTag(JOB_KEY) if (scope != null) { return scope } return setTagIfAbsent(JOB_KEY, CloseableCoroutineScope( SupervisorJob() + Dispatchers.Main )) } 

internal class CloseableCoroutineScope( context: CoroutineContext ) : Closeable, CoroutineScope { override val coroutineContext: CoroutineContext = context override fun close() { coroutineContext.cancel() } ViewModel with viewModelScope 

ViewModel with viewModelScope public abstract class ViewModel { final void clear() { mCleared = true; if (mBagOfTags != null) { synchronized (mBagOfTags) { for (Object value : mBagOfTags.values()) { closeWithRuntimeException(value); } } } onCleared(); } 

class MyViewModel : ViewModel() { override fun onCleared() { viewModelScope.launch { // do something } } } ViewModel with viewModelScope 

androidx.lifecycle: lifecycle-runtime-ktx:2.2.0-rc03 

class MyActivity : AppCompatActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) lifecycleScope.launch { // do something } } } Activities & Fragments with lifecycleScope 

val LifecycleOwner.lifecycleScope: LifecycleCoroutineScope get() = lifecycle.coroutineScope val Lifecycle.coroutineScope: LifecycleCoroutineScope get() { ... val newScope = LifecycleCoroutineScopeImpl( this, SupervisorJob() + Dispatchers.Main.immediate ) ... } Activities & Fragments with lifecycleScope 

class MyActivity : AppCompatActivity() { override fun onDestroy() { super.onDestroy() lifecycleScope.launch { // do something } } } Activities & Fragments with lifecycleScope 

class MyActivity : AppCompatActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) lifecycleScope.launch { // do something } lifecycleScope.launchWhenResumed { // do something } } } Activities & Fragments with lifecycleScope 

Activities & Fragments with lifecycleScope class MyActivity : AppCompatActivity() { override fun onCreate(savedInstanceState: Bundle?) { ... lifecycleScope.launch { lifecycleScope.launchWhenResumed { repeat(100) { delay(30) textView.text = (it + 1).toString() } } 

launch launchWhenResumed VS 

class MyFragment : Fragment() { init { lifecycleScope.launchWhenCreated { // do something } lifecycleScope.launchWhenStarted { // do something } } } Activities & Fragments with lifecycleScope 

Application scope or WorkManager https://www.youtube.com/watch?v=B8ppnjGPAGE&t=910s Application 

LiveData coroutine builder 

ViewModel + LiveData class MyViewModel : ViewModel() { private val _result = MutableLiveData() val result: LiveData = _result init { viewModelScope.launch { val computationResult = doComputation() _result.value = computationResult } } } 

ViewModel + LiveData class MyViewModel : ViewModel() { private val _result = MutableLiveData() val result: LiveData = _result init { viewModelScope.launch(Dispatchers.IO) { val computationResult = doComputation() _result.postValue(computationResult) } } } 

androidx.lifecycle: lifecycle-livedata-ktx:2.2.0-rc03 

liveData coroutine builder class MyViewModel : ViewModel() { val result = liveData { emit(doComputation()) } } 

liveData coroutine builder fun liveData(...): LiveData = CoroutineLiveData(context, timeoutInMs, block) internal class CoroutineLiveData( ... ) : MediatorLiveData() { init { ... val scope = CoroutineScope( Dispatchers.Main.immediate + context + supervisorJob) ... } } 

Dispatchers.Main.immediate ? 

liveData coroutine builder class MyViewModel : ViewModel() { val result = liveData(Dispatchers.IO) { emit(doComputation()) } } 

liveData coroutine builder class MyViewModel : ViewModel() { val result = liveData { emit(doComputation()) emitSource(repo.fetchSomething()) } } class MyRepository { fun fetchSomething(): LiveData { ... 

liveData coroutine builder class MyViewModel : ViewModel() { private val itemId = MutableLiveData() val item = itemId.switchMap { liveData { emit(fetchItem(it)) } } } 

LiveData coroutine builder + with flow 

class MyDataSource { private val weather: String get() = listOf("Sunny", "Rainy", "Cloudy").shuffled().first() fun fetchWeather(): LiveData = liveData { fun fetchWeatherFlow() = flow { while (true) { delay(2_000) emit(weather) } } } Data Source 

emit N values // LiveData -> LiveData val currentWeather: LiveData = dataSource.fetchWeather() 

emit N values // LiveData -> LiveData val currentWeather: LiveData = dataSource.fetchWeather() // flow -> LiveData val currentWeatherFlow: LiveData = liveData { dataSource.fetchWeatherFlow().collect { emit(it) } } 

emit N values // LiveData -> LiveData val currentWeather: LiveData = dataSource.fetchWeather() // flow -> LiveData val currentWeatherFlow: LiveData = dataSource.fetchWeatherFlow().asLiveData() 

emit 1 + emit N // LiveData -> LiveData val currentWeather: LiveData = liveData { emit(LOADING_STRING) emitSource(dataSource.fetchWeather()) } 

emit 1 + emit N // LiveData -> LiveData val currentWeather: LiveData = liveData { emit(LOADING_STRING) emitSource(dataSource.fetchWeather()) } // flow -> LiveData val currentWeatherFlow: LiveData = liveData { emit(LOADING_STRING) emitSource( dataSource.fetchWeatherFlow().asLiveData() ) } 

emit 1 + emit N // LiveData -> LiveData val currentWeather: LiveData = liveData { emit(LOADING_STRING) emitSource(dataSource.fetchWeather()) } // flow -> LiveData val currentWeatherFlow: LiveData = dataSource.fetchWeatherFlow() .onStart { emit(LOADING_STRING) } .asLiveData() 

Transformation // LiveData -> LiveData val currentWeather: LiveData = dataSource.fetchWeather().switchMap { liveData { emit(heavyTransformation(it)) } } 

Transformation // LiveData -> LiveData val currentWeather: LiveData = dataSource.fetchWeather().switchMap { liveData { emit(heavyTransformation(it)) } } // flow -> LiveData val currentWeatherFlow: LiveData = dataSource.fetchWeatherFlow() .map { heavyTransformation(it) } .asLiveData() 

cancelling Coroutine LiveData 

val currentWeather: LiveData = dataSource.fetchWeatherFlow().map { it.toUpperCase() }.onStart { emit("ON START") }.asLiveData() cancelling CoroutineLiveData 

fun Flow.asLiveData( context: CoroutineContext = EmptyCoroutineContext, timeoutInMs: Long = DEFAULT_TIMEOUT ): LiveData = liveData(context, timeoutInMs) { collect { emit(it) } } fun liveData( context: CoroutineContext = EmptyCoroutineContext, timeoutInMs: Long = DEFAULT_TIMEOUT, @BuilderInference block: suspend LiveDataScope.() -> Unit ): LiveData = CoroutineLiveData(context, timeoutInMs, block) cancelling CoroutineLiveData 

internal class CoroutineLiveData( ... ) : MediatorLiveData() { init { ... blockRunner = BlockRunner( ... ) } override fun onInactive() { super.onInactive() blockRunner?.cancel() } } cancelling CoroutineLiveData 

No content

internal class BlockRunner( … ) { fun cancel() { ... cancellationJob = scope.launch(Dispatchers.Main.immediate) { delay(timeoutInMs) if (!liveData.hasActiveObservers()) { ... runningJob?.cancel() runningJob = null } } … cancelling CoroutineLiveData 

val currentWeather: LiveData = dataSource.fetchWeatherFlow().map { it.toUpperCase() }.onStart { emit("ON START") }.asLiveData() }.asLiveData(parentJob) }.asLiveData(viewModelScope.coroutineContext) cancelling CoroutineLiveData 

ViewModel, Repository, DataSource patterns 

No content

CodeLab 

No content

Testing 

Testing Coroutines on Android (Android Dev Summit '19) 

Android Dev Summit 2019 extended Seoul References • LiveData with Coroutines and Flow (Android Dev Summit '19) https://www.youtube.com/watch?v=B8ppnjGPAGE&t=416s • LiveData Overview https://developer.android.com/topic/libraries/architecture/livedata • Use Kotlin coroutines with Architecture components https://developer.android.com/topic/libraries/architecture/coroutines • Easy Coroutines in Android: viewModelScope https://medium.com/androiddevelopers/easy-coroutines-in-android-viewmodelscope-25bffb605471 • Lessons learnt using Coroutines Flow in the Android Dev Summit 2019 app https://medium.com/androiddevelopers/lessons-learnt-using-coroutines-flow-4a6b285c0d06 • iosched adssched2019 branch : https://github.com/google/iosched/tree/adssched2019 

Android Dev Summit 2019 extended Seoul References • CodeLab : Advanced Coroutines with Kotlin Flow and LiveData https://codelabs.developers.google.com/codelabs/advanced-kotlin-coroutines/index.html?index=.. %2F..index#0 • Testing Coroutines on Android (Android Dev Summit '19) https://www.youtube.com/watch?v=KMb0Fs8rCRs&t=11s • Cold flows, hot channels https://medium.com/@elizarov/cold-flows-hot-channels-d74769805f9 • Simple design of Kotlin Flow https://medium.com/@elizarov/simple-design-of-kotlin-flow-4725e7398c4c • Kotlin Flows and Coroutines https://medium.com/@elizarov/kotlin-flows-and-coroutines-256260fb3bdb 

Thank you