In this blog, we will discuss the difference between AndroidViewModel and ViewModel.
In the Android Jetpack architecture components, ViewModel
and AndroidViewModel
are two classes that are used to manage UI-related data across configuration changes. Both classes provide a way to separate the UI logic from the data logic and manage the state of the UI.
The primary difference between ViewModel
and AndroidViewModel
is that AndroidViewModel
is a subclass of ViewModel
that includes a reference to the Application
context, while ViewModel
does not.
Let's take a closer look at each class and how they are used in Android app development.
ViewModel
ViewModel
is designed to be used with data that is specific to the UI and does not require access to the Application
context. It is typically used to store and manage UI-related data that is not persistent, such as the state of a UI component or data that is fetched from a remote server.
For example, let's say we have a simple Android app that displays a list of items fetched from a remote server. We can create a ViewModel
class to manage the data and the state of the UI:
class ItemListViewModel : ViewModel() {
private val repository = ItemRepository()
private val _itemList = MutableLiveData<List<Item>>()
val itemList: LiveData<List<Item>>
get() = _itemList
init {
fetchItemList()
}
private fun fetchItemList() {
viewModelScope.launch {
val itemList = repository.fetchItemList()
_itemList.value = itemList
}
}
}
In this example, we have a ViewModel
class called ItemListViewModel
that fetches a list of items from a remote server and stores the result in a LiveData
object called itemList
. The init
block is called when the ViewModel
is created, and it triggers the fetchItemList()
method to fetch the data.
AndroidViewModel
AndroidViewModel
is designed to be used with data that requires access to the Application
context, such as data that is stored in a local database or shared preferences. It provides a way to access the Application
context without passing it through the UI components, which can cause memory leaks.
For example, let's say we have an Android app that uses a local database to store user data. We can create an AndroidViewModel
class to manage the data and the state of the UI:
class UserViewModel(application: Application) : AndroidViewModel(application) {
private val repository = UserRepository(application)
val userList: LiveData<List<User>> = repository.getUserList()
fun insertUser(user: User) {
repository.insertUser(user)
}
}
In this example, we have an AndroidViewModel
class called UserViewModel
that manages a list of users stored in a local database. The application
parameter is passed to the AndroidViewModel
constructor to provide access to the Application
context. The userList
property is a LiveData
object that contains the list of users, and the insertUser()
method is used to add a new user to the database.
Conclusion
In summary, ViewModel
and AndroidViewModel
are both used to manage UI-related data in Android apps, but AndroidViewModel
is designed for use with data that requires access to the Application
context, while ViewModel
is used for data that is specific to the UI and does not need access to the Application
context. Both classes provide a way to separate the UI logic from the data logic and manage the state of the UI across configuration changes.
If you want to read more content like this, please go check out my profile.