EasyMVP – Android library with annotation processing and bytecode weaving

A powerful, and very simple MVP library with annotation processing and bytecode weaving.

EasyMVP eliminates the boilerplate code for dealing with MVP implementation.

Features

• Easy integration
• Less boilerplate
• Composition over inheritance
• Implement MVP with just few annotations
• Use Loaders to preserve presenters across configurations changes
• Support Clean Architecture approach.

Installation

Configure your project-level build.gradle to include the 'easymvp' plugin:

buildscript {
  repositories {
    jcenter()
   }
  dependencies {
    classpath 'com.sixthsolution.easymvp:easymvp-plugin:1.0.1'
  }
}

Then, apply the 'easymvp' plugin in your module-level build.gradle:

apply plugin: 'easymvp'

android {
  ...
}

There is no need for android-apt plugin for android gradle plugin version 2.2.0-alpha1 or higher. But if your are using it, please apply easymvp plugin after android-apt plugin.

apply plugin: 'com.neenbedankt.android-apt'
apply plugin: 'easymvp'

For reactive API, simply apply the 'easymvp-rx' plugin in your module-level build.gradle and then add the RxJava dependency:

apply plugin: 'easymvp-rx'

dependencies {
  compile 'io.reactivex:rxjava:x.y.z'
}

Usage

First thing you will need to do is to create your view interface.

publicinterfaceMyView {voidshowResult(StringresultText);voidshowError(StringerrorText);
}

Then you should implement MyView in your Activity, Fragment or CustomView.But why?

• Improve unit testability. You can test your presenter without any android SDK dependencies.
• Decouple the code from the implementation view.
• Easy stubbing. For example, you can replace your Activity with a Fragment without any changes in your presenter.
• High level details (such as the presenter), can't depend on low level concrete details like the implementation view.

Presenter

Presenter acts as the middle man. It retrieves data from the data-layer and shows it in the View.

You can create a presenter class by extending of the AbstractPresenter or RxPresenter (available in reactive API).

publicclassMyPresenterextendsAbstractPresenter<MyView> {

}

To understand when the lifecycle methods of the presenter are called take a look at the following table:

View Annotations

Well, here is the magic part. There is no need for any extra inheritance in your Activity, Fragment or View classes to bind the presenter lifecycle.

Presenter's creation, lifecycle-binding, caching and destruction gets handled automatically by these annotations.

For injecting presenter into your activity/fragment/view, you can use @Presenter annotation. Also during configuration changes, previous instance of the presenter will be injected.

EasyMVP uses Loaders to preserve presenters across configurations changes.

Presenter instance will be set to null, after onDestroyed method injection.

@ActivityView example:

@ActivityView(layout=R.layout.my_activity, presenter=MyPresenter.class)publicclassMyActivityextendsAppCompatActivityimplementsMyView {@PresenterMyPresenter presenter;@OverrideprotectedvoidonCreate(BundlesavedInstanceState) {super.onCreate(savedInstanceState);
    }@OverrideprotectedvoidonStart() {super.onStart();// Now presenter is injected.
    }@OverridepublicvoidshowResult(StringresultText) {//do stuff
    }@OverridepublicvoidshowError(StringerrorText) {//do stuff
    }
}

• You can specify the layout in @ActivityView#layout and EasyMVP will automatically inflate it for you.

@FragmentView example:

@FragmentView(presenter=MyPresenter.class)publicclassMyFragmentextendsFragmentimplementsMyView {@PresenterMyPresenter presenter;@OverridepublicvoidonResume() {super.onResume();// Now presenter is injected.
    }@OverridepublicvoidshowResult(StringresultText) {//do stuff
    }@OverridepublicvoidshowError(StringerrorText) {//do stuff
    }
}

@CustomView example:

@CustomView(presenter=MyPresenter.class)publicclassMyCustomViewextendsViewimplementsMyView {@PresenterMyPresenter presenter;@OverrideprotectedvoidonAttachedToWindow() {super.onAttachedToWindow();// Now presenter is injected.
    }@OverridepublicvoidshowResult(StringresultText) {//do stuff
    }@OverridepublicvoidshowError(StringerrorText) {//do stuff
    }
}

Injecting with Dagger

@Presenter annotation will instantiate your presenter class by calling its default constructor, So you can't pass any objects to the constructor.

But if you are using Dagger, you can use its constructor injection feature to inject your presenter.

So what you need is make your presenter injectable and add @Inject annotation before @Presenter. Here is an example:

publicclassMyPresenterextendsAbstractPresenter<MyView> {@InjectpublicMyPresenter(UseCase1useCase1, UseCase2useCase2){

    }
}

@ActivityView(layout=R.layout.my_activity, presenter=MyPresenter.class)publicclassMyActivityextendsAppCompatActivityimplementsMyView {@Inject@PresenterMyPresenter presenter;@OverrideprotectedvoidonCreate(BundlesavedInstanceState) {SomeDaggerComponent.injectTo(this);super.onCreate(savedInstanceState);
     }//...
}

Don't inject dependencies after super.onCreate(savedInstanceState); in activities, super.onActivityCreated(bundle); in fragments and super.onAttachedToWindow(); in custom views.

Clean Architecture Usage

You can follow the principles of Clean Architecture by applying 'easymvp-rx' plugin. Previous part was all about the presentation-layer, Now lets talk about the domain-layer.

Domain Layer holds all your business logic, it encapsulates and implements all of the use cases of the system. This layer is a pure java module without any android SDK dependencies.

UseCase

UseCases are the entry points to the domain layer. These use cases represent all the possible actions a developer can perform from the presentation layer.

Each use case should run off the main thread(UI thread), to avoid reinventing the wheel, EasyMVP uses RxJava to achieve this.

You can create a use case class by extending of the following classes:

publicclassSuggestPlacesextendsObservableUseCase<List<Place>, String> {privatefinalSearchRepository searchRepository;publicSuggestPlaces(SearchRepositorysearchRepository, UseCaseExecutoruseCaseExecutor,PostExecutionThreadpostExecutionThread) {super(useCaseExecutor, postExecutionThread);this.searchRepository = searchRepository;
    }@OverrideprotectedObservable<List<Place>>interact(@NonNullStringquery) {return searchRepository.suggestPlacesByName(query);
    }
}

publicclassInstallThemeextendsCompletableUseCase<File> {privatefinalThemeManager themeManager;privatefinalFileManager fileManager;publicInstallTheme(ThemeManagerthemeManager,FileManagerfileManager,UseCaseExecutoruseCaseExecutor,PostExecutionThreadpostExecutionThread) {super(useCaseExecutor, postExecutionThread);this.themeManager = themeManager;this.fileManager = fileManager;
    }@OverrideprotectedCompletableinteract(@NonNullFilethemePath) {return themeManager.install(themePath)
                .andThen(fileManager.remove(themePath))
                .toCompletable();
    }

}

And the implementations of UseCaseExecutor and PostExecutionThread are:

publicclassUIThreadimplementsPostExecutionThread {@OverridepublicSchedulergetScheduler() {returnAndroidSchedulers.mainThread();
    }
}publicclassBackgroundThreadimplementsUseCaseExecutor {@OverridepublicSchedulergetScheduler() {returnSchedulers.io();
    }
}

DataMapper

Each DataMapper transforms entities from the format most convenient for the use cases, to the format most convenient for the presentation layer.

But, why is it useful?

Let's see SuggestPlaces use case again. Assume that you passed the Mon query to this use case and it emitted:

• Montreal
• Monterrey
• Montpellier

But you want to bold the Mon part of each suggestion like:

• Montreal
• Monterrey
• Montpellier

So, you can use a data mapper to transform the Place object to the format most convenient for your presentation layer.

publicclassPlaceSuggestionMapperextendsDataMapper<List<SuggestedPlace>, List<Place>> {@OverridepublicList<SuggestedPlace>call(List<Place>places) {//TODO for each Place object, use SpannableStringBuilder to make a partial bold effect
    }
}

Note that Place entity lives in the domain layer but SuggestedPlace entity lives in the presentation layer.

So, How to bind DataMapper to ObservableUseCase?

publicclassMyPresenterextendsRxPresenter<MyView> {privateSuggestPlace suggestPlace;privateSuggestPlaceMapper suggestPlaceMapper;@InjectpublicMyPresenter(SuggestPlacesuggestPlace, SuggestPlaceMappersuggestPlaceMapper){this.suggestPlace = suggestPlace;this.suggestPlaceMapper = suggestPlaceMapper;
    }voidsuggestPlaces(Stringquery){
        addSubscription(
                       suggestPlace.execute(query)
                                     .map(suggetsPlaceMapper)
                                     .subscribe(suggestedPlaces->{//do-stuff
                                      })
                        );
    }
}

FAQ

How does EasyMVP work under the hood?

• For each annotated class with @ActivityView, @FragmentView or @CustomView, EasyMVP generates *_ViewDelegate class in the same package. These classes are responsible for binding presenter's lifecycle.
• EasyMVP uses bytecode weaving to call delegate classes inside your view implementation classes. You can find these manipulated classes in build/weaver folder.

Is there any restrictions on using EasyMVP?

• EasyMVP uses android's transform API for bytecode weaving. Related to this issue the Jack toolchain doesn't support it yet.

Documentations

EasyMVP API: Javadocs for the current API release

EasyMVP RX-API: Javadocs for the current RX-API (Clean Architecture API) release

Author

Saeed Masoumi

License

Copyright 2016 6thSolution

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.