I think the solution here is actually to just return the LiveData without using Coroutines. LiveData works out of the box, there's no reason to use Coroutines when returning LiveData.

When using LiveData it already handles it on a background thread. When NOT using LiveData then in that case you can use Coroutines (and maybe eventually Coroutines Channels) or RxJava2.

See this codelab for an example: https://codelabs.developers.google.com/codelabs/android-room-with-a-view-kotlin. Here they need a background thread for inserts but not for the returned LiveData.

Note: there seems to be a mistake in the actual codelab where the DAO is not returning a LiveData. I've corrected that in the sample below.

@Dao
interface WordDao {

    @Query("SELECT * from word_table ORDER BY word ASC")
    fun getAllWords(): LiveData<List<Word>>

    @Insert
    suspend fun insert(word: Word)

    @Query("DELETE FROM word_table")
    fun deleteAll()
}

class WordRepository(private val wordDao: WordDao) {

    val allWords: LiveData<List<Word>> = wordDao.getAllWords()

    @WorkerThread
    suspend fun insert(word: Word) {
        wordDao.insert(word)
    }
}

Remove the suspend function. LiveData is already asynchronous. No need for a suspend function.

@Dao
interface AccountDao{

    @Query("SELECT * FROM account_master")
    fun getAllAccounts(): LiveData<List<Account>>
}

Current implementation of Room doesn't support coroutines with LiveData (we can't define a function to be suspend and return LiveData at the same time). As a workaround you can implement it like the following:

@Dao
interface AccountDao {

@Query("SELECT * FROM account_master")
    suspend fun getAllAccounts(): List<Account>
}

class AccountRepository(private val dao: AccountDao) {

    suspend fun getAccounts(): List<Account> {
         return dao.getAllAccounts()
    }
}

And in your implementation of ViewModel class you can create LiveData object and assign a value to it, retrieved from DB:

class MainViewModel(private val accountRepository: AccountRepository) : ViewModel() {

    private val _accounts: MutableLiveData<List<Account>>
    val accounts = _accounts // To access it from Activity/Fragment

    fun loadAccounts() {
        viewModelScope.launch {
            accounts.value = accountRepository.getAccounts()
        }
    }
}

To use Dispatchers.Main import:

implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.1.1'

Or you can directly return LiveData without marking the function as suspend:

@Dao
interface AccountDao {

    @Query("SELECT * FROM account_master")
    fun getAllAccounts(): LiveData<List<Account>>
}


class AccountRepository(private val dao: AccountDao) {

    fun getAccounts(): LiveData<List<Account>> {
         return dao.getAllAccounts()
    }
}

class MainViewModel(private val accountRepository: AccountRepository) : ViewModel() {

    val accounts = accountRepository.getAccounts()

}