Android MVP explanation

Question

I try to understand what the best way is to program a "clean" Android app. I found an interesting article about it where they use a kind of a 3 layer architecture.

Now I read that android uses the MVP design pattern and try to understand this. The way I understand the MVP principle (in the android context) is that:

• the Model layer are the logic classes
• the presenter are the classes that are "linked" to an XML (the activities)
• the passive view are the XML's.

Is this correct?

When this is correct, is it then also correct that the 3 layer model fits perfectly in the MVP principle because:

1. the presentation layer from the 3 layer architecture fits in the presenter layer of MVP
2. The business and the data layer from the 3 layer architecture fits perfectly in the model part of the MVP?

I hope my questions are clear because it is a complicated topic for me.

Maybe this clears up my vision (way of thinking) about this...

Answer 1

first thing I wanted to clarify is that MVP or any other pattern for that matter is no specific of Android dev and, can be applied to any other framework.

I think you got the gist of it:

• view is usually implemented by activities and fragments and will contain the reference to the presenter
• the presenter is that middle man between the view and model. Retrieves data from the model and returns it already formatted to the view so it doesn't need to do anything else but display it.
• the model can be seen in a simplistic way as the "data provider". It can be as complex as you want, using internal db, lots of clases etc.

If you are interested in Android apps architecture I suggest you watch this talk given at Android dev summit this year. It is one of the bests I've seen

https://www.youtube.com/watch?v=BlkJzgjzL0c

Answer 2

Even though this question has an answer, I don't think this answer is complete by any means.

MVP is a general concept which can have many various implementations, some of which differ substantially. Moreover, the concept itself is very ambiguous - different people can have different concepts in mind when they say MVP. One of the most widespread ones is shown in the below picture:

Regardless of implementation, the general definitions of MVP components are:

• Model: abstraction of "application state storage". The definition of what the "state" is and how it is stored are implementation details. Model implementations should not have dependency on View or Presenter.
• View: abstraction of "user interface". The definition of who the "user" is and how it interacts with the View are implementation details. View implementations should not have dependency on Model or Presenter.
• Presenter: encapsulates application's business logic. Presenter processes user input events received from view, and alters application's state stored in model in response. Presenter also processes changes of application's state stored in model and updates view in response. Presenter usually depends on both the View and the Model.

If you need more information about MVP in context of Android development, you can find it in this post: MVP and MVC Architectural Patterns in Android

Answer 3

Important issues which need to be addressed while implementing MVP in android are activity leaks which cause memory leaks and app crashes due to background process updating closed activity.

Due to presenter having reference to activity, if presenter can't be garbage collected, activity will stay in memory.

Both of the issues can be solved by using life cycle methods of activity or fragment and releasing resources in those methods so that memory leaks and app crashes are prevented.

Cleaning up of resources related background work can be easily implemented using RXJava, for more information about MVP and MVP with RXJava, see http://www.zoftino.com/android-model-view-presenter-mvp-pattern-example

Answer 4

Here is simplest way to implement MVP pattern in your application android_mvp_login_sample

Answer 5

As you have come to know basics of Clean Architechure. The following example depicts how actual your MVP pattern is implemented.

Example:

interface BaseContract {
        interface BaseView {
            //Methods for View
            void onDoSomething();
        }

        interface BasePresenter {
            void doSomething();

        }
    }

    class BaseMainPresenter implements BaseContract.BasePresenter {
        BaseContract.BaseView view;

        BaseMainPresenter(BaseContract.BaseView view) {
            this.view = view;
        }

        @Override
        public void doSomething() {
            if (view != null)
                view.onDoSomething();
        }
    }

    class DemoClass implements BaseContract.BaseView {

        //Create object of Presenter 

        /****
         * Example :
         * BaseMainPresenter baseMainPresenter = new BaseMainPresenter(this);
         */
        @Override
        public void onDoSomething() {
            //Deal with Context here.
        }
    }

Refer below link for sample Actual implementation with scenario & learn more about Clean Architechure : https://github.com/android10/Android-CleanArchitecture

Answer 6

Here on github https://github.com/saksham24/Android-Firebase-Mvp-Mvc-Mvvm-chat i made a repo containing 3 applications with same functionality but written in 3 different android patterns(Mvc, Mvp, Mvvm)

Understanding three different pattern is quite easy if we get a simple good example on them so i made a repo to contribute my knowledge to this developer community. Also the repository is written using proper java guidelines and conventions(including naming and packages, modules) so people looking for such project can also view this repository.

now

1. if you want to know the difference between android Mvp,Mvc, MvvM see this explanation by realm https://academy.realm.io/posts/eric-maxwell-mvc-mvp-and-mvvm-on-android/

2. if you want to compare three pattern see this wonder full blog https://thinkmobiles.com/blog/mvp-vs-mvvm-android-patterns/

Answer 7

Now I read that android uses the MVP design pattern and try to understand this. The way I understand the MVP principle (in the android context) is that:

• the Model layer are the logic classes

• the presenter are the classes that are "linked" to an XML (the activities)

• the passive view are the XML's.

Is this correct?

Not fully: for the Model layer it is true, but for the Presenter it is not. The Presenter is not linked to XML although it has reference to the View through its constructor. The View is the Activity/Fragment in android.

You might want to check here for a sample MVP app for android.