Refactored to include interface, to allow completely own implementation of response handler, Closes android-async-http#280

Author: smarek

library/src/com/loopj/android/http/AsyncHttpClient.java

@@ -34,10 +34,10 @@ class AsyncHttpRequest implements Runnable {
     private final AbstractHttpClient client;
     private final HttpContext context;
     private final HttpUriRequest request;
-    private final AsyncHttpResponseHandler responseHandler;
+    private final ResponseHandlerInterface responseHandler;
     private int executionCount;
 
-    public AsyncHttpRequest(AbstractHttpClient client, HttpContext context, HttpUriRequest request, AsyncHttpResponseHandler responseHandler) {
+    public AsyncHttpRequest(AbstractHttpClient client, HttpContext context, HttpUriRequest request, ResponseHandlerInterface responseHandler) {
         this.client = client;
         this.context = context;
         this.request = request;

library/src/com/loopj/android/http/AsyncHttpRequest.java

@@ -34,6 +34,7 @@
 import java.io.InputStream;
 import java.io.UnsupportedEncodingException;
 import java.lang.ref.WeakReference;
+import java.net.URI;
 
 /**
  * Used to intercept and handle the responses from requests made using
@@ -80,7 +81,7 @@
  * });
  * </pre>
  */
-public class AsyncHttpResponseHandler {
+public class AsyncHttpResponseHandler implements ResponseHandlerInterface {
     private static final String LOG_TAG = "AsyncHttpResponseHandler";
 
     protected static final int SUCCESS_MESSAGE = 0;
@@ -97,6 +98,29 @@ public class AsyncHttpResponseHandler {
     private String responseCharset = DEFAULT_CHARSET;
     private Boolean useSynchronousMode = false;
 
+    private URI requestURI = null;
+    private Header[] requestHeaders = null;
+
+    @Override
+    public URI getRequestURI() {
+        return this.requestURI;
+    }
+
+    @Override
+    public Header[] getRequestHeaders() {
+        return this.requestHeaders;
+    }
+
+    @Override
+    public void setRequestURI(URI requestURI) {
+        this.requestURI = requestURI;
+    }
+
+    @Override
+    public void setRequestHeaders(Header[] requestHeaders) {
+        this.requestHeaders = requestHeaders;
+    }
+
     // avoid leaks by using a non-anonymous handler class
     // with a weak reference
     static class ResponderHandler extends Handler {
@@ -119,12 +143,8 @@ public boolean getUseSynchronousMode() {
         return (useSynchronousMode);
     }
 
-    /**
-     * Set the response handler to use synchronous mode or not
-     *
-     * @param value true indicates that synchronous mode should be used
-     */
-    public void setUseSynchronousMode(Boolean value) {
+    @Override
+    public void setUseSynchronousMode(boolean value) {
         useSynchronousMode = value;
     }
 
@@ -311,27 +331,27 @@ public void onRetry() {
     // Pre-processing of messages (executes in background threadpool thread)
     //
 
-    protected void sendProgressMessage(int bytesWritten, int totalSize) {
-        sendMessage(obtainMessage(PROGRESS_MESSAGE, new Object[]{bytesWritten, totalSize}));
+    final public void sendProgressMessage(int bytesWritten, int bytesTotal) {
+        sendMessage(obtainMessage(PROGRESS_MESSAGE, new Object[]{bytesWritten, bytesTotal}));
     }
 
-    protected void sendSuccessMessage(int statusCode, Header[] headers, byte[] responseBody) {
+    final public void sendSuccessMessage(int statusCode, Header[] headers, byte[] responseBody) {
         sendMessage(obtainMessage(SUCCESS_MESSAGE, new Object[]{statusCode, headers, responseBody}));
     }
 
-    protected void sendFailureMessage(int statusCode, Header[] headers, byte[] responseBody, Throwable error) {
+    final public void sendFailureMessage(int statusCode, Header[] headers, byte[] responseBody, Throwable error) {
         sendMessage(obtainMessage(FAILURE_MESSAGE, new Object[]{statusCode, headers, responseBody, error}));
     }
 
-    protected void sendStartMessage() {
+    final public void sendStartMessage() {
         sendMessage(obtainMessage(START_MESSAGE, null));
     }
 
-    protected void sendFinishMessage() {
+    final public void sendFinishMessage() {
         sendMessage(obtainMessage(FINISH_MESSAGE, null));
     }
 
-    protected void sendRetryMessage() {
+    final public void sendRetryMessage() {
         sendMessage(obtainMessage(RETRY_MESSAGE, null));
     }
 
@@ -408,8 +428,8 @@ protected Message obtainMessage(int responseMessage, Object response) {
         return msg;
     }
 
-    // Interface to AsyncHttpRequest
-    void sendResponseMessage(HttpResponse response) throws IOException {
+    @Override
+    public void sendResponseMessage(HttpResponse response) throws IOException {
         // do not process if request has been cancelled
         if (!Thread.currentThread().isInterrupted()) {
             StatusLine status = response.getStatusLine();

library/src/com/loopj/android/http/AsyncHttpResponseHandler.java

@@ -144,7 +144,7 @@ public void onFailure(int statusCode, Header[] headers, byte[] binaryData, Throw
 
     // Interface to AsyncHttpRequest
     @Override
-    protected void sendResponseMessage(HttpResponse response) throws IOException {
+    public final void sendResponseMessage(HttpResponse response) throws IOException {
         StatusLine status = response.getStatusLine();
         Header[] contentTypeHeaders = response.getHeaders("Content-Type");
         if (contentTypeHeaders.length != 1) {

library/src/com/loopj/android/http/BinaryHttpResponseHandler.java

@@ -322,7 +322,7 @@ public void setHttpEntityIsRepeatable(boolean isRepeatable) {
      * @return HttpEntity resulting HttpEntity to be included along with {@link org.apache.http.client.methods.HttpEntityEnclosingRequestBase}
      * @throws IOException if one of the streams cannot be read
      */
-    public HttpEntity getEntity(AsyncHttpResponseHandler progressHandler) throws IOException {
+    public HttpEntity getEntity(ResponseHandlerInterface progressHandler) throws IOException {
         if (streamParams.isEmpty() && fileParams.isEmpty()) {
             return createFormEntity();
         } else {
@@ -338,7 +338,7 @@ private HttpEntity createFormEntity() {
         }
     }
 
-    private HttpEntity createMultipartEntity(AsyncHttpResponseHandler progressHandler) throws IOException {
+    private HttpEntity createMultipartEntity(ResponseHandlerInterface progressHandler) throws IOException {
         SimpleMultipartEntity entity = new SimpleMultipartEntity(progressHandler);
         entity.setIsRepeatable(isRepeatable);
 

library/src/com/loopj/android/http/RequestParams.java

@@ -0,0 +1,93 @@
+package com.loopj.android.http;
+
+import org.apache.http.Header;
+import org.apache.http.HttpResponse;
+
+import java.io.IOException;
+import java.net.URI;
+
+/**
+ * Interface to standardize implementations
+ */
+public interface ResponseHandlerInterface {
+
+    /**
+     * Returns data whether request completed successfully
+     *
+     * @param response HttpResponse object with data
+     */
+    void sendResponseMessage(HttpResponse response) throws IOException;
+
+    /**
+     * Notifies callback, that request started execution
+     */
+    void sendStartMessage();
+
+    /**
+     * Notifies callback, that request was completed and is being removed from thread pool
+     */
+    void sendFinishMessage();
+
+    /**
+     * Notifies callback, that request (mainly uploading) has progressed
+     *
+     * @param bytesWritten number of written bytes
+     * @param bytesTotal   number of total bytes to be written
+     */
+    void sendProgressMessage(int bytesWritten, int bytesTotal);
+
+    /**
+     * Notifies callback, that request was handled successfully
+     *
+     * @param statusCode   HTTP status code
+     * @param headers      returned headers
+     * @param responseBody returned data
+     */
+    void sendSuccessMessage(int statusCode, Header[] headers, byte[] responseBody);
+
+    /**
+     * Returns if request was completed with error code or failure of implementation
+     *
+     * @param statusCode   returned HTTP status code
+     * @param headers      returned headers
+     * @param responseBody returned data
+     * @param error        cause of request failure
+     */
+    void sendFailureMessage(int statusCode, Header[] headers, byte[] responseBody, Throwable error);
+
+    /**
+     * Notifies callback of retrying request
+     */
+    void sendRetryMessage();
+
+    /**
+     * Returns URI which was used to request
+     *
+     * @return uri of origin request
+     */
+    public URI getRequestURI();
+
+    /**
+     * Returns Header[] which were used to request
+     *
+     * @return headers from origin request
+     */
+    public Header[] getRequestHeaders();
+
+    /**
+     * Helper for handlers to receive Request URI info
+     */
+    public void setRequestURI(URI requestURI);
+
+    /**
+     * Helper for handlers to receive Request Header[] info
+     */
+    public void setRequestHeaders(Header[] requestHeaders);
+
+    /**
+     * Can set, whether the handler should be asynchronous or synchronous
+     *
+     * @param useSynchronousMode whether data should be handled on background Thread on UI Thread
+     */
+    void setUseSynchronousMode(boolean useSynchronousMode);
+}

library/src/com/loopj/android/http/ResponseHandlerInterface.java

@@ -64,13 +64,13 @@ class SimpleMultipartEntity implements HttpEntity {
     // boundary
     private ByteArrayOutputStream out = new ByteArrayOutputStream();
 
-    private AsyncHttpResponseHandler progressHandler;
+    private ResponseHandlerInterface progressHandler;
 
     private int bytesWritten;
 
     private int totalSize;
 
-    public SimpleMultipartEntity(AsyncHttpResponseHandler progressHandler) {
+    public SimpleMultipartEntity(ResponseHandlerInterface progressHandler) {
         final StringBuilder buf = new StringBuilder();
         final Random rand = new Random();
         for (int i = 0; i < 30; i++) {

library/src/com/loopj/android/http/SimpleMultipartEntity.java

@@ -58,7 +58,7 @@ public SyncHttpClient(SchemeRegistry schemeRegistry) {
     @Override
     protected RequestHandle sendRequest(DefaultHttpClient client,
                                         HttpContext httpContext, HttpUriRequest uriRequest,
-                                        String contentType, AsyncHttpResponseHandler responseHandler,
+                                        String contentType, ResponseHandlerInterface responseHandler,
                                         Context context) {
         if (contentType != null) {
             uriRequest.addHeader("Content-Type", contentType);