In this blog post by Google developer Jose Alcérreca it is recommended to use a transformation in this case (see the "LiveData in repositories" paragraph) because ViewModel shouldn't hold any reference related to View (Activity, Context etc) because it made it hard to test.

I think you can use observeForever which does not require the lifecycle owner interface and you can observe results from the viewmodel

Use Flow

The guideline in docs is misunderstood

However ViewModel objects must never observe changes to lifecycle-aware observables, such as LiveData objects.

In this Github issue, he describes that the situations that be applied the above rule are that observed lifecycle-aware observables are hosted by another lifecycle scope. There is no problem that observes LiveData in ViewModel contains observed LiveData.

Use Flow

class MyViewModel : ViewModel() {
    private val myLiveData = MutableLiveData(1)

    init {
        viewModelScope.launch {
            myLiveData.asFlow().collect {
                // Do Something
            }
        }
    }
}

Use StateFlow

class MyViewModel : ViewModel() {
    private val myFlow = MutableStateFlow(1)
    private val myLiveData = myFlow.asLiveData(viewModelScope.coroutineContext)
}

PS

The asFlow makes a flow that makes LiveData activate at starting collect. I think the solution with MediatorLiveData or Transformations and attaching a dummy observer doesn't have differences using the Flow except for emitting value from LiveData is always observed in the ViewModel instance.

Use Kotlin coroutines with Architecture components.

You can use the liveData builder function to call a suspend function, serving the result as a LiveData object.

val user: LiveData<User> = liveData {
    val data = database.loadUser() // loadUser is a suspend function.
    emit(data)
}

You can also emit multiple values from the block. Each emit() call suspends the execution of the block until the LiveData value is set on the main thread.

val user: LiveData<Result> = liveData {
    emit(Result.loading())
    try {
        emit(Result.success(fetchUser()))
    } catch(ioException: Exception) {
        emit(Result.error(ioException))
    }
}

In your gradle config, use androidx.lifecycle:lifecycle-livedata-ktx:2.2.0 or higher.

There is also an article about it.

Update: Also it's possible to change LiveData<YourData> in the Dao interface. You need to add the suspend keyword to the function:

@Query("SELECT * FROM the_table")
suspend fun getAll(): List<YourData>

and in the ViewModel you need to get it asynchronously like that:

viewModelScope.launch(Dispatchers.IO) {
    allData = dao.getAll()
    // It's also possible to sync other data here
}

Its been a while since the original post but I recently stumbled upon the same issue (also with Firebase) and I was able to solve it with Transformations.

I have a repository class that holds liveData objects, collected with Firebase's ValueEventListener. The ViewModel hold a reference to this repository.

Now, in the ViewModel, instead of having a function that returns the LiveData value from the repository, and then pass it to the Fragment via an observer , like this:

fun getMyPayments(): LiveData<HashMap<String, Int>> {
    return repository.provideMyPayments()
}

I use a val with Transformations.map that represent the final result of the LiveData, after being processed by another function in the ViewModel:

val myRoomPaymentsList : LiveData<HashMap<String, HashMap<String, Payment>>> = Transformations.map(repository.provideMyPayments()) {data ->
        getRoomPaymentsList(data)
    }

note that the first parameter is the data source which you observe and the second parameter is the result you want to get. This val is a LiveData val that holds to the most current value from the repository and serves it as needed in the Fragment, keeping all the processing in the ViewModel and only the UI function inside the Framgent itself.

Then, inside my Fragment, I put an observer on this val:

viewModel.myRoomPaymentsList.observe(viewLifecycleOwner, {
    roomPayments = it
    graphFilterPeriod()
})

As an example, if you need to fetch an ID (as LiveData) and use it to make another call for LiveData. Store the ID in selectedID and the Transformations would observe that field and call getAllByID(selectedID) (also LiveData) whenever it changes.

var selectedID = MutableLiveData<Int>()

val objects = Transformations.switchMap(selectedID) { getAllByID(it) }

I know there have already been amazing answers for this topic, but I wanted to add my own as well:

If you want to stick to LiveData you can always use Transformations.map so that you don't have to observe in the ViewModel but rather only in the Fragment/Activity.

Otherwise, you can use SharedFlow, a single event observable. For more, I have written an article here: https://coroutinedispatcher.com/posts/decorate_stateful_mvvm/

You don't have to pass viewLifecycleOwner in the ViewModel because there is no point in calling observe in the ViewModel when the View just needs the latest result after all.