Kaspi.kz v5.85.1 - bJK.java 源代码

package o;

import java.io.IOException;
import java.lang.ref.Reference;
import java.net.ConnectException;
import java.net.Proxy;
import java.net.Socket;
import java.net.SocketException;
import java.security.cert.Certificate;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.TimeUnit;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.SSLPeerUnverifiedException;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSocket;
import javax.net.ssl.SSLSocketFactory;
import kotlin.jvm.functions.Function0;
import kotlin.jvm.internal.DefaultConstructorMarker;
import kotlin.jvm.internal.Intrinsics;
import o.C2126bJc;
import o.C2129bJf;
import o.C2146bKa;
import o.bIV;
import o.bKV;
import okhttp3.internal.http2.ConnectionShutdownException;
import okhttp3.internal.http2.StreamResetException;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

public final class bJK extends C2146bKa.setFieldValue implements bII {
    public static final setError Companion = new setError(null);
    public static final long IDLE_CONNECTION_HEALTHY_NS = 10000000000L;
    private static final int MAX_TUNNEL_ATTEMPTS = 21;
    private static final String NPE_THROW_WITH_NULL = "throw with null exception";
    private int allocationLimit;
    private final List<Reference<bJI>> calls;
    private final bJJ connectionPool;
    private bIV handshake;
    private C2146bKa http2Connection;
    private long idleAtNs;
    private boolean noCoalescedConnections;
    private boolean noNewExchanges;
    private bIZ protocol;
    private Socket rawSocket;
    private int refusedStreamCount;
    private final C2128bJe route;
    private int routeFailureCount;
    private InterfaceC2172bLl sink;
    private Socket socket;
    private bLi source;
    private int successCount;

    public final class setLabel {
        public static final int[] setError;

        static {
            int[] iArr = new int[Proxy.Type.values().length];
            try {
                iArr[Proxy.Type.DIRECT.ordinal()] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                iArr[Proxy.Type.HTTP.ordinal()] = 2;
            } catch (NoSuchFieldError unused2) {
            }
            setError = iArr;
        }
    }

    public final bJJ read() {
        return this.connectionPool;
    }

    public bJK(@NotNull bJJ bjj, @NotNull C2128bJe c2128bJe) {
        Intrinsics.checkNotNullParameter(bjj, bIW.FRAGMENT_ENCODE_SET);
        Intrinsics.checkNotNullParameter(c2128bJe, bIW.FRAGMENT_ENCODE_SET);
        this.connectionPool = bjj;
        this.route = c2128bJe;
        this.allocationLimit = 1;
        this.calls = new ArrayList();
        this.idleAtNs = Long.MAX_VALUE;
    }

    public final void setBackground(boolean z) {
        this.noNewExchanges = z;
    }

    public final boolean setElement() {
        return this.noNewExchanges;
    }

    public final int RemoteActionCompatParcelizer() {
        return this.routeFailureCount;
    }

    public final void setBackground(int i) {
        this.routeFailureCount = i;
    }

    public final List<Reference<bJI>> write() {
        return this.calls;
    }

    public final long IconCompatParcelizer() {
        return this.idleAtNs;
    }

    public final void setOptions(long j) {
        this.idleAtNs = j;
    }

    public final boolean MediaBrowserCompatCustomActionResultReceiver() {
        return this.http2Connection != null;
    }

    public final void AudioAttributesImplBaseParcelizer() {
        synchronized (this) {
            this.noNewExchanges = true;
        }
    }

    public final void AudioAttributesImplApi21Parcelizer() {
        synchronized (this) {
            this.noCoalescedConnections = true;
        }
    }

    public final void AudioAttributesCompatParcelizer() {
        synchronized (this) {
            this.successCount++;
        }
    }

    public final void setFieldValue(int r17, int r18, int r19, int r20, boolean r21, @org.jetbrains.annotations.NotNull o.bIG r22, @org.jetbrains.annotations.NotNull o.bIN r23) {
        throw new UnsupportedOperationException("Method not decompiled: o.bJK.setFieldValue(int, int, int, int, boolean, o.bIG, o.bIN):void");
    }

    private final void setOptions(int i, int i2, int i3, bIG big, bIN bin) throws IOException {
        C2129bJf AudioAttributesImplApi26Parcelizer = AudioAttributesImplApi26Parcelizer();
        bIW AudioAttributesImplBaseParcelizer = AudioAttributesImplApi26Parcelizer.AudioAttributesImplBaseParcelizer();
        for (int i4 = 0; i4 < 21; i4++) {
            setError(i, i2, big, bin);
            AudioAttributesImplApi26Parcelizer = setLabel(i2, i3, AudioAttributesImplApi26Parcelizer, AudioAttributesImplBaseParcelizer);
            if (AudioAttributesImplApi26Parcelizer == null) {
                return;
            }
            Socket socket = this.rawSocket;
            if (socket != null) {
                C2137bJp.setLabel(socket);
            }
            this.rawSocket = null;
            this.sink = null;
            this.source = null;
            bin.setLabel(big, this.route.RemoteActionCompatParcelizer(), this.route.setBackground(), null);
        }
    }

    private final void setError(int i, int i2, bIG big, bIN bin) throws IOException {
        Socket createSocket;
        Proxy background = this.route.setBackground();
        bIA options = this.route.setOptions();
        Proxy.Type type = background.type();
        int i3 = type == null ? -1 : setLabel.setError[type.ordinal()];
        if (i3 == 1 || i3 == 2) {
            createSocket = options.MediaDescriptionCompat().createSocket();
            Intrinsics.setBackground(createSocket);
        } else {
            createSocket = new Socket(background);
        }
        this.rawSocket = createSocket;
        bin.setError(big, this.route.RemoteActionCompatParcelizer(), background);
        createSocket.setSoTimeout(i2);
        try {
            C2166bKw.setError.setFieldValue().setFieldValue(createSocket, this.route.RemoteActionCompatParcelizer(), i);
            try {
                this.source = bLH.setBackground(bLH.setFieldValue(createSocket));
                this.sink = bLH.setLabel(bLH.setError(createSocket));
            } catch (NullPointerException e) {
                if (Intrinsics.setFieldValue(e.getMessage(), NPE_THROW_WITH_NULL)) {
                    throw new IOException(e);
                }
            }
        } catch (ConnectException e2) {
            ConnectException connectException = new ConnectException("Failed to connect to " + this.route.RemoteActionCompatParcelizer());
            connectException.initCause(e2);
            throw connectException;
        }
    }

    private final void setFieldValue(bJF bjf, int i, bIG big, bIN bin) throws IOException {
        if (this.route.setOptions().MediaSessionCompatQueueItem() == null) {
            List<bIZ> MediaMetadataCompat = this.route.setOptions().MediaMetadataCompat();
            bIZ biz = bIZ.H2_PRIOR_KNOWLEDGE;
            if (MediaMetadataCompat.contains(biz)) {
                this.socket = this.rawSocket;
                this.protocol = biz;
                setFieldValue(i);
                return;
            } else {
                this.socket = this.rawSocket;
                this.protocol = bIZ.HTTP_1_1;
                return;
            }
        }
        bin.write(big);
        setBackground(bjf);
        bin.setOptions(big, this.handshake);
        if (this.protocol == bIZ.HTTP_2) {
            setFieldValue(i);
        }
    }

    private final void setFieldValue(int i) throws IOException {
        Socket socket = this.socket;
        Intrinsics.setBackground(socket);
        bLi bli = this.source;
        Intrinsics.setBackground(bli);
        InterfaceC2172bLl interfaceC2172bLl = this.sink;
        Intrinsics.setBackground(interfaceC2172bLl);
        socket.setSoTimeout(0);
        C2146bKa label = new C2146bKa.setError(true, bJD.INSTANCE).setLabel(socket, this.route.setOptions().RatingCompat().ParcelableVolumeInfo(), bli, interfaceC2172bLl).setBackground(this).setLabel(i).setLabel();
        this.http2Connection = label;
        this.allocationLimit = C2146bKa.Companion.setLabel().setFieldValue();
        C2146bKa.setFieldValue(label, false, null, 3, null);
    }

    private final void setBackground(bJF bjf) throws IOException {
        bIA options = this.route.setOptions();
        SSLSocketFactory MediaSessionCompatQueueItem = options.MediaSessionCompatQueueItem();
        SSLSocket sSLSocket = null;
        try {
            Intrinsics.setBackground(MediaSessionCompatQueueItem);
            Socket createSocket = MediaSessionCompatQueueItem.createSocket(this.rawSocket, options.RatingCompat().ParcelableVolumeInfo(), options.RatingCompat().ComponentActivity3(), true);
            Intrinsics.setLabel(createSocket, bIW.FRAGMENT_ENCODE_SET);
            SSLSocket sSLSocket2 = (SSLSocket) createSocket;
            try {
                bIJ error = bjf.setError(sSLSocket2);
                if (error.setElement()) {
                    C2166bKw.setError.setFieldValue().setBackground(sSLSocket2, options.RatingCompat().ParcelableVolumeInfo(), options.MediaMetadataCompat());
                }
                sSLSocket2.startHandshake();
                SSLSession session = sSLSocket2.getSession();
                bIV.setLabel setlabel = bIV.Companion;
                Intrinsics.checkNotNullExpressionValue(session, bIW.FRAGMENT_ENCODE_SET);
                bIV label = setlabel.setLabel(session);
                HostnameVerifier AudioAttributesImplBaseParcelizer = options.AudioAttributesImplBaseParcelizer();
                Intrinsics.setBackground(AudioAttributesImplBaseParcelizer);
                if (AudioAttributesImplBaseParcelizer.verify(options.RatingCompat().ParcelableVolumeInfo(), session)) {
                    bIE AudioAttributesImplApi21Parcelizer = options.AudioAttributesImplApi21Parcelizer();
                    Intrinsics.setBackground(AudioAttributesImplApi21Parcelizer);
                    this.handshake = new bIV(label.AudioAttributesCompatParcelizer(), label.setElement(), label.RemoteActionCompatParcelizer(), new setFieldValue(AudioAttributesImplApi21Parcelizer, label, options));
                    AudioAttributesImplApi21Parcelizer.setError(options.RatingCompat().ParcelableVolumeInfo(), new setBackground());
                    String error2 = error.setElement() ? C2166bKw.setError.setFieldValue().setError(sSLSocket2) : null;
                    this.socket = sSLSocket2;
                    this.source = bLH.setBackground(bLH.setFieldValue(sSLSocket2));
                    this.sink = bLH.setLabel(bLH.setError(sSLSocket2));
                    this.protocol = error2 != null ? bIZ.Companion.setError(error2) : bIZ.HTTP_1_1;
                    C2166bKw.setError.setFieldValue().setFieldValue(sSLSocket2);
                    return;
                }
                List<Certificate> IconCompatParcelizer = label.IconCompatParcelizer();
                if (IconCompatParcelizer.isEmpty()) {
                    throw new SSLPeerUnverifiedException("Hostname " + options.RatingCompat().ParcelableVolumeInfo() + " not verified (no certificates)");
                }
                Certificate certificate = IconCompatParcelizer.get(0);
                Intrinsics.setLabel(certificate, bIW.FRAGMENT_ENCODE_SET);
                X509Certificate x509Certificate = (X509Certificate) certificate;
                throw new SSLPeerUnverifiedException(allTypeAliases_delegatelambda2.setBackground("\n              |Hostname " + options.RatingCompat().ParcelableVolumeInfo() + " not verified:\n              |    certificate: " + bIE.Companion.setFieldValue((Certificate) x509Certificate) + "\n              |    DN: " + x509Certificate.getSubjectDN().getName() + "\n              |    subjectAltNames: " + bKM.setFieldValue.setOptions(x509Certificate) + "\n              ", (String) null, 1, (Object) null));
            } catch (Throwable th) {
                th = th;
                sSLSocket = sSLSocket2;
                if (sSLSocket != null) {
                    C2166bKw.setError.setFieldValue().setFieldValue(sSLSocket);
                }
                if (sSLSocket != null) {
                    C2137bJp.setLabel((Socket) sSLSocket);
                }
                throw th;
            }
        } catch (Throwable th2) {
            th = th2;
        }
    }

    static final class setFieldValue extends ProtoContainerClass implements Function0<List<? extends Certificate>> {
        final bIA setBackground;
        final bIV setError;
        final bIE setFieldValue;

        setFieldValue(bIE bie, bIV biv, bIA bia) {
            super(0);
            this.setFieldValue = bie;
            this.setError = biv;
            this.setBackground = bia;
        }

        public final List<Certificate> invoke() {
            bKN options = this.setFieldValue.setOptions();
            Intrinsics.setBackground(options);
            return options.setOptions(this.setError.IconCompatParcelizer(), this.setBackground.RatingCompat().ParcelableVolumeInfo());
        }
    }

    static final class setBackground extends ProtoContainerClass implements Function0<List<? extends X509Certificate>> {
        setBackground() {
            super(0);
        }

        public final List<X509Certificate> invoke() {
            bIV biv = bJK.this.handshake;
            Intrinsics.setBackground(biv);
            List<Certificate> IconCompatParcelizer = biv.IconCompatParcelizer();
            ArrayList arrayList = new ArrayList(DescriptorUtilsKt.setError(IconCompatParcelizer, 10));
            for (Certificate certificate : IconCompatParcelizer) {
                Intrinsics.setLabel(certificate, bIW.FRAGMENT_ENCODE_SET);
                arrayList.add((X509Certificate) certificate);
            }
            return arrayList;
        }
    }

    private final C2129bJf setLabel(int i, int i2, C2129bJf c2129bJf, bIW biw) throws IOException {
        String str = "CONNECT " + C2137bJp.setLabel(biw, true) + " HTTP/1.1";
        while (true) {
            bLi bli = this.source;
            Intrinsics.setBackground(bli);
            InterfaceC2172bLl interfaceC2172bLl = this.sink;
            Intrinsics.setBackground(interfaceC2172bLl);
            bJV bjv = new bJV(null, this, bli, interfaceC2172bLl);
            TimeUnit timeUnit = TimeUnit.MILLISECONDS;
            bli.timeout().setLabel(i, timeUnit);
            interfaceC2172bLl.timeout().setLabel(i2, timeUnit);
            bjv.setLabel(c2129bJf.IconCompatParcelizer(), str);
            bjv.setError();
            C2126bJc.setError fieldValue = bjv.setFieldValue(false);
            Intrinsics.setBackground(fieldValue);
            C2126bJc background = fieldValue.setBackground(c2129bJf).setBackground();
            bjv.setBackground(background);
            int MediaDescriptionCompat = background.MediaDescriptionCompat();
            if (MediaDescriptionCompat == 200) {
                if (bli.AudioAttributesImplApi26Parcelizer().AudioAttributesCompatParcelizer() && interfaceC2172bLl.AudioAttributesImplApi26Parcelizer().AudioAttributesCompatParcelizer()) {
                    return null;
                }
                throw new IOException("TLS tunnel buffered too many bytes!");
            }
            if (MediaDescriptionCompat == 407) {
                C2129bJf background2 = this.route.setOptions().MediaBrowserCompatMediaItem().setBackground(this.route, background);
                if (background2 == null) {
                    throw new IOException("Failed to authenticate with proxy");
                }
                if (allTypeAliases_delegatelambda2.setBackground("close", C2126bJc.setFieldValue(background, "Connection", null, 2, null), true)) {
                    return background2;
                }
                c2129bJf = background2;
            } else {
                throw new IOException("Unexpected response code for CONNECT: " + background.MediaDescriptionCompat());
            }
        }
    }

    private final C2129bJf AudioAttributesImplApi26Parcelizer() throws IOException {
        C2129bJf error = new C2129bJf.setFieldValue().setOptions(this.route.setOptions().RatingCompat()).setLabel("CONNECT", null).setOptions("Host", C2137bJp.setLabel(this.route.setOptions().RatingCompat(), true)).setOptions("Proxy-Connection", "Keep-Alive").setOptions("User-Agent", C2137bJp.read).setError();
        C2129bJf background = this.route.setOptions().MediaBrowserCompatMediaItem().setBackground(this.route, new C2126bJc.setError().setBackground(error).setOptions(bIZ.HTTP_1_1).setLabel(407).setError("Preemptive Authenticate").setLabel(C2137bJp.setBackground).setLabel(-1L).setOptions(-1L).setFieldValue("Proxy-Authenticate", "OkHttp-Preemptive").setBackground());
        return background == null ? error : background;
    }

    private final boolean setBackground(List<C2128bJe> list) {
        List<C2128bJe> list2 = list;
        if (!(list2 instanceof Collection) || !list2.isEmpty()) {
            for (C2128bJe c2128bJe : list2) {
                Proxy.Type type = c2128bJe.setBackground().type();
                Proxy.Type type2 = Proxy.Type.DIRECT;
                if (type == type2 && this.route.setBackground().type() == type2 && Intrinsics.setFieldValue(this.route.RemoteActionCompatParcelizer(), c2128bJe.RemoteActionCompatParcelizer())) {
                    return true;
                }
            }
        }
        return false;
    }

    private final boolean setFieldValue(bIW biw, bIV biv) {
        List<Certificate> IconCompatParcelizer = biv.IconCompatParcelizer();
        if (IconCompatParcelizer.isEmpty()) {
            return false;
        }
        bKM bkm = bKM.setFieldValue;
        String ParcelableVolumeInfo = biw.ParcelableVolumeInfo();
        Certificate certificate = IconCompatParcelizer.get(0);
        Intrinsics.setLabel(certificate, bIW.FRAGMENT_ENCODE_SET);
        return bkm.setBackground(ParcelableVolumeInfo, (X509Certificate) certificate);
    }

    public final bJP setLabel(@NotNull bIY biy, @NotNull bJR bjr) throws SocketException {
        Intrinsics.checkNotNullParameter(biy, bIW.FRAGMENT_ENCODE_SET);
        Intrinsics.checkNotNullParameter(bjr, bIW.FRAGMENT_ENCODE_SET);
        Socket socket = this.socket;
        Intrinsics.setBackground(socket);
        bLi bli = this.source;
        Intrinsics.setBackground(bli);
        InterfaceC2172bLl interfaceC2172bLl = this.sink;
        Intrinsics.setBackground(interfaceC2172bLl);
        C2146bKa c2146bKa = this.http2Connection;
        if (c2146bKa != null) {
            return new C2148bKc(biy, this, bjr, c2146bKa);
        }
        socket.setSoTimeout(bjr.setOptions());
        bMe timeout = bli.timeout();
        long IconCompatParcelizer = bjr.IconCompatParcelizer();
        TimeUnit timeUnit = TimeUnit.MILLISECONDS;
        timeout.setLabel(IconCompatParcelizer, timeUnit);
        interfaceC2172bLl.timeout().setLabel(bjr.AudioAttributesImplApi21Parcelizer(), timeUnit);
        return new bJV(biy, this, bli, interfaceC2172bLl);
    }

    public final bKV.setLabel setFieldValue(@NotNull bJE bje) throws SocketException {
        Intrinsics.checkNotNullParameter(bje, bIW.FRAGMENT_ENCODE_SET);
        Socket socket = this.socket;
        Intrinsics.setBackground(socket);
        bLi bli = this.source;
        Intrinsics.setBackground(bli);
        InterfaceC2172bLl interfaceC2172bLl = this.sink;
        Intrinsics.setBackground(interfaceC2172bLl);
        socket.setSoTimeout(0);
        AudioAttributesImplBaseParcelizer();
        return new setOptions(bli, interfaceC2172bLl, bje);
    }

    public static final class setOptions extends bKV.setLabel {
        final bJE setError;

        setOptions(bLi bli, InterfaceC2172bLl interfaceC2172bLl, bJE bje) {
            super(true, bli, interfaceC2172bLl);
            this.setError = bje;
        }

        @Override
        public void close() {
            this.setError.setFieldValue(-1L, true, true, null);
        }
    }

    @Override
    public C2128bJe setOptions() {
        return this.route;
    }

    public final void setFieldValue() {
        Socket socket = this.rawSocket;
        if (socket != null) {
            C2137bJp.setLabel(socket);
        }
    }

    @Override
    public Socket setBackground() {
        Socket socket = this.socket;
        Intrinsics.setBackground(socket);
        return socket;
    }

    @Override
    public void setLabel(@NotNull C2152bKh c2152bKh) throws IOException {
        Intrinsics.checkNotNullParameter(c2152bKh, bIW.FRAGMENT_ENCODE_SET);
        c2152bKh.setBackground(bJX.REFUSED_STREAM, (IOException) null);
    }

    @Override
    public void setBackground(@NotNull C2146bKa c2146bKa, @NotNull C2150bKf c2150bKf) {
        synchronized (this) {
            Intrinsics.checkNotNullParameter(c2146bKa, bIW.FRAGMENT_ENCODE_SET);
            Intrinsics.checkNotNullParameter(c2150bKf, bIW.FRAGMENT_ENCODE_SET);
            this.allocationLimit = c2150bKf.setFieldValue();
        }
    }

    @Override
    public bIV setError() {
        return this.handshake;
    }

    public final void setFieldValue(@NotNull bIY biy, @NotNull C2128bJe c2128bJe, @NotNull IOException iOException) {
        Intrinsics.checkNotNullParameter(biy, bIW.FRAGMENT_ENCODE_SET);
        Intrinsics.checkNotNullParameter(c2128bJe, bIW.FRAGMENT_ENCODE_SET);
        Intrinsics.checkNotNullParameter(iOException, bIW.FRAGMENT_ENCODE_SET);
        if (c2128bJe.setBackground().type() != Proxy.Type.DIRECT) {
            bIA options = c2128bJe.setOptions();
            options.MediaBrowserCompatSearchResultReceiver().connectFailed(options.RatingCompat().onCreate(), c2128bJe.setBackground().address(), iOException);
        }
        biy.onCreate().setLabel(c2128bJe);
    }

    public final void setBackground(@NotNull bJI bji, @Nullable IOException iOException) {
        synchronized (this) {
            Intrinsics.checkNotNullParameter(bji, bIW.FRAGMENT_ENCODE_SET);
            if (iOException instanceof StreamResetException) {
                if (((StreamResetException) iOException).setError == bJX.REFUSED_STREAM) {
                    int i = this.refusedStreamCount + 1;
                    this.refusedStreamCount = i;
                    if (i > 1) {
                        this.noNewExchanges = true;
                        this.routeFailureCount++;
                    }
                } else if (((StreamResetException) iOException).setError != bJX.CANCEL || !bji.setError()) {
                    this.noNewExchanges = true;
                    this.routeFailureCount++;
                }
            } else if (!MediaBrowserCompatCustomActionResultReceiver() || (iOException instanceof ConnectionShutdownException)) {
                this.noNewExchanges = true;
                if (this.successCount == 0) {
                    if (iOException != null) {
                        setFieldValue(bji.write(), this.route, iOException);
                    }
                    this.routeFailureCount++;
                }
            }
        }
    }

    @Override
    public bIZ setLabel() {
        bIZ biz = this.protocol;
        Intrinsics.setBackground(biz);
        return biz;
    }

    public String toString() {
        Object obj;
        StringBuilder sb = new StringBuilder();
        sb.append("Connection{");
        sb.append(this.route.setOptions().RatingCompat().ParcelableVolumeInfo());
        sb.append(':');
        sb.append(this.route.setOptions().RatingCompat().ComponentActivity3());
        sb.append(", proxy=");
        sb.append(this.route.setBackground());
        sb.append(" hostAddress=");
        sb.append(this.route.RemoteActionCompatParcelizer());
        sb.append(" cipherSuite=");
        bIV biv = this.handshake;
        if (biv == null || (obj = biv.setElement()) == null) {
            obj = "none";
        }
        sb.append(obj);
        sb.append(" protocol=");
        sb.append(this.protocol);
        sb.append('}');
        return sb.toString();
    }

    public static final class setError {
        public setError(DefaultConstructorMarker defaultConstructorMarker) {
            this();
        }

        private setError() {
        }

        public final bJK setError(@NotNull bJJ bjj, @NotNull C2128bJe c2128bJe, @NotNull Socket socket, long j) {
            Intrinsics.checkNotNullParameter(bjj, bIW.FRAGMENT_ENCODE_SET);
            Intrinsics.checkNotNullParameter(c2128bJe, bIW.FRAGMENT_ENCODE_SET);
            Intrinsics.checkNotNullParameter(socket, bIW.FRAGMENT_ENCODE_SET);
            bJK bjk = new bJK(bjj, c2128bJe);
            bjk.socket = socket;
            bjk.setOptions(j);
            return bjk;
        }
    }

    public final boolean setError(@NotNull bIA bia, @Nullable List<C2128bJe> list) {
        Intrinsics.checkNotNullParameter(bia, bIW.FRAGMENT_ENCODE_SET);
        if (!C2137bJp.write || Thread.holdsLock(this)) {
            if (this.calls.size() >= this.allocationLimit || this.noNewExchanges || !this.route.setOptions().setError(bia)) {
                return false;
            }
            if (Intrinsics.setFieldValue(bia.RatingCompat().ParcelableVolumeInfo(), setOptions().setOptions().RatingCompat().ParcelableVolumeInfo())) {
                return true;
            }
            if (this.http2Connection == null || list == null || !setBackground(list) || bia.AudioAttributesImplBaseParcelizer() != bKM.setFieldValue || !setFieldValue(bia.RatingCompat())) {
                return false;
            }
            try {
                bIE AudioAttributesImplApi21Parcelizer = bia.AudioAttributesImplApi21Parcelizer();
                Intrinsics.setBackground(AudioAttributesImplApi21Parcelizer);
                String ParcelableVolumeInfo = bia.RatingCompat().ParcelableVolumeInfo();
                bIV error = setError();
                Intrinsics.setBackground(error);
                AudioAttributesImplApi21Parcelizer.setError(ParcelableVolumeInfo, error.IconCompatParcelizer());
                return true;
            } catch (SSLPeerUnverifiedException unused) {
                return false;
            }
        }
        throw new AssertionError("Thread " + Thread.currentThread().getName() + " MUST hold lock on " + this);
    }

    private final boolean setFieldValue(bIW biw) {
        bIV biv;
        if (!C2137bJp.write || Thread.holdsLock(this)) {
            bIW RatingCompat = this.route.setOptions().RatingCompat();
            if (biw.ComponentActivity3() != RatingCompat.ComponentActivity3()) {
                return false;
            }
            if (Intrinsics.setFieldValue(biw.ParcelableVolumeInfo(), RatingCompat.ParcelableVolumeInfo())) {
                return true;
            }
            if (this.noCoalescedConnections || (biv = this.handshake) == null) {
                return false;
            }
            Intrinsics.setBackground(biv);
            return setFieldValue(biw, biv);
        }
        throw new AssertionError("Thread " + Thread.currentThread().getName() + " MUST hold lock on " + this);
    }

    public final boolean setFieldValue(boolean z) {
        long j;
        if (!C2137bJp.write || !Thread.holdsLock(this)) {
            long nanoTime = System.nanoTime();
            Socket socket = this.rawSocket;
            Intrinsics.setBackground(socket);
            Socket socket2 = this.socket;
            Intrinsics.setBackground(socket2);
            bLi bli = this.source;
            Intrinsics.setBackground(bli);
            if (socket.isClosed() || socket2.isClosed() || socket2.isInputShutdown() || socket2.isOutputShutdown()) {
                return false;
            }
            C2146bKa c2146bKa = this.http2Connection;
            if (c2146bKa != null) {
                return c2146bKa.setFieldValue(nanoTime);
            }
            synchronized (this) {
                j = this.idleAtNs;
            }
            if (nanoTime - j < IDLE_CONNECTION_HEALTHY_NS || !z) {
                return true;
            }
            return C2137bJp.setFieldValue(socket2, bli);
        }
        throw new AssertionError("Thread " + Thread.currentThread().getName() + " MUST NOT hold lock on " + this);
    }
}