content: /**
   * Copyright 2017 JessYan
   * <p>
   * 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
   * <p>
   * http://www.apache.org/licenses/LICENSE-2.0
   * <p>
   * 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.
   */
  package <%= appPackage %>.integration;
  
  import android.app.Application;
  import android.content.Context;
  
  import <%= appPackage %>.integration.cache.Cache;
  import <%= appPackage %>.integration.cache.CacheType;
  import <%= appPackage %>.mvp.IModel;
  import <%= appPackage %>.utils.Preconditions;
  
  import javax.inject.Inject;
  import javax.inject.Singleton;
  
  import dagger.Lazy;
  import io.rx_cache2.internal.RxCache;
  import retrofit2.Retrofit;
  
  /**
   * ================================================
   * 用来管理网络请求层,以及数据缓存层,以后可能添加数据库请求层
   * 提供给 {@link IModel} 层必要的 Api 做数据处理
   *
   * @see <a href="https://github.com/JessYanCoding/MVPArms/wiki#2.3">RepositoryManager wiki 官方文档</a>
   * Created by JessYan on 13/04/2017 09:52
   * <a href="mailto:jess.yan.effort@gmail.com">Contact me</a>
   * <a href="https://github.com/JessYanCoding">Follow me</a>
   * ================================================
   */
  @Singleton
  public class RepositoryManager implements IRepositoryManager {
      private Lazy<Retrofit> mRetrofit;
      private Lazy<RxCache> mRxCache;
      private Application mApplication;
      private Cache<String, Object> mRetrofitServiceCache;
      private Cache<String, Object> mCacheServiceCache;
      private Cache.Factory mCachefactory;
  
      @Inject
      public RepositoryManager(Lazy<Retrofit> retrofit, Lazy<RxCache> rxCache, Application application
              , Cache.Factory cachefactory) {
          this.mRetrofit = retrofit;
          this.mRxCache = rxCache;
          this.mApplication = application;
          this.mCachefactory = cachefactory;
      }
  
      /**
       * 根据传入的 Class 获取对应的 Retrofit service
       *
       * @param service
       * @param <T>
       * @return
       */
      @Override
      public <T> T obtainRetrofitService(Class<T> service) {
          if (mRetrofitServiceCache == null)
              mRetrofitServiceCache = mCachefactory.build(CacheType.RETROFIT_SERVICE_CACHE);
          Preconditions.checkNotNull(mRetrofitServiceCache,"Cannot return null from a Cache.Factory#build(int) method");
          T retrofitService;
          synchronized (mRetrofitServiceCache) {
              retrofitService = (T) mRetrofitServiceCache.get(service.getName());
              if (retrofitService == null) {
                  retrofitService = mRetrofit.get().create(service);
                  mRetrofitServiceCache.put(service.getName(), retrofitService);
              }
          }
          return retrofitService;
      }
  
      /**
       * 根据传入的 Class 获取对应的 RxCache service
       *
       * @param cache
       * @param <T>
       * @return
       */
      @Override
      public <T> T obtainCacheService(Class<T> cache) {
          if (mCacheServiceCache == null)
              mCacheServiceCache = mCachefactory.build(CacheType.CACHE_SERVICE_CACHE);
          Preconditions.checkNotNull(mCacheServiceCache,"Cannot return null from a Cache.Factory#build(int) method");
          T cacheService;
          synchronized (mCacheServiceCache) {
              cacheService = (T) mCacheServiceCache.get(cache.getName());
              if (cacheService == null) {
                  cacheService = mRxCache.get().using(cache);
                  mCacheServiceCache.put(cache.getName(), cacheService);
              }
          }
          return cacheService;
      }
  
      /**
       * 清理所有缓存
       */
      @Override
      public void clearAllCache() {
          mRxCache.get().evictAll();
      }
  
      @Override
      public Context getContext() {
          return mApplication;
      }
  }
  