Different between ViewModel with LiveData vs ViewModel Without LiveData?

Question

I read many tutorial about viewmodel and livedata but i do not get actually use of livedata within viewmodel class in mvvm pattern. thanks in advance.

Answer 1

Android dev commonly use ViewModel as a container of LiveData like this

class MyViewModel {
    val myLiveData = MutableLiveData<String>()
}

But, why don't we use the String class directly?

class MyViewModel {
    val myString = "Hello"
}

Because we want to use Observer pattern to the String.

model.myLiveData.postValue("Echo")

model.myLiveData.observe(this, Observer {
    // Show "Echo"
    toast(it)
})

Why do we need ViewModel then? Because we want to get the same ViewModel instance (singleton) on our Activity or Fragment.

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    viewModel = ViewModelProviders.of(this)[MyViewModel::class.java]
    viewModel.myLiveData.observe(this, Observer {
        textView.text = it
    })

I think that should be enough to start seeing the difference between ViewModel and LiveData.

Different between ViewModel with LiveData vs ViewModel Without LiveData?

That's up to you, do you need a LiveData on a ViewModel or not?

i do not get actually use of livedata within viewmodel class in mvvm pattern.

After understanding the difference between ViewModel and LiveData, please read more about the MVVM pattern.

The View Model in Model-View-View-Model is not the same as Jetpack's ViewModel and LiveData. View Model in MVVM is a concept, you can create your own View Model using normal Java class. As long as it conforms to the MVVM behavior.

Answer 2

As per Google Docs, if you are already using a library like Rx or Agera, you can continue using them instead of LiveData. But in this case, it is your responsibility to handle object allocation and de-allocation per Android components life cycle.

When working with MVVM pattern, since viewmodel has no reference to view, you'll need observable data holder to observe changes so you can properly update your view.

In this case you can use livedata, one of architecture components or any other observable like from Rx.

The main difference is livedata respects android lifecycle, and rx observables don't.

With livedata, there would be no crash due to stopped activity when onChange called since it's lifecycle aware. But without livedata,it is up to you to handle this case.

Answer 3

The MVVM pattern is to only talk down V -> VM -> M and react up M -> VM -> V. Meaning the View can call methods on the ViewModel but the ViewModel doesn't have a reference to the View to call methods on it (setting data). The way to communicate from the ViewModel to the View is by the View observing some variable (ObservableField, LiveData, RxJava, etc).

LiveData is a great observable object to provide communication between the viewModel and the View especially over state changes like rotation. It also provides great communication between the Model and the View in regards to database changes and Room.