What is view model factory and livedata. Can anyone explain this in simple words?

I want the explanation of this topic as I am unable to understand from the official document that why and how to use this?

Simple Explanation of these two topics

1. What is view Model
2. what is view model factory
3. what is repository
4. what is livedata

1. ViewModel - It is class that can survive configuration changes.
   For example, you have a game in your fragment. Initially, the score is zero and it increases as you play, suppose for some reason you rotate your device, the score will be lost, because after rotation the fragment is re-created and your score is re-initialized to zero. This happens because you are storing your score variable in fragment. If you store it in viewModel, it will survive device rotation. So, you should have all your data in view model, and fragment should only display the data after getting from view model or pass the input to view model. Since all your data is now in ViewModel, you should also do any processing on the data in the view model only. Like, what data to be displayed when, for example how score increases.

2. ViewModelProvider - So, how do we create ViewModel, if we initialize it in our fragment, it's of no use because on configuration change fragment will be re-created therefore ViewModel will be re-created. Hence we don't create view models, we ask a provider to provide view models, and the provider creates view model for us. When we ask for first time, it creates a new ViewModel for us, but every next time, it returns previously created ViewModel, hence not creating it again, even if our fragment is re-created.

3. ViewModelFactory - Now, consider a case in which we need to pass some data in ViewModel during initialization, i.e. we have to call constructor. For example, we want to pass some default score of say 100. How do we do that? We cannot call constructor in fragment, because every time we re-create a fragment, score will be re-initialized. So, we use a factory. Basically, factory creates the view models for us according to our needs, and provider provides the ViewModel to us. We tell the factory how to create the ViewModel and pass data to factory and factory creates the viewModel. The provider works with factory to provide viewModel as mentioned above. If a provider already has a viewModel created, it gives us that, and factory doesn't create a new one.

4. LiveData - Okay, now the viewModel has all data and we do all logic in the viewModel only. Suppose your score changed, how do we update the data in UI? We may have reference of our fragment in viewModel and then update the corresponding view. However, this should NEVER be done. ViewModels should never reference activity or fragment. But, why? Because if you reference a fragment, and the fragment is destroyed when device rotates, you are holding reference to something that doesn't exist, this can lead to bugs.
   So how to update the UI then? We use another class called LiveData. LiveData is observable class. This means you can observe the LiveData for changes. LiveData holds the actual data in the ViewModel class, so basically inside the viewModel all data variables will be wrapped by LiveData. So, our score becomes LiveData<Int> score. Now, in our fragment we observe this LiveData, and whenever the score changes, we know about it in fragment and we can update the data easily.

5. Repository - Whatever we discussed above were actual classes provided by the LifeCycle library. But, repository is a concept class used in MVVM design pattern. Suppose, now you made the game online, so the score is maintained in local database as well as on remote server. So, when you ask ViewModel for your score, it searches local database and remote server. Where do you write code for this? It is written in a separate class which we call repository, because it has APIs for accessing data from all sources. You can do all this logic inside your ViewModel class as well, but for better code, we put it in separate class.

This is some basic explanation about these components. However, there are lots of things that can't be covered in one post. So, I suggest you going through documentation for more details. Just reading the documentation and understanding everything would be difficult, so try implementing whatever you read. You can follow tutorials on CodeLabs.

ViewModel is just a class which has life cycle greater than the android component (basically activity or fragment) . Thus, useful in Android to manage data (save or retrieve). This means any variable ( mostly a Live data) with data stored in viewModel will be have its value safe even after any configuration change ( like device rotation). The Android components can retrieve this value.

Livedata is an observable class meaning it can be observed by the Android component classes. They observe any changes in the livedata and update their UI. Any action on the Ui is an event which can be used to update the livedata.

Repository is a pattern and act as an interface between data layer and Ui Layer. it is mostly used in MVVM architecture. Data layer includes the dao, databases classes etc. and Ui layer includes activities ,fragments or services etc. (Android components). Sometimes, ViewModel needs some classes like above repository class as a dependencies.
The ViewModelFactory lets you assign this dependencies to the viewModel.