Merge pull request android-async-http#765 from fineswap/UsePoolThread

Enable responses to be fired on the same thread which was used in the request.

Author: smarek

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

@@ -1245,7 +1245,7 @@ protected RequestHandle sendRequest(DefaultHttpClient client, HttpContext httpCo
             throw new IllegalArgumentException("ResponseHandler must not be null");
         }
 
-        if (responseHandler.getUseSynchronousMode()) {
+        if (responseHandler.getUseSynchronousMode() && !responseHandler.getUsePoolThread()) {
             throw new IllegalArgumentException("Synchronous ResponseHandler used in AsyncHttpClient. You should create your response handler in a looper thread or use SyncHttpClient instead.");
         }
 

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

@@ -97,11 +97,56 @@ public abstract class AsyncHttpResponseHandler implements ResponseHandlerInterfa
     private String responseCharset = DEFAULT_CHARSET;
     private Handler handler;
     private boolean useSynchronousMode;
+    private boolean usePoolThread;
 
     private URI requestURI = null;
     private Header[] requestHeaders = null;
     private Looper looper = null;
 
+    /**
+     * Creates a new AsyncHttpResponseHandler
+     */
+    public AsyncHttpResponseHandler() {
+        this(null);
+    }
+
+    /**
+     * Creates a new AsyncHttpResponseHandler with a user-supplied looper. If
+     * the passed looper is null, the looper attached to the current thread will
+     * be used.
+     *
+     * @param looper The looper to work with
+     */
+    public AsyncHttpResponseHandler(Looper looper) {
+        this.looper = looper == null ? Looper.myLooper() : looper;
+
+        // Use asynchronous mode by default.
+        setUseSynchronousMode(false);
+
+        // Do not use the pool's thread to fire callbacks by default.
+        setUsePoolThread(false);
+    }
+
+    /**
+     * Creates a new AsyncHttpResponseHandler and decide whether the callbacks
+     * will be fired on current thread's looper or the pool thread's.
+     *
+     * @param usePoolThread Whether to use the pool's thread to fire callbacks
+     */
+    public AsyncHttpResponseHandler(boolean usePoolThread) {
+        // Whether to use the pool's thread to fire callbacks.
+        setUsePoolThread(usePoolThread);
+
+        // When using the pool's thread, there's no sense in having a looper.
+        if (!getUsePoolThread()) {
+            // Use the current thread's looper.
+            this.looper = Looper.myLooper();
+
+            // Use asynchronous mode by default.
+            setUseSynchronousMode(false);
+        }
+    }
+
     @Override
     public URI getRequestURI() {
         return this.requestURI;
@@ -164,6 +209,23 @@ public void setUseSynchronousMode(boolean sync) {
         useSynchronousMode = sync;
     }
 
+    @Override
+    public boolean getUsePoolThread() {
+        return usePoolThread;
+    }
+
+    @Override
+    public void setUsePoolThread(boolean pool) {
+        // If pool thread is to be used, there's no point in keeping a reference
+        // to the looper and no need for a handler.
+        if (pool) {
+            looper = null;
+            handler = null;
+        }
+
+        usePoolThread = pool;
+    }
+
     /**
      * Sets the charset for the response string. If not set, the default is UTF-8.
      *
@@ -178,26 +240,6 @@ public String getCharset() {
         return this.responseCharset == null ? DEFAULT_CHARSET : this.responseCharset;
     }
 
-    /**
-     * Creates a new AsyncHttpResponseHandler
-     */
-    public AsyncHttpResponseHandler() {
-        this(null);
-    }
-
-    /**
-     * Creates a new AsyncHttpResponseHandler with a user-supplied looper. If
-     * the passed looper is null, the looper attached to the current thread will
-     * be used.
-     *
-     * @param looper The looper to work with
-     */
-    public AsyncHttpResponseHandler(Looper looper) {
-        this.looper = looper == null ? Looper.myLooper() : looper;
-        // Use asynchronous mode by default.
-        setUseSynchronousMode(false);
-    }
-
     /**
      * Fired when the request progress, override to handle in your own code
      *

library/src/main/java/com/loopj/android/http/BaseJsonHttpResponseHandler.java

@@ -97,7 +97,7 @@ public void run() {
                     }
                 }
             };
-            if (!getUseSynchronousMode()) {
+            if (!getUseSynchronousMode() && !getUsePoolThread()) {
                 new Thread(parser).start();
             } else {
                 // In synchronous mode everything should be run on one thread
@@ -133,7 +133,7 @@ public void run() {
                     }
                 }
             };
-            if (!getUseSynchronousMode()) {
+            if (!getUseSynchronousMode() && !getUsePoolThread()) {
                 new Thread(parser).start();
             } else {
                 // In synchronous mode everything should be run on one thread

library/src/main/java/com/loopj/android/http/JsonHttpResponseHandler.java

@@ -144,7 +144,7 @@ public void run() {
                     }
                 }
             };
-            if (!getUseSynchronousMode()) {
+            if (!getUseSynchronousMode() && !getUsePoolThread()) {
                 new Thread(parser).start();
             } else {
                 // In synchronous mode everything should be run on one thread
@@ -189,7 +189,7 @@ public void run() {
                     }
                 }
             };
-            if (!getUseSynchronousMode()) {
+            if (!getUseSynchronousMode() && !getUsePoolThread()) {
                 new Thread(parser).start();
             } else {
                 // In synchronous mode everything should be run on one thread

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

@@ -128,6 +128,22 @@ public interface ResponseHandlerInterface {
      */
     boolean getUseSynchronousMode();
 
+    /**
+     * Sets whether the handler should be executed on the pool's thread or the
+     * UI thread
+     *
+     * @param usePoolThread if the ResponseHandler should run on pool's thread
+     */
+    void setUsePoolThread(boolean usePoolThread);
+
+    /**
+     * Returns whether the handler should be executed on the pool's thread
+     * or the UI thread
+     *
+     * @return boolean if the ResponseHandler should run on pool's thread
+     */
+    boolean getUsePoolThread();
+
     /**
      * This method is called once by the system when the response is about to be
      * processed by the system. The library makes sure that a single response