Custom GSON request With Volley

By | April 10, 2016

Volley, be default doesn’t support GSON. But it gives the flexibility to do anything.
Lets see how we can do this.

You can read about Complete Volley Demo in Android from here..

I am going to create a new class for the GSON.
Below is my class for the GSON.

MyGson.java

package com.coderzheaven.volleydemo;

public class MyGson {

    public String Site, demo;

    public String getSite() {
        return Site;
    }

    public void setSite(String site) {
        Site = site;
    }
}

Infolinks

Now create a class named ‘GsonRequest’ for the GSON


package com.coderzheaven.volleydemo;

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;

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));
        }
    }
}

Now to make the GSON call…


GsonRequest<MyGson> myReq = new GsonRequest<MyGson>(jsonUrl,
		MyGson.class, null,
		createSuccessListener(), // listener for success
		createErrorListener());  // listener for failure 
mRequestQueue.add(myReq);


private Response.Listener<MyGson> createSuccessListener() {

	return new Response.Listener<MyGson>() {
		@Override
		public void onResponse(MyGson response) {
			Log.i(TAG, "Response : " + response.getSite());
		}
	};

}

private Response.ErrorListener createErrorListener() {

	return new Response.ErrorListener() {
		@Override
		public void onErrorResponse(VolleyError error) {
			Log.i(TAG, "Error : " + error.getLocalizedMessage());
		}
	};

}

Leave a Reply

Your email address will not be published. Required fields are marked *