大漢易經書院.apk(点击下载) / q.java


package com.baidu.techain.i;

import android.accounts.NetworkErrorException;
import android.content.Context;
import com.meizu.cloud.pushsdk.constants.PushConstants;
import com.xiaomi.mipush.sdk.Constants;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.security.KeyStore;
import java.security.SecureRandom;
import java.security.cert.CertificateException;
import java.security.cert.CertificateExpiredException;
import java.security.cert.CertificateNotYetValidException;
import java.security.cert.X509Certificate;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.TrustManagerFactory;
import javax.net.ssl.X509TrustManager;
import okhttp3.Interceptor;
import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;

/* compiled from: OkHttpUtil */
public class q {
    private static SSLSocketFactory b;
    private static final byte[] c = new byte[1024];
    private static OkHttpClient d;
    private Context a;

    public q(Context context) {
        this.a = context;
    }

    private OkHttpClient a() {
        if (d == null) {
            synchronized (q.class) {
                if (d == null) {
                    OkHttpClient.Builder builder = new OkHttpClient.Builder();
                    try {
                        if (b != null) {
                            builder.hostnameVerifier(org.apache.http.conn.ssl.SSLSocketFactory.STRICT_HOSTNAME_VERIFIER);
                            builder.sslSocketFactory(b);
                        } else {
                            SSLContext instance = SSLContext.getInstance("TLS");
                            TrustManagerFactory instance2 = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
                            instance2.init((KeyStore) null);
                            TrustManager[] trustManagers = instance2.getTrustManagers();
                            if (trustManagers.length <= 0 || !(trustManagers[0] instanceof X509TrustManager)) {
                                throw new IllegalStateException("Unexpected default trust managers:" + Arrays.toString(trustManagers));
                            }
                            instance.init(null, new TrustManager[]{new a((X509TrustManager) trustManagers[0])}, new SecureRandom());
                            b = instance.getSocketFactory();
                            builder.hostnameVerifier(org.apache.http.conn.ssl.SSLSocketFactory.STRICT_HOSTNAME_VERIFIER);
                            builder.sslSocketFactory(b);
                        }
                    } catch (Throwable unused) {
                        c.a();
                    }
                    builder.connectTimeout(120000, TimeUnit.MILLISECONDS);
                    builder.addInterceptor(new Interceptor() {
                        /* class com.baidu.techain.i.q.AnonymousClass1 */

                        public final Response intercept(Interceptor.Chain chain) throws IOException {
                            System.currentTimeMillis();
                            Response proceed = chain.proceed(chain.request());
                            System.currentTimeMillis();
                            return proceed;
                        }
                    });
                    d = builder.build();
                }
            }
        }
        return d;
    }

    private Request b(String str, byte[] bArr) {
        try {
            MediaType parse = MediaType.parse("application/x-www-form-urlencoded; charset=utf-8");
            String str2 = c.g(this.a)[0];
            Request.Builder url = new Request.Builder().url(str);
            if (bArr != null) {
                url.post(RequestBody.create(parse, bArr));
            }
            Request.Builder addHeader = url.addHeader("User-Agent", "techain" + "/" + str2 + "/" + x.a(this.a) + "/3.5.9.0.1").addHeader("Pragma", "no-cache").addHeader("Accept", "*/*");
            return addHeader.addHeader("Accept-Language", Locale.getDefault().getLanguage() + Constants.ACCEPT_TIME_SEPARATOR_SERVER + Locale.getDefault().getCountry()).addHeader("x-device-id", n.a(e.b(this.a))).build();
        } catch (Throwable unused) {
            c.a();
            return null;
        }
    }

    public final String a(String str, byte[] bArr) {
        try {
            if (s.m(this.a)) {
                Response execute = a().newCall(b(str, bArr)).execute();
                int code = execute.code();
                if (code == 200) {
                    return execute.body().string();
                }
                throw new NetworkErrorException(String.valueOf(code));
            }
            throw new NetworkErrorException("Not allow background connect.");
        } catch (Throwable unused) {
            c.a();
            return "";
        }
    }

    public final boolean a(String str, File file) {
        try {
            if (s.m(this.a)) {
                Response execute = a().newCall(new Request.Builder().url(str).build()).execute();
                int code = execute.code();
                if (code == 200) {
                    InputStream byteStream = execute.body().byteStream();
                    boolean a2 = a(byteStream, file);
                    byteStream.close();
                    return a2;
                }
                throw new NetworkErrorException(String.valueOf(code));
            }
            throw new NetworkErrorException("Not allow background connect.");
        } catch (Throwable unused) {
            c.a();
            return false;
        }
    }

    private static boolean a(InputStream inputStream, File file) {
        if (inputStream == null) {
            return false;
        }
        try {
            BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(file));
            while (true) {
                int read = inputStream.read(c);
                if (read != -1) {
                    bufferedOutputStream.write(c, 0, read);
                    bufferedOutputStream.flush();
                } else {
                    bufferedOutputStream.flush();
                    bufferedOutputStream.close();
                    return true;
                }
            }
        } catch (Throwable unused) {
            c.a();
            return false;
        }
    }

    /* access modifiers changed from: package-private */
    /* compiled from: OkHttpUtil */
    public class a implements X509TrustManager {
        private X509TrustManager b = null;

        a(X509TrustManager x509TrustManager) {
            this.b = x509TrustManager;
        }

        @Override // javax.net.ssl.X509TrustManager
        public final void checkClientTrusted(X509Certificate[] x509CertificateArr, String str) throws CertificateException {
            this.b.checkClientTrusted(x509CertificateArr, str);
        }

        @Override // javax.net.ssl.X509TrustManager
        public final void checkServerTrusted(X509Certificate[] x509CertificateArr, String str) throws CertificateException {
            try {
                this.b.checkServerTrusted(x509CertificateArr, str);
            } catch (Throwable th) {
                c.a();
                for (Throwable th2 = th; th2 != null; th2 = th2.getCause()) {
                    if ((th2 instanceof CertificateExpiredException) || (th2 instanceof CertificateNotYetValidException)) {
                        HashMap hashMap = new HashMap();
                        hashMap.put(PushConstants.PUSH_TYPE_NOTIFY, Long.valueOf(System.currentTimeMillis()));
                        c.a(q.this.a.getApplicationContext(), "1003121", (Map<String, Object>) hashMap, true);
                        return;
                    }
                }
                if (th instanceof CertificateException) {
                    throw th;
                }
                throw new CertificateException();
            }
        }

        public final X509Certificate[] getAcceptedIssuers() {
            return this.b.getAcceptedIssuers();
        }
    }

    public static boolean a(Context context) {
        return context.getPackageName().contains("com.baidu.searchbox");
    }
}