MVVM Architecture For Android Development

Short Note
MVVM stands for Model, View, ViewModel.

●​ Model:
This is the data layer of the application. Data layer classes should not directly
communicate with the View. Communications should happen through the
ViewModels.

●​ View:
This is the presentation(User Interface) layer of the application . It
observes(LiveData or Flow) the ViewModel. It should not hold any application
logic related codes.

●​ ViewModel:
ViewModel means "a model for a view". Usually each activity has its own
ViewModel. ViewModel acts as a link between the Model and the View(activity
and fragments). It’s responsible for transforming the data from the Model and
providing them to the View. It also sends data(user inputs) from the view to the
model. In some situations, It also uses callbacks to update the View. ​
​
​
This diagram(copied from google's official documentation) shows the architecture
diagram we follow in Android MVVM projects.
What is the difference between MVVM architecture and MVVM clean architecture?

In MVVM clean architecture, when required we add use case classes between the
ViewModel and Repository. Also we define interfaces first and then create their
implementation classes for many data layer components. MVVM clean architecture is
just a more readable, expandable and testable improvement of MVVM architecture.

MVVM pattern has some similarities with the MVP(Model — View — Presenter) design
pattern as the Presenter role is played by ViewModel. However, the drawbacks of the
MVP pattern has been solved by MVVM in the following ways:
1.​ ViewModel does not hold any kind of reference to the View.
2.​ Many to-1 relationships exist between View and ViewModel.
3.​ No triggering methods to update the View.
Ways to Implement MVVM in the Project
There are 2 ways to implement MVVM design pattern in Android projects:
1.​ Using the DataBinding library released by Google
2.​ Using any tool like RxJava for DataBinding.
Data Binding:
Google releases the Data Binding Library for Android that allows the developers to bind
UI components in the XML layouts with the application’s data repositories. This helps in
minimizing the code of core application logic that binds with View. Further, Two – way
Data Binding is done for binding the objects to the XML layouts so that object and the
layout both can send data to each other. This point can be visualized by the example of
this tutorial.
Syntax for the two way data binding is @={variable}
Advantages of MVVM Architecture
●​ Enhance the reusability of code.
●​ All modules are independent which improves the testability of each layer.
●​ Makes project files maintainable and easy to make changes.
Disadvantages of MVVM Architecture
●​ This design pattern is not ideal for small projects.
●​ If the data binding logic is too complex, the application debug will be a little
harder.

Difference Between MVC, MVP, and MVVM

Design Pattern

MVC(MODEL VIEW MVP(MODEL VIEW MVVM(MODEL

CONTROLLER) PRESENTER) VIEW VIEWMODEL)
 Developed as the second
Industry-recognized
One of the oldest iteration of software
architecture pattern
software architecture architecture which is advanced
for applications.
from MVC.

This architecture
pattern is more
It resolves the problem of
UI(View) and event-driven as it
having a dependent View by
data-access uses data binding
using Presenter as a
mechanism(Model) are and thus makes easy
communication channel
tightly coupled. separation of core
between Model and View.
business logic from
the View.

Controller and View Multiple View can be

exist with the mapped with a single
The one-to-one relationship
one-to-many ViewModel and thus,
exists between Presenter and
relationship. One the one-to-many
View as one Presenter class
Controller can select a relationship exists
manages one View at a time.
different View based between View and
upon required operation. ViewModel.

The View has no The View has

The View has references to the
knowledge about the references to the
Presenter.
Controller. ViewModel
 Easy to make
changes in the
Difficult to make changes
Code layers are loosely application. However,
and modify the app
coupled and thus it is easy to if data binding logic
features as the code
carry out modifications/changes is too complex, it will
layers are tightly
in the application code. be a little harder to
coupled.
debug the
application.

The View takes the

input from the user
User Inputs are handled The View is the entry point to
and acts as the entry
by the Controller. the Application
point of the
application.

Ideal for small scale Ideal for simple and complex Not ideal for small
projects only. applications. scale projects.

Easy to carry out Unit testing

Unit testability is
Limited support to Unit but a tight bond of View and
highest in this
testing. Presenter can make it slightly
architecture.
difficult.
 This architecture has a Has low or no
It has a low dependency on the
high dependency on dependency on the
Android APIs.
Android APIs. Android APIs.

Follows modular and

It does not follow the single responsibility
Follows modular and single
modular and single principle.
responsibility principle.
responsibility principle.

1. How MVVM Works?

The View is responsible for displaying the data and capturing user input,
the Model represents the data and business logic, and the ViewModel acts
as an intermediary between the View and the Model, exposing data and
commands that the View can bind to. When the user interacts with the
View, the ViewModel updates the Model, and any changes in the Model are
automatically reflected in the View through data binding.

2. What are the advantages of using MVVM?

Separation of concerns: It enforces a clear separation between the View,
ViewModel, and Model, which makes the code easier to understand,
maintain, and test.​
Testability: Since the business logic is encapsulated in the ViewModel, it
can be easily unit tested without requiring a user interface.​
Flexibility: Allows a high degree of flexibility in designing user interfaces,
as the View and ViewModel can be easily replaced or modified without
affecting the Model.​
Data binding: MVVM makes use of data binding, which allows for
automatic synchronization of data between the View and the ViewModel,
reducing the need for manual updates and event handling.

3. How does data binding work in MVVM?

Data binding is a key feature of MVVM that allows for the automatic
synchronization of data between the View and the ViewModel. In MVVM,
the View binds to properties or commands exposed by the ViewModel, and
any changes in these properties or commands are automatically reflected
in the View.

4. How does validation work in MVVM?

Validation is done in the ViewModel. The ViewModel validates the data
entered by the user in the View before updating the Model. The View can
display validation errors using data binding and visual cues, such as red
borders or error messages. Validation logic in the ViewModel can be
implemented using data annotations, custom validation rules, or third-party
validation libraries.

5. How do you handle Unit Testing in MVVM

architecture?
●​ In MVVM architecture, unit testing is typically done by writing tests for
the ViewModel to ensure its business logic and behavior are working
correctly. This can be achieved by following these simple steps:​
​
1. Write tests- that define the expected behavior of the ViewModel,
such as input validation, data manipulation, or command execution.​
2. Use mocking or stubbing frameworks to isolate the ViewModel
from external dependencies, such as data sources or services, during
testing.​
3. Execute the tests using a unit testing framework, such as NUnit,
 MSTest, or Jasmine, to validate that the ViewModel behaves as
expected.​
4. Analyze the test results to identify and fix any issues or defects in
the ViewModel’s behavior.​
5. Update the tests as needed to accommodate changes in the
ViewModel’s behavior or requirements.

6. What are some best practices for MVVM

development?
●​ Separate Responsibilities: Keep Model, View, and
ViewModelindependente. The model handles data and logic, View
handles UI, and ViewModel mediates between the Model and View.
●​ Follow Single Responsibility Principle (SRP): Each component should
have a single responsibility, e.g., Model for data, View for UI, and
ViewModel for data manipulation.
●​ Write Unit Tests: Write unit tests for ViewModel to ensure its
correctness and reliability.
●​ Use Dependency Injection: Use dependency injection to provide
dependencies to ViewModel for loose coupling and testability.

7. How do you handle Navigation in MVVM

architecture?
In MVVM architecture, navigation is typically handled through the use of a
separate component called a Navigation Service or Navigator. The
ViewModel is responsible for defining the navigation logic, while the View is
responsible for displaying the UI. When a navigation action is triggered
from the View, such as a button click, the View notifies the ViewModel.​
​
The ViewModel then uses the Navigation Service to request a navigation
action, specifying the target View and any required parameters. The
Navigation Service is responsible for changing the current View to the
target View, which may involve pushing a new View onto the navigation
stack, popping the current View, or replacing the current View with a new
View.

8. Why do you think MVVM is a better choice than

MVC for developing Android apps?
I think that MVVM is a better choice for developing Android apps for a few
reasons. First, it allows for a more separation of concerns between the
different parts of the app, which can make development and maintenance
simpler.
Second, it can make it easier to bind data to the UI, since the ViewModel
can act as a mediator between the data and the View.
Finally, it can help to improve performance, since the ViewModel can
handle tasks that would otherwise need to be done on the UI thread.

9. Is it necessary to use the data binding library with

MVVM on Android?
While the data binding library is not required to use MVVM on Android, it
can greatly simplify the process. The data binding library allows you to bind
data directly to views, eliminating the need for manual view updates. This
can help to keep your code clean and maintainable.

10. Can you explain how data binding works in

MVVM?
Data binding is a process that allows you to automatically synchronize your
ViewModel and View. When data binding is enabled, any changes that you
make to your ViewModel will be automatically reflected in your View. This
makes it easier to keep your View and ViewModel in sync, and can help to
reduce the amount of boilerplate code that you need to write.
11. How does Model-View-ViewModel (MVVM) differ
from other design patterns like Model-View-Controller
(MVC)?
The main difference between MVVM and other design patterns is that
MVVM separates the view (i.e. the user interface) from the model (i.e. the
data). This separation allows for a more modular and testable codebase.
Additionally, MVVM typically uses data binding to automatically update the
view when the model changes, which further reduces the amount of code
that needs to be written.

12. What’s the difference between two-way and

one-way data binding?
Two-way data binding means that changes to either the model or the view
will update the other automatically. One-way data binding means that
changes to the model will update the view, but not vice versa.

13. What are some of the advantages and disadvantages

of using MVVM in Android development?
Some advantages of using MVVM in Android development include the
ability to easily bind data to UI elements, a clean separation of concerns
between the View and ViewModel, and the ability to easily unit test the
ViewModel.
Some disadvantages of using MVVM in Android development include the
potential for a lot of boilerplate code, and the fact that it can be difficult to
debug data bindings.

14. Are there any alternate ways to achieve MVVM

architecture outside of the official data binding
library? If yes, can you give me an example?
There are a few ways to achieve MVVM architecture outside of the official
data binding library. One way is to use the LiveData and ViewModel
classes from the Android Architecture Components library. Another way is
to use the RxJava library to create observables that can be subscribed to
by the UI.

15. How can you improve performance when using

data binding in Android?
One way to improve performance when using data binding is to use the
@Bindable annotation. This annotation tells the data binding system to only
update the UI when the data has actually changed. Without this annotation,
the data binding system will update the UI every time any data is changed,
even if the UI doesn’t need to be updated.

16. How would you implement MVVM without using

the support libraries?
There are a few ways to implement MVVM without using the support
libraries. One way would be to use a library like RxJava to manage your
data bindings. Another way would be to use the Data Binding Library from
Google.

17. What is LiveData? Why should we use it in our

android app?
LiveData is a data holder class that can be observed within a given
lifecycle. This means that you can observe LiveData objects for changes
and update the UI accordingly. LiveData is especially useful in Android
applications because it helps to avoid memory leaks and can automatically
update the UI when data changes.
18 What’s the difference between Observables and
LiveData?
LiveData is an observable data holder class. It is lifecycle-aware, meaning
it respects the lifecycle of other app components, such as activities,
fragments, or services. This awareness ensures LiveData only updates app
component observers that are in an active lifecycle state.
Observables, on the other hand, are not lifecycle-aware. This means they
will continue to emit data even if the observer is no longer in an active
state, such as when an activity has been destroyed. This can lead to
memory leaks if the observer is not unregistered when no longer needed.

19. What is the recommended way of implementing a

ViewModel class in an Android app?
The recommended way of implementing a ViewModel class in an Android
app is to use the Android Architecture Components library. This library
provides a ViewModel class that is specifically designed for use with
Android apps. The ViewModel class is designed to help manage data that
is specific to a particular activity or fragment, and it is also designed to
survive configuration changes such as screen rotations.

20. Can you explain what dependency injection means

in the context of MVVM?
Dependency injection is a technique used to remove the hard-coded
dependencies from a class, making it more flexible and easier to test. In the
context of MVVM, dependency injection can be used to inject view models
into views, allowing the view model and view to be decoupled. This makes
it easier to unit test the view model, as it can be tested in isolation.

21. Does MVVM depend on some other architectural

pattern or framework?
No, MVVM does not depend on any other architectural pattern or
framework.

22. What tools and technologies are used for

implementing MVVM on Android?
There are a few different ways to implement MVVM on Android. One
popular way is to use the Android Data Binding Library, which allows you to
bind data directly to views in your layout file. Other popular tools and
technologies used for MVVM on Android include RxJava and LiveData.

23. Can you explain what reactive programming is?

Reactive programming is a programming paradigm that is concerned with
data streams and the propagation of change. This means that when a
piece of data changes, all observers of that data are notified and updated
automatically. This is in contrast to the more traditional approach of having
to manually keep track of what data has changed and then update the
observers accordingly.

24. How does reactive programming relate to event

handling?
Reactive programming is a programming paradigm that is concerned with
data streams and the propagation of changes. Event handling, on the other
hand, is a way of responding to events that occur in a program. In the
context of Android development, reactive programming can be used to
handle events such as user input, while event handling is used to respond
to events such as button clicks.

25. What do you understand about observables and

observers in the context of reactive programming?
In reactive programming, observables are objects that emit a stream of
data, and observers are objects that consume that data. In the context of
Android development, observables can be used to emit data from a
ViewModel to a View, and observers can be used to consume that data and
update the UI.

26. Do you think RxJava is useful for Java developers

who want to learn more about reactive programming?
Yes, I think RxJava is a great tool for Java developers who want to learn
more about reactive programming. It can be used to create asynchronous
and event-based applications.