Android ViewModel.

The ViewModel class is business logic or screen level state holder.

Lets understand What is ViewModel its Benefits and How it works internally to hold the state.

• ViewModelThe Android ViewModel is a part of the Android Architecture Components, which are a set of libraries and guidelines for building robust, maintainable, and scalable Android applications. The ViewModel is specifically designed to store and manage UI-related data in a lifecycle-conscious manner, separate from the user interface components such as Activities and Fragments.

ViewModel Benefits

• Lifecycle-Aware: ViewModels are designed to be lifecycle-aware, meaning they are tied to the lifecycle of an associated UI component (usually an Activity or Fragment). This helps prevent memory leaks and ensures that the ViewModel's data is retained and properly managed across configuration changes like screen rotations.
• Separation of Concerns: ViewModels help in separating the UI logic from the UI components, making the codebase cleaner and more maintainable. This encourages the "MVVM" (Model-View-ViewModel) architectural pattern.
• Configuration Changes: One of the main benefits of ViewModels is that they survive configuration changes like screen rotations. This is important because it allows your app to maintain its state and data across these changes without needing to reload or re-fetch data.
• No Direct UI References: ViewModels should not hold references to UI components like Views or Activities directly. This helps avoid memory leaks and ensures that the ViewModel is not tightly coupled to specific UI components.
• Data Persistence: ViewModels hold data that's relevant to the UI state, and this data is retained across configuration changes (like device rotation). This eliminates the need to save and restore data explicitly during such events.
• Testing: Since ViewModels are designed to be independent of the UI, they are easy to test. You can write unit tests for ViewModels without needing to deal with UI components.

How it works internally

• Lifecycle Awareness: ViewModels are designed to be lifecycle-aware. This means they are created and managed by the ViewModelStore, which is associated with the lifecycle of the UI component (Activity or Fragment). When the UI component is destroyed, the associated ViewModel is also cleared from the store.
• ViewModelStore: Each UI component (Activity or Fragment) has its own ViewModelStore. This store holds references to all the ViewModels associated with that specific component.
• ViewModelProvider: To create or retrieve a ViewModel, you use the ViewModelProvider class. This class is responsible for checking if a ViewModel already exists in the ViewModelStore associated with the current UI component. If it exists, it returns the existing instance; otherwise, it creates a new instance and adds it to the store.
• No Memory Leaks: ViewModel is designed to avoid memory leaks by not holding references to the UI components themselves. Instead, it holds references to the data relevant to the UI state. This allows the UI components to be garbage collected when they are no longer needed, while the ViewModel's data remains intact in the ViewModelStore.
• Cleared on Lifecycle End: When the associated UI component is destroyed and its lifecycle reaches the "onCleared" state, the ViewModel is informed that it's no longer needed. At this point, the ViewModel's onCleared() method is called, allowing you to perform cleanup tasks, such as releasing resources or cancelling ongoing operations.

In summary, ViewModel is a component that helps manage UI-related data by utilising lifecycle awareness and a ViewModelStore. It retains data across configuration changes, avoids memory leaks, and provides a clean separation of UI logic from the UI components themselves. This results in more maintainable and organised code in your Android app.