RetrofitHelper.java

package com.c9mj.platform.util.retrofit;

import com.blankj.utilcode.utils.NetworkUtils;
import com.c9mj.platform.App;
import com.c9mj.platform.live.mvp.model.LiveBaseBean;
import com.c9mj.platform.util.retrofit.exception.RetrofitException;

import org.reactivestreams.Publisher;

import java.io.File;
import java.util.concurrent.TimeUnit;

import io.reactivex.FlowableTransformer;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.functions.Function;
import io.reactivex.schedulers.Schedulers;
import okhttp3.Cache;
import okhttp3.CacheControl;
import okhttp3.Interceptor;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import retrofit2.Retrofit;
import retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory;
import retrofit2.converter.gson.GsonConverterFactory;

/**
 * author: LMJ
 * date: 2016/9/1
 */
public class RetrofitHelper {

    public static final String BASE_USER_URL = "http://api.douban.com/v2/movie/";
    private static final String BASE_EXPLORE_URL = "http://c.m.163.com";
    private static final String BASE_LIVE_URL = "http://api.maxjia.com";
    private static final String BASE_PANDA_URL = "http://www.panda.tv";
    private static final Interceptor REWRITE_CACHE_CONTROL_INTERCEPTOR = chain -> {

        Request request = chain.request();
        if (!NetworkUtils.isAvailableByPing()) {
            CacheControl cacheControl = new CacheControl.Builder()
                    .maxStale(30, TimeUnit.SECONDS)
                    .build();
            request = request.newBuilder()
                    .cacheControl(CacheControl.FORCE_CACHE)
                    .build();
        }

        Response response = chain.proceed(request);

        if (NetworkUtils.isAvailableByPing()) {
            /**
             * If you have problems in testing on which side is problem (server or app).
             * You can use such feauture to set headers received from server.
             */
            int maxAge = 60 * 60; // 有网络时,设置缓存超时时间1个小时
            response = response.newBuilder()
                    .removeHeader("Pragma")
                    .header("Cache-Control", "public, max-age=" + maxAge)//设置缓存超时时间
                    .build();
        } else {
            int maxStale = 60 * 60;//无网络时，设置超时为4周
            response = response.newBuilder()
                    .removeHeader("Pragma")
                    .header("Cache-Control", "public, only-if-cached, max-stale=" + maxStale)
                    .build();
        }
        return response;
    };
    private static Retrofit explore = null;
    private static Retrofit live = null;
    private static Retrofit user = null;
    private static Retrofit panda = null;

    public static Retrofit getExploreHelper() {
        if (explore == null) {
            try {
                synchronized (RetrofitHelper.class) {
                    if (explore == null) {
                        File httpCacheDirectory = new File(App.getContext().getCacheDir(), "exploreCache");
                        Cache cache = new Cache(httpCacheDirectory, 10 * 1024 * 1024);//缓存10MB
                        OkHttpClient.Builder httpBuidler = new OkHttpClient().newBuilder();
                        httpBuidler.cache(cache)
                                .connectTimeout(10, TimeUnit.SECONDS)//连接超时限制5秒
                                .writeTimeout(10, TimeUnit.SECONDS)
                                .readTimeout(10, TimeUnit.SECONDS)
                                //添加拦截器
//                                .addNetworkInterceptor(REWRITE_CACHE_CONTROL_INTERCEPTOR)//离线缓存
                                .addInterceptor(REWRITE_CACHE_CONTROL_INTERCEPTOR);

                        explore = new Retrofit.Builder()
                                .client(httpBuidler.build())
                                .baseUrl(BASE_EXPLORE_URL)
                                .addConverterFactory(GsonConverterFactory.create())
                                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                                .build();
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return explore;
    }

    public static Retrofit getLiveHelper() {
        if (live == null) {
            synchronized (RetrofitHelper.class) {
                if (live == null) {
                    live = new Retrofit.Builder()
                            .baseUrl(BASE_LIVE_URL)
                            .addConverterFactory(GsonConverterFactory.create())
                            .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                            .build();
                }
            }
        }
        return live;
    }

    public static Retrofit getPandaHelper() {
        if (panda == null) {
            synchronized (RetrofitHelper.class) {
                panda = new Retrofit.Builder()
                        .client(new OkHttpClient.Builder().connectTimeout(5, TimeUnit.SECONDS).build())
                        .baseUrl(BASE_PANDA_URL)
                        .addConverterFactory(GsonConverterFactory.create())
                        .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                        .build();
            }
        }
        return panda;
    }

    public static <T> FlowableTransformer<LiveBaseBean<T>, T> handleLiveResult() {
        return upstream -> upstream.flatMap(new Function<LiveBaseBean<T>, Publisher<T>>() {
            @Override
            public Publisher<T> apply(final LiveBaseBean<T> baseBean) throws Exception {
                return subscriber -> {
                    if (baseBean.getStatus().equals("ok")) {
                        subscriber.onNext(baseBean.getResult());
                    } else {
                        subscriber.onError(new RetrofitException(baseBean.getMsg()));
                    }
                };
            }
        }).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread());
    }
}