95爱播免登录版 v3.1.9 - b.java 源代码

package com.l.a.a;

import android.content.Context;
import com.faceunity.wrapper.faceunity;
import com.huawei.hms.framework.common.ContainerUtils;
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.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.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.client.CredentialsProvider;
import org.apache.http.client.methods.HttpEntityEnclosingRequestBase;
import org.apache.http.client.methods.HttpGet;
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.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 b {

    private int f6544a;

    private int f6545b;

    private int f6546c;

    private final DefaultHttpClient f6547d;
    private final HttpContext e;
    private ExecutorService f;
    private final Map<Context, List<j>> g;
    private final Map<String, String> h;
    private boolean i;

    class a implements HttpRequestInterceptor {
        a() {
        }

        @Override
        public void process(HttpRequest httpRequest, HttpContext httpContext) {
            if (!httpRequest.containsHeader("Accept-Encoding")) {
                httpRequest.addHeader("Accept-Encoding", "gzip");
            }
            for (String str : b.this.h.keySet()) {
                if (httpRequest.containsHeader(str)) {
                    Header firstHeader = httpRequest.getFirstHeader(str);
                    String.format("Headers were overwritten! (%s | %s) overwrites (%s | %s)", str, b.this.h.get(str), firstHeader.getName(), firstHeader.getValue());
                    httpRequest.removeHeader(firstHeader);
                }
                httpRequest.addHeader(str, (String) b.this.h.get(str));
            }
        }
    }

    class C0157b implements HttpResponseInterceptor {
        C0157b(b bVar) {
        }

        @Override
        public void process(HttpResponse httpResponse, HttpContext httpContext) {
            Header contentEncoding;
            HttpEntity entity = httpResponse.getEntity();
            if (entity == null || (contentEncoding = entity.getContentEncoding()) == null) {
                return;
            }
            for (HeaderElement headerElement : contentEncoding.getElements()) {
                if (headerElement.getName().equalsIgnoreCase("gzip")) {
                    httpResponse.setEntity(new d(entity));
                    return;
                }
            }
        }
    }

    class c implements HttpRequestInterceptor {
        c(b bVar) {
        }

        @Override
        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) {
                return;
            }
            authState.setAuthScheme(new BasicScheme());
            authState.setCredentials(credentials);
        }
    }

    private static class d extends HttpEntityWrapper {

        InputStream f6549a;

        PushbackInputStream f6550b;

        GZIPInputStream f6551c;

        public d(HttpEntity httpEntity) {
            super(httpEntity);
        }

        @Override
        public void consumeContent() throws IOException {
            b.z(this.f6549a);
            b.z(this.f6550b);
            b.z(this.f6551c);
            super.consumeContent();
        }

        @Override
        public InputStream getContent() throws IOException {
            this.f6549a = ((HttpEntityWrapper) this).wrappedEntity.getContent();
            PushbackInputStream pushbackInputStream = new PushbackInputStream(this.f6549a, 2);
            this.f6550b = pushbackInputStream;
            if (!b.m(pushbackInputStream)) {
                return this.f6550b;
            }
            GZIPInputStream gZIPInputStream = new GZIPInputStream(this.f6550b);
            this.f6551c = gZIPInputStream;
            return gZIPInputStream;
        }

        @Override
        public long getContentLength() {
            HttpEntity httpEntity = ((HttpEntityWrapper) this).wrappedEntity;
            if (httpEntity == null) {
                return 0L;
            }
            return httpEntity.getContentLength();
        }
    }

    public b() {
        this(false, 80, 443);
    }

    public static void A(OutputStream outputStream) {
        if (outputStream != null) {
            try {
                outputStream.close();
            } catch (IOException unused) {
            }
        }
    }

    private HttpEntityEnclosingRequestBase b(HttpEntityEnclosingRequestBase httpEntityEnclosingRequestBase, HttpEntity httpEntity) {
        if (httpEntity != null) {
            httpEntityEnclosingRequestBase.setEntity(httpEntity);
        }
        return httpEntityEnclosingRequestBase;
    }

    public static void d(Class<?> cls) {
        if (cls != null) {
            m.a(cls);
        }
    }

    public static void e(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 unused) {
            }
        }
    }

    private static SchemeRegistry i(boolean z, int i, int i2) {
        if (i < 1) {
            i = 80;
        }
        if (i2 < 1) {
            i2 = 443;
        }
        SSLSocketFactory a2 = z ? h.a() : SSLSocketFactory.getSocketFactory();
        SchemeRegistry schemeRegistry = new SchemeRegistry();
        schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), i));
        schemeRegistry.register(new Scheme("https", a2, i2));
        return schemeRegistry;
    }

    public static String k(boolean z, String str, k kVar) {
        if (str == null) {
            return null;
        }
        if (z) {
            str = str.replace(" ", "%20");
        }
        if (kVar == null) {
            return str;
        }
        String trim = kVar.a().trim();
        if (trim.equals("")) {
            return str;
        }
        if (trim.equals("?")) {
            return str;
        }
        StringBuilder sb = new StringBuilder();
        sb.append(str);
        sb.append(str.contains("?") ? ContainerUtils.FIELD_DELIMITER : "?");
        return sb.toString() + trim;
    }

    public static boolean m(PushbackInputStream pushbackInputStream) throws IOException {
        if (pushbackInputStream == null) {
            return false;
        }
        byte[] bArr = new byte[2];
        int read = pushbackInputStream.read(bArr);
        pushbackInputStream.unread(bArr);
        return read == 2 && 35615 == ((bArr[0] & 255) | ((bArr[1] << 8) & 65280));
    }

    public static void z(InputStream inputStream) {
        if (inputStream != null) {
            try {
                inputStream.close();
            } catch (IOException unused) {
            }
        }
    }

    public void c(String str, String str2) {
        this.h.put(str, str2);
    }

    public j f(Context context, String str, k kVar, l lVar) {
        return q(this.f6547d, this.e, new HttpGet(k(this.i, str, kVar)), null, lVar, context);
    }

    public j g(Context context, String str, l lVar) {
        return f(context, str, null, lVar);
    }

    public j h(Context context, String str, Header[] headerArr, k kVar, l lVar) {
        HttpGet httpGet = new HttpGet(k(this.i, str, kVar));
        if (headerArr != null) {
            httpGet.setHeaders(headerArr);
        }
        return q(this.f6547d, this.e, httpGet, null, lVar, context);
    }

    protected ExecutorService j() {
        return Executors.newCachedThreadPool();
    }

    public j l(Context context, String str, Header[] headerArr, k kVar, l lVar) {
        HttpHead httpHead = new HttpHead(k(this.i, str, kVar));
        if (headerArr != null) {
            httpHead.setHeaders(headerArr);
        }
        return q(this.f6547d, this.e, httpHead, null, lVar, context);
    }

    protected com.l.a.a.c n(DefaultHttpClient defaultHttpClient, HttpContext httpContext, HttpUriRequest httpUriRequest, String str, l lVar, Context context) {
        return new com.l.a.a.c(defaultHttpClient, httpContext, httpUriRequest, lVar);
    }

    public j o(Context context, String str, HttpEntity httpEntity, String str2, l lVar) {
        DefaultHttpClient defaultHttpClient = this.f6547d;
        HttpContext httpContext = this.e;
        HttpPost httpPost = new HttpPost(URI.create(str).normalize());
        b(httpPost, httpEntity);
        return q(defaultHttpClient, httpContext, httpPost, str2, lVar, context);
    }

    public j p(Context context, String str, HttpEntity httpEntity, String str2, l lVar) {
        DefaultHttpClient defaultHttpClient = this.f6547d;
        HttpContext httpContext = this.e;
        HttpPut httpPut = new HttpPut(URI.create(str).normalize());
        b(httpPut, httpEntity);
        return q(defaultHttpClient, httpContext, httpPut, str2, lVar, context);
    }

    protected j q(DefaultHttpClient defaultHttpClient, HttpContext httpContext, HttpUriRequest httpUriRequest, String str, l lVar, Context context) {
        if (httpUriRequest == null) {
            throw new IllegalArgumentException("HttpUriRequest must not be null");
        }
        if (lVar == null) {
            throw new IllegalArgumentException("ResponseHandler must not be null");
        }
        if (lVar.getUseSynchronousMode()) {
            throw new IllegalArgumentException("Synchronous ResponseHandler used in AsyncHttpClient. You should create your response handler in a looper thread or use SyncHttpClient instead.");
        }
        if (str != null && (!(httpUriRequest instanceof HttpEntityEnclosingRequestBase) || ((HttpEntityEnclosingRequestBase) httpUriRequest).getEntity() == null)) {
            httpUriRequest.setHeader("Content-Type", str);
        }
        lVar.setRequestHeaders(httpUriRequest.getAllHeaders());
        lVar.setRequestURI(httpUriRequest.getURI());
        com.l.a.a.c n = n(defaultHttpClient, httpContext, httpUriRequest, str, lVar, context);
        this.f.submit(n);
        j jVar = new j(n);
        if (context != null) {
            List<j> list = this.g.get(context);
            synchronized (this.g) {
                if (list == null) {
                    list = Collections.synchronizedList(new LinkedList());
                    this.g.put(context, list);
                }
            }
            if (lVar instanceof i) {
                ((i) lVar).a(httpUriRequest);
            }
            list.add(jVar);
            Iterator<j> it = list.iterator();
            while (it.hasNext()) {
                if (it.next().d()) {
                    it.remove();
                }
            }
        }
        return jVar;
    }

    public void r(int i) {
        if (i < 1000) {
            i = 10000;
        }
        this.f6545b = i;
        HttpParams params = this.f6547d.getParams();
        ConnManagerParams.setTimeout(params, this.f6545b);
        HttpConnectionParams.setConnectionTimeout(params, this.f6545b);
    }

    public void s(boolean z) {
        t(z, z, z);
    }

    public void t(boolean z, boolean z2, boolean z3) {
        this.f6547d.getParams().setBooleanParameter("http.protocol.reject-relative-redirect", !z2);
        this.f6547d.getParams().setBooleanParameter("http.protocol.allow-circular-redirects", z3);
        this.f6547d.setRedirectHandler(new g(z));
    }

    public void u(int i) {
        if (i < 1000) {
            i = 10000;
        }
        this.f6546c = i;
        HttpConnectionParams.setSoTimeout(this.f6547d.getParams(), this.f6546c);
    }

    public void v(SSLSocketFactory sSLSocketFactory) {
        this.f6547d.getConnectionManager().getSchemeRegistry().register(new Scheme("https", sSLSocketFactory, 443));
    }

    public void w(int i) {
        if (i < 1000) {
            i = 10000;
        }
        r(i);
        u(i);
    }

    public void x(boolean z) {
        this.i = z;
    }

    public void y(String str) {
        HttpProtocolParams.setUserAgent(this.f6547d.getParams(), str);
    }

    public b(boolean z, int i, int i2) {
        this(i(z, i, i2));
    }

    public b(SchemeRegistry schemeRegistry) {
        this.f6544a = 10;
        this.f6545b = 10000;
        this.f6546c = 10000;
        this.i = true;
        BasicHttpParams basicHttpParams = new BasicHttpParams();
        ConnManagerParams.setTimeout(basicHttpParams, this.f6545b);
        ConnManagerParams.setMaxConnectionsPerRoute(basicHttpParams, new ConnPerRouteBean(this.f6544a));
        ConnManagerParams.setMaxTotalConnections(basicHttpParams, 10);
        HttpConnectionParams.setSoTimeout(basicHttpParams, this.f6546c);
        HttpConnectionParams.setConnectionTimeout(basicHttpParams, this.f6545b);
        HttpConnectionParams.setTcpNoDelay(basicHttpParams, true);
        HttpConnectionParams.setSocketBufferSize(basicHttpParams, faceunity.FU_ADM_FLAG_TEXTURE_ROTATE_90);
        HttpProtocolParams.setVersion(basicHttpParams, HttpVersion.HTTP_1_1);
        ThreadSafeClientConnManager threadSafeClientConnManager = new ThreadSafeClientConnManager(basicHttpParams, schemeRegistry);
        this.f = j();
        this.g = Collections.synchronizedMap(new WeakHashMap());
        this.h = new HashMap();
        this.e = new SyncBasicHttpContext(new BasicHttpContext());
        DefaultHttpClient defaultHttpClient = new DefaultHttpClient(threadSafeClientConnManager, basicHttpParams);
        this.f6547d = defaultHttpClient;
        defaultHttpClient.addRequestInterceptor(new a());
        defaultHttpClient.addResponseInterceptor(new C0157b(this));
        defaultHttpClient.addRequestInterceptor(new c(this), 0);
        defaultHttpClient.setHttpRequestRetryHandler(new m(5, 1500));
    }
}