How get result to UI Thread from an android kotlin coroutines

Question

I didn't understand how kotlin coroutines work. I need to do a long work on an asynchronous thread and get the result on the UI Thread in an Android app. Can someone give me some examples? For example

private fun getCountries(){
        viewModelScope.launch { 
            val a = model.getAllCountries()
            countriesList.value = a
        }
}

will lunch model.getAllCountries() async but in the end how can i get result to UI Thread?

Regardless of what scope you launch your coroutines from, you can always execute code on the UI thread by using `withContext(Dispatchers.Main)`, so for example: private fun getCountries(){ viewModelScope.launch { val a = model.getAllCountries() withContext(Dispatchers.Main) { countriesList.value = a } } } — Viktor Penelski, Oct 07 '19 at 18:58

score 8 · Accepted Answer · edited Jul 18 '23 at 00:37

8

Well! Adding to @ianhanniballake's answer,

In your function,

private fun getCountries(){
   // 1
   viewModelScope.launch {  
      val a = model.getAllCountries()
      countriesList.value = a
   }
}

You have launched your suspend function from viewModel scope, and the default context is the main thread.

Now the thread on which suspend fun getAllCountries will work will be specified in the definition of getAllCountries function.

So it can be written something like

suspend fun getAllCountries(): Countries {
   // 2
   return withContext(Dispatchers.IO) { 
    service.getCountries()
   }
}

We specify a new thread to call the server using withContext, and after return from withContext block, we are back on main thread.

edited Jul 18 '23 at 00:37

AllDayAmazing

2,383
1
24
25

answered Oct 07 '19 at 19:24

Rachit Mishra

6,101
4
30
51

So if i want run getAllCountries on async i must use return withContext(Disptachers.IO) ? – Graziano Rizzi Oct 07 '19 at 20:06
Yes :) Using withContext(), you specify the context(thread) of the operation. – Rachit Mishra Oct 08 '19 at 21:30

score 4 · Answer 2 · answered Oct 07 '19 at 19:13

As per the documentation for viewModelScope:

This scope is bound to Dispatchers.Main.immediate

Where Dispatchers.Main is the Kotlin way of saying 'the main thread'. This means that, by default, all of the code in the launch block runs on the main thread. Your getAllCountries(), if it wants to run on a different thread, would want to use withContext(Disptachers.IO) to move to the IO coroutine dispatcher, as an example.

Therefore in this case, the result of your method is already on the main thread and there's nothing else you need to do.

score 3 · Answer 3 · answered Oct 08 '19 at 12:48

I need to do a long work on an asynchronous thread

There's no such thing as an asynchronous thread, actually. Whether your network operations are sync or async gets decided by the implementation of the network API you're using.

If you have a blocking network operation, it will stay blocking even when you apply coroutines. The value of coroutines for that use case is limited to making it a bit easier to transfer the result back to the UI thread.

You achieve this by launching a coroutine with the UI dispatcher (the default) and then switching to a thread pool to perform a blocking operation without blocking the UI thread:

    viewModelScope.launch { 
        countriesList.value = withContext(Dispatchers.IO) {
            model.getAllCountries()
        }
    }

Note that a thread inside the thread pool underlying the IO dispatcher will still be blocked, so in terms of the usage of system resources this doesn't make a difference. There will be as many blocked native threads as there are concurrent network calls.

score 0 · Answer 4 · answered Oct 08 '19 at 14:18

Another solution would be to post your result within a MutableLiveData inside your ViewModel class and observe the LiveData in your view.

Your ViewModel class:

class CountriesViewModel : ViewModel() {
    private val parentJob = Job()
    val coroutineContext: CoroutineContext
        get() = parentJob + Dispatchers.Default
    val viewModelScope = CoroutineScope(coroutineContext)
    val countries: MutableLiveData<ArrayList<Country>> = MutableLiveData()
    val model = MyModel()

    fun getCountries(){
        viewModelScope.launch {
            val countriesList = model.getAllCountries()
            countries.postValue(countries)
        }
    }
}

Your view class (E.g. a fragment)

class CountriesFragment : Fragment(){
        private lateinit var countriesVM : CountriesViewModel
        override fun onCreate(savedInstanceState: Bundle?) {
            super.onCreate(savedInstanceState)
            countriesVM = ViewModelProviders.of(this).get(CountriesViewModel::class.java)
            // calling api in your view model here
            countriesVM.getCountries()
        }

        override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
            super.onViewCreated(view, savedInstanceState)
            // observer is notified of the changes on countries livedata
            countriesVM.countries.observe(this, Observer { countries ->
                // Update ui here
                updateUI(countries)
            })
        }
    }

How get result to UI Thread from an android kotlin coroutines

4 Answers4