Demystifying Android ViewModel: How Does It Work Under the Hood?

6 min readSep 1, 2024

Ever wondered what magic keeps your app’s data intact during configuration changes? Let’s dive deep into Android’s ViewModel and unravel its internal workings!

Introduction

Imagine you’re using a navigation app while driving, and you rotate your phone to get a better view. You wouldn’t want the app to restart or lose your current route, right? Similarly, in app development, ensuring data persists across configuration changes like screen rotations is crucial for seamless user experience. This is where Android’s ViewModel comes into play.

In this article, we’ll explore the inner workings of Android ViewModel, understand how it manages to retain data across configuration changes, and learn how it contributes to building robust and efficient applications. We’ll break down complex concepts into relatable explanations and practical examples, making it easy for you to grasp and implement in your projects.

What is a ViewModel?

At its core, a ViewModel is a class designed to store and manage UI-related data in a lifecycle-conscious way. It allows data to survive configuration changes such as screen rotations, ensuring a smooth and consistent user experience.

Analogy Time: Think of ViewModel as a dedicated assistant for your activity or fragment. This assistant keeps track of important information, so even if your activity needs to restart (like when the screen rotates), your assistant still holds all the necessary data ready to be used again.

Key Responsibilities of ViewModel:

Data Persistence: Maintains UI-related data during configuration changes.
Lifecycle Awareness: Knows about the lifecycle of its associated UI controllers (activities/fragments) and acts accordingly.
Separation of Concerns: Helps in keeping the UI controllers lean by handling data operations, leading to cleaner and more maintainable code.

The Need for ViewModel

Before ViewModel was introduced, developers faced challenges in maintaining data consistency during configuration changes. Traditional methods involved using onSaveInstanceState() or retaining fragments, which could be cumbersome and error-prone.

Problems with Old Approaches:

Complexity: Manually handling data saving and restoration increased code complexity.
Performance Issues: Large amounts of data could cause performance bottlenecks when saved in onSaveInstanceState().
Error-Prone: Increased chances of bugs due to manual handling of lifecycle events.

Enter ViewModel: ViewModel addresses these issues by providing a simple and effective way to retain data seamlessly, reducing boilerplate code and potential errors.

How ViewModel Works Internally

Understanding the internal mechanics of ViewModel helps in leveraging its full potential. Let’s dissect how ViewModel operates under the hood.

Lifecycle Awareness

ViewModel is designed to be lifecycle-aware, meaning it knows about the lifecycle states of its associated UI controllers and behaves accordingly.

Creation: A ViewModel is created when the UI controller (activity/fragment) requests it for the first time.
Retention: It is retained as long as the UI controller is alive and during its configuration changes.
Destruction: It is cleared when the UI controller is finished or destroyed permanently.

How Does It Achieve This? ViewModel leverages Android Architecture Components to monitor lifecycle events and manage its existence appropriately.

ViewModelStore and ViewModelProvider

Two key players facilitate the lifecycle management of ViewModel: ViewModelStore and ViewModelProvider.

ViewModelStore

Role: Acts as a container that holds ViewModel instances.
Functionality: Ensures that ViewModels are retained across configuration changes by storing them in a place that’s not affected by such changes.

Analogy: Think of ViewModelStore as a secure locker that keeps your important documents (ViewModels) safe, regardless of what’s happening outside (configuration changes).

ViewModelProvider

Role: Responsible for creating and retrieving ViewModel instances from the ViewModelStore.
Functionality: Provides a way to obtain ViewModels scoped to the lifecycle of UI controllers.

Process Flow:

When a ViewModel is requested, ViewModelProvider checks the ViewModelStore.
If the ViewModel exists, it returns the existing instance.
If not, it creates a new instance and stores it in the ViewModelStore for future use.

Code Illustration:

class MainActivity : AppCompatActivity() {
    private lateinit var viewModel: MainViewModel

override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // Obtaining ViewModel instance
        viewModel = ViewModelProvider(this).get(MainViewModel::class.java)
        setContentView(R.layout.activity_main)
    }
}

override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // Obtaining ViewModel instance
        viewModel = ViewModelProvider(this).get(MainViewModel::class.java)
        setContentView(R.layout.activity_main)
    }
}

In this example, ViewModelProvider checks if MainViewModel exists in the ViewModelStore. If it does, it provides the existing instance; otherwise, it creates and stores a new one.

Data Retention Across Configuration Changes

The magic of data retention lies in the separation between the UI controllers and the ViewModelStore.

Configuration Change Occurs: When a configuration change happens (e.g., screen rotation), the activity is destroyed and recreated.
ViewModel Retention: Since ViewModelStore is associated with the activity’s lifecycle owner but exists outside the activity itself, it survives the destruction and recreation process.
Data Persistence: The new instance of the activity retrieves the same ViewModel from the ViewModelStore, maintaining continuity in data.

Visual Representation:

[Activity Instance 1] --requests--> [ViewModel] stored in [ViewModelStore]
      | (configuration change)
[Activity Instance 2] --requests--> [Same ViewModel] from [ViewModelStore]

Benefits:

Seamless Data Persistence: Users experience no data loss during configuration changes.
Efficient Resource Usage: Prevents unnecessary data re-fetching or recomputation.
Simplified Codebase: Reduces boilerplate code for handling configuration changes manually.

ViewModel in Action: A Practical Example

Let’s consider a practical scenario where ViewModel showcases its capabilities.

Scenario: Building a news app that fetches and displays articles from an API.

Without ViewModel:

On screen rotation, the activity is recreated, and the app re-fetches data from the API.
This leads to unnecessary network calls and a poor user experience due to repeated loading.

With ViewModel:

Data Fetching: The ViewModel fetches data from the API and holds it.
UI Update: The activity observes the data from the ViewModel and updates the UI.
Configuration Change: On rotation, the activity is recreated but retrieves the same ViewModel instance.
Data Persistence: The UI instantly displays the existing data without re-fetching from the API.

Implementation Example:

class NewsViewModel : ViewModel() {
    private val _articles = MutableLiveData<List<Article>>()
    val articles: LiveData<List<Article>> get() = _articles

init {
        fetchArticles()
    }
    private fun fetchArticles() {
        // Assume we have a Repository that fetches articles
        Repository.getArticles { fetchedArticles ->
            _articles.postValue(fetchedArticles)
        }
    }
}
class NewsActivity : AppCompatActivity() {
    private val viewModel: NewsViewModel by viewModels()
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_news)
        viewModel.articles.observe(this, { articles ->
            // Update UI with articles
        })
    }
}

Outcome:

Users enjoy a smooth experience without redundant loading.
The app efficiently uses resources by avoiding unnecessary network requests.
Code remains clean and maintainable by separating concerns effectively.

Best Practices for Using ViewModel

To harness the full power of ViewModel, consider the following best practices:

Keep UI Logic Separate: Use ViewModel strictly for UI-related data and logic; avoid referencing views or context directly to prevent memory leaks.
Leverage LiveData: Combine ViewModel with LiveData for observable and lifecycle-aware data handling.
Avoid Heavy Operations: Perform intensive tasks like network calls or database operations in repositories or use cases, and supply results to ViewModel.
Use Factory for Parameters: When ViewModel requires parameters, utilize ViewModelProvider.Factory to supply dependencies properly.

Example of ViewModel with Factory:

class UserViewModel(private val userId: String) : ViewModel() {
    // ViewModel implementation
}

class UserViewModelFactory(private val userId: String) : ViewModelProvider.Factory {
    override fun <T : ViewModel> create(modelClass: Class<T>): T {
        return UserViewModel(userId) as T
    }
}
// Usage in Activity
val factory = UserViewModelFactory("user123")
val viewModel = ViewModelProvider(this, factory).get(UserViewModel::class.java)

Conclusion

Android’s ViewModel is a powerful tool that simplifies data management across configuration changes, enhances user experience, and promotes clean architecture in app development. By understanding its internal workings and following best practices, developers can build robust, efficient, and user-friendly applications with ease.

Remember, ViewModel is your app’s trusty assistant, diligently preserving and managing data behind the scenes, so you can focus on delivering exceptional user experiences.