Android Volley Loader. Движение в сторону библиотеки

public static FeedLoader with(Context context) {     if (singleton == null) {         synchronized (FeedLoader.class) {             if (singleton == null) {                 singleton = new FeedLoader(context);             }         }     }     return singleton; } 

package net.appz.feedloader;  import android.content.Context; import android.os.Bundle; import android.support.v4.app.FragmentActivity; import android.support.v4.app.LoaderManager; import android.support.v4.content.Loader;  /**  * Created by App-z.net on 04.04.15.  */ public class FeedLoader {      private static volatile FeedLoader singleton = null;      private Context context = null;     private boolean DEBUG = true;     private String TAG = getClass().getSimpleName();      private DelivererFeedLoader delivererFeedLoader = new DelivererFeedLoader();      public FeedLoader(Context context) {         this.context = context;     }      LoaderManager.LoaderCallbacks<Object> callback = new LoaderManager.LoaderCallbacks<Object>() {         @Override         public Loader<Object> onCreateLoader(int id, Bundle args) {             return new FeedLoaderWrapper(context , args);         }          @Override         public void onLoadFinished(Loader<Object> loader, Object data) {             delivererFeedLoader.callBackMap.get(loader.getId()).onResponse(loader.getId(), data);         }          @Override         public void onLoaderReset(Loader<Object> loader) {          }     };      public FeedLoader addLoader(int loaderId, String url, Class<?> loaderClazz, DelivererFeedLoader.Listener callback){         delivererFeedLoader.loaderClazzMap.put(loaderId, loaderClazz);         delivererFeedLoader.callBackMap.put(loaderId, callback);         delivererFeedLoader.urlFeeds.put(loaderId, url);         return singleton;     }      public void start(int loaderId, final Context context) {         Bundle bundle = new Bundle();         bundle.putParcelable("delivererFeedLoader", delivererFeedLoader);          ((FragmentActivity)context).getSupportLoaderManager().                 restartLoader(loaderId, bundle, callback);     }      public static FeedLoader with(Context context) {         if (singleton == null) {             synchronized (FeedLoader.class) {                 if (singleton == null) {                     singleton = new FeedLoader(context);                 }             }         }         return singleton;     } } 

package net.appz.feedloader;  /**  * Created by App-z.net on 05.04.15.  */  import android.content.Context; import android.os.Bundle; import android.support.v4.content.Loader; import android.util.Log;  import com.android.volley.RequestQueue; import com.android.volley.Response; import com.android.volley.VolleyError; import com.android.volley.toolbox.Volley;  /**  *  * @param <D>  */ class FeedLoaderWrapper<D> extends Loader<D> {      private boolean DEBUG = true;     private String TAG = getClass().getSimpleName();      private DelivererFeedLoader delivererFeedLoader = new DelivererFeedLoader();      private RequestQueue requestQueue;      /**      * Stores away the application context associated with context.      * Since Loaders can be used across multiple activities it's dangerous to      * store the context directly; always use {@link #getContext()} to retrieve      * the Loader's Context, don't use the constructor argument directly.      * The Context returned by {@link #getContext} is safe to use across      * Activity instances.      *      * @param context used to retrieve the application context.      */     public FeedLoaderWrapper(Context context, Bundle bundle) {         super(context);         delivererFeedLoader = bundle.getParcelable("delivererFeedLoader");         requestQueue = Volley.newRequestQueue(context);         // run only once         onContentChanged();     }      /**      * Get Data      */     private void doRequest(Class<?> clazz) {         String urlFeed = delivererFeedLoader.urlFeeds.get(getId());         final GsonRequest gsonRequest = new GsonRequest(urlFeed,                 clazz,                 null,                 new Response.Listener<D>() {                     @Override                     public void onResponse(D data) {                         deliverResult(data);                     }                 }, new Response.ErrorListener() {             @Override             public void onErrorResponse(VolleyError volleyError) {                 if (volleyError != null)                     //deliverResult(null);                     if (DEBUG) Log.e(TAG, "volleyError: " + volleyError.getMessage());                         delivererFeedLoader.callBackMap.get(getId()).onErrorResponse(volleyError);             }         });         requestQueue.add(gsonRequest);     }      @Override     protected void onStartLoading() {         if (takeContentChanged())             forceLoad();     }      @Override     protected void onStopLoading() {         if (DEBUG) Log.i(TAG, "Loader onStopLoading()");         requestQueue.cancelAll(this);         super.onStopLoading();     }      @Override     protected void onReset() {         if (DEBUG) Log.i(TAG, "Loader onReset()");         requestQueue.cancelAll(this);         super.onReset();     }      @Override     public void onForceLoad() {         super.onForceLoad();          String urlFeed = delivererFeedLoader.urlFeeds.get(getId());         if (DEBUG) Log.d(TAG, "Loader onForceLoad() : feedUrl = " + urlFeed);         doRequest(delivererFeedLoader.loaderClazzMap.get(getId()));     } } 

package net.appz.feedloader;  import android.os.Parcel; import android.os.Parcelable; import com.android.volley.VolleyError; import java.util.HashMap;  /**  * Created by App-z.net on 05.04.15.  */ public class DelivererFeedLoader implements Parcelable {     HashMap<Integer, Class> loaderClazzMap = new HashMap<>();     HashMap<Integer, Listener> callBackMap = new HashMap<>();     HashMap<Integer, String> urlFeeds = new HashMap<>();      public DelivererFeedLoader(){}      protected DelivererFeedLoader(Parcel in) {         loaderClazzMap = (HashMap) in.readValue(HashMap.class.getClassLoader());         callBackMap = (HashMap) in.readValue(HashMap.class.getClassLoader());         urlFeeds = (HashMap) in.readValue(HashMap.class.getClassLoader());     }      @Override     public int describeContents() {         return 0;     }      @Override     public void writeToParcel(Parcel dest, int flags) {         dest.writeValue(loaderClazzMap);         dest.writeValue(callBackMap);         dest.writeValue(urlFeeds);     }      @SuppressWarnings("unused")     public static final Parcelable.Creator<DelivererFeedLoader> CREATOR = new Parcelable.Creator<DelivererFeedLoader>() {         @Override         public DelivererFeedLoader createFromParcel(Parcel in) {             return new DelivererFeedLoader(in);         }          @Override         public DelivererFeedLoader[] newArray(int size) {             return new DelivererFeedLoader[size];         }     };      public interface Listener<D>{         void onResponse(int loaderId, D data);         void onErrorResponse(VolleyError data);     } } 

package net.appz.feedloader;  import com.android.volley.AuthFailureError; import com.android.volley.NetworkResponse; import com.android.volley.ParseError; import com.android.volley.Request; import com.android.volley.Response; import com.android.volley.toolbox.HttpHeaderParser; import com.google.gson.Gson; import com.google.gson.JsonSyntaxException;  import java.io.UnsupportedEncodingException; import java.util.Map;  /**  * Created by App-z.net on 29.03.15.  */ public class GsonRequest<T> extends Request<T> {     private final Gson gson = new Gson();     private final Class<T> clazz;     private final Map<String, String> headers;     private final Response.Listener<T> listener;      /**      * Make a GET request and return a parsed object from JSON.      *      * @param url URL of the request to make      * @param clazz Relevant class object, for Gson's reflection      * @param headers Map of request headers      */     public GsonRequest(String url, Class<T> clazz, Map<String, String> headers,                        Response.Listener<T> listener, Response.ErrorListener errorListener) {         super(Method.GET, url, errorListener);         this.clazz = clazz;         this.headers = headers;         this.listener = listener;     }      @Override     public Map<String, String> getHeaders() throws AuthFailureError {         return headers != null ? headers : super.getHeaders();     }      @Override     protected void deliverResponse(T response) {         listener.onResponse(response);     }      @Override     protected Response<T> parseNetworkResponse(NetworkResponse response) {         try {             String json = new String(                     response.data,                     HttpHeaderParser.parseCharset(response.headers));             return Response.success(                     gson.fromJson(json, clazz),                     HttpHeaderParser.parseCacheHeaders(response));         } catch (UnsupportedEncodingException e) {             return Response.error(new ParseError(e));         } catch (JsonSyntaxException e) {             return Response.error(new ParseError(e));         }     } }