A fast integration framework: MVP+Dagger+mainstream framework, it is enough

Preface

In the Android technology circle this year, the words MVP, Dagger2, Rxjava, and Retrofit are very popular. You can find a lot of articles about these technologies in any technical forum you open. Github is also full of open source projects or demos titled "xxxx" based on MVP+Retrofit+RxJava+Dagger2+MaterialDesign.

But everyone is so enthusiastic about open-sourcing such projects, and has been doing the same thing over and over again to teach everyone how to use it. Have you ever thought about relying on a third-party library to quickly build such a framework?

characteristic

• Automatically generate MVP, Dagger2 related classes
• Version Update
• Changelog
• A universal framework, suitable for all types of projects, supports the development of large projects, and the Demo package structure can be used directly
• All are managed using Dagger2 (connecting all modules using Dagger is not a simple use)
• Extensive use of RxJava
• After changing the package name (do not change the common package), you can use it directly and quickly access it (please follow the steps below to access the old project)
• All UI adaptive
• The image loading class ImageLoader uses the strategy mode and builder mode to easily switch the image loading framework and function extension
• The Model layer provides Retrofit API and RxCache. You can choose whether to use cache.
• Global http Request (request parameters, headers) Response (results returned by the server, headers, time consumed) information monitoring, can parse JSON and perform corresponding global operations based on the status code
• Global Rxjava error handling, automatic retry after error, capture all errors of the entire application

Framework

Package Structure

Development Notes

• Developers need to have certain Android development capabilities
• Developers must have experience using Dagger2, Rxjava, and Retrofit. If you have not used them, you must understand them, otherwise it will be difficult to use them.

Libraries Introduction

1. Mvp is an Mvp architecture project officially produced by Google, which contains multiple different architecture branches (this is the Dagger branch).
2. Dagger2Google is a dependency injection framework based on Square's Dagger1. It dynamically generates code through apt, and its performance is better than the framework that uses reflection technology to inject dependencies.
3. Rxjava provides an elegant responsive API to solve asynchronous requests.
4. RxAndroid provides responsive APIs for Android.
5. RxLifecycle is a pitfall that everyone knows when using RxJava on Android, which is the unsubscription of the life cycle. This framework solves this problem by binding the life cycle of activity and fragment.
6. Rxbinding is JakeWharton's View binding framework, which elegantly handles View response events.
7. RxCache is a cache library that uses annotations to add secondary cache (memory, disk) to Retrofit
8. RetrofitSquare's network request library greatly reduces the code and steps of http requests.
9. Okhttp is also produced by Square. I won’t introduce it in detail. Anyone who works on Android should know it.
10. Autolayout is the Android full-size adaptation framework of Hongyang.
11. GsonGoogle's official Json Convert framework.
12. ButterknifeJakeWharton is a view injection framework.
13. Androideventbus is a lightweight Eventbus using annotations.
14. The Log framework produced by TimberJakeWharton has very little internal code, but the idea is very good.
15. Glide is the default encapsulated image loading library for this framework. You can refer to the examples to change to other libraries. The API is similar to Picasso, but the cache mechanism is more complex than Picasso. It is fast and suitable for processing large image streams. It supports gfit. Fresco is too big! It has a great advantage below 5.0. The default memory management used by systems above 5.0 is similar to Fresco.
16. Realm's speed and cross-platform nature make it the most popular database today. The only drawback is that the so library is too large.
17. LeakCanarySquare is a tool designed to detect memory leaks in Android and Java, and to display memory leak information in the notification bar.
18. RxErroHandlerRxjava error handling library, which can retry after an error occurs

1 Development Preparation

This framework is suitable for your own customization. It is not uploaded to Jcenter or Maven for the time being. Please download or clone it yourself.

1.1 Importing the framework

 compile project( ':arms' )

1.2 Reference config.build

This framework provides a config.gradle file that references a large number of third-party libraries for third-party library version management. Copy config.gradle to the root directory and reference it in the project's ***build.gradle

1.2.1 Using config.build

Because it is referenced in ***build.gradle, rootProject.xxx can be used in all build.gradle files of the entire project to use its contents

It can also be used to manage some project information, so that multiple modules can directly use one information

1.3 Dependency on Dagger2

This framework is all managed by Dagger2, so it must rely on Dagger2. Find the build.gradle of the app and add the following code

[[180060]]

1.4 Configure AndroidManifest

1.4.1 Adding permissions

1.4.2 Configuring Autolayout Meta

When using the Autolayout adaptive framework, you must configure the Meta attributes and the width and height of the design. For details, refer to Autolayout

1.4.3 Referencing Glide Custom Attributes

This framework uses Glide to load images by default, but provides a manager ImageLoader to provide a unified interface. The strategist mode can easily replace the image loading framework. This framework provides Glide's custom cache configuration information by default. Before using it, reference its custom configuration information

 <! --glide configuration-->  
 <meta-data
           android: name = "com.jess.arms.widget.imageloader.glide.GlideConfiguration"  
           android:value= "GlideModule" />

1.5 Obfuscation

Since this framework relies on a lot of third-party libraries, all rules have been provided in proguard-rules.pro under arms Module. If you want to use it, please copy it to replace proguard-rules.pro in app Module. When obfuscating, you can modify or add rules according to your needs. Before obfuscating, be sure to add Java Bean and custom components into the rules.

1.6 Version Update

! The package name of the common package must not be modified. For old versions, you need to find the class with the same name as the common package and delete it, then re-install it.

New reference to the class in the common package

If you obtained this framework by cloning or downloading:

1. You can directly use the command line git pull origin master to pull the latest version and automatically merge it
2. If you change the package name, you must execute the command git rm --cache -r app/src/main/java/me/jessyan/mvparms, and the content of Demo will not be pulled next time

If you obtain this framework by forking it to your own repository, clone or download it:

1. git remote add arms https://github.com/JessYanCoding/MVPArms.git Add a remote repository, arms is the code name of the remote repository, which can be customized. In the future, this code name will be used to operate the remote repository
2. git fetch arms pulls the latest version of the remote repository
3. git merge arms/master --allow-unrelated-histories merges the remote repository into the current branch
4. If this framework is updated later, just repeat steps 2 and 3. --allow-unrelated-histories is only added during the first merge.
5. If you change the package name, you must execute the command git rm --cache -r app/src/main/java/me/jessyan/mvparms, and the content of Demo will not be pulled next time

2 Quick Start

2.1 Inheriting BaseApplication

The Application of the new project inherits from BaseApplication and is declared in AndroidManifest

2.1.1 AppComponent

The Application life cycle is the same as that of the App, so it is suitable for providing some singleton objects. This framework uses Dagger2 management, so AppComponent is used to provide all global singleton objects.

Create the AppComponent interface

• Constructing an AppComponent object

• ServiceModule (provides RetrofitApi) and CacheModule (provides cache) need to be created by yourself, for details, see ServiceModule (2.1.2) and CacheModule (2.1.3)

2.1.2 ServiceModule

ServiceModule provides the Service corresponding to RetrofitApi. These Service objects are injected into ServiceManager (which must inherit BaseServiceManager) in AppComponent for unified management.

• Define Retrofit Service by yourself as follows. If you are familiar with Retrofit, please ignore it.

 public interface CommonService { 
 
   String HEADER_API_VERSION = "Accept: application/vnd.github.v3+json" ; 
 
   @Headers({HEADER_API_VERSION})
 @GET( "/users" )
   Observable<List< User >> getUsers(@Query( "since" ) int lastIdQueried, @Query( "per_page" ) int perPage);
 }

• Define ServiceModule, where Retrofit object (provided by ClientModule) is used to instantiate Service interface and provide all Service objects (multiple Service interfaces can be divided according to different logics)

 @Module
 public class ServiceModule { 
 
 @Singleton
 @Provides
   CommonService provideCommonService(Retrofit retrofit) {
 return retrofit.create (CommonService.class) ;
 } 
 
 }

• AppComponent injects all services into ServiceManager, and all Model layers can get this object, which means that each Model can request any API.

2.1.3 CacheModule

The Cache layer uses RxCache by default. CacheModule provides Cache objects corresponding to RetrofitApi. These Cache objects are injected into CacheManager (which must inherit BaseCacheManager) in AppComponent for unified management.

• Define the RxCache Provider yourself as follows. If you are familiar with RxCache, please ignore it.

 public interface CommonCache { 
 
   @LifeCache(duration = 2, timeUnit = TimeUnit.MINUTES)
   Observable<Reply<List< User >>> getUsers(Observable<List< User >> oUsers, DynamicKey idLastUserQueried, EvictProvider evictProvider); 
 
 }

• Define CacheModule, where RxCache object (provided by ClientModule) is used to instantiate all Cache interfaces and provide all Cache objects

 @Module
 public class CacheModule { 
 
 @Singleton
 @Provides
   CommonCache provideCommonService(RxCache rxCache) {
 return rxCache.using(CommonCache.class);
 } 
 
 }

• AppComponent injects all Cache into CacheManager, and all Model layers can get all Cache objects

2.2 Inheriting BaseActivity

Let the base class Activity of the project inherit BaseActivity. BaseActivity injects Presenter by default, so if you want to use Presenter, you must specify the corresponding paradigm and provide the Component required to inject Presenter.

2.3 Inherit BaseFragment

Let the base class Fragment of the project inherit BaseFragment. BaseFragment injects Presenter by default, so if you want to use Presenter, you must specify the corresponding paradigm and provide the Component required to inject Presenter.

2.4 MVP in Action

Define the business logic MVP and inherit the base class of MVP. Here, you can define the MVP class slightly more roughly, that is, you don’t need to define different MVP classes for each Fragment and Activity (each page). You can use a group of MVP classes according to the same business logic.

2.4.1 Contract

Here, according to Google's official MVP project, the MVP interface can be defined in the Contract for easy management. This framework does not need to define the Presenter interface, so the Contract only defines the Model and View interfaces.

2.4.2 View

Generally, Activity or Fragment implements the View interface defined in the Contract so that Presenter can call the corresponding method to operate the UI. BaseActivity injects Presenter by default. If you want to use Presenter, you must specify the Presenter type and implement setupActivityComponent to provide the Component and Module required by Presenter.

2.4.3 Model

Model implements the Model interface of Contract and inherits BaseModel, specifies the paradigm as ServiceManager and CacheManager defined above, and then obtains the required Service and Cache through the two Managers to provide the required data for Presenter (whether to use cache is up to you to choose)

2.4.4 Presenter

Most of the functions of Presenter in MVP are to obtain data from the Model layer interface and display the data by calling the View layer interface. First, implement BasePresenter, specify the Model and View paradigms, and be sure to specify the interfaces defined in the Contract. The Model and View required by Presenter are injected using Dagger2, which is both decoupled and convenient for testing. How to inject?

2.4.5 MVP Module

The Module here provides the implementation class of the View and Model interfaces (interfaces defined in the Contract) corresponding to the current business logic. The Model needs the ServiceManager and CacheManager provided in the AppComponent to implement network requests and caches, so it is necessary to get these two Managers through the Component dependency AppComponent

2.4.6 MVP Component

It should be noted here that this Component must rely on AppComponent so that it can provide the ServiceManager and CacheManager required by the Model. The inject() method can be used to inject the objects provided in the Module and AppComponent into the corresponding class. The parameters in inject() cannot be interfaces. How to inject?

 @ActivityScope
 @Component(modules = UserModule.class,dependencies = AppComponent.class)
 public interface UserComponent {
   void inject(UserActivity activity);
 }

2.4.7 Dagger Scope

In the above code, ActivityScope appears in a large number of Modules and Components. Dagger2 uses Scope to limit the life of objects provided in each Module. Dagger2 only provides one @SingletonScope by default, which is a singleton. This framework provides @ActivityScope and @FragmentScope. If you have other requirements, please implement them yourself. After Module and Component define the same Scope, the life cycle of the objects provided in the Module will be the same as that in the Component (that is, during the Component life cycle, if you need to use the objects provided in the Module, you will only call the @Provide annotated method once to get this object)

2.4.8 MVP Summary

In the future, each business logic will repeat these classes, just changing the name. It is worth noting that when you first use MVP, you will feel that there are many more classes for no reason, which is very cumbersome and troublesome. However, when the page code logic becomes more and more, you will find the benefits, clear logic, decoupling, easy team collaboration, easy testing, and easy error location. Therefore, this framework now provides Template to automatically generate code to solve this pain point, allowing developers to use this framework more happily.

3 Function Usage

3.1 App global configuration information (injected using Dagger)

GlobeConfigModule uses the builder mode to encapsulate the global configuration information of the App into the Module (using Dagger to inject it into the place where the configuration information is needed). You can configure CacheFile, InterCeptor, etc. Because the builder mode is used, if you have other configuration information that needs to be injected using Dagger, you can directly add it to the Builder without affecting other places.

 //If you need to add a Boolean field to the Log tool class to determine whether to print the Log
 @Module
 public class GlobeConfigModule {
 private Boolean isLog; 
 
       private GlobeConfigModule(Buidler buidler) {
           this.isLog = builder.isLog
 } 
 
 public   static Builder builder() {
 return new Buidler();
 } 
 
 public   static final class Buidler {
           private Boolean isLog; 
 
           privateBuidler() {} 
 
 //1. Add a method to Builder to accept the isLog field
 public Buildler isLog(Boolean isLog) {
             this.isLog = isLog;
 return this;
 } 
 
 public GlobeConfigModule build() {
 return new GlobeConfigModule(this);
 } 
 
 } 
 
 //2. Use @Provides to return isLog for Dagger to inject into the Log tool class
 @Singleton
 @Provides
       Boolean provideIsLog() {
 return isLog;
 }
 }

3.2 Global capture of HTTP requests and responses

Pass in GlobeHttpHandler through the GlobeConfigModule.globeHttpHandler() method

 @Override
   protected GlobeConfigModule getGlobeConfigModule() {
 return GlobeConfigModule
 .buidler()
               .baseurl(Api.APP_DOMAIN)
 .globeHttpHandler(new GlobeHttpHandler() {// Here you can provide a global processing class for http response results,
 // Here you can get the result returned by the server one step ahead of the client, and do some operations, such as token timeout and re-acquisition
 @Override
 public Response onHttpResultResponse(String httpResult, Interceptor.Chain chain, Response response) {
 //Here you can get the result of each http request before the client, parse it into json, and do some operations, such as detecting that the token has expired
 // Re-request token and re-execute the request
 try {
                           if (!TextUtils.isEmpty(httpResult)) {
                               JSONArray array = new JSONArray(httpResult);
                               JSONObject object = (JSONObject) array.get(0);
                               String login = object.getString( "login" );
                               String avatar_url = object.getString( "avatar_url" );
                               Timber.tag(TAG).w( "result ------>" + login + " || avatar_url------>" + avatar_url);
 } 
 
                       } catch (JSONException e) {
                           e.printStackTrace();
 return response;
 } 
 
 
 //If you find that the token is expired, you can first request the *** token, and then put the new token into the request to request again
 //Note that proceed has been called before this callback, so you must create a network request yourself, such as using okhttp to use a new request to request
                       // create a new request and   modify it accordingly using the new token
 // Request newRequest = chain.request().newBuilder().header( "token" , newToken)
 // .build(); 
 
 // // retry the request
 //
 // response.body(). close ();
 //If you use okhttp to make a new request, after the request is successful, return the returned response 
 
 //If no new result is needed, return the response parameter directly
 return response;
 } 
 
 // Here you can get the request before requesting the server and do some operations such as adding a token or header to the request
 @Override
 public Request onHttpRequestBefore(Interceptor.Chain chain, Request request) {
 //If you need to do some operations before requesting the server, return a request that has been operated on, such as adding a header, and return the request if no operation is performed 
 
                       // return chain.request().newBuilder().header( "token" , tokenId)
 // .build();
 return request;
 }
 })
 .build();
 }

3.3 Global error handling and re-execution when errors occur

If you need to use Rxjava's global error handling, you need to pass in ResponseErrorListener through the GlobeConfigModule.responseErrorListener() method, and use ErrorHandleSubscriber every time you call subscribe with Rxjava, and pass in the RxErrorHandler provided in AppComponent. This Subscribe has implemented the OnError method by default. If you want to customize it, you can override the OnError method

• Use in RxJava

3.4 Switching the Image Request Framework

This framework uses Glide by default to implement the image loading function, and uses ImagerLoader to provide a unified interface. ImagerLoader uses the strategy mode and the builder mode, which can dynamically switch the image framework (for example, switch to Picasso), and the parameters passed in when loading the image can also be expanded at will (the loadImage method does not need to be modified when the parameters need to be expanded, all through the Builder expansion, for example, if you want the internal image loading framework to clear the cache, you only need to define a boolean field, and the internal if|else is based on this field, and other operations are similar)

• When using ImageLoader, you must pass in an image loading implementation class that implements the BaseImageLoaderStrategy interface to achieve dynamic switching. Therefore, you must first implement BaseImageLoaderStrategy. When implementing, you must specify an implementation class that inherits from ImageConfig. Using the builder pattern, you can store some information, such as URL, ImageView, Placeholder, etc., which can be continuously expanded for use by the image loading framework.

• Implementing ImageCofig using the builder pattern

 public class PicassoImageConfig extends ImageConfig{ 
 
   private PicassoImageConfig(Buidler builder) {
       this.url = builder.url;
       this.imageView = builder.imageView;
       this.placeholder = builder.placeholder;
       this.errorPic = builder.errorPic;
 } 
 
 public   static Buidler builder() {
 return new Buidler();
 } 
 
 
 public   static final class Buidler {
 private String url;
       private ImageView imageView;
       private int placeholder;
       protected int errorPic; 
 
 private Buidler() {
 } 
 
 public Builder url(String url) {
 this.url = url;
 return this;
 } 
 
 public Buildler placeholder( int placeholder) {
           this.placeholder = placeholder;
 return this;
 } 
 
 public Buildler errorPic( int errorPic){
           this.errorPic = errorPic;
 return this;
 } 
 
 public Buildler imagerView(ImageView imageView) {
           this.imageView = imageView;
 return this;
 } 
 
 public PicassoImageConfig build() {
           if (url == null ) throw new IllegalStateException( "url is required" );
           if (imageView == null ) throw new IllegalStateException( "imageview is required" );
 return new PicassoImageConfig(this);
 }
 }
 }

• When constructing ImageLoader, you can pass in PicassoImageLoaderStrategy(), or you can get the ImageLoader object through AppComponent and replace the previous implementation with setLoadImgStrategy(new PicassoImageLoaderStrategy) (Glide is used by default).

3.***ndroidEventBus Tag

This framework uses AndroidEventBus to implement the event bus. This framework uses annotations to mark target methods and uniformly writes Tag constants to the EventBusTag interface for easy management. If you want to use AndroidEventBus in the current object, please rewrite useEventBus() in the Activity, Fragment, Presenter that you need to use. Return true to indicate use, and return true by default.

3.6 AutoLayout Components

This framework uses the AutoLayout framework to achieve control adaptation. To make the components adaptive, this framework must let its parent control remeasure and rewrite LayoutParams. The official only provides three ViewGroups by default, AutoRelativeLayout, AutoLinearLayout, and AutoFrameLayout to implement these operations. To facilitate developers, this framework provides some commonly used AutoLayout components. In the autolayout package under the widget package of the framework, you can make the child controls adaptive by referencing them in xml. It also provides a Template (on the *** page) for generating the Auto series Views required for adaptation. For example, if you need to make the child controls of ScrollView adaptive, use this Template to enter ScrollView to generate AutoScrollView, which can be referenced in xml.

3.7 Customizing PopupWindow

The framework provides a custom PopupWindow component CustomPopupWindow in builder mode. After implementing the layout yourself, you can directly use this implementation of PopupWindow. Using the builder mode, you can freely expand custom parameters.

3.8 Quickly implement RecycleView

This framework provides DefaultAdapter and BaseHolder base classes to quickly implement Recycleview.

• BaseHolder initializes ButterKnife and AutoLayout by default. After inheritance, you can not only inject View directly, but also make the layout adaptive to the screen.
• RecycleView does not provide Item click events by default. You can use DefaultAdapter to call setOnItemClickListener to implement Item click events.

3.9 Permission Management (Adapt to Android 6.0 Permission Management)

This framework uses RxPermissions for permission management (adapted to Android 6.0), and provides the PermissionUtil tool class to implement permission requests in one line of code. Detailed explanation of permission management adapted to Android 6.0

 PermissionUtil.launchCamera(new RequestPermission() {
 @Override
 public void onRequestPermissionSuccess() {
 launchCapture(); //Do some operations after successfully requesting permission
 }
       }, mRxPermissions, mRootView, mErrorHandler);

3.10 Gradle configuration starts Debug mode

In the build.gradle of the main project (app), configure whether to enable printing logs or use LeakCanary and other debugging tools

• Configure in build.gradle

• Use in code (for example, do some initialization settings in the application)

3.11 AppManager (manages all activities)

AppManager is used to manage all Activities. It holds a List of all surviving Activities (onDestroy is not called) and a currently frontmost Activity (onPause is not called). AppManager encapsulates multiple methods that can be easily operated. You can also remotely control all its methods through EventBus without holding AppManager. In this way, we can perform global operations on any Activity anywhere in the entire app. For example, when the app request network times out, let the frontmost Activity display the connection timeout interaction page (this logic does not need to be written into the currently requested Activity, and can be globally unified in a singleton class, because the current Activity can be obtained at any time through AppManager)

Remote control is achieved through EventBus post Message. Different methods and Handlers are distinguished by different whats. Similarly, you can add corresponding methods in AppManager according to your needs.

Summarize

If you are building a new project, clone (or download) the entire project directly, use Demo as the main module, and then change the project package name to your own package name. Demo contains a package structure that can be used directly. A mainstream MVP+Dagger2+Retrofit+Rxjava framework is easily built successfully. Now you refer to the format of UserActivity under the Demo MVP package, use Template to automatically generate MVP and Dagger2 related classes under the corresponding package, and consult the Wiki document to slowly master this framework. It is better to use it in the project as soon as possible than to read more articles. Learning in practice is always the fastest.