How can I get the query result at once when I use Room?

Question: at once meaning synchronous or what ? if yes, what happens if the function to get the result has to take a longer time? like network call? well you can decide to do that on another thread.

What I think is for you to use a mutable Object and use the postValue function to dispatch the result to the observers. It should look something like below:

class HomeViewModel(val mApplication: Application, private val mDBVoiceRepository: DBVoiceRepository) : AndroidViewModel(mApplication) {
    private val voices = MutableLiveData<Long>()

    fun getTotalOfVoiceAsLiveData(): LiveData<Long> {
        voices.postValue(mDBVoiceRepository.getTotalOfVoiceAsLiveData().value)
        return voices;
    }
}

Making use of it in your Fragment will look like below:

override fun onActivityCreated(savedInstanceState: Bundle?) {
        super.onActivityCreated(savedInstanceState)
        if (activity != null) {
            val viewModel = ViewModelProvider(requireActivity())
            viewModel.get(HomeViewModel::class.java).getTotalOfVoiceAsLiveData().observe(viewLifecycleOwner, Observer { voices: Long ? ->
                voices // Sound of music ? be very free to use ...
            })
        }
    }

Happy Coding.

You can return Deferred<Long> from viewModelScope.async. I recommend you to use:

val deferred = viewModelScope.async(Dispatchers.IO) {
    return@async mDBVoiceRepository.getTotalOfVoice() 
}
val value = deferred.await()

await() is suspend

Edit: If you want to get a getter which will use in your activity or fragment you need to write a suspend function like this:

suspend fun getTotalOfVoice(): Long {
    return viewModelScope.async(Dispatchers.IO) {
                return@async mDBVoiceRepository.getTotalOfVoice()
    }.await()
}

But mvvm pattern allows you to create LiveData inside your ViewModel, which gives your fragment an observer.

In view model:

private val _totalOfVoiceLD: MutableLiveData<Long> = MutableLiveData()
val totalOfVoiceLD: LiveData<Long>
        get() = _totalOfVoiceLD

fun updateTotalOfVoice() {
        viewModelScope.launch(Dispatchers.IO) {
            val totalOfVoice = mDBVoiceRepository.getTotalOfVoice()
            _totalOfVoiceLD.postValue(totalOfVoice)
        }
}

and in your fragment:

override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        viewModel.totalOfVoiceLD.observe(viewLifecycleOwner, Observer { totalOfVoice ->
            totalOfVoiceTextView.text = totalOfVoice.toString()
        })
    }

You can use coroutineContext.async to get data from DB and wait for getting it's response with data by using .await function for a async dispatch.

suspend fun getAllVoices() : Long{
  val awatingResults = viewModelScope.async(Dispatchers.IO) {
      mDBVoiceRepository.getTotalOfVoice() 
  }
  val records = awatingResults.await()
  return records
}

It is necessary to call a Suspend function from a coroutine and async.await() is always called in a suspended function so,

val voiceLiveData: MutableLiveData<Long> = MutableLiveData()

fun getAllVoicesFromDB() {
   viewModelScope.launch(Dispatchers.IO) {
       voiceLiveData.postValue(mDBVoiceRepository.getTotalOfVoice())
   }
}

Now call it where ever you want to get your voice data from database and also remember do your further work inside your voiceLiveData observer where you get your response of voices :)

I hope to get the result at once, but LiveData is lazy

Sorry to tell, but this is how the Room interface is designed. You are right with the lazyness of the returned LiveData object. But this allows you to handle it on a different thread without having to manually handle different threads.

Based on your new information!

You basically have two options:

A) you could do the following:

1. load data from Room via LivaData
2. add observer that stores the current total amount
3. when the button is clicked you just read the local copy

In your View: (only one observer and one clickListener)

    val totalVoiceCount: long
    val viewModel = ViewModelProvider(requireActivity()).get(HomeViewModel::class.java)
    viewModel.getTotalOfVoiceAsLiveData().observe(viewLifecycleOwner, Observer { totalOfVoice : Long ? ->
            if (totalOfVoice != null)
                totalVoiceCount = totalOfVoice
        })

    btnStart.setOnClickListener{
        viewModel.recordVoice(totalVoiceCount)
    }

In your ViewModel: (the logic and everything else)

    fun recordVoice(totalVoiceCount : long){
        val fileName = createdFileanme(totalVoiceCount)
        // create your recording // depending on how you do this, it probably runs on a background thread anyways
    }

    fun createdFileName(totalVoiceCount : long){
        return "untitled"+ String.valueOf(totalVoiceCount)
    }

This works reliably because the LiveData has enough time to update the local copy of totalVoiceCount before the user has the chance to click the button.

B) Based on the answer in your parallel question you can of course outsource even more to a background thread. Then you also have the option to call the DAO query with a non-livedata return (as room returns non-livedata queries only on background threads). Is it worth to implement the threading suggestion of Ridcully? Not possible to answer without knowing what else is going on simultaneously... To me it seems like an overkill, but he is right that the more you do on background threads the better for your refresh rate..

Live data is designed to be lazy, when the value of the live data changes internally it emits and wherever you are observing it, the onChange function will be invoked. It is designed to fire and forget. Because room uses background thread to run the query. You can't expect live data to behave like sharedpreference where you store key value pair. If you want to achieve something like that. I would suggest you to use Paper Db or Realm.

If you need your Room result synchronously, your code should be execute in IO thread. In case of coroutines, you can use Dispatchers.IO. Your code can be changed to this to pass the error.

class HomeViewModel(val mApplication: Application, private val mDBVoiceRepository: DBVoiceRepository) : AndroidViewModel(mApplication) {

    fun getTotalOfVoice():Long {
        viewModelScope.launch(Dispatchers.IO) { // here
            return mDBVoiceRepository.getTotalOfVoice()
        }
    }
}

If you must run the queries in the main thread, then:

1. Allow android room to execute queries in main thread.

    val dbInstance = Room
        .databaseBuilder(ctx, YourDBClass::class.java, "YourDBName")
        .allowMainThreadQueries()
        .build()
   

2. Define the dao method as follows

   @Dao
   interface DBVoiceDao{
      @Query("SELECT count(id) FROM voice_table")
      fun getTotalOfVoice(): Long
   }
   

3. Access the method in the repository

   fun getTotalOfVoice():Long {
       return dao.getTotalOfVoice()        
   }