try/catch

SharedFlow

/**
 * Convenience property delegate for accessing and setting the live data value
 */
class LiveDataDelegate<T> : MutableLiveData<T> {

    constructor(value: T) : super(value)
    constructor() : super()

    operator fun getValue(thisRef: Any?, property: KProperty<*>): T? = value
    operator fun setValue(thisObj: Any?, property: KProperty<*>, value: T?) {
        this.value = value
    }
}

// In Some ViewModel
private val stateDelegate = LiveDateDelegate(SomeState())
private var _state by stateDelegate
private val state: LiveData<SomeState> 
  get() = _state

fun onSomeUserEvent() {
  // no need to call state.value
  _state = _state.copy(
    // update the state
  )
}

SomeViewModel: ViewModel(), LifecycleObserver {

   init {
       viewModelScope.launch { databaseStuff() }
   }

   suspend fun databaseStuff() =
       liveData {
           emit(ViewState.Loading)
           emit(retrieveDataUseCase.getDatabaseStuff().fold({
               ViewState.Error
           }, {
               if (it.retrievedFromDatabase) {
                   ViewState.ReadFromDatabase(it)
               } else {
                   ViewState.SuccessfulFetch(it)
               }
           }))
       }
   }
}

SomeFragment: Fragment() {
   viewLifecycleOwner.lifecycleScope.launchWhenCreated {
       viewModel.databaseStuff().observe(viewLifecycleOwner, {
           renderState(it)
       })
   }
}

SomeOtherViewModel: ViewModel(), LifecycleObserver {
   init {
       viewModelScope.launch { databaseStuff() }
   }

   val myLiveData: LiveData<Item>
       get() = _myLiveData
   private val _myLiveData = MutableLiveData<Item>()

   @ExperimentalCoroutinesApi
   suspend fun databaseStuff() =
       retrieveDataUseCase.itemFlow().collect {
           _myLiveData.value = it
       }
   }
}

SomeOtherFragment: Fragment() {
   viewLifecycleOwner.lifecycleScope.launchWhenCreated {
       viewModel.myLiveData.observe(viewLifecycleOwner, {
           renderState(ViewState.SuccessfulFetch(it))
       })
   }
}

Locale

interface TasksDataSource {
    fun getTasks(forceUpdate: Boolean): Single<List<Task>> {
        if (forceUpdate) refreshTasks()
        return getTasks()
    }

    fun getTasks(): Single<List<Task>>

    ...
}

loadUrl()

evaluateJavascript()

evaluateJavascript()

loadUrl()

evaluateJavascript()