package g.i0.j;

import android.os.Build;
import android.util.Log;
import g.x;
import java.io.EOFException;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.security.NoSuchAlgorithmException;
import java.security.cert.Certificate;
import java.security.cert.TrustAnchor;
import java.security.cert.X509Certificate;
import java.util.List;
import java.util.Objects;
import javax.annotation.Nullable;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLPeerUnverifiedException;
import javax.net.ssl.SSLSocket;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.X509TrustManager;

/* JADX INFO: loaded from: classes.dex */
public class a extends f {

    /* JADX INFO: renamed from: c, reason: collision with root package name */
    public final Class<?> f6393c;

    /* JADX INFO: renamed from: d, reason: collision with root package name */
    public final e<Socket> f6394d;

    /* JADX INFO: renamed from: e, reason: collision with root package name */
    public final e<Socket> f6395e;

    /* JADX INFO: renamed from: f, reason: collision with root package name */
    public final e<Socket> f6396f;

    /* JADX INFO: renamed from: g, reason: collision with root package name */
    public final e<Socket> f6397g;

    /* JADX INFO: renamed from: h, reason: collision with root package name */
    public final c f6398h;

    /* JADX INFO: renamed from: g.i0.j.a$a, reason: collision with other inner class name */
    public static final class C0087a extends g.i0.l.c {

        /* JADX INFO: renamed from: a, reason: collision with root package name */
        public final Object f6399a;

        /* JADX INFO: renamed from: b, reason: collision with root package name */
        public final Method f6400b;

        public C0087a(Object obj, Method method) {
            this.f6399a = obj;
            this.f6400b = method;
        }

        @Override // g.i0.l.c
        public List<Certificate> a(List<Certificate> list, String str) throws SSLPeerUnverifiedException {
            try {
                return (List) this.f6400b.invoke(this.f6399a, (X509Certificate[]) list.toArray(new X509Certificate[list.size()]), "RSA", str);
            } catch (IllegalAccessException e2) {
                throw new AssertionError(e2);
            } catch (InvocationTargetException e3) {
                SSLPeerUnverifiedException sSLPeerUnverifiedException = new SSLPeerUnverifiedException(e3.getMessage());
                sSLPeerUnverifiedException.initCause(e3);
                throw sSLPeerUnverifiedException;
            }
        }

        public boolean equals(Object obj) {
            return obj instanceof C0087a;
        }

        public int hashCode() {
            return 0;
        }
    }

    public static final class b implements g.i0.l.e {

        /* JADX INFO: renamed from: a, reason: collision with root package name */
        public final X509TrustManager f6401a;

        /* JADX INFO: renamed from: b, reason: collision with root package name */
        public final Method f6402b;

        public b(X509TrustManager x509TrustManager, Method method) {
            this.f6402b = method;
            this.f6401a = x509TrustManager;
        }

        @Override // g.i0.l.e
        public X509Certificate a(X509Certificate x509Certificate) {
            try {
                TrustAnchor trustAnchor = (TrustAnchor) this.f6402b.invoke(this.f6401a, x509Certificate);
                if (trustAnchor != null) {
                    return trustAnchor.getTrustedCert();
                }
                return null;
            } catch (IllegalAccessException e2) {
                throw g.i0.c.a("unable to get issues and signature", e2);
            } catch (InvocationTargetException unused) {
                return null;
            }
        }

        public boolean equals(Object obj) {
            if (obj == this) {
                return true;
            }
            if (!(obj instanceof b)) {
                return false;
            }
            b bVar = (b) obj;
            return this.f6401a.equals(bVar.f6401a) && this.f6402b.equals(bVar.f6402b);
        }

        public int hashCode() {
            return (this.f6402b.hashCode() * 31) + this.f6401a.hashCode();
        }
    }

    public static final class c {

        /* JADX INFO: renamed from: a, reason: collision with root package name */
        public final Method f6403a;

        /* JADX INFO: renamed from: b, reason: collision with root package name */
        public final Method f6404b;

        /* JADX INFO: renamed from: c, reason: collision with root package name */
        public final Method f6405c;

        public c(Method method, Method method2, Method method3) {
            this.f6403a = method;
            this.f6404b = method2;
            this.f6405c = method3;
        }
    }

    public a(Class<?> cls, e<Socket> eVar, e<Socket> eVar2, e<Socket> eVar3, e<Socket> eVar4) throws NoSuchMethodException {
        Method method;
        Method method2;
        Method method3 = null;
        try {
            Class<?> cls2 = Class.forName("dalvik.system.CloseGuard");
            Method method4 = cls2.getMethod("get", new Class[0]);
            method2 = cls2.getMethod("open", String.class);
            method = cls2.getMethod("warnIfOpen", new Class[0]);
            method3 = method4;
        } catch (Exception unused) {
            method = null;
            method2 = null;
        }
        this.f6398h = new c(method3, method2, method);
        this.f6393c = cls;
        this.f6394d = eVar;
        this.f6395e = eVar2;
        this.f6396f = eVar3;
        this.f6397g = eVar4;
    }

    @Override // g.i0.j.f
    public g.i0.l.c c(X509TrustManager x509TrustManager) {
        try {
            Class<?> cls = Class.forName("android.net.http.X509TrustManagerExtensions");
            return new C0087a(cls.getConstructor(X509TrustManager.class).newInstance(x509TrustManager), cls.getMethod("checkServerTrusted", X509Certificate[].class, String.class, String.class));
        } catch (Exception unused) {
            return new g.i0.l.a(d(x509TrustManager));
        }
    }

    @Override // g.i0.j.f
    public g.i0.l.e d(X509TrustManager x509TrustManager) {
        try {
            Method declaredMethod = x509TrustManager.getClass().getDeclaredMethod("findTrustAnchorByIssuerAndSignature", X509Certificate.class);
            declaredMethod.setAccessible(true);
            return new b(x509TrustManager, declaredMethod);
        } catch (NoSuchMethodException unused) {
            return new g.i0.l.b(x509TrustManager.getAcceptedIssuers());
        }
    }

    @Override // g.i0.j.f
    public void f(SSLSocket sSLSocket, String str, List<x> list) {
        if (str != null) {
            this.f6394d.c(sSLSocket, Boolean.TRUE);
            this.f6395e.c(sSLSocket, str);
        }
        e<Socket> eVar = this.f6397g;
        if (eVar != null) {
            if (eVar.a(sSLSocket.getClass()) != null) {
                Object[] objArr = new Object[1];
                h.f fVar = new h.f();
                int size = list.size();
                for (int i2 = 0; i2 < size; i2++) {
                    x xVar = list.get(i2);
                    if (xVar != x.HTTP_1_0) {
                        fVar.Z(xVar.toString().length());
                        fVar.e0(xVar.toString());
                    }
                }
                try {
                    objArr[0] = fVar.s(fVar.f6543d);
                    this.f6397g.d(sSLSocket, objArr);
                } catch (EOFException e2) {
                    throw new AssertionError(e2);
                }
            }
        }
    }

    @Override // g.i0.j.f
    public void g(Socket socket, InetSocketAddress inetSocketAddress, int i2) throws IOException {
        try {
            socket.connect(inetSocketAddress, i2);
        } catch (AssertionError e2) {
            if (!g.i0.c.r(e2)) {
                throw e2;
            }
            throw new IOException(e2);
        } catch (ClassCastException e3) {
            if (Build.VERSION.SDK_INT != 26) {
                throw e3;
            }
            IOException iOException = new IOException("Exception in connect");
            iOException.initCause(e3);
            throw iOException;
        } catch (SecurityException e4) {
            IOException iOException2 = new IOException("Exception in connect");
            iOException2.initCause(e4);
            throw iOException2;
        }
    }

    @Override // g.i0.j.f
    public SSLContext h() {
        if (0 != 0) {
            try {
                return SSLContext.getInstance("TLSv1.2");
            } catch (NoSuchAlgorithmException unused) {
            }
        }
        try {
            return SSLContext.getInstance("TLS");
        } catch (NoSuchAlgorithmException e2) {
            throw new IllegalStateException("No TLS provider", e2);
        }
    }

    @Override // g.i0.j.f
    @Nullable
    public String i(SSLSocket sSLSocket) {
        byte[] bArr;
        e<Socket> eVar = this.f6396f;
        if (eVar == null) {
            return null;
        }
        if ((eVar.a(sSLSocket.getClass()) != null) && (bArr = (byte[]) this.f6396f.d(sSLSocket, new Object[0])) != null) {
            return new String(bArr, g.i0.c.f6162i);
        }
        return null;
    }

    @Override // g.i0.j.f
    public Object j(String str) {
        c cVar = this.f6398h;
        Method method = cVar.f6403a;
        if (method == null) {
            return null;
        }
        try {
            Object objInvoke = method.invoke(null, new Object[0]);
            cVar.f6404b.invoke(objInvoke, str);
            return objInvoke;
        } catch (Exception unused) {
            return null;
        }
    }

    @Override // g.i0.j.f
    public boolean k(String str) {
        try {
            Class<?> cls = Class.forName("android.security.NetworkSecurityPolicy");
            return p(str, cls, cls.getMethod("getInstance", new Class[0]).invoke(null, new Object[0]));
        } catch (ClassNotFoundException | NoSuchMethodException unused) {
            return true;
        } catch (IllegalAccessException e2) {
            e = e2;
            throw g.i0.c.a("unable to determine cleartext support", e);
        } catch (IllegalArgumentException e3) {
            e = e3;
            throw g.i0.c.a("unable to determine cleartext support", e);
        } catch (InvocationTargetException e4) {
            e = e4;
            throw g.i0.c.a("unable to determine cleartext support", e);
        }
    }

    @Override // g.i0.j.f
    public void l(int i2, String str, @Nullable Throwable th) {
        int iMin;
        int i3 = i2 != 5 ? 3 : 5;
        if (th != null) {
            str = str + '\n' + Log.getStackTraceString(th);
        }
        int i4 = 0;
        int length = str.length();
        while (i4 < length) {
            int iIndexOf = str.indexOf(10, i4);
            if (iIndexOf == -1) {
                iIndexOf = length;
            }
            while (true) {
                iMin = Math.min(iIndexOf, i4 + 4000);
                Log.println(i3, "OkHttp", str.substring(i4, iMin));
                if (iMin >= iIndexOf) {
                    break;
                } else {
                    i4 = iMin;
                }
            }
            i4 = iMin + 1;
        }
    }

    @Override // g.i0.j.f
    public void m(String str, Object obj) {
        c cVar = this.f6398h;
        Objects.requireNonNull(cVar);
        boolean z = false;
        if (obj != null) {
            try {
                cVar.f6405c.invoke(obj, new Object[0]);
                z = true;
            } catch (Exception unused) {
            }
        }
        if (z) {
            return;
        }
        l(5, str, null);
    }

    @Override // g.i0.j.f
    @Nullable
    public X509TrustManager o(SSLSocketFactory sSLSocketFactory) {
        Object objN = f.n(sSLSocketFactory, this.f6393c, "sslParameters");
        if (objN == null) {
            try {
                objN = f.n(sSLSocketFactory, Class.forName("com.google.android.gms.org.conscrypt.SSLParametersImpl", false, sSLSocketFactory.getClass().getClassLoader()), "sslParameters");
            } catch (ClassNotFoundException unused) {
                return super.o(sSLSocketFactory);
            }
        }
        X509TrustManager x509TrustManager = (X509TrustManager) f.n(objN, X509TrustManager.class, "x509TrustManager");
        return x509TrustManager != null ? x509TrustManager : (X509TrustManager) f.n(objN, X509TrustManager.class, "trustManager");
    }

    public final boolean p(String str, Class<?> cls, Object obj) {
        try {
            try {
                return ((Boolean) cls.getMethod("isCleartextTrafficPermitted", String.class).invoke(obj, str)).booleanValue();
            } catch (NoSuchMethodException unused) {
                return ((Boolean) cls.getMethod("isCleartextTrafficPermitted", new Class[0]).invoke(obj, new Object[0])).booleanValue();
            }
        } catch (NoSuchMethodException unused2) {
            return true;
        }
    }
}