Android MVP With Examples

In this tutorial, we’ll be discussing the android MVP principles and develop an application based on it. Since the start, we’ve been developing applications by adding all the business logic inside the Activity. Let’s analyze the cons of our current approach before digging into the new principles.

Android MVP

With our current approach, the MainActivity class contains all the implementation logic of our application. We’ve been using stuff ranging from Retrofit callbacks to data models(SharedPref, POJO classes) all inside the Activity class.

Eventually, our Activities become god classes and cause problems in maintainability, readability, scalability and refactoring an already bloated code.

Unit testing gets tough since the implementation logic is tightly coupled with the Android APIs. This is where MVP ( Model View Presenter) comes in handy. It allows us to write a clean and flexible code base while giving the luxury to switch any part of the code without much hassle.

Model View Presenter

Model View Presenter divides our application into three layers namely the Model, View and Presenter.

  1. Model: This handles the data part of our application
  2. Presenter: It acts as a bridge that connects a Model and a View.
  3. View: This is responsible for laying out views with the relevant data as instructed by the Presenter

Note: The View never communicates with Model directly.

Android MVP Architecture

The diagram below depicts a basic MVP structure.


Android MVP Guidelines

  1. Activity, Fragment and a CustomView act as the View part of the application.
  2. The Presenter is responsible for listening to user interactions (on the View) and model updates (database, APIs) as well as updating the Model and the View.
  3. Generally, a View and Presenter are in a one to one relationship. One Presenter class manages one View at a time.
  4. Interfaces need to be defined and implemented to communicate between View-Presenter and Presenter-Model.
  5. The Presenter is responsible for handling all the background tasks. Android SDK classes must be avoided in the presenter classes.
  6. The View and Model classes can’t have a reference of one another.

Having covered the theory of MVP architecture, let’s build an android MVP app now.

Android MVP Example App Project Structure


The android mvp project consists of 3 interface files (also known as contracts). The Impl files are where the interfaces are implemented.

We’ll be creating a single activity application that’ll display a random quote from a list of quotes present in an ArrayList. We’ll see how the presenter manages to keep the business logic of the application away from the activity class.

Note: Interactors are classes built for fetching data from your database, web services, or any other data source.

Android MVP app code

The code for the activity_main.xml layout is given below.

The code for the GetQuoteInteractor interface is given below.

It contains a nested interface onFinishedListener. We’ll be using a handler inside our below. On completion of the handler, the above onFinished method would be triggered.

The interface is defined below.

showProgress() and hideProgress() would be used for displaying and hiding the progressBar while the next random quote is fetched from the GetQuoteInteractorImpl class.

setQuote() will set the random string on the textView.

The code for the interface is given below.

The class is defined below.

The above class implements the Presenter and nested interface from GetQuoteInteractor. Moreover it instantiates the MainView and GetQuoteInteractor interfaces (View and Model respectively).

onButtonClick method would be triggered in the MainActivity class when the button is clicked and will display a progressBar while it gets the next random quote.

onDestroy() method would be invoked inside the lifecycle method onDestroy() of the MainActivity.

onFinished() method gets called when the handler is completed inside the GetQuoteInteractorImpl. It returns the string which will be displayed in the TextView using the MainView’s instance.

The code for the which implements MainView interface is given below.

showProgress() and hideProgress() methods shows and hides the textView as well to prevent overlapping the current text and the progressBar.

Note: The above class contains is now devoid of the business logic and is responsible for only updating the UI based on the changes triggered by the Presenter layer.

The output of the above android MVP application is given below.
android mvp pattern app example

Note: Google recommends to keep a single contract interface file for the Model View and Presenter.

So let’s club the interfaces defined above into one.

The project structure now looks like this:


The code for the interface is given below.

This brings an end to this tutorial. There’s a lot more to explore in MVP pattern that we’ll be discussing soon.

You can download the Android MVP Hello World Project from the link below.

Reference: Wikipedia

By admin

Leave a Reply

%d bloggers like this: