Basic library refactoring

Author: smarek

library/build.gradle

@@ -24,7 +24,7 @@ android {
 }
 
 dependencies {
-    compile 'cz.msebera.android:httpclient:4.3.6'
+    compile 'cz.msebera.android:httpclient:4.4.1.1'
 }
 
 android.libraryVariants.all { variant ->

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

@@ -18,23 +18,23 @@
 
 package com.loopj.android.http;
 
+import com.loopj.android.http.handlers.RangeFileAsyncHttpResponseHandler;
+import com.loopj.android.http.interfaces.ResponseHandlerInterface;
+import com.loopj.android.http.utils.Utils;
+
 import java.io.IOException;
 import java.net.MalformedURLException;
-import java.net.UnknownHostException;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import cz.msebera.android.httpclient.HttpResponse;
-import cz.msebera.android.httpclient.client.HttpRequestRetryHandler;
 import cz.msebera.android.httpclient.client.methods.HttpUriRequest;
-import cz.msebera.android.httpclient.impl.client.AbstractHttpClient;
-import cz.msebera.android.httpclient.protocol.HttpContext;
+import cz.msebera.android.httpclient.impl.client.CloseableHttpClient;
 
 /**
  * Internal class, representing the HttpRequest, done in asynchronous manner
  */
 public class AsyncHttpRequest implements Runnable {
-    private final AbstractHttpClient client;
-    private final HttpContext context;
+    private final CloseableHttpClient client;
     private final HttpUriRequest request;
     private final ResponseHandlerInterface responseHandler;
     private final AtomicBoolean isCancelled = new AtomicBoolean();
@@ -43,9 +43,8 @@ public class AsyncHttpRequest implements Runnable {
     private volatile boolean isFinished;
     private boolean isRequestPreProcessed;
 
-    public AsyncHttpRequest(AbstractHttpClient client, HttpContext context, HttpUriRequest request, ResponseHandlerInterface responseHandler) {
-        this.client = Utils.notNull(client, "client");
-        this.context = Utils.notNull(context, "context");
+    public AsyncHttpRequest(CloseableHttpClient httpClient, HttpUriRequest request, ResponseHandlerInterface responseHandler) {
+        this.client = Utils.notNull(httpClient, "client");
         this.request = Utils.notNull(request, "request");
         this.responseHandler = Utils.notNull(responseHandler, "responseHandler");
     }
@@ -103,7 +102,7 @@ public void run() {
         }
 
         try {
-            makeRequestWithRetries();
+            makeRequest();
         } catch (IOException e) {
             if (!isCancelled()) {
                 responseHandler.sendFailureMessage(0, null, null, e);
@@ -143,7 +142,7 @@ private void makeRequest() throws IOException {
             ((RangeFileAsyncHttpResponseHandler) responseHandler).updateRequestHeaders(request);
         }
 
-        HttpResponse response = client.execute(request, context);
+        HttpResponse response = client.execute(request);
 
         if (isCancelled()) {
             return;
@@ -167,49 +166,6 @@ private void makeRequest() throws IOException {
         responseHandler.onPostProcessResponse(responseHandler, response);
     }
 
-    private void makeRequestWithRetries() throws IOException {
-        boolean retry = true;
-        IOException cause = null;
-        HttpRequestRetryHandler retryHandler = client.getHttpRequestRetryHandler();
-        try {
-            while (retry) {
-                try {
-                    makeRequest();
-                    return;
-                } catch (UnknownHostException e) {
-                    // switching between WI-FI and mobile data networks can cause a retry which then results in an UnknownHostException
-                    // while the WI-FI is initialising. The retry logic will be invoked here, if this is NOT the first retry
-                    // (to assist in genuine cases of unknown host) which seems better than outright failure
-                    cause = new IOException("UnknownHostException exception: " + e.getMessage());
-                    retry = (executionCount > 0) && retryHandler.retryRequest(e, ++executionCount, context);
-                } catch (NullPointerException e) {
-                    // there's a bug in HttpClient 4.0.x that on some occasions causes
-                    // DefaultRequestExecutor to throw an NPE, see
-                    // https://code.google.com/p/android/issues/detail?id=5255
-                    cause = new IOException("NPE in HttpClient: " + e.getMessage());
-                    retry = retryHandler.retryRequest(cause, ++executionCount, context);
-                } catch (IOException e) {
-                    if (isCancelled()) {
-                        // Eating exception, as the request was cancelled
-                        return;
-                    }
-                    cause = e;
-                    retry = retryHandler.retryRequest(cause, ++executionCount, context);
-                }
-                if (retry) {
-                    responseHandler.sendRetryMessage(executionCount);
-                }
-            }
-        } catch (Exception e) {
-            // catch anything else to ensure failure message is propagated
-            AsyncHttpClient.log.e("AsyncHttpRequest", "Unhandled exception origin cause", e);
-            cause = new IOException("Unhandled exception: " + e.getMessage());
-        }
-
-        // cleaned up to throw IOException
-        throw (cause);
-    }
-
     public boolean isCancelled() {
         boolean cancelled = isCancelled.get();
         if (cancelled) {

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

@@ -0,0 +1,75 @@
+/*
+    Copyright (c) 2015 Marek Sebera <[email protected]>
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        https://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+package com.loopj.android.http;
+
+import com.loopj.android.http.interfaces.HttpClientProviderInterface;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import cz.msebera.android.httpclient.Header;
+import cz.msebera.android.httpclient.HttpHost;
+import cz.msebera.android.httpclient.client.CookieStore;
+import cz.msebera.android.httpclient.client.HttpRequestRetryHandler;
+import cz.msebera.android.httpclient.conn.HttpClientConnectionManager;
+import cz.msebera.android.httpclient.impl.client.CloseableHttpClient;
+import cz.msebera.android.httpclient.impl.client.HttpClients;
+import cz.msebera.android.httpclient.impl.conn.PoolingHttpClientConnectionManager;
+
+public class DefaultHttpClientProvider implements HttpClientProviderInterface {
+
+    protected HttpHost proxy;
+    protected CookieStore cookieStore;
+    protected final Collection<? extends Header> commonHeaders = new ArrayList<Header>();
+    protected HttpRequestRetryHandler retryHandler;
+
+    @Override
+    public final CloseableHttpClient provide() {
+        return HttpClients.custom()
+                .setConnectionManager(getConnectionManager())
+                .setProxy(getProxy())
+                .setDefaultCookieStore(getCookieStore())
+                .setUserAgent(getUserAgent())
+                .setDefaultHeaders(getHeaders())
+                .setRetryHandler(getRetryHandler())
+                .build();
+    }
+
+    private HttpRequestRetryHandler getRetryHandler() {
+        return retryHandler;
+    }
+
+    public String getUserAgent() {
+        return "AsyncHttpClient ".concat(BuildConfig.VERSION_NAME);
+    }
+
+    public HttpClientConnectionManager getConnectionManager() {
+        return new PoolingHttpClientConnectionManager();
+    }
+
+    public HttpHost getProxy() {
+        return proxy;
+    }
+
+    public CookieStore getCookieStore() {
+        return cookieStore;
+    }
+
+    public Collection<? extends Header> getHeaders() {
+        return commonHeaders;
+    }
+
+}