package com.baidu.tts.loopj; import android.content.Context; import android.os.Looper; import androidx.core.view.MotionEventCompat; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.io.PushbackInputStream; import java.lang.reflect.Field; import java.net.URI; import java.net.URL; import java.net.URLDecoder; import java.util.Collections; import java.util.HashMap; import java.util.Iterator; import java.util.LinkedList; import java.util.List; import java.util.Map; import java.util.WeakHashMap; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.zip.GZIPInputStream; import org.altbeacon.bluetooth.Pdu; import org.apache.http.Header; import org.apache.http.HeaderElement; import org.apache.http.HttpEntity; import org.apache.http.HttpException; import org.apache.http.HttpHost; import org.apache.http.HttpRequest; import org.apache.http.HttpRequestInterceptor; import org.apache.http.HttpResponse; import org.apache.http.HttpResponseInterceptor; import org.apache.http.HttpVersion; import org.apache.http.auth.AuthScope; import org.apache.http.auth.AuthState; import org.apache.http.auth.Credentials; import org.apache.http.auth.UsernamePasswordCredentials; import org.apache.http.client.CookieStore; import org.apache.http.client.CredentialsProvider; import org.apache.http.client.HttpClient; import org.apache.http.client.RedirectHandler; import org.apache.http.client.methods.HttpEntityEnclosingRequestBase; import org.apache.http.client.methods.HttpHead; import org.apache.http.client.methods.HttpPost; import org.apache.http.client.methods.HttpPut; import org.apache.http.client.methods.HttpUriRequest; import org.apache.http.conn.ClientConnectionManager; import org.apache.http.conn.params.ConnManagerParams; import org.apache.http.conn.params.ConnPerRouteBean; import org.apache.http.conn.scheme.PlainSocketFactory; import org.apache.http.conn.scheme.Scheme; import org.apache.http.conn.scheme.SchemeRegistry; import org.apache.http.conn.ssl.SSLSocketFactory; import org.apache.http.entity.HttpEntityWrapper; import org.apache.http.impl.auth.BasicScheme; import org.apache.http.impl.client.DefaultHttpClient; import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager; import org.apache.http.params.BasicHttpParams; import org.apache.http.params.HttpConnectionParams; import org.apache.http.params.HttpParams; import org.apache.http.params.HttpProtocolParams; import org.apache.http.protocol.BasicHttpContext; import org.apache.http.protocol.HttpContext; import org.apache.http.protocol.SyncBasicHttpContext; public class AsyncHttpClient { public static final int DEFAULT_MAX_CONNECTIONS = 10; public static final int DEFAULT_MAX_RETRIES = 5; public static final int DEFAULT_RETRY_SLEEP_TIME_MILLIS = 1500; public static final int DEFAULT_SOCKET_BUFFER_SIZE = 8192; public static final int DEFAULT_SOCKET_TIMEOUT = 10000; public static final String ENCODING_GZIP = "gzip"; public static final String HEADER_ACCEPT_ENCODING = "Accept-Encoding"; public static final String HEADER_CONTENT_DISPOSITION = "Content-Disposition"; public static final String HEADER_CONTENT_ENCODING = "Content-Encoding"; public static final String HEADER_CONTENT_RANGE = "Content-Range"; public static final String HEADER_CONTENT_TYPE = "Content-Type"; public static final String LOG_TAG = "AsyncHttpClient"; public static LogInterface log = new LogHandler(); private final Map<String, String> clientHeaderMap; private int connectTimeout; private final DefaultHttpClient httpClient; private final HttpContext httpContext; private boolean isUrlEncodingEnabled; private int maxConnections; private final Map<Context, List<RequestHandle>> requestMap; private int responseTimeout; private ExecutorService threadPool; public AsyncHttpClient() { this(false, 80, 443); } public AsyncHttpClient(int i) { this(false, i, 443); } public AsyncHttpClient(int i, int i2) { this(false, i, i2); } public AsyncHttpClient(boolean z, int i, int i2) { this(getDefaultSchemeRegistry(z, i, i2)); } private static SchemeRegistry getDefaultSchemeRegistry(boolean z, int i, int i2) { SSLSocketFactory sSLSocketFactory; if (i < 1) { i = 80; log.d(LOG_TAG, "Invalid HTTP port number specified, defaulting to 80"); } if (i2 < 1) { i2 = 443; log.d(LOG_TAG, "Invalid HTTPS port number specified, defaulting to 443"); } if (z) { sSLSocketFactory = MySSLSocketFactory.getFixedSocketFactory(); } else { sSLSocketFactory = SSLSocketFactory.getSocketFactory(); } SchemeRegistry schemeRegistry = new SchemeRegistry(); schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), i)); schemeRegistry.register(new Scheme("https", sSLSocketFactory, i2)); return schemeRegistry; } public AsyncHttpClient(SchemeRegistry schemeRegistry) { this.maxConnections = 10; this.connectTimeout = 10000; this.responseTimeout = 10000; boolean z = true; this.isUrlEncodingEnabled = true; BasicHttpParams basicHttpParams = new BasicHttpParams(); ConnManagerParams.setTimeout(basicHttpParams, (long) this.connectTimeout); ConnManagerParams.setMaxConnectionsPerRoute(basicHttpParams, new ConnPerRouteBean(this.maxConnections)); ConnManagerParams.setMaxTotalConnections(basicHttpParams, 10); HttpConnectionParams.setSoTimeout(basicHttpParams, this.responseTimeout); HttpConnectionParams.setConnectionTimeout(basicHttpParams, this.connectTimeout); HttpConnectionParams.setTcpNoDelay(basicHttpParams, true); HttpConnectionParams.setSocketBufferSize(basicHttpParams, 8192); HttpProtocolParams.setVersion(basicHttpParams, HttpVersion.HTTP_1_1); ClientConnectionManager createConnectionManager = createConnectionManager(schemeRegistry, basicHttpParams); Utils.asserts(createConnectionManager == null ? false : z, "Custom implementation of #createConnectionManager(SchemeRegistry, BasicHttpParams) returned null"); this.threadPool = getDefaultThreadPool(); this.requestMap = Collections.synchronizedMap(new WeakHashMap()); this.clientHeaderMap = new HashMap(); this.httpContext = new SyncBasicHttpContext(new BasicHttpContext()); this.httpClient = new DefaultHttpClient(createConnectionManager, basicHttpParams); this.httpClient.addRequestInterceptor(new HttpRequestInterceptor() { /* class com.baidu.tts.loopj.AsyncHttpClient.AnonymousClass1 */ public void process(HttpRequest httpRequest, HttpContext httpContext) { if (!httpRequest.containsHeader(AsyncHttpClient.HEADER_ACCEPT_ENCODING)) { httpRequest.addHeader(AsyncHttpClient.HEADER_ACCEPT_ENCODING, AsyncHttpClient.ENCODING_GZIP); } for (String str : AsyncHttpClient.this.clientHeaderMap.keySet()) { if (httpRequest.containsHeader(str)) { Header firstHeader = httpRequest.getFirstHeader(str); AsyncHttpClient.log.d(AsyncHttpClient.LOG_TAG, String.format("Headers were overwritten! (%s | %s) overwrites (%s | %s)", str, AsyncHttpClient.this.clientHeaderMap.get(str), firstHeader.getName(), firstHeader.getValue())); httpRequest.removeHeader(firstHeader); } httpRequest.addHeader(str, (String) AsyncHttpClient.this.clientHeaderMap.get(str)); } } }); this.httpClient.addResponseInterceptor(new HttpResponseInterceptor() { /* class com.baidu.tts.loopj.AsyncHttpClient.AnonymousClass2 */ public void process(HttpResponse httpResponse, HttpContext httpContext) { Header contentEncoding; HttpEntity entity = httpResponse.getEntity(); if (!(entity == null || (contentEncoding = entity.getContentEncoding()) == null)) { for (HeaderElement headerElement : contentEncoding.getElements()) { if (headerElement.getName().equalsIgnoreCase(AsyncHttpClient.ENCODING_GZIP)) { httpResponse.setEntity(new InflatingEntity(entity)); return; } } } } }); this.httpClient.addRequestInterceptor(new HttpRequestInterceptor() { /* class com.baidu.tts.loopj.AsyncHttpClient.AnonymousClass3 */ public void process(HttpRequest httpRequest, HttpContext httpContext) throws HttpException, IOException { Credentials credentials; AuthState authState = (AuthState) httpContext.getAttribute("http.auth.target-scope"); CredentialsProvider credentialsProvider = (CredentialsProvider) httpContext.getAttribute("http.auth.credentials-provider"); HttpHost httpHost = (HttpHost) httpContext.getAttribute("http.target_host"); if (authState.getAuthScheme() == null && (credentials = credentialsProvider.getCredentials(new AuthScope(httpHost.getHostName(), httpHost.getPort()))) != null) { authState.setAuthScheme(new BasicScheme()); authState.setCredentials(credentials); } } }, 0); this.httpClient.setHttpRequestRetryHandler(new RetryHandler(5, DEFAULT_RETRY_SLEEP_TIME_MILLIS)); } public static void allowRetryExceptionClass(Class<?> cls) { if (cls != null) { RetryHandler.addClassToWhitelist(cls); } } public static void blockRetryExceptionClass(Class<?> cls) { if (cls != null) { RetryHandler.addClassToBlacklist(cls); } } public HttpClient getHttpClient() { return this.httpClient; } public HttpContext getHttpContext() { return this.httpContext; } public void setLoggingEnabled(boolean z) { log.setLoggingEnabled(z); } public boolean isLoggingEnabled() { return log.isLoggingEnabled(); } public void setLoggingLevel(int i) { log.setLoggingLevel(i); } public int getLoggingLevel() { return log.getLoggingLevel(); } public LogInterface getLogInterface() { return log; } public void setLogInterface(LogInterface logInterface) { if (logInterface != null) { log = logInterface; } } public void setCookieStore(CookieStore cookieStore) { this.httpContext.setAttribute("http.cookie-store", cookieStore); } public void setThreadPool(ExecutorService executorService) { this.threadPool = executorService; } public ExecutorService getThreadPool() { return this.threadPool; } /* access modifiers changed from: protected */ public ExecutorService getDefaultThreadPool() { return Executors.newCachedThreadPool(); } /* access modifiers changed from: protected */ public ClientConnectionManager createConnectionManager(SchemeRegistry schemeRegistry, BasicHttpParams basicHttpParams) { return new ThreadSafeClientConnManager(basicHttpParams, schemeRegistry); } public void setEnableRedirects(boolean z, boolean z2, boolean z3) { this.httpClient.getParams().setBooleanParameter("http.protocol.reject-relative-redirect", !z2); this.httpClient.getParams().setBooleanParameter("http.protocol.allow-circular-redirects", z3); this.httpClient.setRedirectHandler(new MyRedirectHandler(z)); } public void setEnableRedirects(boolean z, boolean z2) { setEnableRedirects(z, z2, true); } public void setEnableRedirects(boolean z) { setEnableRedirects(z, z, z); } public void setRedirectHandler(RedirectHandler redirectHandler) { this.httpClient.setRedirectHandler(redirectHandler); } public void setUserAgent(String str) { HttpProtocolParams.setUserAgent(this.httpClient.getParams(), str); } public int getMaxConnections() { return this.maxConnections; } public void setMaxConnections(int i) { if (i < 1) { i = 10; } this.maxConnections = i; ConnManagerParams.setMaxConnectionsPerRoute(this.httpClient.getParams(), new ConnPerRouteBean(this.maxConnections)); } public void setTimeout(int i) { if (i < 1000) { i = 10000; } setConnectTimeout(i); setResponseTimeout(i); } public int getConnectTimeout() { return this.connectTimeout; } public void setConnectTimeout(int i) { if (i < 1000) { i = 10000; } this.connectTimeout = i; HttpParams params = this.httpClient.getParams(); ConnManagerParams.setTimeout(params, (long) this.connectTimeout); HttpConnectionParams.setConnectionTimeout(params, this.connectTimeout); } public int getResponseTimeout() { return this.responseTimeout; } public void setResponseTimeout(int i) { if (i < 1000) { i = 10000; } this.responseTimeout = i; HttpConnectionParams.setSoTimeout(this.httpClient.getParams(), this.responseTimeout); } public void setProxy(String str, int i) { this.httpClient.getParams().setParameter("http.route.default-proxy", new HttpHost(str, i)); } public void setProxy(String str, int i, String str2, String str3) { this.httpClient.getCredentialsProvider().setCredentials(new AuthScope(str, i), new UsernamePasswordCredentials(str2, str3)); this.httpClient.getParams().setParameter("http.route.default-proxy", new HttpHost(str, i)); } public void setSSLSocketFactory(SSLSocketFactory sSLSocketFactory) { this.httpClient.getConnectionManager().getSchemeRegistry().register(new Scheme("https", sSLSocketFactory, 443)); } public void setMaxRetriesAndTimeout(int i, int i2) { this.httpClient.setHttpRequestRetryHandler(new RetryHandler(i, i2)); } public void removeAllHeaders() { this.clientHeaderMap.clear(); } public void addHeader(String str, String str2) { this.clientHeaderMap.put(str, str2); } public void removeHeader(String str) { this.clientHeaderMap.remove(str); } public void setBasicAuth(String str, String str2) { setBasicAuth(str, str2, false); } public void setBasicAuth(String str, String str2, boolean z) { setBasicAuth(str, str2, null, z); } public void setBasicAuth(String str, String str2, AuthScope authScope) { setBasicAuth(str, str2, authScope, false); } public void setBasicAuth(String str, String str2, AuthScope authScope, boolean z) { setCredentials(authScope, new UsernamePasswordCredentials(str, str2)); setAuthenticationPreemptive(z); } public void setCredentials(AuthScope authScope, Credentials credentials) { if (credentials == null) { log.d(LOG_TAG, "Provided credentials are null, not setting"); return; } CredentialsProvider credentialsProvider = this.httpClient.getCredentialsProvider(); if (authScope == null) { authScope = AuthScope.ANY; } credentialsProvider.setCredentials(authScope, credentials); } public void setAuthenticationPreemptive(boolean z) { if (z) { this.httpClient.addRequestInterceptor(new PreemptiveAuthorizationHttpRequestInterceptor(), 0); } else { this.httpClient.removeRequestInterceptorByClass(PreemptiveAuthorizationHttpRequestInterceptor.class); } } public void clearCredentialsProvider() { this.httpClient.getCredentialsProvider().clear(); } public void cancelRequests(Context context, final boolean z) { if (context == null) { log.e(LOG_TAG, "Passed null Context to cancelRequests"); return; } final List<RequestHandle> list = this.requestMap.get(context); this.requestMap.remove(context); if (Looper.myLooper() == Looper.getMainLooper()) { this.threadPool.submit(new Runnable() { /* class com.baidu.tts.loopj.AsyncHttpClient.AnonymousClass4 */ public void run() { AsyncHttpClient.this.cancelRequests((AsyncHttpClient) list, (List) z); } }); return; } cancelRequests(list, z); } /* access modifiers changed from: private */ /* access modifiers changed from: public */ private void cancelRequests(List<RequestHandle> list, boolean z) { if (list != null) { for (RequestHandle requestHandle : list) { requestHandle.cancel(z); } } } public void cancelAllRequests(boolean z) { for (List<RequestHandle> list : this.requestMap.values()) { if (list != null) { for (RequestHandle requestHandle : list) { requestHandle.cancel(z); } } } this.requestMap.clear(); } public void cancelRequestsByTAG(Object obj, boolean z) { if (obj == null) { log.d(LOG_TAG, "cancelRequestsByTAG, passed TAG is null, cannot proceed"); return; } for (List<RequestHandle> list : this.requestMap.values()) { if (list != null) { for (RequestHandle requestHandle : list) { if (obj.equals(requestHandle.getTag())) { requestHandle.cancel(z); } } } } } public RequestHandle head(String str, ResponseHandlerInterface responseHandlerInterface) { return head(null, str, null, responseHandlerInterface); } public RequestHandle head(String str, RequestParams requestParams, ResponseHandlerInterface responseHandlerInterface) { return head(null, str, requestParams, responseHandlerInterface); } public RequestHandle head(Context context, String str, ResponseHandlerInterface responseHandlerInterface) { return head(context, str, null, responseHandlerInterface); } public RequestHandle head(Context context, String str, RequestParams requestParams, ResponseHandlerInterface responseHandlerInterface) { return sendRequest(this.httpClient, this.httpContext, new HttpHead(getUrlWithQueryString(this.isUrlEncodingEnabled, str, requestParams)), null, responseHandlerInterface, context); } public RequestHandle head(Context context, String str, Header[] headerArr, RequestParams requestParams, ResponseHandlerInterface responseHandlerInterface) { HttpHead httpHead = new HttpHead(getUrlWithQueryString(this.isUrlEncodingEnabled, str, requestParams)); if (headerArr != null) { httpHead.setHeaders(headerArr); } return sendRequest(this.httpClient, this.httpContext, httpHead, null, responseHandlerInterface, context); } public RequestHandle get(String str, ResponseHandlerInterface responseHandlerInterface) { return get(null, str, null, responseHandlerInterface); } public RequestHandle get(String str, RequestParams requestParams, ResponseHandlerInterface responseHandlerInterface) { return get(null, str, requestParams, responseHandlerInterface); } public RequestHandle get(Context context, String str, ResponseHandlerInterface responseHandlerInterface) { return get(context, str, null, responseHandlerInterface); } public RequestHandle get(Context context, String str, RequestParams requestParams, ResponseHandlerInterface responseHandlerInterface) { return sendRequest(this.httpClient, this.httpContext, new HttpGet(getUrlWithQueryString(this.isUrlEncodingEnabled, str, requestParams)), null, responseHandlerInterface, context); } public RequestHandle get(Context context, String str, Header[] headerArr, RequestParams requestParams, ResponseHandlerInterface responseHandlerInterface) { HttpGet httpGet = new HttpGet(getUrlWithQueryString(this.isUrlEncodingEnabled, str, requestParams)); if (headerArr != null) { httpGet.setHeaders(headerArr); } return sendRequest(this.httpClient, this.httpContext, httpGet, null, responseHandlerInterface, context); } public RequestHandle get(Context context, String str, HttpEntity httpEntity, String str2, ResponseHandlerInterface responseHandlerInterface) { return sendRequest(this.httpClient, this.httpContext, addEntityToRequestBase(new HttpGet(URI.create(str).normalize()), httpEntity), str2, responseHandlerInterface, context); } public RequestHandle post(String str, ResponseHandlerInterface responseHandlerInterface) { return post(null, str, null, responseHandlerInterface); } public RequestHandle post(String str, RequestParams requestParams, ResponseHandlerInterface responseHandlerInterface) { return post(null, str, requestParams, responseHandlerInterface); } public RequestHandle post(Context context, String str, RequestParams requestParams, ResponseHandlerInterface responseHandlerInterface) { return post(context, str, paramsToEntity(requestParams, responseHandlerInterface), null, responseHandlerInterface); } public RequestHandle post(Context context, String str, HttpEntity httpEntity, String str2, ResponseHandlerInterface responseHandlerInterface) { return sendRequest(this.httpClient, this.httpContext, addEntityToRequestBase(new HttpPost(getURI(str)), httpEntity), str2, responseHandlerInterface, context); } public RequestHandle post(Context context, String str, Header[] headerArr, RequestParams requestParams, String str2, ResponseHandlerInterface responseHandlerInterface) { HttpPost httpPost = new HttpPost(getURI(str)); if (requestParams != null) { httpPost.setEntity(paramsToEntity(requestParams, responseHandlerInterface)); } if (headerArr != null) { httpPost.setHeaders(headerArr); } return sendRequest(this.httpClient, this.httpContext, httpPost, str2, responseHandlerInterface, context); } public RequestHandle post(Context context, String str, Header[] headerArr, HttpEntity httpEntity, String str2, ResponseHandlerInterface responseHandlerInterface) { HttpEntityEnclosingRequestBase addEntityToRequestBase = addEntityToRequestBase(new HttpPost(getURI(str)), httpEntity); if (headerArr != null) { addEntityToRequestBase.setHeaders(headerArr); } return sendRequest(this.httpClient, this.httpContext, addEntityToRequestBase, str2, responseHandlerInterface, context); } public RequestHandle put(String str, ResponseHandlerInterface responseHandlerInterface) { return put(null, str, null, responseHandlerInterface); } public RequestHandle put(String str, RequestParams requestParams, ResponseHandlerInterface responseHandlerInterface) { return put(null, str, requestParams, responseHandlerInterface); } public RequestHandle put(Context context, String str, RequestParams requestParams, ResponseHandlerInterface responseHandlerInterface) { return put(context, str, paramsToEntity(requestParams, responseHandlerInterface), null, responseHandlerInterface); } public RequestHandle put(Context context, String str, HttpEntity httpEntity, String str2, ResponseHandlerInterface responseHandlerInterface) { return sendRequest(this.httpClient, this.httpContext, addEntityToRequestBase(new HttpPut(getURI(str)), httpEntity), str2, responseHandlerInterface, context); } public RequestHandle put(Context context, String str, Header[] headerArr, HttpEntity httpEntity, String str2, ResponseHandlerInterface responseHandlerInterface) { HttpEntityEnclosingRequestBase addEntityToRequestBase = addEntityToRequestBase(new HttpPut(getURI(str)), httpEntity); if (headerArr != null) { addEntityToRequestBase.setHeaders(headerArr); } return sendRequest(this.httpClient, this.httpContext, addEntityToRequestBase, str2, responseHandlerInterface, context); } public RequestHandle patch(String str, ResponseHandlerInterface responseHandlerInterface) { return patch(null, str, null, responseHandlerInterface); } public RequestHandle patch(String str, RequestParams requestParams, ResponseHandlerInterface responseHandlerInterface) { return patch(null, str, requestParams, responseHandlerInterface); } public RequestHandle patch(Context context, String str, RequestParams requestParams, ResponseHandlerInterface responseHandlerInterface) { return patch(context, str, paramsToEntity(requestParams, responseHandlerInterface), null, responseHandlerInterface); } public RequestHandle patch(Context context, String str, HttpEntity httpEntity, String str2, ResponseHandlerInterface responseHandlerInterface) { return sendRequest(this.httpClient, this.httpContext, addEntityToRequestBase(new HttpPatch(getURI(str)), httpEntity), str2, responseHandlerInterface, context); } public RequestHandle patch(Context context, String str, Header[] headerArr, HttpEntity httpEntity, String str2, ResponseHandlerInterface responseHandlerInterface) { HttpEntityEnclosingRequestBase addEntityToRequestBase = addEntityToRequestBase(new HttpPatch(getURI(str)), httpEntity); if (headerArr != null) { addEntityToRequestBase.setHeaders(headerArr); } return sendRequest(this.httpClient, this.httpContext, addEntityToRequestBase, str2, responseHandlerInterface, context); } public RequestHandle delete(String str, ResponseHandlerInterface responseHandlerInterface) { return delete((Context) null, str, responseHandlerInterface); } public RequestHandle delete(Context context, String str, ResponseHandlerInterface responseHandlerInterface) { return sendRequest(this.httpClient, this.httpContext, new HttpDelete(getURI(str)), null, responseHandlerInterface, context); } public RequestHandle delete(Context context, String str, Header[] headerArr, ResponseHandlerInterface responseHandlerInterface) { HttpDelete httpDelete = new HttpDelete(getURI(str)); if (headerArr != null) { httpDelete.setHeaders(headerArr); } return sendRequest(this.httpClient, this.httpContext, httpDelete, null, responseHandlerInterface, context); } public void delete(String str, RequestParams requestParams, AsyncHttpResponseHandler asyncHttpResponseHandler) { sendRequest(this.httpClient, this.httpContext, new HttpDelete(getUrlWithQueryString(this.isUrlEncodingEnabled, str, requestParams)), null, asyncHttpResponseHandler, null); } public RequestHandle delete(Context context, String str, Header[] headerArr, RequestParams requestParams, ResponseHandlerInterface responseHandlerInterface) { HttpDelete httpDelete = new HttpDelete(getUrlWithQueryString(this.isUrlEncodingEnabled, str, requestParams)); if (headerArr != null) { httpDelete.setHeaders(headerArr); } return sendRequest(this.httpClient, this.httpContext, httpDelete, null, responseHandlerInterface, context); } public RequestHandle delete(Context context, String str, HttpEntity httpEntity, String str2, ResponseHandlerInterface responseHandlerInterface) { return sendRequest(this.httpClient, this.httpContext, addEntityToRequestBase(new HttpDelete(URI.create(str).normalize()), httpEntity), str2, responseHandlerInterface, context); } /* access modifiers changed from: protected */ public AsyncHttpRequest newAsyncHttpRequest(DefaultHttpClient defaultHttpClient, HttpContext httpContext2, HttpUriRequest httpUriRequest, String str, ResponseHandlerInterface responseHandlerInterface, Context context) { return new AsyncHttpRequest(defaultHttpClient, httpContext2, httpUriRequest, responseHandlerInterface); } /* access modifiers changed from: protected */ public RequestHandle sendRequest(DefaultHttpClient defaultHttpClient, HttpContext httpContext2, HttpUriRequest httpUriRequest, String str, ResponseHandlerInterface responseHandlerInterface, Context context) { List<RequestHandle> list; if (httpUriRequest == null) { throw new IllegalArgumentException("HttpUriRequest must not be null"); } else if (responseHandlerInterface == null) { throw new IllegalArgumentException("ResponseHandler must not be null"); } else if (!responseHandlerInterface.getUseSynchronousMode() || responseHandlerInterface.getUsePoolThread()) { if (str != null) { if (!(httpUriRequest instanceof HttpEntityEnclosingRequestBase) || ((HttpEntityEnclosingRequestBase) httpUriRequest).getEntity() == null || !httpUriRequest.containsHeader(HEADER_CONTENT_TYPE)) { httpUriRequest.setHeader(HEADER_CONTENT_TYPE, str); } else { log.w(LOG_TAG, "Passed contentType will be ignored because HttpEntity sets content type"); } } responseHandlerInterface.setRequestHeaders(httpUriRequest.getAllHeaders()); responseHandlerInterface.setRequestURI(httpUriRequest.getURI()); AsyncHttpRequest newAsyncHttpRequest = newAsyncHttpRequest(defaultHttpClient, httpContext2, httpUriRequest, str, responseHandlerInterface, context); this.threadPool.submit(newAsyncHttpRequest); RequestHandle requestHandle = new RequestHandle(newAsyncHttpRequest); if (context != null) { synchronized (this.requestMap) { list = this.requestMap.get(context); if (list == null) { list = Collections.synchronizedList(new LinkedList()); this.requestMap.put(context, list); } } list.add(requestHandle); Iterator<RequestHandle> it = list.iterator(); while (it.hasNext()) { if (it.next().shouldBeGarbageCollected()) { it.remove(); } } } return requestHandle; } else { throw new IllegalArgumentException("Synchronous ResponseHandler used in AsyncHttpClient. You should create your response handler in a looper thread or use SyncHttpClient instead."); } } /* access modifiers changed from: protected */ public URI getURI(String str) { return URI.create(str).normalize(); } public void setURLEncodingEnabled(boolean z) { this.isUrlEncodingEnabled = z; } public static String getUrlWithQueryString(boolean z, String str, RequestParams requestParams) { if (str == null) { return null; } if (z) { try { URL url = new URL(URLDecoder.decode(str, "UTF-8")); str = new URI(url.getProtocol(), url.getUserInfo(), url.getHost(), url.getPort(), url.getPath(), url.getQuery(), url.getRef()).toASCIIString(); } catch (Exception e) { log.e(LOG_TAG, "getUrlWithQueryString encoding URL", e); } } if (requestParams == null) { return str; } String trim = requestParams.getParamString().trim(); if (trim.equals("") || trim.equals("?")) { return str; } StringBuilder sb = new StringBuilder(); sb.append(str); sb.append(str.contains("?") ? "&" : "?"); String sb2 = sb.toString(); return sb2 + trim; } public static boolean isInputStreamGZIPCompressed(PushbackInputStream pushbackInputStream) throws IOException { if (pushbackInputStream == null) { return false; } byte[] bArr = new byte[2]; int read = pushbackInputStream.read(bArr); pushbackInputStream.unread(bArr); int i = (bArr[0] & Pdu.MANUFACTURER_DATA_PDU_TYPE) | ((bArr[1] << 8) & MotionEventCompat.ACTION_POINTER_INDEX_MASK); if (read == 2 && 35615 == i) { return true; } return false; } public static void silentCloseInputStream(InputStream inputStream) { if (inputStream != null) { try { inputStream.close(); } catch (IOException e) { log.w(LOG_TAG, "Cannot close input stream", e); } } } public static void silentCloseOutputStream(OutputStream outputStream) { if (outputStream != null) { try { outputStream.close(); } catch (IOException e) { log.w(LOG_TAG, "Cannot close output stream", e); } } } private HttpEntity paramsToEntity(RequestParams requestParams, ResponseHandlerInterface responseHandlerInterface) { if (requestParams == null) { return null; } try { return requestParams.getEntity(responseHandlerInterface); } catch (IOException e) { if (responseHandlerInterface != null) { responseHandlerInterface.sendFailureMessage(0, null, null, e); return null; } e.printStackTrace(); return null; } } public boolean isUrlEncodingEnabled() { return this.isUrlEncodingEnabled; } private HttpEntityEnclosingRequestBase addEntityToRequestBase(HttpEntityEnclosingRequestBase httpEntityEnclosingRequestBase, HttpEntity httpEntity) { if (httpEntity != null) { httpEntityEnclosingRequestBase.setEntity(httpEntity); } return httpEntityEnclosingRequestBase; } public static void endEntityViaReflection(HttpEntity httpEntity) { if (httpEntity instanceof HttpEntityWrapper) { Field field = null; try { Field[] declaredFields = HttpEntityWrapper.class.getDeclaredFields(); int length = declaredFields.length; int i = 0; while (true) { if (i >= length) { break; } Field field2 = declaredFields[i]; if (field2.getName().equals("wrappedEntity")) { field = field2; break; } i++; } if (field != null) { field.setAccessible(true); HttpEntity httpEntity2 = (HttpEntity) field.get(httpEntity); if (httpEntity2 != null) { httpEntity2.consumeContent(); } } } catch (Throwable th) { log.e(LOG_TAG, "wrappedEntity consume", th); } } } private static class InflatingEntity extends HttpEntityWrapper { GZIPInputStream gzippedStream; PushbackInputStream pushbackStream; InputStream wrappedStream; public InflatingEntity(HttpEntity httpEntity) { super(httpEntity); } public InputStream getContent() throws IOException { this.wrappedStream = this.wrappedEntity.getContent(); this.pushbackStream = new PushbackInputStream(this.wrappedStream, 2); if (!AsyncHttpClient.isInputStreamGZIPCompressed(this.pushbackStream)) { return this.pushbackStream; } this.gzippedStream = new GZIPInputStream(this.pushbackStream); return this.gzippedStream; } public long getContentLength() { if (this.wrappedEntity == null) { return 0; } return this.wrappedEntity.getContentLength(); } public void consumeContent() throws IOException { AsyncHttpClient.silentCloseInputStream(this.wrappedStream); AsyncHttpClient.silentCloseInputStream(this.pushbackStream); AsyncHttpClient.silentCloseInputStream(this.gzippedStream); AsyncHttpClient.super.consumeContent(); } } }