Manejar una respuesta vacía en un JSONRequest con Volley

Estoy usando Volley para hacer una solicitud POST en mi aplicación, y en mi caso, una buena respuesta es un 201 con un cuerpo vacío. Estoy usando un JSONRequest , para hacer la llamada.

Mi problema es que el manejador de respuesta de error se llama porque la respuesta está vacía.

A continuación se presenta mi solicitud:

  Request request = new JsonRequest<Object>(Request.Method.POST, url, body, new Response.Listener<Object>() { @Override public void onResponse(Object response) { } }, new ErrorListener(context)) { @Override protected Response<Object> parseNetworkResponse(NetworkResponse response) { Log.d(TAG, "success!!!!!!"); if (response.statusCode == 201) mListener.resetPasswordWasSent(); return null; } @Override public Map<String, String> getHeaders() throws AuthFailureError { Map<String,String> params = new HashMap<String, String>(); params.put("Content-Type","application/json"); params.put("Accept", "application/json"); return params; } }; requestQueue.add(request); 

Mi función parseNetworkResponse se llama, entonces el ErrorListener , y el método onResponse nunca recibe visitas porque obtengo una NullPointerException en el ErrorListener .

Puedo ignorar la NullPointerException en mi detector de errores, pero prefiero no hacerlo. Obviamente, puedo simplemente enviar mi devolución de llamada en el parseNetworkResponse , pero no quiero tener ningún error apareciendo.

¿Alguien sabe cómo debería manejar esto?

Editar: Aquí está el stacktrace:

 05-06 09:44:19.586 27546-27560/com.threepoundhealth.euco E/Volley﹕ [1830] NetworkDispatcher.run: Unhandled exception java.lang.NullPointerException java.lang.NullPointerException at com.android.volley.NetworkDispatcher.run(NetworkDispatcher.java:126) 

Puede utilizar una StringRequest . Su oyente será llamado con una cadena vacía "".

Podrías intentar cortar así. Cree una subclase JsonObjectRequest, parseNetworkResponse método parseNetworkResponse y compruebe los datos de respuesta, si es un byte[] vacío byte[] , sustituya la representación byte[] de un json {} vacío.

 public class VolleyJsonRequest extends JsonObjectRequest { ... @Override protected Response<JSONObject> parseNetworkResponse(NetworkResponse response) { try { if (response.data.length == 0) { byte[] responseData = "{}".getBytes("UTF8"); response = new NetworkResponse(response.statusCode, responseData, response.headers, response.notModified); } } catch (UnsupportedEncodingException e) { e.printStackTrace(); } return super.parseNetworkResponse(response); } } 

Conseguí el mismo problema y desarrollé una solución global para manejarlo (y poca falta de funcionalidad de Volley), lo posteé en otro hilo, pero creo que puede ayudar a muchas personas que están buscando una solución a su problema.

  /** * Created by laurentmeyer on 25/07/15. */ public class GenericRequest<T> extends JsonRequest<T> { private final Gson gson = new Gson(); private final Class<T> clazz; private final Map<String, String> headers; // Used for request which do not return anything from the server private boolean muteRequest = false; /** * Basically, this is the constructor which is called by the others. * It allows you to send an object of type A to the server and expect a JSON representing a object of type B. * The problem with the #JsonObjectRequest is that you expect a JSON at the end. * We can do better than that, we can directly receive our POJO. * That's what this class does. * * @param method: HTTP Method * @param classtype: Classtype to parse the JSON coming from the server * @param url: url to be called * @param requestBody: The body being sent * @param listener: Listener of the request * @param errorListener: Error handler of the request * @param headers: Added headers */ private GenericRequest(int method, Class<T> classtype, String url, String requestBody, Response.Listener<T> listener, Response.ErrorListener errorListener, Map<String, String> headers) { super(method, url, requestBody, listener, errorListener); clazz = classtype; this.headers = headers; configureRequest(); } /** * Method to be called if you want to send some objects to your server via body in JSON of the request (with headers and not muted) * * @param method: HTTP Method * @param url: URL to be called * @param classtype: Classtype to parse the JSON returned from the server * @param toBeSent: Object which will be transformed in JSON via Gson and sent to the server * @param listener: Listener of the request * @param errorListener: Error handler of the request * @param headers: Added headers */ public GenericRequest(int method, String url, Class<T> classtype, Object toBeSent, Response.Listener<T> listener, Response.ErrorListener errorListener, Map<String, String> headers) { this(method, classtype, url, new Gson().toJson(toBeSent), listener, errorListener, headers); } /** * Method to be called if you want to send some objects to your server via body in JSON of the request (without header and not muted) * * @param method: HTTP Method * @param url: URL to be called * @param classtype: Classtype to parse the JSON returned from the server * @param toBeSent: Object which will be transformed in JSON via Gson and sent to the server * @param listener: Listener of the request * @param errorListener: Error handler of the request */ public GenericRequest(int method, String url, Class<T> classtype, Object toBeSent, Response.Listener<T> listener, Response.ErrorListener errorListener) { this(method, classtype, url, new Gson().toJson(toBeSent), listener, errorListener, new HashMap<String, String>()); } /** * Method to be called if you want to send something to the server but not with a JSON, just with a defined String (without header and not muted) * * @param method: HTTP Method * @param url: URL to be called * @param classtype: Classtype to parse the JSON returned from the server * @param requestBody: String to be sent to the server * @param listener: Listener of the request * @param errorListener: Error handler of the request */ public GenericRequest(int method, String url, Class<T> classtype, String requestBody, Response.Listener<T> listener, Response.ErrorListener errorListener) { this(method, classtype, url, requestBody, listener, errorListener, new HashMap<String, String>()); } /** * Method to be called if you want to GET something from the server and receive the POJO directly after the call (no JSON). (Without header) * * @param url: URL to be called * @param classtype: Classtype to parse the JSON returned from the server * @param listener: Listener of the request * @param errorListener: Error handler of the request */ public GenericRequest(String url, Class<T> classtype, Response.Listener<T> listener, Response.ErrorListener errorListener) { this(Request.Method.GET, url, classtype, "", listener, errorListener); } /** * Method to be called if you want to GET something from the server and receive the POJO directly after the call (no JSON). (With headers) * * @param url: URL to be called * @param classtype: Classtype to parse the JSON returned from the server * @param listener: Listener of the request * @param errorListener: Error handler of the request * @param headers: Added headers */ public GenericRequest(String url, Class<T> classtype, Response.Listener<T> listener, Response.ErrorListener errorListener, Map<String, String> headers) { this(Request.Method.GET, classtype, url, "", listener, errorListener, headers); } /** * Method to be called if you want to send some objects to your server via body in JSON of the request (with headers and muted) * * @param method: HTTP Method * @param url: URL to be called * @param classtype: Classtype to parse the JSON returned from the server * @param toBeSent: Object which will be transformed in JSON via Gson and sent to the server * @param listener: Listener of the request * @param errorListener: Error handler of the request * @param headers: Added headers * @param mute: Muted (put it to true, to make sense) */ public GenericRequest(int method, String url, Class<T> classtype, Object toBeSent, Response.Listener<T> listener, Response.ErrorListener errorListener, Map<String, String> headers, boolean mute) { this(method, classtype, url, new Gson().toJson(toBeSent), listener, errorListener, headers); this.muteRequest = mute; } /** * Method to be called if you want to send some objects to your server via body in JSON of the request (without header and muted) * * @param method: HTTP Method * @param url: URL to be called * @param classtype: Classtype to parse the JSON returned from the server * @param toBeSent: Object which will be transformed in JSON via Gson and sent to the server * @param listener: Listener of the request * @param errorListener: Error handler of the request * @param mute: Muted (put it to true, to make sense) */ public GenericRequest(int method, String url, Class<T> classtype, Object toBeSent, Response.Listener<T> listener, Response.ErrorListener errorListener, boolean mute) { this(method, classtype, url, new Gson().toJson(toBeSent), listener, errorListener, new HashMap<String, String>()); this.muteRequest = mute; } /** * Method to be called if you want to send something to the server but not with a JSON, just with a defined String (without header and not muted) * * @param method: HTTP Method * @param url: URL to be called * @param classtype: Classtype to parse the JSON returned from the server * @param requestBody: String to be sent to the server * @param listener: Listener of the request * @param errorListener: Error handler of the request * @param mute: Muted (put it to true, to make sense) */ public GenericRequest(int method, String url, Class<T> classtype, String requestBody, Response.Listener<T> listener, Response.ErrorListener errorListener, boolean mute) { this(method, classtype, url, requestBody, listener, errorListener, new HashMap<String, String>()); this.muteRequest = mute; } @Override protected Response<T> parseNetworkResponse(NetworkResponse response) { // The magic of the mute request happens here if (muteRequest) { if (response.statusCode >= 200 && response.statusCode <= 299) { // If the status is correct, we return a success but with a null object, because the server didn't return anything return Response.success(null, HttpHeaderParser.parseCacheHeaders(response)); } } else { try { // If it's not muted; we just need to create our POJO from the returned JSON and handle correctly the errors String json = new String(response.data, HttpHeaderParser.parseCharset(response.headers)); T parsedObject = gson.fromJson(json, clazz); return Response.success(parsedObject, HttpHeaderParser.parseCacheHeaders(response)); } catch (UnsupportedEncodingException e) { return Response.error(new ParseError(e)); } catch (JsonSyntaxException e) { return Response.error(new ParseError(e)); } } return null; } @Override public Map<String, String> getHeaders() throws AuthFailureError { return headers != null ? headers : super.getHeaders(); } private void configureRequest() { // Set retry policy // Add headers, for auth for example // ... } } 

Aquí está la respuesta original en el otro hilo.

FlipAndroid es un fan de Google para Android, Todo sobre Android Phones, Android Wear, Android Dev y Aplicaciones para Android Aplicaciones.